BASELINE: Update Chromium to 85.0.4183.14085-based

Change-Id: Iaa42f4680837c57725b1344f108c0196741f6057
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>

14 files changed, 157 insertions, 96 deletions

diff --git a/chromium/content/renderer/service_worker/controller_service_worker_connector.h b/chromium/content/renderer/service_worker/controller_service_worker_connector.h
index fffa08afadb..43276e168db 100644
--- a/chromium/content/renderer/service_worker/controller_service_worker_connector.h
+++ b/chromium/content/renderer/service_worker/controller_service_worker_connector.h
@@ -121,8 +121,7 @@ class CONTENT_EXPORT ControllerServiceWorkerConnector
   base::ObserverList<Observer>::Unchecked observer_list_;
 
   // The web-exposed client id, used for FetchEvent#clientId (i.e.,
-  // ServiceWorkerProviderHost::client_uuid and not
-  // ServiceWorkerProviderHost::provider_id).
+  // ServiceWorkerContainerHost::client_uuid).
   std::string client_id_;
 
   DISALLOW_COPY_AND_ASSIGN(ControllerServiceWorkerConnector);
diff --git a/chromium/content/renderer/service_worker/embedded_worker_instance_client_impl.cc b/chromium/content/renderer/service_worker/embedded_worker_instance_client_impl.cc
index 34af7fec6ce..e46e3ce0623 100644
--- a/chromium/content/renderer/service_worker/embedded_worker_instance_client_impl.cc
+++ b/chromium/content/renderer/service_worker/embedded_worker_instance_client_impl.cc
@@ -13,7 +13,6 @@
 #include "content/child/scoped_child_process_reference.h"
 #include "content/common/service_worker/service_worker_utils.h"
 #include "content/public/common/content_client.h"
-#include "content/renderer/render_thread_impl.h"
 #include "content/renderer/service_worker/service_worker_context_client.h"
 #include "content/renderer/worker/fetch_client_settings_object_helpers.h"
 #include "mojo/public/cpp/bindings/pending_remote.h"
@@ -30,6 +29,7 @@ namespace content {
 // static
 void EmbeddedWorkerInstanceClientImpl::Create(
     scoped_refptr<base::SingleThreadTaskRunner> initiator_thread_task_runner,
+    const std::vector<std::string>& cors_exempt_header_list,
     mojo::PendingReceiver<blink::mojom::EmbeddedWorkerInstanceClient>
         receiver) {
   // This won't be leaked because the lifetime will be managed internally.
@@ -38,15 +38,18 @@ void EmbeddedWorkerInstanceClientImpl::Create(
   // a chance to stop by calling TerminateWorkerContext() and waiting
   // before destructing.
   new EmbeddedWorkerInstanceClientImpl(std::move(receiver),
-                                       std::move(initiator_thread_task_runner));
+                                       std::move(initiator_thread_task_runner),
+                                       cors_exempt_header_list);
 }
 
 void EmbeddedWorkerInstanceClientImpl::CreateForRequest(
     scoped_refptr<base::SingleThreadTaskRunner> initiator_thread_task_runner,
+    const std::vector<std::string>& cors_exempt_header_list,
     mojo::PendingReceiver<blink::mojom::EmbeddedWorkerInstanceClient>
         receiver) {
   EmbeddedWorkerInstanceClientImpl::Create(
-      std::move(initiator_thread_task_runner), std::move(receiver));
+      std::move(initiator_thread_task_runner), cors_exempt_header_list,
+      std::move(receiver));
 }
 
 void EmbeddedWorkerInstanceClientImpl::WorkerContextDestroyed() {
@@ -87,7 +90,7 @@ void EmbeddedWorkerInstanceClientImpl::StartWorker(
       std::move(params->subresource_loader_factories),
       std::move(params->subresource_loader_updater),
       params->script_url_to_skip_throttling, initiator_thread_task_runner_,
-      params->service_worker_route_id);
+      params->service_worker_route_id, cors_exempt_header_list_);
   // Record UMA to indicate StartWorker is received on renderer.
   StartWorkerHistogramEnum metric =
       params->is_installed ? StartWorkerHistogramEnum::RECEIVED_ON_INSTALLED
@@ -105,8 +108,8 @@ void EmbeddedWorkerInstanceClientImpl::StartWorker(
     installed_scripts_manager_params =
         std::make_unique<blink::WebServiceWorkerInstalledScriptsManagerParams>(
             std::move(params->installed_scripts_info->installed_urls),
-            params->installed_scripts_info->manager_receiver.PassPipe(),
-            params->installed_scripts_info->manager_host_remote.PassPipe());
+            std::move(params->installed_scripts_info->manager_receiver),
+            std::move(params->installed_scripts_info->manager_host_remote));
   }
 
   auto worker =
