network service: pass a URLLoaderFactory to renderers on SW registration

content/browser/service_worker/service_worker_dispatcher_host.cc

 // Copyright 2013 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/browser/service_worker/service_worker_dispatcher_host.h"
 
 #include <utility>
 
 #include "base/debug/crash_logging.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "content/browser/bad_message.h"
 #include "content/browser/service_worker/embedded_worker_registry.h"
 #include "content/browser/service_worker/embedded_worker_status.h"
 #include "content/browser/service_worker/service_worker_client_utils.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_handle.h"
 #include "content/browser/service_worker/service_worker_navigation_handle_core.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_registration_handle.h"
+#include "content/browser/service_worker/service_worker_url_loader_factory_creation.h"
 #include "content/common/service_worker/embedded_worker_messages.h"
 #include "content/common/service_worker/service_worker_event_dispatcher.mojom.h"
 #include "content/common/service_worker/service_worker_messages.h"
 #include "content/common/service_worker/service_worker_types.h"
 #include "content/common/service_worker/service_worker_utils.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/browser_side_navigation_policy.h"
 #include "content/public/common/child_process_host.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/origin_util.h"
+#include "content/public/common/service_manager_connection.h"
+#include "content/public/common/service_names.mojom.h"
 #include "ipc/ipc_message_macros.h"
 #include "net/http/http_util.h"
 #include "third_party/WebKit/public/platform/modules/serviceworker/WebServiceWorkerError.h"
 #include "url/gurl.h"
 
 using blink::WebServiceWorkerError;
 
 namespace content {
 
 namespace {
@@ skipping 1193 matching lines @@
 
   ServiceWorkerRegistration* registration =
       GetContext()->GetLiveRegistration(registration_id);
   DCHECK(registration);
 
   ServiceWorkerRegistrationObjectInfo info;
   ServiceWorkerVersionAttributes attrs;
   GetRegistrationObjectInfoAndVersionAttributes(
       provider_host->AsWeakPtr(), registration, &info, &attrs);
 
+  mojo::ScopedMessagePipeHandle url_loader_factory;
+  const bool network_service_enabled =
+      base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableNetworkService);
+  if (network_service_enabled) {
+    url_loader_factory =
+        ServiceWorkerURLLoaderFactoryCreation::InitializeForRenderer(
+            provider_host)
+            .PassHandle();
+  }
+
   Send(new ServiceWorkerMsg_ServiceWorkerRegistered(
-      thread_id, request_id, info, attrs));
+      thread_id, request_id, info, attrs, url_loader_factory.release()));
 }
 
 void ServiceWorkerDispatcherHost::UpdateComplete(
     int thread_id,
     int provider_id,
     int request_id,
     ServiceWorkerStatusCode status,
     const std::string& status_message,
     int64_t registration_id) {
   TRACE_EVENT_ASYNC_END2(
@@ skipping 156 matching lines @@
   ServiceWorkerRegistrationObjectInfo info;
   ServiceWorkerVersionAttributes attrs;
   if (status == SERVICE_WORKER_OK) {
     DCHECK(registration.get());
     if (!registration->is_uninstalling()) {
       GetRegistrationObjectInfoAndVersionAttributes(
           provider_host->AsWeakPtr(), registration.get(), &info, &attrs);
     }
   }
 
+  // TODO(scottmg): Pass url loader factory.
   Send(new ServiceWorkerMsg_DidGetRegistration(
-      thread_id, request_id, info, attrs));
+      thread_id, request_id, info, attrs, mojo::MessagePipeHandle()));
 }
 
 void ServiceWorkerDispatcherHost::GetRegistrationsComplete(
     int thread_id,
     int provider_id,
     int request_id,
     ServiceWorkerStatusCode status,
     const std::vector<scoped_refptr<ServiceWorkerRegistration>>&
         registrations) {
   TRACE_EVENT_ASYNC_END1("ServiceWorker",
@@ skipping 14 matching lines @@
                                                &error_type, &error_message);
     Send(new ServiceWorkerMsg_ServiceWorkerGetRegistrationsError(
         thread_id, request_id, error_type,
         base::ASCIIToUTF16(kServiceWorkerGetRegistrationErrorPrefix) +
             error_message));
     return;
   }
 
   std::vector<ServiceWorkerRegistrationObjectInfo> object_infos;
   std::vector<ServiceWorkerVersionAttributes> version_attrs;
+  std::vector<mojo::MessagePipeHandle> url_loader_factories;
 
   for (const auto& registration : registrations) {
     DCHECK(registration.get());
     if (!registration->is_uninstalling()) {
       ServiceWorkerRegistrationObjectInfo object_info;
       ServiceWorkerVersionAttributes version_attr;
       GetRegistrationObjectInfoAndVersionAttributes(
           provider_host->AsWeakPtr(), registration.get(), &object_info,
           &version_attr);
       object_infos.push_back(object_info);
       version_attrs.push_back(version_attr);
+      url_loader_factories.push_back(mojo::MessagePipeHandle());
     }
   }
 
+  // TODO(scottmg): Pass url loader factory.
   Send(new ServiceWorkerMsg_DidGetRegistrations(thread_id, request_id,
-                                                object_infos, version_attrs));
+                                                object_infos, version_attrs,
+                                                url_loader_factories));
 }
 
 void ServiceWorkerDispatcherHost::GetRegistrationForReadyComplete(
     int thread_id,
     int request_id,
     base::WeakPtr<ServiceWorkerProviderHost> provider_host,
     ServiceWorkerRegistration* registration) {
   DCHECK(registration);
   TRACE_EVENT_ASYNC_END1(
       "ServiceWorker", "ServiceWorkerDispatcherHost::GetRegistrationForReady",
       request_id, "Registration ID",
       registration ? registration->id() : kInvalidServiceWorkerRegistrationId);
   if (!GetContext())
     return;
 
   ServiceWorkerRegistrationObjectInfo info;
   ServiceWorkerVersionAttributes attrs;
   GetRegistrationObjectInfoAndVersionAttributes(
       provider_host, registration, &info, &attrs);
+  // TODO(scottmg): Pass url loader factory.
   Send(new ServiceWorkerMsg_DidGetRegistrationForReady(
-        thread_id, request_id, info, attrs));
+      thread_id, request_id, info, attrs, mojo::MessagePipeHandle()));
 }
 
 ServiceWorkerContextCore* ServiceWorkerDispatcherHost::GetContext() {
   if (!context_wrapper_.get())
     return nullptr;
   return context_wrapper_->context();
 }
 
 ServiceWorkerProviderHost*
 ServiceWorkerDispatcherHost::GetProviderHostForRequest(ProviderStatus* status,
@@ skipping 75 matching lines @@
   if (!handle) {
     bad_message::ReceivedBadMessage(this,
                                     bad_message::SWDH_TERMINATE_BAD_HANDLE);
     return;
   }
   handle->version()->StopWorker(
       base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
 }
 
 }  // namespace content