network service: Create URLLoader for service worker navigation case

content/browser/service_worker/service_worker_request_handler.cc

 // Copyright 2014 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_request_handler.h"
 
 #include <string>
 #include <utility>
 
 #include "base/macros.h"
@@ skipping 37 matching lines @@
       return NULL;
     return handler->MaybeCreateJob(
         request, network_delegate, resource_context_);
   }
 
  private:
   ResourceContext* resource_context_;
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerRequestInterceptor);
 };
 
+void AttachToURLRequest(net::URLRequest* url_request,
+                        std::unique_ptr<ServiceWorkerRequestHandler> handler) {
+  url_request->SetUserData(&kUserDataKey, std::move(handler));
+}
+
+void CreateURLLoader(mojom::URLLoaderFactoryPtrInfo* url_loader_factory_info,
+                     const ResourceRequest& resource_request,
+                     ResourceContext* resource_context,
+                     std::unique_ptr<ServiceWorkerRequestHandler> handler) {
+  *url_loader_factory_info = handler->MaybeCreateURLLoader(
+      resource_request, resource_context, std::move(handler));
+}
+
 void FinalizeHandlerInitialization(
-    net::URLRequest* request,
     ServiceWorkerProviderHost* provider_host,
     storage::BlobStorageContext* blob_storage_context,
     bool skip_service_worker,
     FetchRequestMode request_mode,
     FetchCredentialsMode credentials_mode,
     FetchRedirectMode redirect_mode,
     ResourceType resource_type,
     RequestContextType request_context_type,
     RequestContextFrameType frame_type,
-    scoped_refptr<ResourceRequestBodyImpl> body) {
+    scoped_refptr<ResourceRequestBodyImpl> body,
+    const ServiceWorkerRequestHandler::HandlerCreated& on_created) {
   std::unique_ptr<ServiceWorkerRequestHandler> handler(
       provider_host->CreateRequestHandler(
           request_mode, credentials_mode, redirect_mode, resource_type,
           request_context_type, frame_type, blob_storage_context->AsWeakPtr(),
           body, skip_service_worker));
   if (!handler)
     return;
 
-  request->SetUserData(&kUserDataKey, std::move(handler));
+  on_created.Run(std::move(handler));

[kinuko, 2017/05/08 14:55:47]

I think this method and InitializeForNavigationInternal can return SWReqHandler
and the caller (InitializeForNavigation*) can call either AttachToURLRequest or
CreateURLLoader, which is easier to follow?

[scottmg, 2017/05/08 20:12:31]

The only reason I did that the complicated way was that the call to
navigation_handle_core->DidCreateProviderHost() now occurs before
AttachToURLRequest/CreateURLLoader. However, looking at what it does, this seems
to be OK, so I've updated it to the more direct method you suggested.

In fact, FinalizeHandlerInitialization() wasn't doing anything useful any more,
so I just called provider_host->CreateRequestHandler() directly.

 }
 
 }  // namespace
 
 // PlzNavigate
 void ServiceWorkerRequestHandler::InitializeForNavigation(
-    net::URLRequest* request,
+    net::URLRequest* url_request,
     ServiceWorkerNavigationHandleCore* navigation_handle_core,
     storage::BlobStorageContext* blob_storage_context,
     bool skip_service_worker,
     ResourceType resource_type,
     RequestContextType request_context_type,
     RequestContextFrameType frame_type,
     bool is_parent_frame_secure,
     scoped_refptr<ResourceRequestBodyImpl> body,
     const base::Callback<WebContents*(void)>& web_contents_getter) {
-  CHECK(IsBrowserSideNavigationEnabled());
+  InitializeForNavigationImpl(url_request->url(), navigation_handle_core,
+                              blob_storage_context, skip_service_worker,
+                              resource_type, request_context_type, frame_type,
+                              is_parent_frame_secure, body, web_contents_getter,
+                              base::Bind(&AttachToURLRequest, url_request));
+}
 