@@ -114,8 +117,8 @@ void EmbeddedWorkerInstanceClientImpl::StartWorker(
   service_worker_context_client_->StartWorkerContextOnInitiatorThread(
       std::move(worker), std::move(start_data),
       std::move(installed_scripts_manager_params),
-      params->content_settings_proxy.PassPipe(), cache_storage.PassPipe(),
-      browser_interface_broker.PassPipe());
+      std::move(params->content_settings_proxy), std::move(cache_storage),
+      std::move(browser_interface_broker));
 }
 
 void EmbeddedWorkerInstanceClientImpl::StopWorker() {
@@ -128,9 +131,11 @@ void EmbeddedWorkerInstanceClientImpl::StopWorker() {
 
 EmbeddedWorkerInstanceClientImpl::EmbeddedWorkerInstanceClientImpl(
     mojo::PendingReceiver<blink::mojom::EmbeddedWorkerInstanceClient> receiver,
-    scoped_refptr<base::SingleThreadTaskRunner> initiator_thread_task_runner)
+    scoped_refptr<base::SingleThreadTaskRunner> initiator_thread_task_runner,
+    const std::vector<std::string>& cors_exempt_header_list)
     : receiver_(this, std::move(receiver)),
-      initiator_thread_task_runner_(std::move(initiator_thread_task_runner)) {
+      initiator_thread_task_runner_(std::move(initiator_thread_task_runner)),
+      cors_exempt_header_list_(cors_exempt_header_list) {
   DCHECK(initiator_thread_task_runner_->BelongsToCurrentThread());
   receiver_.set_disconnect_handler(base::BindOnce(
       &EmbeddedWorkerInstanceClientImpl::OnError, base::Unretained(this)));
diff --git a/chromium/content/renderer/service_worker/embedded_worker_instance_client_impl.h b/chromium/content/renderer/service_worker/embedded_worker_instance_client_impl.h
index 1e7bb540976..085104e81b0 100644
--- a/chromium/content/renderer/service_worker/embedded_worker_instance_client_impl.h
+++ b/chromium/content/renderer/service_worker/embedded_worker_instance_client_impl.h
@@ -46,6 +46,7 @@ class CONTENT_EXPORT EmbeddedWorkerInstanceClientImpl
   // instead of just creating an instance of EmbeddedWorkerInstanceClient.
   static void Create(
       scoped_refptr<base::SingleThreadTaskRunner> initiator_task_runner,
+      const std::vector<std::string>& cors_exempt_header_list,
       mojo::PendingReceiver<blink::mojom::EmbeddedWorkerInstanceClient>
           receiver);
 
@@ -54,6 +55,7 @@ class CONTENT_EXPORT EmbeddedWorkerInstanceClientImpl
   // service_manager::BinderRegistry.
   static void CreateForRequest(
       scoped_refptr<base::SingleThreadTaskRunner> initiator_task_runner,
+      const std::vector<std::string>& cors_exempt_header_list,
       mojo::PendingReceiver<blink::mojom::EmbeddedWorkerInstanceClient>
           receiver);
 
@@ -72,7 +74,8 @@ class CONTENT_EXPORT EmbeddedWorkerInstanceClientImpl
   EmbeddedWorkerInstanceClientImpl(
       mojo::PendingReceiver<blink::mojom::EmbeddedWorkerInstanceClient>
           receiver,
-      scoped_refptr<base::SingleThreadTaskRunner> initiator_thread_task_runner);
+      scoped_refptr<base::SingleThreadTaskRunner> initiator_thread_task_runner,
+      const std::vector<std::string>& cors_exempt_header_list);
 
   // blink::mojom::EmbeddedWorkerInstanceClient implementation
   void StartWorker(blink::mojom::EmbeddedWorkerStartParamsPtr params) override;
@@ -89,6 +92,8 @@ class CONTENT_EXPORT EmbeddedWorkerInstanceClientImpl
   // StartWorker().
   scoped_refptr<base::SingleThreadTaskRunner> initiator_thread_task_runner_;
 
+  std::vector<std::string> cors_exempt_header_list_;
+
   // nullptr means worker is not running.
   std::unique_ptr<ServiceWorkerContextClient> service_worker_context_client_;
 
diff --git a/chromium/content/renderer/service_worker/service_worker_context_client.cc b/chromium/content/renderer/service_worker/service_worker_context_client.cc
index a6f1f799c44..77df196f12c 100644
--- a/chromium/content/renderer/service_worker/service_worker_context_client.cc
+++ b/chromium/content/renderer/service_worker/service_worker_context_client.cc
@@ -47,6 +47,7 @@
 #include "third_party/blink/public/common/service_worker/service_worker_utils.h"
 #include "third_party/blink/public/mojom/blob/blob.mojom.h"
 #include "third_party/blink/public/mojom/blob/blob_registry.mojom.h"
+#include "third_party/blink/public/mojom/browser_interface_broker.mojom.h"
 #include "third_party/blink/public/mojom/loader/request_context_frame_type.mojom.h"
 #include "third_party/blink/public/mojom/service_worker/service_worker.mojom.h"
 #include "third_party/blink/public/mojom/service_worker/service_worker_client.mojom.h"
@@ -112,7 +113,8 @@ ServiceWorkerContextClient::ServiceWorkerContextClient(
         subresource_loader_updater,
     const GURL& script_url_to_skip_throttling,
     scoped_refptr<base::SingleThreadTaskRunner> initiator_thread_task_runner,
-    int32_t service_worker_route_id)
+    int32_t service_worker_route_id,
+    const std::vector<std::string>& cors_exempt_header_list)
     : service_worker_version_id_(service_worker_version_id),
       service_worker_scope_(service_worker_scope),
       script_url_(script_url),
@@ -128,7 +130,8 @@ ServiceWorkerContextClient::ServiceWorkerContextClient(
           std::move(subresource_loader_updater)),
       owner_(owner),
       start_timing_(std::move(start_timing)),
-      service_worker_route_id_(service_worker_route_id) {
+      service_worker_route_id_(service_worker_route_id),
+      cors_exempt_header_list_(cors_exempt_header_list) {
   DCHECK(initiator_thread_task_runner_->RunsTasksInCurrentSequence());
   DCHECK(owner_);
   DCHECK(subresource_loaders);
@@ -176,14 +179,16 @@ void ServiceWorkerContextClient::StartWorkerContextOnInitiatorThread(
     std::unique_ptr<blink::WebEmbeddedWorkerStartData> start_data,
     std::unique_ptr<blink::WebServiceWorkerInstalledScriptsManagerParams>
         installed_scripts_manager_params,
-    mojo::ScopedMessagePipeHandle content_settings_handle,
-    mojo::ScopedMessagePipeHandle cache_storage,
-    mojo::ScopedMessagePipeHandle browser_interface_broker) {
+    mojo::PendingRemote<blink::mojom::WorkerContentSettingsProxy>
+        content_settings,
+    mojo::PendingRemote<blink::mojom::CacheStorage> cache_storage,
+    mojo::PendingRemote<blink::mojom::BrowserInterfaceBroker>
+        browser_interface_broker) {
   DCHECK(initiator_thread_task_runner_->RunsTasksInCurrentSequence());
   worker_ = std::move(worker);
   worker_->StartWorkerContext(
       std::move(start_data), std::move(installed_scripts_manager_params),
-      std::move(content_settings_handle), std::move(cache_storage),
+      std::move(content_settings), std::move(cache_storage),
       std::move(browser_interface_broker), initiator_thread_task_runner_);
 }
 
@@ -193,15 +198,14 @@ blink::WebEmbeddedWorker& ServiceWorkerContextClient::worker() {
 }
 
 void ServiceWorkerContextClient::WorkerReadyForInspectionOnInitiatorThread(
-    mojo::ScopedMessagePipeHandle devtools_agent_remote,
-    mojo::ScopedMessagePipeHandle devtools_agent_host_receiver) {
+    blink::CrossVariantMojoRemote<blink::mojom::DevToolsAgentInterfaceBase>
+        devtools_agent_remote,
+    blink::CrossVariantMojoReceiver<
+        blink::mojom::DevToolsAgentHostInterfaceBase>
+        devtools_agent_host_receiver) {
   DCHECK(initiator_thread_task_runner_->RunsTasksInCurrentSequence());
-  mojo::PendingRemote<blink::mojom::DevToolsAgent> agent_remote(
-      std::move(devtools_agent_remote), blink::mojom::DevToolsAgent::Version_);
-  mojo::PendingReceiver<blink::mojom::DevToolsAgentHost> receiver(
-      std::move(devtools_agent_host_receiver));
-  instance_host_->OnReadyForInspection(std::move(agent_remote),
-                                       std::move(receiver));
+  instance_host_->OnReadyForInspection(std::move(devtools_agent_remote),
+                                       std::move(devtools_agent_host_receiver));
 }
 
 void ServiceWorkerContextClient::FailedToFetchClassicScript() {
@@ -241,10 +245,10 @@ void ServiceWorkerContextClient::WorkerContextStarted(
   context_ = std::make_unique<WorkerContextData>(this);
 
   DCHECK(pending_service_worker_receiver_.is_valid());
-  proxy_->BindServiceWorker(pending_service_worker_receiver_.PassPipe());
+  proxy_->BindServiceWorker(std::move(pending_service_worker_receiver_));
 
   DCHECK(controller_receiver_.is_valid());
-  proxy_->BindControllerServiceWorker(controller_receiver_.PassPipe());
+  proxy_->BindControllerServiceWorker(std::move(controller_receiver_));
 
   GetContentClient()
       ->renderer()
@@ -386,7 +390,8 @@ ServiceWorkerContextClient::CreateWorkerFetchContextOnInitiatorThread() {
           ->renderer()
           ->CreateWebSocketHandshakeThrottleProvider(),
       std::move(preference_watcher_receiver_),
-      std::move(pending_subresource_loader_updater_), service_worker_route_id_);
+      std::move(pending_subresource_loader_updater_), service_worker_route_id_,
+      cors_exempt_header_list_);
 }
 
 void ServiceWorkerContextClient::OnNavigationPreloadResponse(
diff --git a/chromium/content/renderer/service_worker/service_worker_context_client.h b/chromium/content/renderer/service_worker/service_worker_context_client.h
index 7d5dc2f5e57..f98e8214100 100644
--- a/chromium/content/renderer/service_worker/service_worker_context_client.h
+++ b/chromium/content/renderer/service_worker/service_worker_context_client.h
@@ -36,6 +36,8 @@
 #include "third_party/blink/public/mojom/service_worker/service_worker_provider.mojom-forward.h"
 #include "third_party/blink/public/mojom/service_worker/service_worker_registration.mojom-forward.h"
 #include "third_party/blink/public/mojom/worker/subresource_loader_updater.mojom-forward.h"
+#include "third_party/blink/public/mojom/worker/worker_content_settings_proxy.mojom-forward.h"
+#include "third_party/blink/public/mojom/worker/worker_content_settings_proxy.mojom.h"
 #include "third_party/blink/public/platform/modules/service_worker/web_service_worker_error.h"
 #include "third_party/blink/public/web/modules/service_worker/web_service_worker_context_client.h"
 #include "third_party/blink/public/web/modules/service_worker/web_service_worker_context_proxy.h"
@@ -110,7 +112,8 @@ class CONTENT_EXPORT ServiceWorkerContextClient
           subresource_loader_updater,
       const GURL& script_url_to_skip_throttling,
       scoped_refptr<base::SingleThreadTaskRunner> initiator_thread_task_runner,
-      int32_t service_worker_route_id);
+      int32_t service_worker_route_id,
+      const std::vector<std::string>& cors_exempt_header_list);
   // Called on the initiator thread.
   ~ServiceWorkerContextClient() override;
 
@@ -119,17 +122,22 @@ class CONTENT_EXPORT ServiceWorkerContextClient
       std::unique_ptr<blink::WebEmbeddedWorker> worker,
       std::unique_ptr<blink::WebEmbeddedWorkerStartData> start_data,
       std::unique_ptr<blink::WebServiceWorkerInstalledScriptsManagerParams>,
-      mojo::ScopedMessagePipeHandle content_settings_handle,
-      mojo::ScopedMessagePipeHandle cache_storage,
-      mojo::ScopedMessagePipeHandle browser_interface_broker);
+      mojo::PendingRemote<blink::mojom::WorkerContentSettingsProxy>
+          content_settings,
+      mojo::PendingRemote<blink::mojom::CacheStorage> cache_storage,
+      mojo::PendingRemote<blink::mojom::BrowserInterfaceBroker>
+          browser_interface_broker);
 
   // Called on the initiator thread.
   blink::WebEmbeddedWorker& worker();
 
   // WebServiceWorkerContextClient overrides.
   void WorkerReadyForInspectionOnInitiatorThread(
-      mojo::ScopedMessagePipeHandle devtools_agent_ptr_info,
-      mojo::ScopedMessagePipeHandle devtools_agent_host_request) override;
+      blink::CrossVariantMojoRemote<blink::mojom::DevToolsAgentInterfaceBase>
+          devtools_agent_remote,
+      blink::CrossVariantMojoReceiver<
+          blink::mojom::DevToolsAgentHostInterfaceBase>
+          devtools_agent_host_receiver) override;
   void FailedToFetchClassicScript() override;
   void FailedToFetchModuleScript() override;
   void WorkerScriptLoadedOnWorkerThread() override;
