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 431 matching lines @@
     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_service_worker_provider_id(
+      common_params.service_worker_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 46 matching lines @@
   // CommitNavigation IPC, and then back to the browser again in the
   // DidCommitProvisionalLoad and the DocumentLoadComplete IPCs.
   base::TimeTicks ui_timestamp =
       base::TimeTicks() + base::TimeDelta::FromSecondsD(request->uiStartTime());
   FrameMsg_UILoadMetricsReportType::Value report_type =
       static_cast<FrameMsg_UILoadMetricsReportType::Value>(
           request->inputPerfMetricReportPolicy());
   return CommonNavigationParams(
       request->url(), referrer, extra_data->transition_type(),
       FrameMsg_Navigate_Type::NORMAL, true, should_replace_current_entry,
-      ui_timestamp, report_type, GURL(), GURL());
+      ui_timestamp, report_type, GURL(), GURL(),
+      extra_data->service_worker_provider_id());

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

If i understand correctly, i think this is called in preperation of asking the
browser to do the navigation. Is that right?

* How does the value provided here get used downstream in the browser process?

* Can the browser decide to offload the nav to a different process?

[michaeln, 2015/09/18 23:03:56]

Ok, this id is definitely not useful.

The object it identifies will be deleted prior to startLoad() returning and any
other msg being processed by the loop. According to nate this is by desigin. The
original policy/provisional loader+swprovider is deleted (per the snippet below)
and a new loader+swprovider gets created if/when the browser process decides to
delegate the navigation back to the this child process.

snipped from FrameLoader::startLoad(...)

    // stopAllLoaders can detach the LocalFrame, so protect it.
    RefPtrWillBeRawPtr<LocalFrame> protect(m_frame.get());
    if ((!m_policyDocumentLoader->shouldContinueForNavigationPolicy(...) {
        detachDocumentLoader(m_policyDocumentLoader);
        return;
    }

The MakeCommonNavigationParams() function is called inside of
m_policyDocumentLoader->shouldContinueForNavigationPolicy. The documentLoader
and its associated ServiceWorkerNetworkProvider are deleted inside of
detachDocumentLoader().

Eventually we get an ipc to RenderFrameImpl::OnCommitNavigation(). As currently
coded in the cl, the value of CommonNavigationParams.service_worker_provider_id
in that message is kInvalidServiceWorkerProviderId. Yet the stream override url
has an actual blob:url in it.

I'll look more closely at the corresponding control flow in the browser process?

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

This has been removed.

 }
 
 #if !defined(OS_ANDROID) || defined(ENABLE_MEDIA_PIPELINE_ON_ANDROID)
 media::Context3D GetSharedMainThreadContext3D() {
   cc::ContextProvider* provider =
       RenderThreadImpl::current()->SharedMainThreadContextProvider().get();
   if (!provider)
     return media::Context3D();
   return media::Context3D(provider->ContextGL(), provider->GrContext());
 }
@@ skipping 2038 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 service_worker_provider_id = kInvalidServiceWorkerProviderId;
+    if (original_request.extraData()) {

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

I think this new bit of code is specific to PlzNavigate, if thats right please
annotate it with the // PlzNavigate comment too. I think the extraData() only
applies to PlzNavigate initiated navigations, is that right? 

I really appreciate the use of the PlzNavigate comment to annotate where the two
different modes of doing navigations differ. Otherwise we have mysteries like
"why is extra_data sometimes null and other times not and does it matter" that
nearly nobody knows the answer to.

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

Done.
There's a bit of duplication here now but I find it easier to understand this
way since the tests are different for PlzNavigate anyway.

+      RequestExtraData* extra_data =
+          static_cast<RequestExtraData*>(original_request.extraData());
+      service_worker_provider_id = extra_data->service_worker_provider_id();
+    }
+
     scoped_ptr<ServiceWorkerNetworkProvider> network_provider(
-        new ServiceWorkerNetworkProvider(routing_id_, provider_type));
+        new ServiceWorkerNetworkProvider(routing_id_, provider_type,
+                                         service_worker_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 2241 matching lines @@
   WebDataSource* provisional_data_source = frame_->provisionalDataSource();
   WebDataSource* current_data_source = frame_->dataSource();
   WebDataSource* data_source =
       provisional_data_source ? provisional_data_source : current_data_source;
 
   // The current entry can only be replaced if there already is an entry in the
   // history list.
   if (data_source && render_view_->history_list_length_ > 0) {
     should_replace_current_entry = data_source->replacesCurrentHistoryItem();
   }
+
+  DCHECK_EQ(FETCH_REQUEST_MODE_NO_CORS,
+            GetFetchRequestModeForWebURLRequest(*request));
+  DCHECK_EQ(FETCH_CREDENTIALS_MODE_SAME_ORIGIN,
+            GetFetchCredentialsModeForWebURLRequest(*request));
+  DCHECK(GetFetchRedirectModeForWebURLRequest(*request) ==
+         FetchRedirectMode::FOLLOW_MODE);

[michaeln, 2015/09/18 23:03:56]

I've patched it in and am seeing these DCHECKs get hit on every navigation?

Is there something more I need to do in addition to running with
--enable-browser-side-navigation to test things?

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

That's because the values for navigation requests have changed in the meantime.
I fixed them.

+  DCHECK_IMPLIES(!frame_->parent(),
+                 GetRequestContextFrameTypeForWebURLRequest(*request) ==
+                 REQUEST_CONTEXT_FRAME_TYPE_TOP_LEVEL);
+  DCHECK_IMPLIES(frame_->parent(),
+                 GetRequestContextFrameTypeForWebURLRequest(*request) ==
+                 REQUEST_CONTEXT_FRAME_TYPE_NESTED);
+
   Send(new FrameHostMsg_BeginNavigation(
       routing_id_,
       MakeCommonNavigationParams(request, should_replace_current_entry),
       BeginNavigationParams(
-          request->httpMethod().latin1(), GetWebURLRequestHeaders(*request),
-          GetLoadFlagsForWebURLRequest(*request), request->hasUserGesture()),
+          request->httpMethod().latin1(),
+          GetWebURLRequestHeaders(*request),
+          GetLoadFlagsForWebURLRequest(*request),
+          request->hasUserGesture(),
+          request->skipServiceWorker(),
+          GetRequestContextTypeForWebURLRequest(*request)),
       GetRequestBodyForWebURLRequest(*request)));
 }
 
 void RenderFrameImpl::LoadDataURL(const CommonNavigationParams& params,
                                   WebFrame* frame) {
   // A loadData request with a specified base URL.
   std::string mime_type, charset, data;
   if (net::DataURL::Parse(params.url, &mime_type, &charset, &data)) {
     const GURL base_url = params.base_url_for_data_url.is_empty() ?
         params.url : params.base_url_for_data_url;
@@ skipping 244 matching lines @@
   mojo::ServiceProviderPtr service_provider;
   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