Expose WebServiceWorkerNetworkProvider on DataSource

content/renderer/render_frame_impl.cc

Index: content/renderer/render_frame_impl.cc
diff --git a/content/renderer/render_frame_impl.cc b/content/renderer/render_frame_impl.cc
index 8e044057fbe78485f1770d1631295832a1c25df8..7d668a4939666ee64186cec687231153350a05b1 100644
--- a/content/renderer/render_frame_impl.cc
+++ b/content/renderer/render_frame_impl.cc
@@ -187,6 +187,7 @@
 #include "third_party/WebKit/public/platform/WebURLError.h"
 #include "third_party/WebKit/public/platform/WebURLResponse.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
+#include "third_party/WebKit/public/platform/modules/serviceworker/WebServiceWorkerNetworkProvider.h"
 #include "third_party/WebKit/public/platform/scheduler/renderer/renderer_scheduler.h"
 #include "third_party/WebKit/public/web/WebColorSuggestion.h"
 #include "third_party/WebKit/public/web/WebConsoleMessage.h"
@@ -2982,16 +2983,14 @@ RenderFrameImpl::createServiceWorkerProvider() {
   if (!ChildThreadImpl::current())
     return nullptr;  // May be null in some tests.
   ServiceWorkerNetworkProvider* provider =
-      ServiceWorkerNetworkProvider::FromDocumentState(
-          DocumentState::FromDataSource(frame_->dataSource()));
-  DCHECK(provider);
+      ServiceWorkerNetworkProvider::GetInwardProviderForNavigation(
+          frame_->dataSource()->getServiceWorkerNetworkProvider());
   if (!provider->context()) {
     // The context can be null when the frame is sandboxed.
     return nullptr;
   }
   return new WebServiceWorkerProviderImpl(
-      ChildThreadImpl::current()->thread_safe_sender(),
-      provider->context());
+      ChildThreadImpl::current()->thread_safe_sender(), provider->context());
 }
 
 void RenderFrameImpl::didAccessInitialDocument() {
@@ -3413,12 +3412,10 @@ void RenderFrameImpl::didCreateDataSource(blink::WebLocalFrame* frame,
   // Create the serviceworker's per-document network observing object if it
   // does not exist (When navigation happens within a page, the provider already
   // exists).
-  if (ServiceWorkerNetworkProvider::FromDocumentState(
-          DocumentState::FromDataSource(datasource)))
+  if (datasource->getServiceWorkerNetworkProvider())
     return;
 
-  ServiceWorkerNetworkProvider::AttachToDocumentState(
-      DocumentState::FromDataSource(datasource),
+  datasource->setServiceWorkerNetworkProvider(
       ServiceWorkerNetworkProvider::CreateForNavigation(
           routing_id_, navigation_state->request_params(), frame,
           content_initiated));
@@ -4275,38 +4272,6 @@ void RenderFrameImpl::willSendRequest(blink::WebLocalFrame* frame,
   // when it is re-created in the new process.
   bool should_replace_current_entry = data_source->replacesCurrentHistoryItem();
 
-  int provider_id = kInvalidServiceWorkerProviderId;
-  if (request.getFrameType() == blink::WebURLRequest::FrameTypeTopLevel ||
-      request.getFrameType() == blink::WebURLRequest::FrameTypeNested) {
-    // |provisionalDataSource| may be null in some content::ResourceFetcher
-    // use cases, we don't hook those requests.
-    if (frame->provisionalDataSource()) {
-      ServiceWorkerNetworkProvider* provider =
-          ServiceWorkerNetworkProvider::FromDocumentState(
-              DocumentState::FromDataSource(frame->provisionalDataSource()));
-      DCHECK(provider);
-      provider_id = provider->provider_id();
-    }
-  } else if (frame->dataSource()) {
-    ServiceWorkerNetworkProvider* provider =
-        ServiceWorkerNetworkProvider::FromDocumentState(
-            DocumentState::FromDataSource(frame->dataSource()));
-    DCHECK(provider);
-    provider_id = provider->provider_id();
-    // If the provider does not have a controller at this point, the renderer
-    // expects the request to never be handled by a controlling service worker,
-    // so set the ServiceWorkerMode to skip local workers here. Otherwise, a
-    // service worker that is in the process of becoming the controller (i.e.,
-    // via claim()) on the browser-side could handle the request and break
-    // the assumptions of the renderer.
-    if (!provider->IsControlledByServiceWorker() &&
-        request.getServiceWorkerMode() !=
-            blink::WebURLRequest::ServiceWorkerMode::None) {
-      request.setServiceWorkerMode(
-          blink::WebURLRequest::ServiceWorkerMode::Foreign);
-    }
-  }
-
   WebFrame* parent = frame->parent();
   int parent_routing_id = parent ? GetRoutingIdForFrameOrProxy(parent) : -1;
 
@@ -4324,7 +4289,6 @@ void RenderFrameImpl::willSendRequest(blink::WebLocalFrame* frame,
       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_service_worker_provider_id(provider_id);
   extra_data->set_stream_override(std::move(stream_override));
   bool is_prefetch =
       GetContentClient()->renderer()->IsPrefetchOnly(this, request);
@@ -4357,6 +4321,38 @@ void RenderFrameImpl::willSendRequest(blink::WebLocalFrame* frame,
 
   request.setExtraData(extra_data);
 
+  // Initializes service worker related request info.
+  // This must be done after we set extra data.

[falken, 2017/03/10 04:26:00]

Could you also write (briefly) why the order matters, to guard against comment
staleness in case the code later changes. It's not obvious to me.

[kinuko, 2017/03/10 05:52:28]

Revised to make it order-independent.

+  if (request.getFrameType() == blink::WebURLRequest::FrameTypeTopLevel ||
+      request.getFrameType() == blink::WebURLRequest::FrameTypeNested) {
+    // |provisionalDataSource| may be null in some content::ResourceFetcher
+    // use cases, we don't hook those requests.
+    if (frame->provisionalDataSource()) {
+      blink::WebServiceWorkerNetworkProvider* provider =
+          frame->provisionalDataSource()->getServiceWorkerNetworkProvider();
+      DCHECK(provider);
+      provider->willSendRequest(request);
+    }
+  } else if (frame->dataSource()) {
+    blink::WebServiceWorkerNetworkProvider* provider =
+        frame->dataSource()->getServiceWorkerNetworkProvider();
+    DCHECK(provider);
+    provider->willSendRequest(request);
+
+    // If the provider does not have a controller at this point, the renderer
+    // expects the request to never be handled by a controlling service worker,
+    // so set the ServiceWorkerMode to skip local workers here. Otherwise, a
+    // service worker that is in the process of becoming the controller (i.e.,
+    // via claim()) on the browser-side could handle the request and break
+    // the assumptions of the renderer.
+    if (!provider->isControlledByServiceWorker() &&
+        request.getServiceWorkerMode() !=
+            blink::WebURLRequest::ServiceWorkerMode::None) {
+      request.setServiceWorkerMode(
+          blink::WebURLRequest::ServiceWorkerMode::Foreign);
+    }
+  }
+
   if (request.getPreviewsState() == WebURLRequest::PreviewsUnspecified) {
     if (is_main_frame_ && !navigation_state->request_committed()) {
       request.setPreviewsState(static_cast<WebURLRequest::PreviewsState>(
@@ -4656,22 +4652,6 @@ blink::WebScreenOrientationClient*
   return screen_orientation_dispatcher_;
 }
 
-bool RenderFrameImpl::isControlledByServiceWorker(WebDataSource& data_source) {
-  ServiceWorkerNetworkProvider* provider =
-      ServiceWorkerNetworkProvider::FromDocumentState(
-          DocumentState::FromDataSource(&data_source));
-  return provider->IsControlledByServiceWorker();
-}
-
-int64_t RenderFrameImpl::serviceWorkerID(WebDataSource& data_source) {
-  ServiceWorkerNetworkProvider* provider =
-      ServiceWorkerNetworkProvider::FromDocumentState(
-          DocumentState::FromDataSource(&data_source));
-  if (provider->context() && provider->context()->controller())
-    return provider->context()->controller()->version_id();
-  return kInvalidServiceWorkerVersionId;
-}
-
 void RenderFrameImpl::postAccessibilityEvent(const blink::WebAXObject& obj,
                                              blink::WebAXEvent event) {
   HandleWebAccessibilityEvent(obj, event);