[Proof-of-concept] PlzNavigate and Service Worker

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 395 matching lines @@
 
     if (url.GetOrigin() != GURL(opener->document().url()).GetOrigin())
       return true;
   }
   return false;
 }
 
 WebURLRequest CreateURLRequestForNavigation(
     const CommonNavigationParams& common_params,
     scoped_ptr<StreamOverrideParameters> stream_override,
+    int navigation_provider_id,
     bool is_view_source_mode_enabled) {
   WebURLRequest request(common_params.url);
   if (is_view_source_mode_enabled)
     request.setCachePolicy(WebURLRequest::ReturnCacheDataElseLoad);
 
   if (common_params.referrer.url.is_valid()) {
     WebString web_referrer = WebSecurityPolicy::generateReferrerHeader(
         common_params.referrer.policy,
         common_params.url,
         WebString::fromUTF8(common_params.referrer.url.spec()));
     if (!web_referrer.isEmpty())
       request.setHTTPReferrer(web_referrer, common_params.referrer.policy);
   }
 
   RequestExtraData* extra_data = new RequestExtraData();
   extra_data->set_stream_override(stream_override.Pass());
+  extra_data->set_navigation_provider_id(navigation_provider_id);
   request.setExtraData(extra_data);
 
   // Set the ui timestamp for this navigation. Currently the timestamp here is
   // only non empty when the navigation was triggered by an Android intent. The
   // timestamp is converted to a double version supported by blink. It will be
   // passed back to the browser in the DidCommitProvisionalLoad and the
   // DocumentLoadComplete IPCs.
   base::TimeDelta ui_timestamp = common_params.ui_timestamp - base::TimeTicks();
   request.setUiStartTime(ui_timestamp.InSecondsF());
   request.setInputPerfMetricReportPolicy(
@@ skipping 628 matching lines @@
 
 void RenderFrameImpl::OnNavigate(
     const CommonNavigationParams& common_params,
     const StartNavigationParams& start_params,
     const RequestNavigationParams& request_params) {
   DCHECK(!base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableBrowserSideNavigation));
   TRACE_EVENT2("navigation", "RenderFrameImpl::OnNavigate", "id", routing_id_,
                "url", common_params.url.possibly_invalid_spec());
   NavigateInternal(common_params, start_params, request_params,
-                   scoped_ptr<StreamOverrideParameters>());
+                   scoped_ptr<StreamOverrideParameters>(),
+                   kInvalidServiceWorkerProviderId);
 }
 
 void RenderFrameImpl::NavigateToSwappedOutURL() {
   // We use loadRequest instead of loadHTMLString because the former commits
   // synchronously.  Otherwise a new navigation can interrupt the navigation
   // to kSwappedOutURL. If that happens to be to the page we had been
   // showing, then WebKit will never send a commit and we'll be left spinning.
   // Set the is_swapped_out_ bit to true, so IPC filtering is in effect and
   // the navigation to swappedout:// is not announced to the browser side.
   is_swapped_out_ = true;
@@ skipping 1412 matching lines @@
   // 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 ((frame->effectiveSandboxFlags() & blink::WebSandboxFlags::Origin) ==
         blink::WebSandboxFlags::Origin) {
       provider_type = SERVICE_WORKER_PROVIDER_FOR_SANDBOXED_FRAME;
     }
+    const WebURLRequest& original_request = datasource->originalRequest();
+    int navigation_provider_id = kInvalidServiceWorkerProviderId;
+    if (original_request.extraData()) {
+      RequestExtraData* extra_data =
+          static_cast<RequestExtraData*>(original_request.extraData());
+      navigation_provider_id = extra_data->navigation_provider_id();
+    }
     scoped_ptr<ServiceWorkerNetworkProvider> network_provider(
-        new ServiceWorkerNetworkProvider(routing_id_, provider_type));
+        new ServiceWorkerNetworkProvider(routing_id_, provider_type,
+                                         navigation_provider_id));
+
     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();
@@ skipping 666 matching lines @@
 
   // The request's extra data may indicate that we should set a custom user
   // agent. This needs to be done here, after WebKit is through with setting the
   // user agent on its own. Similarly, it may indicate that we should set an
   // X-Requested-With header. This must be done here to avoid breaking CORS
   // checks.
   // PlzNavigate: there may also be a stream url associated with the request.
   WebString custom_user_agent;
   WebString requested_with;
   scoped_ptr<StreamOverrideParameters> stream_override;
