Support Service Worker NavigationPreload with PlzNavigate.

content/browser/service_worker/service_worker_provider_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_provider_host.h"
 
 #include <utility>
 
 #include "base/guid.h"
 #include "base/stl_util.h"
@@ skipping 34 matching lines @@
       called(false) {
 }
 
 ServiceWorkerProviderHost::OneShotGetReadyCallback::~OneShotGetReadyCallback() {
 }
 
 // static
 std::unique_ptr<ServiceWorkerProviderHost>
 ServiceWorkerProviderHost::PreCreateNavigationHost(
     base::WeakPtr<ServiceWorkerContextCore> context,
+    const MojoURLLoaderFactoryGetter& url_loader_factory_getter,
     bool are_ancestors_secure) {
   CHECK(IsBrowserSideNavigationEnabled());
   // Generate a new browser-assigned id for the host.
   int provider_id = g_next_navigation_provider_id--;
-  return std::unique_ptr<ServiceWorkerProviderHost>(
-      new ServiceWorkerProviderHost(
+  std::unique_ptr<ServiceWorkerProviderHost> host(
+      base::MakeUnique<ServiceWorkerProviderHost>(
           ChildProcessHost::kInvalidUniqueID, MSG_ROUTING_NONE, provider_id,
           SERVICE_WORKER_PROVIDER_FOR_WINDOW,
           are_ancestors_secure ? FrameSecurityLevel::SECURE
                                : FrameSecurityLevel::INSECURE,
           context, nullptr));
+  host->url_loader_factory_getter_ = url_loader_factory_getter;
+  return host;
 }
 
 ServiceWorkerProviderHost::ServiceWorkerProviderHost(
     int render_process_id,
     int route_id,
     int provider_id,
     ServiceWorkerProviderType provider_type,
     FrameSecurityLevel parent_frame_security_level,
     base::WeakPtr<ServiceWorkerContextCore> context,
     ServiceWorkerDispatcherHost* dispatcher_host)
     : client_uuid_(base::GenerateGUID()),
       render_process_id_(render_process_id),
       route_id_(route_id),
       render_thread_id_(kDocumentMainThreadId),
       provider_id_(provider_id),
       provider_type_(provider_type),
       parent_frame_security_level_(parent_frame_security_level),
       context_(context),
       dispatcher_host_(dispatcher_host),
-      allow_association_(true) {
+      allow_association_(true),
+      url_loader_factory_getter_(
+          dispatcher_host_ ? dispatcher_host_->url_loader_factory_getter()
+                           : MojoURLLoaderFactoryGetter()) {
   DCHECK_NE(SERVICE_WORKER_PROVIDER_UNKNOWN, provider_type_);
 
   // PlzNavigate
   CHECK(render_process_id != ChildProcessHost::kInvalidUniqueID ||
         IsBrowserSideNavigationEnabled());
 
   if (provider_type_ == SERVICE_WORKER_PROVIDER_FOR_CONTROLLER) {
     // Actual thread id is set when the service worker context gets started.
     render_thread_id_ = kInvalidEmbeddedWorkerThreadId;
   }
@@ skipping 238 matching lines @@
     RequestContextFrameType frame_type,
     base::WeakPtr<storage::BlobStorageContext> blob_storage_context,
     scoped_refptr<ResourceRequestBodyImpl> body) {
   if (IsHostToRunningServiceWorker()) {
     return std::unique_ptr<ServiceWorkerRequestHandler>(
         new ServiceWorkerContextRequestHandler(
             context_, AsWeakPtr(), blob_storage_context, resource_type));
   }
   if (ServiceWorkerUtils::IsMainResourceType(resource_type) ||
       controlling_version()) {
-    // |dispatcher_host_| may be null in some unittests.
     return std::unique_ptr<ServiceWorkerRequestHandler>(
         new ServiceWorkerControlleeRequestHandler(
             context_, AsWeakPtr(), blob_storage_context, request_mode,
             credentials_mode, redirect_mode, resource_type,
             request_context_type, frame_type, body,
-            dispatcher_host_ ? dispatcher_host_->url_loader_factory_getter()
-                             : MojoURLLoaderFactoryGetter()));
+            url_loader_factory_getter_));
   }
   return std::unique_ptr<ServiceWorkerRequestHandler>();
 }
 
 ServiceWorkerObjectInfo
 ServiceWorkerProviderHost::GetOrCreateServiceWorkerHandle(
     ServiceWorkerVersion* version) {
   DCHECK(dispatcher_host_);
   if (!context_ || !version)
     return ServiceWorkerObjectInfo();
@@ skipping 89 matching lines @@
           render_thread_id_, provider_id()));
     }
   }
 
   render_process_id_ = ChildProcessHost::kInvalidUniqueID;
   route_id_ = MSG_ROUTING_NONE;
   render_thread_id_ = kInvalidEmbeddedWorkerThreadId;
   provider_id_ = kInvalidServiceWorkerProviderId;
   provider_type_ = SERVICE_WORKER_PROVIDER_UNKNOWN;
   dispatcher_host_ = nullptr;
+  url_loader_factory_getter_ = MojoURLLoaderFactoryGetter();
 }
 
 void ServiceWorkerProviderHost::CompleteCrossSiteTransfer(
     int new_process_id,
     int new_frame_id,
     int new_provider_id,
     ServiceWorkerProviderType new_provider_type,
     ServiceWorkerDispatcherHost* new_dispatcher_host) {
   DCHECK_EQ(ChildProcessHost::kInvalidUniqueID, render_process_id_);
   DCHECK_NE(ChildProcessHost::kInvalidUniqueID, new_process_id);
@@ skipping 183 matching lines @@
 void ServiceWorkerProviderHost::Send(IPC::Message* message) const {
   DCHECK(dispatcher_host_);
   DCHECK(IsReadyToSendMessages());
   dispatcher_host_->Send(message);
 }
 
 void ServiceWorkerProviderHost::FinalizeInitialization(
     int process_id,
     int frame_routing_id,
     ServiceWorkerDispatcherHost* dispatcher_host) {
+  DCHECK(dispatcher_host);
   render_process_id_ = process_id;
   route_id_ = frame_routing_id;
   dispatcher_host_ = dispatcher_host;
+  url_loader_factory_getter_ = dispatcher_host_->url_loader_factory_getter();
 
   for (const GURL& pattern : associated_patterns_)
     IncreaseProcessReference(pattern);
 
   for (auto& key_registration : matching_registrations_)
     IncreaseProcessReference(key_registration.second->pattern());
 
   if (associated_registration_.get()) {
     SendAssociateRegistrationMessage();
-    if (dispatcher_host_ && associated_registration_->active_version()) {
+    if (associated_registration_->active_version()) {
       Send(new ServiceWorkerMsg_SetControllerServiceWorker(
           render_thread_id_, provider_id(),
           GetOrCreateServiceWorkerHandle(
               associated_registration_->active_version()),
           false /* shouldNotifyControllerChange */));
     }
   }
 }
 
 }  // namespace content