@@ -239,7 +247,7 @@ class CONTENT_EXPORT ServiceWorkerContextClient
       instance_host_;
 
   // This holds blink.mojom.ServiceWorkerContainer(Host) connections to the
-  // browser-side ServiceWorkerProviderHost to keep it alive there.
+  // browser-side ServiceWorkerHost to keep it alive there.
   // Note: |service_worker_provider_info_->script_loader_factory_remote| is
   // moved to WebServiceWorkerNetworkProviderImpl when
   // CreateServiceWorkerNetworkProvider is called.
@@ -279,6 +287,8 @@ class CONTENT_EXPORT ServiceWorkerContextClient
 
   int32_t service_worker_route_id_;
 
+  std::vector<std::string> cors_exempt_header_list_;
+
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerContextClient);
 };
 
diff --git a/chromium/content/renderer/service_worker/service_worker_fetch_context_impl.cc b/chromium/content/renderer/service_worker/service_worker_fetch_context_impl.cc
index 930a79063be..b6dc30a5041 100644
--- a/chromium/content/renderer/service_worker/service_worker_fetch_context_impl.cc
+++ b/chromium/content/renderer/service_worker/service_worker_fetch_context_impl.cc
@@ -36,7 +36,8 @@ ServiceWorkerFetchContextImpl::ServiceWorkerFetchContextImpl(
         preference_watcher_receiver,
     mojo::PendingReceiver<blink::mojom::SubresourceLoaderUpdater>
         pending_subresource_loader_updater,
-    int32_t service_worker_route_id)
+    int32_t service_worker_route_id,
+    const std::vector<std::string>& cors_exempt_header_list)
     : renderer_preferences_(renderer_preferences),
       worker_script_url_(worker_script_url),
       pending_url_loader_factory_(std::move(pending_url_loader_factory)),
