Implement dumb URLLoader{Factory} for ServiceWorker script loading (for try)

content/renderer/service_worker/service_worker_context_client.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/service_worker/service_worker_context_client.h"
 
 #include <map>
 #include <memory>
 #include <utility>
 
@@ skipping 82 matching lines @@
 
   // Blink calls this method for each request starting with the main script,
   // we tag them with the provider id.
   void WillSendRequest(blink::WebURLRequest& request) override {
     std::unique_ptr<RequestExtraData> extra_data(new RequestExtraData);
     extra_data->set_service_worker_provider_id(provider_->provider_id());
     extra_data->set_originated_from_service_worker(true);
     // Service workers are only available in secure contexts, so all requests
     // are initiated in a secure context.
     extra_data->set_initiated_in_secure_context(true);
+    extra_data->set_url_loader_factory_override(
+        provider_->script_loader_factory());
     request.SetExtraData(extra_data.release());
   }
 
   int GetProviderID() const override { return provider_->provider_id(); }
 
  private:
   std::unique_ptr<ServiceWorkerNetworkProvider> provider_;
 };
 
 class StreamHandleListener
@@ skipping 434 matching lines @@
   return g_worker_client_tls.Pointer()->Get();
 }
 
 ServiceWorkerContextClient::ServiceWorkerContextClient(
     int embedded_worker_id,
     int64_t service_worker_version_id,
     const GURL& service_worker_scope,
     const GURL& script_url,
     mojom::ServiceWorkerEventDispatcherRequest dispatcher_request,
     mojom::EmbeddedWorkerInstanceHostAssociatedPtrInfo instance_host,
+    mojom::ServiceWorkerProviderClientInfoPtr provider_client_info,
     std::unique_ptr<EmbeddedWorkerInstanceClientImpl> embedded_worker_client)
     : embedded_worker_id_(embedded_worker_id),
       service_worker_version_id_(service_worker_version_id),
       service_worker_scope_(service_worker_scope),
       script_url_(script_url),
       sender_(ChildThreadImpl::current()->thread_safe_sender()),
       main_thread_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       proxy_(nullptr),
       pending_dispatcher_request_(std::move(dispatcher_request)),
       embedded_worker_client_(std::move(embedded_worker_client)) {
   instance_host_ =
       mojom::ThreadSafeEmbeddedWorkerInstanceHostAssociatedPtr::Create(
           std::move(instance_host), main_thread_task_runner_);
   TRACE_EVENT_ASYNC_BEGIN0("ServiceWorker",
                            "ServiceWorkerContextClient::StartingWorkerContext",
                            this);
   TRACE_EVENT_ASYNC_STEP_INTO0(
       "ServiceWorker",
       "ServiceWorkerContextClient::StartingWorkerContext",
       this,
       "PrepareWorker");
+  // Create a content::ServiceWorkerNetworkProvider for this data source so
+  // we can observe its requests.
+  pending_network_provider_ = base::MakeUnique<ServiceWorkerNetworkProvider>(
+      std::move(provider_client_info));
+  provider_context_ = pending_network_provider_->context();
 }
 
 ServiceWorkerContextClient::~ServiceWorkerContextClient() {}
 
 void ServiceWorkerContextClient::OnMessageReceived(
     int thread_id,
     int embedded_worker_id,
     const IPC::Message& message) {
   CHECK_EQ(embedded_worker_id_, embedded_worker_id);
   bool handled = true;
@@ skipping 121 matching lines @@
   DCHECK_NE(registration_info.registration_id,
             kInvalidServiceWorkerRegistrationId);
 
   DCHECK(pending_dispatcher_request_.is_pending());
   DCHECK(!context_->event_dispatcher_binding.is_bound());
   context_->event_dispatcher_binding.Bind(
       std::move(pending_dispatcher_request_));
 
   SetRegistrationInServiceWorkerGlobalScope(registration_info, version_attrs);
 
-  (*instance_host_)
-      ->OnThreadStarted(WorkerThread::GetCurrentId(),
-                        provider_context_->provider_id());
+  (*instance_host_)->OnThreadStarted(WorkerThread::GetCurrentId());
 
   TRACE_EVENT_ASYNC_STEP_INTO0(
       "ServiceWorker",
       "ServiceWorkerContextClient::StartingWorkerContext",
       this,
       "ExecuteScript");
 }
 
 void ServiceWorkerContextClient::DidEvaluateWorkerScript(bool success) {
   DCHECK(worker_task_runner_->RunsTasksInCurrentSequence());
@@ skipping 355 matching lines @@
   DispatchPaymentRequestEventCallback callback =
       std::move(context_->payment_request_event_callbacks[payment_request_id]);
   std::move(callback).Run(EventResultToStatus(result),
                           base::Time::FromDoubleT(event_dispatch_time));
   context_->payment_request_event_callbacks.erase(payment_request_id);
 }
 
 std::unique_ptr<blink::WebServiceWorkerNetworkProvider>
 ServiceWorkerContextClient::CreateServiceWorkerNetworkProvider() {
   DCHECK(main_thread_task_runner_->RunsTasksInCurrentSequence());
-
-  // Create a content::ServiceWorkerNetworkProvider for this data source so
-  // we can observe its requests.
-  std::unique_ptr<ServiceWorkerNetworkProvider> provider =
-      base::MakeUnique<ServiceWorkerNetworkProvider>(
-          MSG_ROUTING_NONE, SERVICE_WORKER_PROVIDER_FOR_CONTROLLER,
-          true /* is_parent_frame_secure */);
-  provider_context_ = provider->context();
-  network_provider_id_ = provider->provider_id();
-
-  // Tell the network provider about which version to load.
-  provider->SetServiceWorkerVersionId(service_worker_version_id_,
-                                      embedded_worker_id_);
-
   // Blink is responsible for deleting the returned object.
   return base::MakeUnique<WebServiceWorkerNetworkProviderImpl>(
-      std::move(provider));
+      std::move(pending_network_provider_));
 }
 
 std::unique_ptr<blink::WebWorkerFetchContext>
 ServiceWorkerContextClient::CreateServiceWorkerFetchContext() {
   DCHECK(main_thread_task_runner_->RunsTasksInCurrentSequence());
   DCHECK(base::FeatureList::IsEnabled(features::kOffMainThreadFetch));
   mojom::WorkerURLLoaderFactoryProviderPtr worker_url_loader_factory_provider;
   RenderThreadImpl::current()
       ->blink_platform_impl()
       ->GetInterfaceProvider()
       ->GetInterface(mojo::MakeRequest(&worker_url_loader_factory_provider));
 
   // Blink is responsible for deleting the returned object.
   return base::MakeUnique<ServiceWorkerFetchContextImpl>(
       script_url_, worker_url_loader_factory_provider.PassInterface(),
-      network_provider_id_);
+      provider_context_->provider_id());
 }
 
 std::unique_ptr<blink::WebServiceWorkerProvider>
 ServiceWorkerContextClient::CreateServiceWorkerProvider() {
   DCHECK(main_thread_task_runner_->RunsTasksInCurrentSequence());
   DCHECK(provider_context_);
 
   // Blink is responsible for deleting the returned object.
   return base::MakeUnique<WebServiceWorkerProviderImpl>(
       sender_.get(), provider_context_.get());
@@ skipping 556 matching lines @@
 }
 
 base::WeakPtr<ServiceWorkerContextClient>
 ServiceWorkerContextClient::GetWeakPtr() {
   DCHECK(worker_task_runner_->RunsTasksInCurrentSequence());
   DCHECK(context_);
   return context_->weak_factory.GetWeakPtr();
 }
 
 }  // namespace content