network service: pass a URLLoaderFactory to renderers on SW registration

content/child/service_worker/service_worker_dispatcher.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/child/service_worker/service_worker_dispatcher.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/lazy_instance.h"
@@ skipping 403 matching lines @@
   ProviderContextMap::iterator provider = provider_contexts_.find(provider_id);
   if (provider == provider_contexts_.end())
     return;
   provider->second->OnDisassociateRegistration();
 }
 
 void ServiceWorkerDispatcher::OnRegistered(
     int thread_id,
     int request_id,
     const ServiceWorkerRegistrationObjectInfo& info,
-    const ServiceWorkerVersionAttributes& attrs) {
+    const ServiceWorkerVersionAttributes& attrs,
+    const mojo::MessagePipeHandle& url_loader_factory) {
   TRACE_EVENT_ASYNC_STEP_INTO0("ServiceWorker",
                                "ServiceWorkerDispatcher::RegisterServiceWorker",
                                request_id,
                                "OnRegistered");
   TRACE_EVENT_ASYNC_END0("ServiceWorker",
                          "ServiceWorkerDispatcher::RegisterServiceWorker",
                          request_id);
   WebServiceWorkerRegistrationCallbacks* callbacks =
       pending_registration_callbacks_.Lookup(request_id);
   DCHECK(callbacks);
   if (!callbacks)
     return;
 
+  if (url_loader_factory.is_valid()) {
+    // Chrome doesn't use interface versioning.
+    url_loader_factory_.Bind(mojom::URLLoaderFactoryPtrInfo(
+        mojo::ScopedMessagePipeHandle(url_loader_factory), 0u));
+  }
+
   callbacks->OnSuccess(WebServiceWorkerRegistrationImpl::CreateHandle(
       GetOrAdoptRegistration(info, attrs)));
   pending_registration_callbacks_.Remove(request_id);
 }
 
 void ServiceWorkerDispatcher::OnUpdated(int thread_id, int request_id) {
   TRACE_EVENT_ASYNC_STEP_INTO0("ServiceWorker",
                                "ServiceWorkerDispatcher::UpdateServiceWorker",
                                request_id, "OnUpdated");
   TRACE_EVENT_ASYNC_END0("ServiceWorker",
@@ skipping 26 matching lines @@
   if (!callbacks)
     return;
   callbacks->OnSuccess(is_success);
   pending_unregistration_callbacks_.Remove(request_id);
 }
 
 void ServiceWorkerDispatcher::OnDidGetRegistration(
     int thread_id,
     int request_id,
     const ServiceWorkerRegistrationObjectInfo& info,
-    const ServiceWorkerVersionAttributes& attrs) {
+    const ServiceWorkerVersionAttributes& attrs,
+    const mojo::MessagePipeHandle& url_loader_factory) {
   TRACE_EVENT_ASYNC_STEP_INTO0(
       "ServiceWorker",
       "ServiceWorkerDispatcher::GetRegistration",
       request_id,
       "OnDidGetRegistration");
   TRACE_EVENT_ASYNC_END0("ServiceWorker",
                          "ServiceWorkerDispatcher::GetRegistration",
                          request_id);
   WebServiceWorkerGetRegistrationCallbacks* callbacks =
       pending_get_registration_callbacks_.Lookup(request_id);
   DCHECK(callbacks);
   if (!callbacks)
     return;
 
   scoped_refptr<WebServiceWorkerRegistrationImpl> registration;
   if (info.handle_id != kInvalidServiceWorkerRegistrationHandleId)
     registration = GetOrAdoptRegistration(info, attrs);
 
+  // TODO(scottmg) factory
+
   callbacks->OnSuccess(
       WebServiceWorkerRegistrationImpl::CreateHandle(registration));
   pending_get_registration_callbacks_.Remove(request_id);
 }
 
 void ServiceWorkerDispatcher::OnDidGetRegistrations(
     int thread_id,
     int request_id,
     const std::vector<ServiceWorkerRegistrationObjectInfo>& infos,
-    const std::vector<ServiceWorkerVersionAttributes>& attrs) {
+    const std::vector<ServiceWorkerVersionAttributes>& attrs,
+    const std::vector<mojo::MessagePipeHandle>& url_loader_factories) {
   TRACE_EVENT_ASYNC_STEP_INTO0(
       "ServiceWorker",
       "ServiceWorkerDispatcher::GetRegistrations",
       request_id,
       "OnDidGetRegistrations");
   TRACE_EVENT_ASYNC_END0("ServiceWorker",
                          "ServiceWorkerDispatcher::GetRegistrations",
                          request_id);
 
   WebServiceWorkerGetRegistrationsCallbacks* callbacks =
       pending_get_registrations_callbacks_.Lookup(request_id);
   DCHECK(callbacks);
   if (!callbacks)
     return;
 
+  // TODO(scottmg) factory
+
   using WebServiceWorkerRegistrationHandles =
       WebServiceWorkerProvider::WebServiceWorkerRegistrationHandles;
   std::unique_ptr<WebServiceWorkerRegistrationHandles> registrations =
       base::MakeUnique<WebServiceWorkerRegistrationHandles>(infos.size());
   for (size_t i = 0; i < infos.size(); ++i) {
     if (infos[i].handle_id == kInvalidServiceWorkerHandleId)
       continue;
     (*registrations)[i] = WebServiceWorkerRegistrationImpl::CreateHandle(
         GetOrAdoptRegistration(infos[i], attrs[i]));
   }
 
   callbacks->OnSuccess(std::move(registrations));
   pending_get_registrations_callbacks_.Remove(request_id);
 }
 
 void ServiceWorkerDispatcher::OnDidGetRegistrationForReady(
     int thread_id,
     int request_id,
     const ServiceWorkerRegistrationObjectInfo& info,
-    const ServiceWorkerVersionAttributes& attrs) {
+    const ServiceWorkerVersionAttributes& attrs,
+    const mojo::MessagePipeHandle& url_loader_factory) {
   TRACE_EVENT_ASYNC_STEP_INTO0(
       "ServiceWorker",
       "ServiceWorkerDispatcher::GetRegistrationForReady",
       request_id,
       "OnDidGetRegistrationForReady");
   TRACE_EVENT_ASYNC_END0("ServiceWorker",
                          "ServiceWorkerDispatcher::GetRegistrationForReady",
                          request_id);
   WebServiceWorkerGetRegistrationForReadyCallbacks* callbacks =
       get_for_ready_callbacks_.Lookup(request_id);
   DCHECK(callbacks);
   if (!callbacks)
     return;
 
+  // TODO(scottmg): factory
+
   callbacks->OnSuccess(WebServiceWorkerRegistrationImpl::CreateHandle(
       GetOrAdoptRegistration(info, attrs)));
   get_for_ready_callbacks_.Remove(request_id);
 }
 
 void ServiceWorkerDispatcher::OnDidEnableNavigationPreload(int thread_id,
                                                            int request_id) {
   WebEnableNavigationPreloadCallbacks* callbacks =
       enable_navigation_preload_callbacks_.Lookup(request_id);
   DCHECK(callbacks);
@@ skipping 350 matching lines @@
   return ServiceWorkerRegistrationHandleReference::Adopt(
       info, thread_safe_sender_.get());
 }
 
 std::unique_ptr<ServiceWorkerHandleReference> ServiceWorkerDispatcher::Adopt(
     const ServiceWorkerObjectInfo& info) {
   return ServiceWorkerHandleReference::Adopt(info, thread_safe_sender_.get());
 }
 
 }  // namespace content