@@ -49,7 +50,8 @@ ServiceWorkerFetchContextImpl::ServiceWorkerFetchContextImpl(
           std::move(preference_watcher_receiver)),
       pending_subresource_loader_updater_(
           std::move(pending_subresource_loader_updater)),
-      service_worker_route_id_(service_worker_route_id) {}
+      service_worker_route_id_(service_worker_route_id),
+      cors_exempt_header_list_(cors_exempt_header_list) {}
 
 ServiceWorkerFetchContextImpl::~ServiceWorkerFetchContextImpl() {}
 
@@ -62,6 +64,7 @@ void ServiceWorkerFetchContextImpl::SetTerminateSyncLoadEvent(
 void ServiceWorkerFetchContextImpl::InitializeOnWorkerThread(
     blink::AcceptLanguagesWatcher* watcher) {
   resource_dispatcher_ = std::make_unique<ResourceDispatcher>();
+  resource_dispatcher_->SetCorsExemptHeaderList(cors_exempt_header_list_);
   resource_dispatcher_->set_terminate_sync_load_event(
       terminate_sync_load_event_);
   preference_watcher_receiver_.Bind(
@@ -97,13 +100,12 @@ ServiceWorkerFetchContextImpl::GetURLLoaderFactory() {
 
 std::unique_ptr<blink::WebURLLoaderFactory>
 ServiceWorkerFetchContextImpl::WrapURLLoaderFactory(
-    mojo::ScopedMessagePipeHandle url_loader_factory_handle) {
+    blink::CrossVariantMojoRemote<network::mojom::URLLoaderFactoryInterfaceBase>
+        url_loader_factory) {
   return std::make_unique<WebURLLoaderFactoryImpl>(
       resource_dispatcher_->GetWeakPtr(),
       base::MakeRefCounted<network::WrapperSharedURLLoaderFactory>(
-          mojo::PendingRemote<network::mojom::URLLoaderFactory>(
-              std::move(url_loader_factory_handle),
-              network::mojom::URLLoaderFactory::Version_)));
+          std::move(url_loader_factory)));
 }
 
 blink::WebURLLoaderFactory*
@@ -202,7 +204,8 @@ blink::WebString ServiceWorkerFetchContextImpl::GetAcceptLanguages() const {
   return blink::WebString::FromUTF8(renderer_preferences_.accept_languages);
 }
 
-mojo::ScopedMessagePipeHandle
+blink::CrossVariantMojoReceiver<
+    blink::mojom::WorkerTimingContainerInterfaceBase>
 ServiceWorkerFetchContextImpl::TakePendingWorkerTimingReceiver(int request_id) {
   // No receiver exists because requests from service workers are never handled
   // by a service worker.
diff --git a/chromium/content/renderer/service_worker/service_worker_fetch_context_impl.h b/chromium/content/renderer/service_worker/service_worker_fetch_context_impl.h
index 24a4c220089..d7f7634c330 100644
--- a/chromium/content/renderer/service_worker/service_worker_fetch_context_impl.h
+++ b/chromium/content/renderer/service_worker/service_worker_fetch_context_impl.h
@@ -52,14 +52,17 @@ class CONTENT_EXPORT ServiceWorkerFetchContextImpl final
           preference_watcher_receiver,
       mojo::PendingReceiver<blink::mojom::SubresourceLoaderUpdater>
           pending_subresource_loader_updater,
-      int32_t service_worker_route_id);
+      int32_t service_worker_route_id,
+      const std::vector<std::string>& cors_exempt_header_list);
 
   // blink::WebServiceWorkerFetchContext implementation:
   void SetTerminateSyncLoadEvent(base::WaitableEvent*) override;
   void InitializeOnWorkerThread(blink::AcceptLanguagesWatcher*) override;
   blink::WebURLLoaderFactory* GetURLLoaderFactory() override;
   std::unique_ptr<blink::WebURLLoaderFactory> WrapURLLoaderFactory(
-      mojo::ScopedMessagePipeHandle url_loader_factory_handle) override;
+      blink::CrossVariantMojoRemote<
+          network::mojom::URLLoaderFactoryInterfaceBase> url_loader_factory)
+      override;
   blink::WebURLLoaderFactory* GetScriptLoaderFactory() override;
   void WillSendRequest(blink::WebURLRequest&) override;
   blink::mojom::ControllerServiceWorkerMode GetControllerServiceWorkerMode()
