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 "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/site_instance_impl.h"
 #include "content/common/resource_request_body.h"
+#include "content/common/service_worker/service_worker_types.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 "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;
 }
 
+// Next ServiceWorkerProviderHost ID for navigations, starts at -2 and keeps
+// going down.
+int g_next_navigation_provider_id = -2;
+
+// Returns the next ServiceWorkerProviderHost ID for navigations,
+// kInvalidServiceWorkerProviderId if the frame is sandboxed.
+int GetNextNavigationProviderId(blink::WebSandboxFlags sandbox_flags) {
+  if ((sandbox_flags & blink::WebSandboxFlags::Origin) ==
+          blink::WebSandboxFlags::Origin)
+    return kInvalidServiceWorkerProviderId;
+  return g_next_navigation_provider_id--;
+}
+
 }  // 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 139 matching lines @@
             Referrer::SanitizeForRequest(common_params_.url,
                                          common_params_.referrer),
             begin_params_.has_user_gesture, common_params_.transition, false);
 
     // Abort the request if needed. This will destroy the NavigationRequest.
     if (result == NavigationThrottle::CANCEL_AND_IGNORE) {
       frame_tree_node_->ResetNavigationRequest(false);
       return false;
     }
 
+    // Initialize the service_worker_provider_id here.
+    blink::WebSandboxFlags sandbox_flags =
+        frame_tree_node_->current_replication_state().sandbox_flags;
+    int service_worker_provider_id = GetNextNavigationProviderId(sandbox_flags);
+
+    info_->service_worker_provider_id = service_worker_provider_id;
+    request_params_.service_worker_provider_id = service_worker_provider_id;
+    navigation_handle_->set_service_worker_provider_id(

[michaeln, 2015/10/07 01:16:44]

Nice, deferring this swspecific init work until this point is definitely an
improvement.

This could be a great place to create a wrapper class that encapsulates the
serviceworker specific bits of what happens on the browser-side and to take
ownership of it.

[Fabrice (no longer in Chrome), 2015/10/07 12:59:43]

One of the issues is that we are currently on the IO thread and the dtor for
this new class will be called on the UI thread. We'd be passing a whole lot of
information to a new class while adding little in the way of clarification since
the dtor for the SWPH would end being called from another file anyway.
However, I can add comments to clarify the lifetime of the SWPH for navigations
at creation and destruction time and who will be responsible for that.

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

Hmmm, but thats not right? First, this method runs on the UI thread (right?).
And the only input needed for the wrapper class would be the
ServiceWorkerContextWrapper and maybe the sandbox_flags. Here's a public
interface that I think covers it. And the NavigationHandle having a scoped_ptr<>
to one of these would actually clarify ownership at a glance.

class ServiceWorkerNavigationHandle {
 public:
  ServiceWorkerNavigationHandle(context_wrapper, sandbox_flags);
  ~ServiceWorkerNavigationHandle();
  int provider_host_id();
  ServiceWorkerContextWrapper* context_wrapper();
};

Internally that class would
* produce the magic id value
* construct the host object and initialize it properly on the io thread
* conditionally destruct the host if needed

It might be more little complicated to put that class together than it is to
have the logic be diffuse as in the existing CL. I understand you want to be
done with the CL.

+        service_worker_provider_id);
+
     loader_ = NavigationURLLoader::Create(
         frame_tree_node_->navigator()->GetController()->GetBrowserContext(),
         info_.Pass(), this);
     return true;
   }
 
   // There is no need to make a network request for this navigation, so commit
   // it immediately.
   state_ = RESPONSE_STARTED;
   frame_tree_node_->navigator()->CommitNavigation(
@@ skipping 59 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