PlzNavigate: Make ServiceWorker work with PlzNavigate.

content/browser/loader/resource_dispatcher_host_impl.cc

 // Copyright (c) 2012 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.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 
 #include <algorithm>
 #include <set>
@@ skipping 35 matching lines @@
 #include "content/browser/loader/redirect_to_file_resource_handler.h"
 #include "content/browser/loader/resource_message_filter.h"
 #include "content/browser/loader/resource_request_info_impl.h"
 #include "content/browser/loader/stream_resource_handler.h"
 #include "content/browser/loader/sync_resource_handler.h"
 #include "content/browser/loader/throttling_resource_handler.h"
 #include "content/browser/loader/upload_data_stream_builder.h"
 #include "content/browser/renderer_host/render_view_host_delegate.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/resource_context_impl.h"
+#include "content/browser/service_worker/service_worker_provider_host.h"
 #include "content/browser/service_worker/service_worker_request_handler.h"
 #include "content/browser/streams/stream.h"
 #include "content/browser/streams/stream_context.h"
 #include "content/browser/streams/stream_registry.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/common/appcache_interfaces.h"
 #include "content/common/navigation_params.h"
 #include "content/common/resource_messages.h"
 #include "content/common/site_isolation_policy.h"
 #include "content/common/ssl_status_serialization.h"
@@ skipping 1287 matching lines @@
 
   // Initialize the service worker handler for the request. We don't use
   // ServiceWorker for synchronous loads to avoid renderer deadlocks.
   ServiceWorkerRequestHandler::InitializeHandler(
       new_request.get(), filter_->service_worker_context(), blob_context,
       child_id, request_data.service_worker_provider_id,
       request_data.skip_service_worker || is_sync_load,
       request_data.fetch_request_mode, request_data.fetch_credentials_mode,
       request_data.fetch_redirect_mode, request_data.resource_type,
       request_data.fetch_request_context_type, request_data.fetch_frame_type,
-      request_data.request_body);
+      request_data.request_body, nullptr);
 
   // Have the appcache associate its extra info with the request.
   AppCacheInterceptor::SetExtraRequestInfo(
       new_request.get(), filter_->appcache_service(), child_id,
       request_data.appcache_host_id, request_data.resource_type,
       request_data.should_reset_appcache);
 
   scoped_ptr<ResourceHandler> handler(
        CreateResourceHandler(
            new_request.get(),
@@ skipping 550 matching lines @@
 void ResourceDispatcherHostImpl::FinishedWithResourcesForRequest(
     net::URLRequest* request) {
   ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest(request);
   IncrementOutstandingRequestsCount(-1, info);
 }
 
 void ResourceDispatcherHostImpl::BeginNavigationRequest(
     ResourceContext* resource_context,
     int frame_tree_node_id,
     const NavigationRequestInfo& info,
-    NavigationURLLoaderImplCore* loader) {
+    NavigationURLLoaderImplCore* loader,
+    ServiceWorkerContextWrapper* service_worker_context) {
   // PlzNavigate: BeginNavigationRequest currently should only be used for the
   // browser-side navigations project.
   CHECK(base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableBrowserSideNavigation));
 
   ResourceType resource_type = info.is_main_frame ?
       RESOURCE_TYPE_MAIN_FRAME : RESOURCE_TYPE_SUB_FRAME;
 
   if (is_shutdown_ ||
       // TODO(davidben): Check ShouldServiceRequest here. This is important; it
@@ skipping 44 matching lines @@
   }
 
   SetReferrerForRequest(new_request.get(), info.common_params.referrer);
 
   net::HttpRequestHeaders headers;
   headers.AddHeadersFromString(info.begin_params.headers);
   new_request->SetExtraRequestHeaders(headers);
 
   new_request->SetLoadFlags(load_flags);
 
+  storage::BlobStorageContext* blob_context = GetBlobStorageContext(
+      GetChromeBlobStorageContextForResourceContext(resource_context));
+
   // Resolve elements from request_body and prepare upload data.
   if (info.request_body.get()) {
-    storage::BlobStorageContext* blob_context = GetBlobStorageContext(
-        GetChromeBlobStorageContextForResourceContext(resource_context));
     AttachRequestBodyBlobDataHandles(
         info.request_body.get(),
         blob_context);
     // TODO(davidben): The FileSystemContext is null here. In the case where
     // another renderer requested this navigation, this should be the same
     // FileSystemContext passed into ShouldServiceRequest.
     new_request->set_upload(UploadDataStreamBuilder::Build(
         info.request_body.get(),
         blob_context,
         nullptr,  // file_system_context
@@ skipping 45 matching lines @@
   if (new_request->url().SchemeIs(url::kBlobScheme)) {
     // Hang on to a reference to ensure the blob is not released prior
     // to the job being started.
     ChromeBlobStorageContext* blob_context =
         GetChromeBlobStorageContextForResourceContext(resource_context);
     storage::BlobProtocolHandler::SetRequestedBlobDataHandle(
         new_request.get(),
         blob_context->context()->GetBlobDataFromPublicURL(new_request->url()));
   }
 
-  // TODO(davidben): Attach ServiceWorkerRequestHandler.
-  // TODO(michaeln): Help out with this and that.
+  RequestContextFrameType frame_type = info.is_main_frame ?
+      REQUEST_CONTEXT_FRAME_TYPE_TOP_LEVEL :
+      REQUEST_CONTEXT_FRAME_TYPE_NESTED;
+  // TODO: sync loads should set skip_service_worker to true.
+  ServiceWorkerRequestHandler::InitializeHandler(

[michaeln, 2015/09/16 00:56:42]

I think it'd be worth creating a new Init method for this case in particular
instead of swiss-army-knifing the existing method. Considerably more needs to
happen now in addition to creating a handler and associating it with the request
object.

ServiceWorkerRequestHandler::InitializeForNavigationRequest
- pre-create a providerhost instance with the no-process-id
- stash a ptr to it in the |core|->AddNavigationProviderHost(p)
- create and init the handler (akin to what InitializeHandler does today)
- assign ownership of the newly created providerhost to the handler

[Fabrice (no longer in Chrome), 2015/09/30 17:32:07]

Done.

+      new_request.get(),
+      service_worker_context,
+      blob_context,
+      (filter_ != nullptr) ? filter_->child_id() : -1,
+      info.common_params.service_worker_provider_id,
+      info.begin_params.skip_service_worker,
+      FETCH_REQUEST_MODE_NO_CORS,
+      FETCH_CREDENTIALS_MODE_SAME_ORIGIN,
+      FetchRedirectMode::FOLLOW_MODE,
+      resource_type,
+      info.begin_params.request_context_type,
+      frame_type,
+      info.request_body,
+      loader);
+
   // TODO(davidben): Attach AppCacheInterceptor.
 
   scoped_ptr<ResourceHandler> handler(new NavigationResourceHandler(
       new_request.get(), loader));
 
   // TODO(davidben): Pass in the appropriate appcache_service. Also fix the
   // dependency on child_id/route_id. Those are used by the ResourceScheduler;
   // currently it's a no-op.
   handler = AddStandardHandlers(new_request.get(), resource_type,
                                 resource_context,
@@ skipping 320 matching lines @@
     load_flags |= net::LOAD_PREFETCH;
   }
 
   if (is_sync_load)
     load_flags |= net::LOAD_IGNORE_LIMITS;
 
   return load_flags;
 }
 
 }  // namespace content