PlzNavigate: Make ServiceWorker work with PlzNavigate.

content/browser/frame_host/navigation_request.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/frame_host/navigation_request.h"
 
+#include "base/command_line.h"
 #include "content/browser/frame_host/frame_tree.h"
 #include "content/browser/frame_host/frame_tree_node.h"
 #include "content/browser/frame_host/navigation_controller_impl.h"
 #include "content/browser/frame_host/navigation_handle_impl.h"
 #include "content/browser/frame_host/navigation_request_info.h"
 #include "content/browser/frame_host/navigator.h"
 #include "content/browser/loader/navigation_url_loader.h"
+#include "content/browser/service_worker/service_worker_provider_host.h"
 #include "content/browser/site_instance_impl.h"
 #include "content/common/resource_request_body.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_throttle.h"
 #include "content/public/browser/stream_handle.h"
 #include "content/public/common/content_client.h"
+#include "content/public/common/content_switches.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_request_headers.h"
 #include "net/url_request/redirect_info.h"
+#include "third_party/WebKit/public/web/WebSandboxFlags.h"
 
 namespace content {
 
 namespace {
 
 // Returns the net load flags to use based on the navigation type.
 // TODO(clamy): unify the code with what is happening on the renderer side.
 int LoadFlagFromNavigationType(FrameMsg_Navigate_Type::Value navigation_type) {
   int load_flags = net::LOAD_NORMAL;
   switch (navigation_type) {
@@ skipping 10 matching lines @@
     case FrameMsg_Navigate_Type::RESTORE_WITH_POST:
       load_flags |= net::LOAD_ONLY_FROM_CACHE;
       break;
     case FrameMsg_Navigate_Type::NORMAL:
     default:
       break;
   }
   return load_flags;
 }
 
+
+// PlzNavigate

[clamy, 2015/10/02 10:34:44]

No need for PlzNavigate prefix, this is a PlzNavigate only class.

[Fabrice (no longer in Chrome), 2015/10/02 16:37:34]

Done.

+// Next ServiceWorkerProviderHost ID for navigations, starts at -2 and keeps
+// going down.
+int g_next_navigation_provider_id = -2;
+
+// PlzNavigate
+// Returns the next ServiceWorkerProviderHost ID for navigations.
+// Returns kInvalidServiceWorkerProviderId if sandbox_flags indicates a
+// sandboxed frame.
+// Returns kInvalidServiceWorkerProviderId for current navigation.
+int GetNextNavigationProviderId(blink::WebSandboxFlags sandbox_flags) {
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(

[clamy, 2015/10/02 10:34:44]

This is a PlzNavigate only class, so no need to handle the current architecture.

[Fabrice (no longer in Chrome), 2015/10/02 16:37:34]

Done.

+          switches::kEnableBrowserSideNavigation)) {
+    bool sandboxed_frame = (sandbox_flags & blink::WebSandboxFlags::Origin) ==
+        blink::WebSandboxFlags::Origin;
+    if (sandboxed_frame)
+      return kInvalidServiceWorkerProviderId;
+    return g_next_navigation_provider_id--;
+  }
+  return kInvalidServiceWorkerProviderId;
+}
+
 }  // namespace
 
 // static
 scoped_ptr<NavigationRequest> NavigationRequest::CreateBrowserInitiated(
     FrameTreeNode* frame_tree_node,
     const GURL& dest_url,
     const Referrer& dest_referrer,
     const FrameNavigationEntry& frame_entry,
     const NavigationEntryImpl& entry,
     FrameMsg_Navigate_Type::Value navigation_type,
@@ skipping 14 matching lines @@
   // Fill POST data from the browser in the request body.
   scoped_refptr<ResourceRequestBody> request_body;
   if (entry.GetHasPostData()) {
     request_body = new ResourceRequestBody();
     request_body->AppendBytes(
         reinterpret_cast<const char *>(
             entry.GetBrowserInitiatedPostData()->front()),
         entry.GetBrowserInitiatedPostData()->size());
   }
 
+  blink::WebSandboxFlags sandbox_flags =
+      frame_tree_node->current_replication_state().sandbox_flags;
   scoped_ptr<NavigationRequest> navigation_request(new NavigationRequest(
       frame_tree_node,
-      entry.ConstructCommonNavigationParams(dest_url, dest_referrer,
-                                            frame_entry, navigation_type),
-      BeginNavigationParams(method, headers.ToString(),
-                            LoadFlagFromNavigationType(navigation_type), false),
+      entry.ConstructCommonNavigationParams(
+          dest_url, dest_referrer, frame_entry, navigation_type),
+      BeginNavigationParams(method,
+                            headers.ToString(),
+                            LoadFlagFromNavigationType(navigation_type),
+                            false, // has_user_gestures
+                            false, // skip_service_worker
+                            REQUEST_CONTEXT_TYPE_HYPERLINK),
       entry.ConstructRequestNavigationParams(
           frame_entry, navigation_start, is_same_document_history_load,
           frame_tree_node->has_committed_real_load(),
           controller->GetPendingEntryIndex() == -1,
           controller->GetIndexOfEntry(&entry),
           controller->GetLastCommittedEntryIndex(),
-          controller->GetEntryCount()),
+          controller->GetEntryCount(),
+          GetNextNavigationProviderId(sandbox_flags)),
       request_body, true, &frame_entry, &entry));
   return navigation_request.Pass();
 }
 
 // static
 scoped_ptr<NavigationRequest> NavigationRequest::CreateRendererInitiated(
     FrameTreeNode* frame_tree_node,
     const CommonNavigationParams& common_params,
     const BeginNavigationParams& begin_params,
     scoped_refptr<ResourceRequestBody> body,
     int current_history_list_offset,
     int current_history_list_length) {
+  blink::WebSandboxFlags sandbox_flags =
+      frame_tree_node->current_replication_state().sandbox_flags;
+
   // TODO(clamy): Check if some PageState should be provided here.
   // TODO(clamy): See how we should handle override of the user agent when the
   // navigation may start in a renderer and commit in another one.
   // TODO(clamy): See if the navigation start time should be measured in the
   // renderer and sent to the browser instead of being measured here.
   // TODO(clamy): The pending history list offset should be properly set.
   // TODO(clamy): Set has_committed_real_load.
-  RequestNavigationParams request_params;
-  request_params.current_history_list_offset = current_history_list_offset;
-  request_params.current_history_list_length = current_history_list_length;
+  RequestNavigationParams request_params(
+      false,  // is_overriding_user_agent
+      base::TimeTicks::Now(),  // browser_navigation_start
+      std::vector<GURL>(),  // redirects
+      false,  // can_load_local_resources
+      base::Time::Now(),  // request_time
+      PageState(),  // page_state
+      -1,  // page_id
+      0,  // nav_entry_id
+      false,  // is_same_document_history_load
+      false,  // has_committed_real_load
+      false,  // intended_as_new_entry
+      -1,  // pending_history_list_offset
+      current_history_list_offset,
+      current_history_list_length,
+      false,  // should_clear_history_list
+      GetNextNavigationProviderId(sandbox_flags));
   scoped_ptr<NavigationRequest> navigation_request(
       new NavigationRequest(frame_tree_node, common_params, begin_params,
                             request_params, body, false, nullptr, nullptr));
   return navigation_request.Pass();
 }
 
 NavigationRequest::NavigationRequest(
     FrameTreeNode* frame_tree_node,
     const CommonNavigationParams& common_params,
     const BeginNavigationParams& begin_params,
@@ skipping 29 matching lines @@
 
   const GURL& first_party_for_cookies =
       frame_tree_node->IsMainFrame()
           ? common_params.url
           : frame_tree_node->frame_tree()->root()->current_url();
   bool parent_is_main_frame = !frame_tree_node->parent() ?
       false : frame_tree_node->parent()->IsMainFrame();
   info_.reset(new NavigationRequestInfo(
       common_params, begin_params, first_party_for_cookies,
       frame_tree_node->IsMainFrame(), parent_is_main_frame,
-      frame_tree_node->frame_tree_node_id(), body));
+      frame_tree_node->frame_tree_node_id(),
+      request_params.service_worker_provider_id, body));
 }
 
 NavigationRequest::~NavigationRequest() {
 }
 
 bool NavigationRequest::BeginNavigation() {
   DCHECK(!loader_);
   DCHECK(state_ == NOT_STARTED || state_ == WAITING_FOR_RENDERER_RESPONSE);
   state_ = STARTED;
 
@@ skipping 24 matching lines @@
   frame_tree_node_->navigator()->CommitNavigation(
       frame_tree_node_, nullptr, scoped_ptr<StreamHandle>());
   return false;
 
   // TODO(davidben): Fire (and add as necessary) observer methods such as
   // DidStartProvisionalLoadForFrame for the navigation.
 }
 
 void NavigationRequest::CreateNavigationHandle(NavigatorDelegate* delegate) {
   navigation_handle_ = NavigationHandleImpl::Create(
-      common_params_.url, frame_tree_node_->IsMainFrame(), delegate);
+      common_params_.url, frame_tree_node_->IsMainFrame(), delegate,
+      request_params_.service_worker_provider_id);
 }
 
 void NavigationRequest::TransferNavigationHandleOwnership(
     RenderFrameHostImpl* render_frame_host) {
   render_frame_host->SetNavigationHandle(navigation_handle_.Pass());
   render_frame_host->navigation_handle()->ReadyToCommitNavigation(
       render_frame_host);
 }
 
 void NavigationRequest::OnRequestRedirected(
@@ skipping 39 matching lines @@
   frame_tree_node_->navigator()->FailedNavigation(
       frame_tree_node_, has_stale_copy_in_cache, net_error);
 }
 
 void NavigationRequest::OnRequestStarted(base::TimeTicks timestamp) {
   frame_tree_node_->navigator()->LogResourceRequestTime(timestamp,
                                                         common_params_.url);
 }
 
 }  // namespace content