+  int navigation_provider_id = kInvalidServiceWorkerProviderId;
   if (request.extraData()) {
     RequestExtraData* old_extra_data =
         static_cast<RequestExtraData*>(request.extraData());
 
     custom_user_agent = old_extra_data->custom_user_agent();
     if (!custom_user_agent.isNull()) {
       if (custom_user_agent.isEmpty())
         request.clearHTTPHeaderField("User-Agent");
       else
         request.setHTTPHeaderField("User-Agent", custom_user_agent);
     }
 
     requested_with = old_extra_data->requested_with();
     if (!requested_with.isNull()) {
       if (requested_with.isEmpty())
         request.clearHTTPHeaderField("X-Requested-With");
       else
         request.setHTTPHeaderField("X-Requested-With", requested_with);
     }
     stream_override = old_extra_data->TakeStreamOverrideOwnership();
+    navigation_provider_id = old_extra_data->navigation_provider_id();
   }
 
   // Add the default accept header for frame request if it has not been set
   // already.
   if ((request.frameType() == blink::WebURLRequest::FrameTypeTopLevel ||
        request.frameType() == blink::WebURLRequest::FrameTypeNested) &&
       request.httpHeaderField(WebString::fromUTF8(kAcceptHeader)).isEmpty()) {
     request.setHTTPHeaderField(WebString::fromUTF8(kAcceptHeader),
                                WebString::fromUTF8(kDefaultAcceptHeader));
   }
@@ skipping 59 matching lines @@
   extra_data->set_allow_download(
       navigation_state->common_params().allow_download);
   extra_data->set_transition_type(transition_type);
   extra_data->set_should_replace_current_entry(should_replace_current_entry);
   extra_data->set_transferred_request_child_id(
       navigation_state->start_params().transferred_request_child_id);
   extra_data->set_transferred_request_request_id(
       navigation_state->start_params().transferred_request_request_id);
   extra_data->set_service_worker_provider_id(provider_id);
   extra_data->set_stream_override(stream_override.Pass());
+  extra_data->set_navigation_provider_id(navigation_provider_id);
   request.setExtraData(extra_data);
 
   // TODO(creis): Update prefetching to work with out-of-process iframes.
   WebFrame* top_frame = frame->top();
   if (top_frame && top_frame->isWebLocalFrame()) {
     DocumentState* top_document_state =
         DocumentState::FromDataSource(top_frame->dataSource());
     if (top_document_state) {
       // TODO(gavinp): separate out prefetching and prerender field trials
       // if the rel=prerender rel type is sticking around.
@@ skipping 800 matching lines @@
 void RenderFrameImpl::FocusedNodeChangedForAccessibility(const WebNode& node) {
   if (renderer_accessibility())
     renderer_accessibility()->AccessibilityFocusedNodeChanged(node);
 }
 
 // PlzNavigate
 void RenderFrameImpl::OnCommitNavigation(
     const ResourceResponseHead& response,
     const GURL& stream_url,
     const CommonNavigationParams& common_params,
-    const RequestNavigationParams& request_params) {
+    const RequestNavigationParams& request_params,
+    int navigation_provider_id) {
   CHECK(base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableBrowserSideNavigation));
   // This will override the url requested by the WebURLLoader, as well as
   // provide it with the response to the request.
   scoped_ptr<StreamOverrideParameters> stream_override(
       new StreamOverrideParameters());
   stream_override->stream_url = stream_url;
   stream_override->response = response;
 
   NavigateInternal(common_params, StartNavigationParams(), request_params,
-                   stream_override.Pass());
+                   stream_override.Pass(), navigation_provider_id);
 }
 
 void RenderFrameImpl::OnFailedNavigation(
     const CommonNavigationParams& common_params,
     const RequestNavigationParams& request_params,
     bool has_stale_copy_in_cache,
     int error_code) {
   bool is_reload = IsReload(common_params.navigation_type);
   bool is_history_navigation = request_params.page_state.IsValid();
   WebURLRequest::CachePolicy cache_policy =
       WebURLRequest::UseProtocolCachePolicy;
   RenderFrameImpl::PrepareRenderViewForNavigation(
       common_params.url, request_params, &is_reload, &cache_policy);
 
   GetContentClient()->SetActiveURL(common_params.url);
 
   pending_navigation_params_.reset(new NavigationParams(
       common_params, StartNavigationParams(), request_params));
 
   // Inform the browser of the start of the provisional load. This is needed so
   // that the load is properly tracked by the WebNavigation API.
   Send(new FrameHostMsg_DidStartProvisionalLoadForFrame(
       routing_id_, common_params.url));
 
   // Send the provisional load failure.
   blink::WebURLError error =
       CreateWebURLError(common_params.url, has_stale_copy_in_cache, error_code);
   WebURLRequest failed_request = CreateURLRequestForNavigation(
       common_params, scoped_ptr<StreamOverrideParameters>(),
-      frame_->isViewSourceModeEnabled());
+      kInvalidServiceWorkerProviderId, frame_->isViewSourceModeEnabled());
   SendFailedProvisionalLoad(failed_request, error, frame_);
 
   if (!ShouldDisplayErrorPageForFailedLoad(error_code, common_params.url)) {
     // TODO(avi): Remove this; we shouldn't ever be dropping navigations.
     // http://crbug.com/501960
     Send(new FrameHostMsg_DidDropNavigation(routing_id_));
     return;
   }
 
   // Make sure errors are not shown in view source mode.
