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/service_worker/service_worker_navigation_handle.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 "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 171 matching lines @@
             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;
     }
 
     loader_ = NavigationURLLoader::Create(
         frame_tree_node_->navigator()->GetController()->GetBrowserContext(),
-        info_.Pass(), this);
+        info_.Pass(), navigation_handle_->service_worker_handle(), 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(
       frame_tree_node_, nullptr, scoped_ptr<StreamHandle>());
   return false;
 
@@ skipping 37 matching lines @@
   loader_->FollowRedirect();
 
   navigation_handle_->DidRedirectNavigation(redirect_info.new_url);
 }
 
 void NavigationRequest::OnResponseStarted(
     const scoped_refptr<ResourceResponse>& response,
     scoped_ptr<StreamHandle> body) {
   DCHECK(state_ == STARTED);
   state_ = RESPONSE_STARTED;
+
+  // Update the service worker params of the request params.
+  request_params_.should_create_service_worker =
+      (frame_tree_node_->current_replication_state().sandbox_flags &

[michaeln, 2015/10/20 22:12:53]

i'm wondering about potential errors stemming from the sandbox_flags in the
renderer and browser not matching or the flag changing between when we're
sampleing it (here vs in the ctor)

[nasko, 2015/10/20 23:07:42]

There is important behavior here. Sandbox flags updating works by updating
sandbox_flags, but keeping effective_sandbox_flags around. Security checks
usually need to be performed against the effective_sandbox_flags. That said, I
can't find where any spec talks about the interaction of the allow-same-origin
flag and ServiceWorker. Can you point me to that?

[clamy, 2015/10/21 16:33:48]

So should I change to checking against effective_sandbox_flags?

For the effects of it changing between when we're sampleing it:
- allowed to not allowed: we pre-created a SWProviderHost, but will not create
the corresponding renderer object. The SWProviderHost will be destroyed when the
navigation commits.
- not to allowed to allowed: we did not pre-create a SWProviderHost for the
navigation. However, we will create a SWNetworkProvider in the renderer when the
navigation commits.

Is that acceptable behavior for ServiceWorker?

[nasko, 2015/10/21 22:28:08]

I can't say for certain which one should be used, since I don't know what the
spec requires. michaeln@/kinuko@, can you help point us to the spec that
explains how sandbox flags and SW interact?

[kinuko, 2015/10/22 12:16:02]

In the latter case the first main resource load may not be controlled but
subsequent resource loads could be controlled?  That might feel slightly weird,
though I don't strongly feel we should make it behave differently. (The spec
text for dynamically changing sandbox flag seems to be a little unclear too)

It'd be still probably worth noting this behavior in a comment?

+       blink::WebSandboxFlags::Origin) != blink::WebSandboxFlags::Origin;
+  if (navigation_handle_->service_worker_handle()) {
+    request_params_.service_worker_provider_id =
+        navigation_handle_->service_worker_handle()
+            ->service_worker_provider_host_id();
+  }
+
   frame_tree_node_->navigator()->CommitNavigation(frame_tree_node_,
                                                   response.get(), body.Pass());
 }
 
 void NavigationRequest::OnRequestFailed(bool has_stale_copy_in_cache,
                                         int net_error) {
   DCHECK(state_ == STARTED);
   state_ = FAILED;
   navigation_handle_->set_net_error_code(static_cast<net::Error>(net_error));
   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