-  // Only create a handler when there is a ServiceWorkerNavigationHandlerCore
-  // to take ownership of a pre-created SeviceWorkerProviderHost.
-  if (!navigation_handle_core)
-    return;
-
-  // Create the handler even for insecure HTTP since it's used in the
-  // case of redirect to HTTPS.
-  if (!request->url().SchemeIsHTTPOrHTTPS() &&
-      !OriginCanAccessServiceWorkers(request->url())) {
-    return;
-  }
-
-  if (!navigation_handle_core->context_wrapper() ||
-      !navigation_handle_core->context_wrapper()->context()) {
-    return;
-  }
-
-  // Initialize the SWProviderHost.
-  std::unique_ptr<ServiceWorkerProviderHost> provider_host =
-      ServiceWorkerProviderHost::PreCreateNavigationHost(
-          navigation_handle_core->context_wrapper()->context()->AsWeakPtr(),
-          is_parent_frame_secure, web_contents_getter);
-
-  FinalizeHandlerInitialization(
-      request, provider_host.get(), blob_storage_context, skip_service_worker,
-      FETCH_REQUEST_MODE_NAVIGATE, FETCH_CREDENTIALS_MODE_INCLUDE,
-      FetchRedirectMode::MANUAL_MODE, resource_type, request_context_type,
-      frame_type, body);
-
-  // Transfer ownership to the ServiceWorkerNavigationHandleCore.
-  // In the case of a successful navigation, the SWProviderHost will be
-  // transferred to its "final" destination in the OnProviderCreated handler. If
-  // the navigation fails, it will be destroyed along with the
-  // ServiceWorkerNavigationHandleCore.
-  navigation_handle_core->DidPreCreateProviderHost(std::move(provider_host));
+// PlzNavigate and --enable-network-service
+mojom::URLLoaderFactoryPtrInfo
+ServiceWorkerRequestHandler::InitializeForNavigationNetworkService(
+    const ResourceRequest& resource_request,
+    ResourceContext* resource_context,
+    ServiceWorkerNavigationHandleCore* navigation_handle_core,
+    storage::BlobStorageContext* blob_storage_context,
+    bool skip_service_worker,
+    ResourceType resource_type,
+    RequestContextType request_context_type,
+    RequestContextFrameType frame_type,
+    bool is_parent_frame_secure,
+    scoped_refptr<ResourceRequestBodyImpl> body,
+    const base::Callback<WebContents*(void)>& web_contents_getter) {
+  mojom::URLLoaderFactoryPtrInfo result;
+  InitializeForNavigationImpl(resource_request.url, navigation_handle_core,
+                              blob_storage_context, skip_service_worker,
+                              resource_type, request_context_type, frame_type,
+                              is_parent_frame_secure, body, web_contents_getter,
+                              base::Bind(&CreateURLLoader, &result,
+                                         resource_request, resource_context));
+  return std::move(result);
 }
 
 void ServiceWorkerRequestHandler::InitializeHandler(
     net::URLRequest* request,
     ServiceWorkerContextWrapper* context_wrapper,
     storage::BlobStorageContext* blob_storage_context,
     int process_id,
     int provider_id,
     bool skip_service_worker,
     FetchRequestMode request_mode,
@@ skipping 13 matching lines @@
   if (!context_wrapper || !context_wrapper->context() ||
       provider_id == kInvalidServiceWorkerProviderId) {
     return;
   }
 
   ServiceWorkerProviderHost* provider_host =
       context_wrapper->context()->GetProviderHost(process_id, provider_id);
   if (!provider_host || !provider_host->IsContextAlive())
     return;
 
-  FinalizeHandlerInitialization(request, provider_host, blob_storage_context,
-                                skip_service_worker, request_mode,
-                                credentials_mode, redirect_mode, resource_type,
-                                request_context_type, frame_type, body);
+  FinalizeHandlerInitialization(
+      provider_host, blob_storage_context, skip_service_worker, request_mode,
+      credentials_mode, redirect_mode, resource_type, request_context_type,
+      frame_type, body, base::Bind(&AttachToURLRequest, request));
 }
 
 ServiceWorkerRequestHandler* ServiceWorkerRequestHandler::GetHandler(
     const net::URLRequest* request) {
   return static_cast<ServiceWorkerRequestHandler*>(
       request->GetUserData(&kUserDataKey));
 }
 
 std::unique_ptr<net::URLRequestInterceptor>
 ServiceWorkerRequestHandler::CreateInterceptor(
@@ skipping 66 matching lines @@
     base::WeakPtr<storage::BlobStorageContext> blob_storage_context,
     ResourceType resource_type)
     : context_(context),
       provider_host_(provider_host),
       blob_storage_context_(blob_storage_context),
       resource_type_(resource_type),
       old_process_id_(0),
       old_provider_id_(kInvalidServiceWorkerProviderId) {
 }
 
+void ServiceWorkerRequestHandler::InitializeForNavigationImpl(
+    const GURL& url,
+    ServiceWorkerNavigationHandleCore* navigation_handle_core,
+    storage::BlobStorageContext* blob_storage_context,
+    bool skip_service_worker,
+    ResourceType resource_type,
+    RequestContextType request_context_type,
+    RequestContextFrameType frame_type,
+    bool is_parent_frame_secure,
+    scoped_refptr<ResourceRequestBodyImpl> body,
+    const base::Callback<WebContents*(void)>& web_contents_getter,
+    const HandlerCreated& on_handler_created) {
+  CHECK(IsBrowserSideNavigationEnabled());
+
+  // Only create a handler when there is a ServiceWorkerNavigationHandlerCore
+  // to take ownership of a pre-created SeviceWorkerProviderHost.
+  if (!navigation_handle_core)
+    return;
+
+  // Create the handler even for insecure HTTP since it's used in the
+  // case of redirect to HTTPS.
+  if (!url.SchemeIsHTTPOrHTTPS() && !OriginCanAccessServiceWorkers(url)) {
+    return;
+  }
+
+  if (!navigation_handle_core->context_wrapper() ||
+      !navigation_handle_core->context_wrapper()->context()) {
+    return;
+  }
+
+  // Initialize the SWProviderHost.
+  std::unique_ptr<ServiceWorkerProviderHost> provider_host =
+      ServiceWorkerProviderHost::PreCreateNavigationHost(
+          navigation_handle_core->context_wrapper()->context()->AsWeakPtr(),
+          is_parent_frame_secure, web_contents_getter);
+
+  FinalizeHandlerInitialization(
+      provider_host.get(), blob_storage_context, skip_service_worker,
+      FETCH_REQUEST_MODE_NAVIGATE, FETCH_CREDENTIALS_MODE_INCLUDE,
+      FetchRedirectMode::MANUAL_MODE, resource_type, request_context_type,
+      frame_type, body, on_handler_created);
+
+  // Transfer ownership to the ServiceWorkerNavigationHandleCore.
+  // In the case of a successful navigation, the SWProviderHost will be
+  // transferred to its "final" destination in the OnProviderCreated handler. If
+  // the navigation fails, it will be destroyed along with the
+  // ServiceWorkerNavigationHandleCore.
+  navigation_handle_core->DidPreCreateProviderHost(std::move(provider_host));
+}
+
 }  // namespace content