PlzNavigate: Make ServiceWorker work with PlzNavigate.

content/renderer/render_frame_impl.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/renderer/render_frame_impl.h"
 
 #include <map>
 #include <string>
 
 #include "base/auto_reset.h"
@@ skipping 24 matching lines @@
 #include "content/child/webmessageportchannel_impl.h"
 #include "content/child/websocket_bridge.h"
 #include "content/child/weburlresponse_extradata_impl.h"
 #include "content/common/accessibility_messages.h"
 #include "content/common/clipboard_messages.h"
 #include "content/common/frame_messages.h"
 #include "content/common/frame_replication_state.h"
 #include "content/common/input_messages.h"
 #include "content/common/navigation_params.h"
 #include "content/common/service_worker/service_worker_types.h"
+#include "content/common/service_worker/service_worker_utils.h"
 #include "content/common/site_isolation_policy.h"
 #include "content/common/swapped_out_messages.h"
 #include "content/common/view_messages.h"
 #include "content/public/common/bindings_policy.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/context_menu_params.h"
 #include "content/public/common/isolated_world_ids.h"
 #include "content/public/common/page_state.h"
 #include "content/public/common/resource_response.h"
@@ skipping 2522 matching lines @@
         document_state->set_load_type(DocumentState::LINK_LOAD_CACHE_ONLY);
         break;
       default:
         NOTREACHED();
     }
   }
 
   // Create the serviceworker's per-document network observing object if it
   // does not exist (When navigation happens within a page, the provider already
   // exists).
-  if (!ServiceWorkerNetworkProvider::FromDocumentState(
-          DocumentState::FromDataSource(datasource))) {
-    ServiceWorkerProviderType provider_type =
-        SERVICE_WORKER_PROVIDER_FOR_WINDOW;
+  if (ServiceWorkerNetworkProvider::FromDocumentState(
+          DocumentState::FromDataSource(datasource)))
+    return;
+
+  bool browser_side_navigation =
+      base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableBrowserSideNavigation);
+  scoped_ptr<ServiceWorkerNetworkProvider> network_provider;
+
+  if (browser_side_navigation && content_initiated) {

[michaeln, 2015/10/08 02:18:51]

thnx for restructuring this code, the different cases are a lot easier to follow
now

+    // PlzNavigate
+    // Initialize an empty ServiceWorkerNetworkProvider.

[michaeln, 2015/10/08 02:18:51]

nit: this comment isn't needed, it states the obvious

A comment that explains how there are two calls to this methods for two
different objects, one prior to sending the message requesting the browser to
navigate, and another after when committing the navigation, would help.

+    network_provider = scoped_ptr<ServiceWorkerNetworkProvider>(
+        new ServiceWorkerNetworkProvider());
+  } else if (browser_side_navigation && !content_initiated) {
+    // PlzNavigate
+    // Retrieve the service_worker_provider_id from the RequestNavigationParams.

[michaeln, 2015/10/08 02:18:51]

nit: also stating the obvious

+    NavigationStateImpl* navigation_state = static_cast<NavigationStateImpl*>(
+        DocumentState::FromDataSource(datasource)->navigation_state());
+    int service_worker_provider_id =
+        navigation_state->request_params().service_worker_provider_id;
+
+    // The browser sets service_worker_provider_id to
+    // kInvalidServiceWorkerProviderId for sandboxed frames.
+    if (service_worker_provider_id == kInvalidServiceWorkerProviderId) {
+      network_provider = scoped_ptr<ServiceWorkerNetworkProvider>(
+          new ServiceWorkerNetworkProvider());
+    } else {
+      DCHECK(ServiceWorkerUtils::IsBrowserAssignedProviderId(
+          service_worker_provider_id));
+      network_provider = scoped_ptr<ServiceWorkerNetworkProvider>(
+          new ServiceWorkerNetworkProvider(
+              routing_id_, SERVICE_WORKER_PROVIDER_FOR_WINDOW,
+              service_worker_provider_id));
+    }
+  } else {
     if ((frame->effectiveSandboxFlags() & blink::WebSandboxFlags::Origin) ==
         blink::WebSandboxFlags::Origin) {
-      provider_type = SERVICE_WORKER_PROVIDER_FOR_SANDBOXED_FRAME;
+      network_provider = scoped_ptr<ServiceWorkerNetworkProvider>(
+          new ServiceWorkerNetworkProvider(
+              routing_id_, SERVICE_WORKER_PROVIDER_FOR_SANDBOXED_FRAME));

[michaeln, 2015/10/08 02:18:51]

nit: could use the empty ctor here too so its clear that what you get on line
2164 matches what you get here

+    } else {
+      network_provider = scoped_ptr<ServiceWorkerNetworkProvider>(
+          new ServiceWorkerNetworkProvider(
+              routing_id_, SERVICE_WORKER_PROVIDER_FOR_WINDOW));
     }
-    scoped_ptr<ServiceWorkerNetworkProvider> network_provider(
-        new ServiceWorkerNetworkProvider(routing_id_, provider_type));
-    ServiceWorkerNetworkProvider::AttachToDocumentState(
-        DocumentState::FromDataSource(datasource),
-        network_provider.Pass());
   }
+
+  ServiceWorkerNetworkProvider::AttachToDocumentState(
+      DocumentState::FromDataSource(datasource), network_provider.Pass());
 }
 
 void RenderFrameImpl::didStartProvisionalLoad(blink::WebLocalFrame* frame,
                                               double triggering_event_time) {
   DCHECK(!frame_ || frame_ == frame);
   WebDataSource* ds = frame->provisionalDataSource();
 
   // In fast/loader/stop-provisional-loads.html, we abort the load before this
   // callback is invoked.
   if (!ds)
@@ skipping 727 matching lines @@
 
   int provider_id = kInvalidServiceWorkerProviderId;
   if (request.frameType() == blink::WebURLRequest::FrameTypeTopLevel ||
       request.frameType() == blink::WebURLRequest::FrameTypeNested) {
     // |provisionalDataSource| may be null in some content::ResourceFetcher
     // use cases, we don't hook those requests.
     if (frame->provisionalDataSource()) {
       ServiceWorkerNetworkProvider* provider =
           ServiceWorkerNetworkProvider::FromDocumentState(
               DocumentState::FromDataSource(frame->provisionalDataSource()));
+      DCHECK(provider);
       provider_id = provider->provider_id();
     }
   } else if (frame->dataSource()) {
     ServiceWorkerNetworkProvider* provider =
         ServiceWorkerNetworkProvider::FromDocumentState(
             DocumentState::FromDataSource(frame->dataSource()));
+    DCHECK(provider);
     provider_id = provider->provider_id();
     // Explicitly set the SkipServiceWorker flag here if the renderer process
     // hasn't received SetControllerServiceWorker message.
     if (!provider->IsControlledByServiceWorker())
       request.setSkipServiceWorker(true);
   }
 
   WebFrame* parent = frame->parent();
   int parent_routing_id = MSG_ROUTING_NONE;
   if (!parent) {
@@ skipping 1850 matching lines @@
   mojo::ServiceProviderPtr service_provider(21);
   mojo::URLRequestPtr request(mojo::URLRequest::New());
   request->url = mojo::String::From(url);
   mojo_shell_->ConnectToApplication(request.Pass(), GetProxy(&service_provider),
                                     nullptr, nullptr,
                                     base::Bind(&OnGotContentHandlerID));
   return service_provider.Pass();
 }
 
 }  // namespace content