@@ skipping 239 matching lines @@
     WebUserGestureIndicator::consumeUserGesture();
   }
 
   Send(new FrameHostMsg_OpenURL(routing_id_, params));
 }
 
 void RenderFrameImpl::NavigateInternal(
     const CommonNavigationParams& common_params,
     const StartNavigationParams& start_params,
     const RequestNavigationParams& request_params,
-    scoped_ptr<StreamOverrideParameters> stream_params) {
+    scoped_ptr<StreamOverrideParameters> stream_params,
+    int navigation_provider_id) {
   bool browser_side_navigation =
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableBrowserSideNavigation);
   bool is_reload = IsReload(common_params.navigation_type);
   bool is_history_navigation = request_params.page_state.IsValid();
   WebURLRequest::CachePolicy cache_policy =
       WebURLRequest::UseProtocolCachePolicy;
   RenderFrameImpl::PrepareRenderViewForNavigation(
       common_params.url, request_params, &is_reload, &cache_policy);
 
   GetContentClient()->SetActiveURL(common_params.url);
 
   // If this frame isn't in the same process as the main frame, it may naively
   // assume that this is the first navigation in the iframe, but this may not
   // actually be the case. Inform the frame's state machine if this frame has
   // already committed other loads.
   if (request_params.has_committed_real_load && frame_->parent())
     frame_->setCommittedFirstRealLoad();
 
   if (is_reload && !render_view_->history_controller()->GetCurrentEntry()) {
     // We cannot reload if we do not have any history state.  This happens, for
     // example, when recovering from a crash.
     is_reload = false;
     cache_policy = WebURLRequest::ReloadIgnoringCacheData;
   }
 
   pending_navigation_params_.reset(

[michaeln, 2015/07/30 01:35:08]

According to the comments about this data member, seems like this struct might
be a better place to store the new magic number needed inside of
didCreateDataSource().

  // Temporarily holds state pertaining to a navigation that has been initiated
  // until the NavigationState corresponding to the new navigation is created in
  // didCreateDataSource().
  scoped_ptr<NavigationParams> pending_navigation_params_;

So the new id value is received by this class in OnCommitNavigation, stored by
this class in pending_navigation_params_, and then finally used in
didCreateDataSource. I think that could reduce the scope of 'things' that need
to be aware of the new value, wdyt?

[Fabrice (no longer in Chrome), 2015/08/06 15:39:15]

Yes, CommonNavigationParams seems like a better use for this. It is a member of
NavigationParams.

       new NavigationParams(common_params, start_params, request_params));
 
   // Create parameters for a standard navigation.
   blink::WebFrameLoadType load_type = blink::WebFrameLoadType::Standard;
   bool should_load_request = false;
   WebHistoryItem item_for_history_navigation;
   WebURLRequest request = CreateURLRequestForNavigation(
-      common_params, stream_params.Pass(), frame_->isViewSourceModeEnabled());
+      common_params, stream_params.Pass(), navigation_provider_id,

[nasko, 2015/08/07 17:51:12]

Why do we need to pass this? The stream is the result of what ServiceWorker
returned to us (if it kicked in), so adding it again will likely not do
anything. It will be even worse if SW is engaged on requesting the response from
a SW.

[kinuko, 2015/08/11 14:43:04]

This is mainly to associate browser-side SW object (i.e. SWProviderHost, which
is identified by nav_provider_id) and renderer-side SW object (i.e. SWProvider,
which is created later in RenderFrameImpl::didCreateDataSource).

We embed nav_provider_id here in the request so that later in
RenderFrameImpl::didCreateDataSource (which is called when the document loader
is created in blink) we can create SWProvider with the same nav_provider_id.

+      frame_->isViewSourceModeEnabled());
 
   // PlzNavigate: Make sure that Blink's loader will not try to use browser side
   // navigation for this request (since it already went to the browser).
   if (browser_side_navigation)
     request.setCheckForBrowserSideNavigation(false);
 
   // If we are reloading, then use the history state of the current frame.
   // Otherwise, if we have history state, then we need to navigate to it, which
   // corresponds to a back/forward navigation event. Update the parameters
   // depending on the navigation type.
@@ skipping 582 matching lines @@
 void RenderFrameImpl::RegisterMojoServices() {
   // Only main frame have ImageDownloader service.
   if (!frame_->parent()) {
     GetServiceRegistry()->AddService<image_downloader::ImageDownloader>(
         base::Bind(&ImageDownloaderImpl::CreateMojoService,
                    base::Unretained(this)));
   }
 }
 
 }  // namespace content