Expose WebServiceWorkerNetworkProvider on DataSource

content/child/service_worker/service_worker_network_provider.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/child/service_worker/service_worker_network_provider.h"
 
 #include "base/atomic_sequence_num.h"
 #include "content/child/child_thread_impl.h"
+#include "content/child/request_extra_data.h"
+#include "content/child/service_worker/service_worker_handle_reference.h"
 #include "content/child/service_worker/service_worker_provider_context.h"
 #include "content/common/navigation_params.h"
 #include "content/common/service_worker/service_worker_messages.h"
 #include "content/common/service_worker/service_worker_provider_host_info.h"
 #include "content/common/service_worker/service_worker_utils.h"
 #include "content/public/common/browser_side_navigation_policy.h"
 #include "ipc/ipc_sync_channel.h"
 #include "third_party/WebKit/public/platform/WebSecurityOrigin.h"
+#include "third_party/WebKit/public/platform/modules/serviceworker/WebServiceWorkerNetworkProvider.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebSandboxFlags.h"
 
 namespace content {
 
 namespace {
 
-const char kUserDataKey[] = "SWProviderKey";
-
 // Must be unique in the child process.
 int GetNextProviderId() {
   static base::StaticAtomicSequenceNumber sequence;
   return sequence.GetNext();  // We start at zero.
 }
 
 // Returns whether it's possible for a document whose frame is a descendant of
 // |frame| to be a secure context, not considering scheme exceptions (since any
 // document can be a secure context if it has a scheme exception). See
 // Document::isSecureContextImpl for more details.
 bool IsFrameSecure(blink::WebFrame* frame) {
   while (frame) {
     if (!frame->getSecurityOrigin().isPotentiallyTrustworthy())
       return false;
     frame = frame->parent();
   }
   return true;
 }
 
+// An WebServiceWorkerNetworkProvider for frame. This wraps
+// ServiceWorkerNetworkProvider implementation and is owned by blink.
+class WebServiceWorkerNetworkProviderForNavigation

[horo, 2017/03/10 04:43:28]

"ForNavigation" looks misleading. I think "ForFrame" is better.

This class is created when the navigation happens.
But it will be used for all requests from the frame.

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

Done.  (Does it make sense to CreateForNavigation too?  It looks a little weird
to return XForFrame from XForNavigation)

[horo, 2017/03/10 07:35:33]

I think the method name CreateForNavigation is OK.

+    : public blink::WebServiceWorkerNetworkProvider {
+ public:
+  WebServiceWorkerNetworkProviderForNavigation(
+      std::unique_ptr<ServiceWorkerNetworkProvider> provider)
+      : provider_(std::move(provider)) {}
+
+  void willSendRequest(blink::WebURLRequest& request) override {
+    RequestExtraData* extra_data =
+        static_cast<RequestExtraData*>(request.getExtraData());
+    DCHECK(extra_data);
+    extra_data->set_service_worker_provider_id(provider_->provider_id());
+  }
+
+  bool isControlledByServiceWorker() override {
+    return provider_->IsControlledByServiceWorker();
+  }
+
+  int64_t serviceWorkerID() override {
+    if (provider_->context() && provider_->context()->controller())
+      return provider_->context()->controller()->version_id();
+    return kInvalidServiceWorkerVersionId;
+  }
+
+  ServiceWorkerNetworkProvider* provider() { return provider_.get(); }
+
+ private:
+  std::unique_ptr<ServiceWorkerNetworkProvider> provider_;
+};
+
 }  // namespace
 
-void ServiceWorkerNetworkProvider::AttachToDocumentState(
-    base::SupportsUserData* datasource_userdata,
-    std::unique_ptr<ServiceWorkerNetworkProvider> network_provider) {
-  datasource_userdata->SetUserData(&kUserDataKey, network_provider.release());
-}
-
-ServiceWorkerNetworkProvider* ServiceWorkerNetworkProvider::FromDocumentState(
-    base::SupportsUserData* datasource_userdata) {
-  return static_cast<ServiceWorkerNetworkProvider*>(
-      datasource_userdata->GetUserData(&kUserDataKey));
-}
-
 // static
-std::unique_ptr<ServiceWorkerNetworkProvider>
+std::unique_ptr<blink::WebServiceWorkerNetworkProvider>
 ServiceWorkerNetworkProvider::CreateForNavigation(
     int route_id,
     const RequestNavigationParams& request_params,
     blink::WebLocalFrame* frame,
     bool content_initiated) {
   bool browser_side_navigation = IsBrowserSideNavigationEnabled();
   bool should_create_provider_for_window = false;
   int service_worker_provider_id = kInvalidServiceWorkerProviderId;
   std::unique_ptr<ServiceWorkerNetworkProvider> network_provider;
 
@@ skipping 36 matching lines @@
           service_worker_provider_id));
       network_provider = std::unique_ptr<ServiceWorkerNetworkProvider>(
           new ServiceWorkerNetworkProvider(
               route_id, SERVICE_WORKER_PROVIDER_FOR_WINDOW,
               service_worker_provider_id, is_parent_frame_secure));
     }
   } else {
     network_provider = std::unique_ptr<ServiceWorkerNetworkProvider>(
         new ServiceWorkerNetworkProvider());
   }
-  return network_provider;
+  return base::MakeUnique<WebServiceWorkerNetworkProviderForNavigation>(
+      std::move(network_provider));
+}
+
+// static
+ServiceWorkerNetworkProvider*
+ServiceWorkerNetworkProvider::GetInwardProviderForNavigation(
+    blink::WebServiceWorkerNetworkProvider* provider) {
+  return static_cast<WebServiceWorkerNetworkProviderForNavigation*>(provider)
+      ->provider();
 }
 
 ServiceWorkerNetworkProvider::ServiceWorkerNetworkProvider(
     int route_id,
     ServiceWorkerProviderType provider_type,
     int browser_provider_id,
     bool is_parent_frame_secure)
     : provider_id_(browser_provider_id) {
   if (provider_id_ == kInvalidServiceWorkerProviderId)
     return;
@@ skipping 37 matching lines @@
     return;  // May be null in some tests.
   dispatcher_host_->OnSetHostedVersionId(provider_id(), version_id,
                                          embedded_worker_id);
 }
 
 bool ServiceWorkerNetworkProvider::IsControlledByServiceWorker() const {
   return context() && context()->controller();
 }
 
 }  // namespace content