@@ -70,8 +73,9 @@ class CONTENT_EXPORT ServiceWorkerFetchContextImpl final
   CreateWebSocketHandshakeThrottle(
       scoped_refptr<base::SingleThreadTaskRunner> task_runner) override;
   blink::WebString GetAcceptLanguages() const override;
-  mojo::ScopedMessagePipeHandle TakePendingWorkerTimingReceiver(
-      int request_id) override;
+  blink::CrossVariantMojoReceiver<
+      blink::mojom::WorkerTimingContainerInterfaceBase>
+  TakePendingWorkerTimingReceiver(int request_id) override;
   void SetIsOfflineMode(bool) override;
   blink::mojom::SubresourceLoaderUpdater* GetSubresourceLoaderUpdater()
       override;
@@ -136,6 +140,7 @@ class CONTENT_EXPORT ServiceWorkerFetchContextImpl final
   blink::AcceptLanguagesWatcher* accept_languages_watcher_ = nullptr;
 
   int32_t service_worker_route_id_;
+  std::vector<std::string> cors_exempt_header_list_;
   bool is_offline_mode_ = false;
 };
 
diff --git a/chromium/content/renderer/service_worker/service_worker_fetch_context_impl_unittest.cc b/chromium/content/renderer/service_worker/service_worker_fetch_context_impl_unittest.cc
index 236fbcdead3..3bedd8a075c 100644
--- a/chromium/content/renderer/service_worker/service_worker_fetch_context_impl_unittest.cc
+++ b/chromium/content/renderer/service_worker/service_worker_fetch_context_impl_unittest.cc
@@ -48,7 +48,8 @@ TEST_F(ServiceWorkerFetchContextImplTest, SkipThrottling) {
       std::make_unique<FakeURLLoaderThrottleProvider>(),
       /*websocket_handshake_throttle_provider=*/nullptr, mojo::NullReceiver(),
       mojo::NullReceiver(),
-      /*service_worker_route_id=*/-1);
+      /*service_worker_route_id=*/-1,
+      /*cors_exempt_header_list=*/std::vector<std::string>());
 
   {
     // Call WillSendRequest() for kScriptURL.
diff --git a/chromium/content/renderer/service_worker/service_worker_network_provider_for_frame.cc b/chromium/content/renderer/service_worker/service_worker_network_provider_for_frame.cc
index 3a105adba2f..cc1f91ef808 100644
--- a/chromium/content/renderer/service_worker/service_worker_network_provider_for_frame.cc
+++ b/chromium/content/renderer/service_worker/service_worker_network_provider_for_frame.cc
@@ -62,17 +62,17 @@ class ServiceWorkerNetworkProviderForFrame::NewDocumentObserver
 std::unique_ptr<ServiceWorkerNetworkProviderForFrame>
 ServiceWorkerNetworkProviderForFrame::Create(
     RenderFrameImpl* frame,
-    blink::mojom::ServiceWorkerProviderInfoForClientPtr provider_info,
+    blink::mojom::ServiceWorkerContainerInfoForClientPtr container_info,
     blink::mojom::ControllerServiceWorkerInfoPtr controller_info,
     scoped_refptr<network::SharedURLLoaderFactory> fallback_loader_factory) {
-  DCHECK(provider_info);
+  DCHECK(container_info);
 
   auto provider =
       base::WrapUnique(new ServiceWorkerNetworkProviderForFrame(frame));
   provider->context_ = base::MakeRefCounted<ServiceWorkerProviderContext>(
       blink::mojom::ServiceWorkerContainerType::kForWindow,
-      std::move(provider_info->client_receiver),
-      std::move(provider_info->host_remote), std::move(controller_info),
+      std::move(container_info->client_receiver),
+      std::move(container_info->host_remote), std::move(controller_info),
       std::move(fallback_loader_factory));
 
   return provider;
@@ -175,14 +175,13 @@ void ServiceWorkerNetworkProviderForFrame::DispatchNetworkQuiet() {
   context()->DispatchNetworkQuiet();
 }
 
-mojo::ScopedMessagePipeHandle
+blink::CrossVariantMojoReceiver<
+    blink::mojom::WorkerTimingContainerInterfaceBase>
 ServiceWorkerNetworkProviderForFrame::TakePendingWorkerTimingReceiver(
     int request_id) {
   if (!context())
     return {};
-  auto worker_timing_receiver =
-      context()->TakePendingWorkerTimingReceiver(request_id);
-  return worker_timing_receiver.PassPipe();
+  return context()->TakePendingWorkerTimingReceiver(request_id);
 }
 
 void ServiceWorkerNetworkProviderForFrame::NotifyExecutionReady() {
diff --git a/chromium/content/renderer/service_worker/service_worker_network_provider_for_frame.h b/chromium/content/renderer/service_worker/service_worker_network_provider_for_frame.h
index d70fe501123..81624c1b8d8 100644
--- a/chromium/content/renderer/service_worker/service_worker_network_provider_for_frame.h
+++ b/chromium/content/renderer/service_worker/service_worker_network_provider_for_frame.h
@@ -31,7 +31,7 @@ class CONTENT_EXPORT ServiceWorkerNetworkProviderForFrame final
   // the loading context, e.g. a frame, provides it.
   static std::unique_ptr<ServiceWorkerNetworkProviderForFrame> Create(
       RenderFrameImpl* frame,
-      blink::mojom::ServiceWorkerProviderInfoForClientPtr provider_info,
+      blink::mojom::ServiceWorkerContainerInfoForClientPtr container_info,
       blink::mojom::ControllerServiceWorkerInfoPtr controller_info,
       scoped_refptr<network::SharedURLLoaderFactory> fallback_loader_factory);
 
@@ -52,8 +52,9 @@ class CONTENT_EXPORT ServiceWorkerNetworkProviderForFrame final
       override;
   int64_t ControllerServiceWorkerID() override;
   void DispatchNetworkQuiet() override;
-  mojo::ScopedMessagePipeHandle TakePendingWorkerTimingReceiver(
-      int request_id) override;
+  blink::CrossVariantMojoReceiver<
+      blink::mojom::WorkerTimingContainerInterfaceBase>
+  TakePendingWorkerTimingReceiver(int request_id) override;
 
   ServiceWorkerProviderContext* context() { return context_.get(); }
 
diff --git a/chromium/content/renderer/service_worker/service_worker_provider_context.h b/chromium/content/renderer/service_worker/service_worker_provider_context.h
index b0bac601dbf..79fc21d5d15 100644
--- a/chromium/content/renderer/service_worker/service_worker_provider_context.h
+++ b/chromium/content/renderer/service_worker/service_worker_provider_context.h
@@ -80,7 +80,7 @@ class CONTENT_EXPORT ServiceWorkerProviderContext
       public blink::mojom::ServiceWorkerContainer,
       public blink::mojom::ServiceWorkerWorkerClientRegistry {
  public:
-  // |receiver_| is connected to the content::ServiceWorkerProviderHost that
+  // |receiver| is connected to the content::ServiceWorkerContainerHost that
   // notifies of changes to the registration's and workers' status.
   //
   // |controller_info| contains the endpoint and object info that is needed to
@@ -155,11 +155,11 @@ class CONTENT_EXPORT ServiceWorkerProviderContext
   CloneRemoteContainerHost();
 
   // Called when WebServiceWorkerNetworkProvider is destructed. This function
-  // severs the Mojo binding to the browser-side ServiceWorkerProviderHost. The
+  // severs the Mojo binding to the browser-side ServiceWorkerContainerHost. The
   // reason WebServiceWorkerNetworkProvider is special compared to the other
   // providers, is that it is destructed synchronously when a service worker
   // client (Document) is removed from the DOM. Once this happens, the
-  // ServiceWorkerProviderHost must destruct quickly in order to remove the
+  // ServiceWorkerContainerHost must destruct quickly in order to remove the
   // ServiceWorkerClient from the system (thus allowing unregistration/update to
   // occur and ensuring the Clients API doesn't return the client).
   //
@@ -167,9 +167,7 @@ class CONTENT_EXPORT ServiceWorkerProviderContext
   // state.
   void OnNetworkProviderDestroyed();
 
-  // Gets the blink::mojom::ServiceWorkerContainerHost* for sending requests to
-  // browser-side ServiceWorkerProviderHost. May be nullptr if
-  // OnNetworkProviderDestroyed() has already been called.
+  // May be nullptr if OnNetworkProviderDestroyed() has already been called.
   // Currently this can be called only for clients that are Documents,
   // see comments of |container_host_|.
   blink::mojom::ServiceWorkerContainerHost* container_host() const;
@@ -237,12 +235,12 @@ class CONTENT_EXPORT ServiceWorkerProviderContext
   const blink::mojom::ServiceWorkerContainerType container_type_;
   scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner_;
 
-  // This keeps the connection to the content::ServiceWorkerProviderHost in the
+  // This keeps the connection to the content::ServiceWorkerContainerHost in the
   // browser process alive.
   mojo::AssociatedReceiver<blink::mojom::ServiceWorkerContainer> receiver_;
 
   // The |container_host_| remote represents the connection to the
-  // browser-side ServiceWorkerProviderHost, whose lifetime is bound to
+  // browser-side ServiceWorkerContainerHost, whose lifetime is bound to
   // |container_host_| via the Mojo connection. This may be nullptr if the Mojo
   // connection was broken in OnNetworkProviderDestroyed().
   //
diff --git a/chromium/content/renderer/service_worker/service_worker_subresource_loader.cc b/chromium/content/renderer/service_worker/service_worker_subresource_loader.cc
index 59b2ded1431..dadffb46dc7 100644
--- a/chromium/content/renderer/service_worker/service_worker_subresource_loader.cc
+++ b/chromium/content/renderer/service_worker/service_worker_subresource_loader.cc
@@ -480,6 +480,10 @@ void ServiceWorkerSubresourceLoader::UpdateResponseTiming(
   // dispatching the fetch event, so set it to |dispatch_event_time|.
   response_head_->load_timing.service_worker_ready_time =
       timing->dispatch_event_time;
+  response_head_->load_timing.service_worker_fetch_start =
+      timing->dispatch_event_time;
+  response_head_->load_timing.service_worker_respond_with_settled =
+      timing->respond_with_settled_time;
   fetch_event_timing_ = std::move(timing);
 }
 
@@ -566,10 +570,9 @@ void ServiceWorkerSubresourceLoader::StartResponse(
   // Read side data if necessary.  We only do this if both the
   // |side_data_blob| is available to read and the request is destined
   // for a script.
-  auto resource_type =
-      static_cast<blink::mojom::ResourceType>(resource_request_.resource_type);
+  auto request_destination = resource_request_.destination;
   if (response->side_data_blob &&
-      resource_type == blink::mojom::ResourceType::kScript) {
+      request_destination == network::mojom::RequestDestination::kScript) {
     side_data_as_blob_.Bind(std::move(response->side_data_blob->blob));
     side_data_as_blob_->ReadSideData(base::BindOnce(
         &ServiceWorkerSubresourceLoader::OnSideDataReadingComplete,
diff --git a/chromium/content/renderer/service_worker/service_worker_subresource_loader_unittest.cc b/chromium/content/renderer/service_worker/service_worker_subresource_loader_unittest.cc
index 2d4094787b7..d57c51b2425 100644
--- a/chromium/content/renderer/service_worker/service_worker_subresource_loader_unittest.cc
+++ b/chromium/content/renderer/service_worker/service_worker_subresource_loader_unittest.cc
@@ -97,12 +97,16 @@ class FakeControllerServiceWorker
 
   static blink::mojom::FetchAPIResponsePtr OkResponse(
       blink::mojom::SerializedBlobPtr blob_body,
-      network::mojom::FetchResponseSource response_source) {
+      network::mojom::FetchResponseSource response_source,
+      base::Time response_time,
+      std::string cache_storage_cache_name) {
     auto response = blink::mojom::FetchAPIResponse::New();
     response->status_code = 200;
     response->status_text = "OK";
     response->response_type = network::mojom::FetchResponseType::kDefault;
     response->response_source = response_source;
+    response->response_time = response_time;
+    response->cache_storage_cache_name = cache_storage_cache_name;
     response->blob = std::move(blob_body);
     if (response->blob) {
       response->headers.emplace("Content-Length",
@@ -223,6 +227,12 @@ class FakeControllerServiceWorker
     response_source_ = source;
   }
 
+  void SetCacheStorageCacheName(std::string cache_name) {
+    cache_storage_cache_name_ = cache_name;
+  }
+
+  void SetResponseTime(base::Time time) { response_time_ = time; }
+
   // blink::mojom::ControllerServiceWorker:
   void DispatchFetchEventForSubresource(
       blink::mojom::DispatchFetchEventParamsPtr params,
@@ -240,11 +250,13 @@ class FakeControllerServiceWorker
 
     auto timing = blink::mojom::ServiceWorkerFetchEventTiming::New();
     timing->dispatch_event_time = base::TimeTicks::Now();
+    timing->respond_with_settled_time = base::TimeTicks::Now();
 
     switch (response_mode_) {
       case ResponseMode::kDefault:
         response_callback->OnResponse(
-            OkResponse(nullptr /* blob_body */, response_source_),
+            OkResponse(nullptr /* blob_body */, response_source_,
+                       response_time_, cache_storage_cache_name_),
             std::move(timing));
         std::move(callback).Run(
             blink::mojom::ServiceWorkerEventStatus::COMPLETED);
@@ -255,14 +267,16 @@ class FakeControllerServiceWorker
         break;
       case ResponseMode::kStream:
         response_callback->OnResponseStream(
-            OkResponse(nullptr /* blob_body */, response_source_),
+            OkResponse(nullptr /* blob_body */, response_source_,
+                       response_time_, cache_storage_cache_name_),
             std::move(stream_handle_), std::move(timing));
         std::move(callback).Run(
             blink::mojom::ServiceWorkerEventStatus::COMPLETED);
         break;
       case ResponseMode::kBlob:
         response_callback->OnResponse(
-            OkResponse(std::move(blob_body_), response_source_),
+            OkResponse(std::move(blob_body_), response_source_, response_time_,
+                       cache_storage_cache_name_),
             std::move(timing));
         std::move(callback).Run(
             blink::mojom::ServiceWorkerEventStatus::COMPLETED);
@@ -294,7 +308,8 @@ class FakeControllerServiceWorker
             blob->blob.InitWithNewPipeAndPassReceiver());
 
         // Respond with a 206 response.
-        auto response = OkResponse(std::move(blob), response_source_);
+        auto response = OkResponse(std::move(blob), response_source_,
+                                   response_time_, cache_storage_cache_name_);
         response->status_code = 206;
         response->headers.emplace(
             "Content-Range", base::StringPrintf("bytes %zu-%zu/%zu", start, end,
@@ -381,6 +396,9 @@ class FakeControllerServiceWorker
   network::mojom::FetchResponseSource response_source_ =
       network::mojom::FetchResponseSource::kUnspecified;
 
+  std::string cache_storage_cache_name_;
+  base::Time response_time_;
+
   DISALLOW_COPY_AND_ASSIGN(FakeControllerServiceWorker);
 };
 
@@ -460,7 +478,6 @@ network::mojom::URLResponseHeadPtr CreateResponseInfoFromServiceWorker() {
   head->was_fallback_required_by_service_worker = false;
   head->url_list_via_service_worker = std::vector<GURL>();
   head->response_type = network::mojom::FetchResponseType::kDefault;
-  head->is_in_cache_storage = false;
   head->cache_storage_cache_name = std::string();
   head->did_service_worker_navigation_preload = false;
   return head;
@@ -537,23 +554,28 @@ class ServiceWorkerSubresourceLoaderTest : public ::testing::Test {
     EXPECT_EQ(expected_info.url_list_via_service_worker,
               info.url_list_via_service_worker);
     EXPECT_EQ(expected_info.response_type, info.response_type);
-    EXPECT_EQ(expected_info.is_in_cache_storage, info.is_in_cache_storage);
     EXPECT_EQ(expected_info.cache_storage_cache_name,
               info.cache_storage_cache_name);
+    EXPECT_EQ(expected_info.response_time, info.response_time);
+    EXPECT_EQ(expected_info.service_worker_response_source,
+              info.service_worker_response_source);
     EXPECT_EQ(expected_info.did_service_worker_navigation_preload,
               info.did_service_worker_navigation_preload);
     EXPECT_NE(expected_info.load_timing.service_worker_start_time,
               info.load_timing.service_worker_start_time);
     EXPECT_NE(expected_info.load_timing.service_worker_ready_time,
               info.load_timing.service_worker_ready_time);
+    EXPECT_NE(expected_info.load_timing.service_worker_fetch_start,
+              info.load_timing.service_worker_fetch_start);
+    EXPECT_NE(expected_info.load_timing.service_worker_respond_with_settled,
+              info.load_timing.service_worker_respond_with_settled);
   }
 
   network::ResourceRequest CreateRequest(const GURL& url) {
     network::ResourceRequest request;
     request.url = url;
     request.method = "GET";
-    request.resource_type =
-        static_cast<int>(blink::mojom::ResourceType::kSubResource);
+    request.destination = network::mojom::RequestDestination::kEmpty;
     return request;
   }
 
@@ -601,8 +623,7 @@ class ServiceWorkerSubresourceLoaderTest : public ::testing::Test {
         CreateSubresourceLoaderFactory();
     network::ResourceRequest request =
         CreateRequest(GURL("https://www.example.com/big-file"));
-    request.resource_type =
-        static_cast<int>(blink::mojom::ResourceType::kMedia);
+    request.destination = network::mojom::RequestDestination::kVideo;
     request.headers.SetHeader("Range", range_header);
     mojo::Remote<network::mojom::URLLoader> loader;
     std::unique_ptr<network::TestURLLoaderClient> client;
@@ -917,7 +938,10 @@ TEST_F(ServiceWorkerSubresourceLoaderTest, StreamResponse) {
   client->RunUntilResponseReceived();
 
   auto& info = client->response_head();
-  ExpectResponseInfo(*info, *CreateResponseInfoFromServiceWorker());
+  auto expected_info = CreateResponseInfoFromServiceWorker();
+  expected_info->service_worker_response_source =
+      network::mojom::FetchResponseSource::kNetwork;
+  ExpectResponseInfo(*info, *expected_info);
 
   // Write the body stream.
   uint32_t written_bytes = sizeof(kResponseBody) - 1;
@@ -1019,6 +1043,10 @@ TEST_F(ServiceWorkerSubresourceLoaderTest, BlobResponse) {
   fake_controller_.RespondWithBlob(kMetadata, kResponseBody);
   fake_controller_.SetResponseSource(
       network::mojom::FetchResponseSource::kCacheStorage);
+  std::string cache_name = "v2";
+  fake_controller_.SetCacheStorageCacheName(cache_name);
+  base::Time response_time = base::Time::Now();
+  fake_controller_.SetResponseTime(response_time);
 
   mojo::Remote<network::mojom::URLLoaderFactory> factory =
       CreateSubresourceLoaderFactory();
@@ -1026,17 +1054,18 @@ TEST_F(ServiceWorkerSubresourceLoaderTest, BlobResponse) {
   // Perform the request.
   network::ResourceRequest request =
       CreateRequest(GURL("https://www.example.com/foo.js"));
-  request.resource_type = static_cast<int>(blink::mojom::ResourceType::kScript);
+  request.destination = network::mojom::RequestDestination::kScript;
   mojo::Remote<network::mojom::URLLoader> loader;
   std::unique_ptr<network::TestURLLoaderClient> client;
   StartRequest(factory, request, &loader, &client);
   client->RunUntilResponseReceived();
 
   auto expected_info = CreateResponseInfoFromServiceWorker();
-  // |is_in_cache_storage| should be true because |fake_controller_| sets the
-  // response source as CacheStorage.
-  expected_info->is_in_cache_storage = true;
   auto& info = client->response_head();
+  expected_info->response_time = response_time;
+  expected_info->cache_storage_cache_name = cache_name;
+  expected_info->service_worker_response_source =
+      network::mojom::FetchResponseSource::kCacheStorage;
   ExpectResponseInfo(*info, *expected_info);
   EXPECT_EQ(39, info->content_length);
 
@@ -1083,7 +1112,7 @@ TEST_F(ServiceWorkerSubresourceLoaderTest, BlobResponseWithoutMetadata) {
   // Perform the request.
   network::ResourceRequest request =
       CreateRequest(GURL("https://www.example.com/foo.js"));
-  request.resource_type = static_cast<int>(blink::mojom::ResourceType::kScript);
+  request.destination = network::mojom::RequestDestination::kScript;
   mojo::Remote<network::mojom::URLLoader> loader;
   std::unique_ptr<network::TestURLLoaderClient> client;
   StartRequest(factory, request, &loader, &client);
@@ -1130,18 +1159,16 @@ TEST_F(ServiceWorkerSubresourceLoaderTest, BlobResponseNonScript) {
   // Perform the request.
   network::ResourceRequest request =
       CreateRequest(GURL("https://www.example.com/foo.txt"));
-  request.resource_type =
-      static_cast<int>(blink::mojom::ResourceType::kSubResource);
+  request.destination = network::mojom::RequestDestination::kEmpty;
   mojo::Remote<network::mojom::URLLoader> loader;
   std::unique_ptr<network::TestURLLoaderClient> client;
   StartRequest(factory, request, &loader, &client);
   client->RunUntilResponseReceived();
 
-  auto expected_info = CreateResponseInfoFromServiceWorker();
-  // |is_in_cache_storage| should be true because |fake_controller_| sets the
-  // response source as CacheStorage.
-  expected_info->is_in_cache_storage = true;
   auto& info = client->response_head();
+  auto expected_info = CreateResponseInfoFromServiceWorker();
+  expected_info->service_worker_response_source =
+      network::mojom::FetchResponseSource::kCacheStorage;
   ExpectResponseInfo(*info, *expected_info);
   EXPECT_EQ(33, info->content_length);
 
diff --git a/chromium/content/renderer/service_worker/web_service_worker_provider_impl.cc b/chromium/content/renderer/service_worker/web_service_worker_provider_impl.cc
index b1f3087729c..55441bc85c4 100644
--- a/chromium/content/renderer/service_worker/web_service_worker_provider_impl.cc
+++ b/chromium/content/renderer/service_worker/web_service_worker_provider_impl.cc
@@ -312,8 +312,8 @@ void WebServiceWorkerProviderImpl::OnDidGetRegistrationForReady(
   // GetRegistrationForReady() needs to respond some non-sense params even if it
   // has found that the request is a bad message and has called
   // mojo::ReportBadMessage(), this is forced by Mojo, please see
-  // content::ServiceWorkerProviderHost::GetRegistrationForReady(). We'll find a
-  // better solution once the discussion at
+  // content::ServiceWorkerContainerHost::GetRegistrationForReady(). We'll find
+  // a better solution once the discussion at
   // https://groups.google.com/a/chromium.org/forum/#!topic/chromium-mojo/NNsogKNurlA
   // settled.
   CHECK(registration);