Clean up and document ServiceWorkerNetworkProvider's ctors

Make ServiceWorkerNetworkProvider's ctors private, adds
specific creation methods like:
- CreateForSharedWorker
- CreateForController

Bug: 740070
Change-Id: Ib17d50f2bf49b3895569551f805892b4c3706d38
Reviewed-on: https://chromium-review.googlesource.com/597553Reviewed-by: Matt Falkenhagen <falken@chromium.org>
Commit-Queue: Kinuko Yasuda <kinuko@chromium.org>
Cr-Commit-Position: refs/heads/master@{#491332}

content/child/service_worker/service_worker_network_provider.cc

@@ -139,27 +139,39 @@ ServiceWorkerNetworkProvider::CreateForNavigation(
     const bool is_parent_frame_secure = IsFrameSecure(frame->Parent());
 
     if (service_worker_provider_id == kInvalidServiceWorkerProviderId) {
-      network_provider = std::unique_ptr<ServiceWorkerNetworkProvider>(
-          new ServiceWorkerNetworkProvider(route_id,
-                                           SERVICE_WORKER_PROVIDER_FOR_WINDOW,
-                                           is_parent_frame_secure));
+      network_provider = base::WrapUnique(new ServiceWorkerNetworkProvider(
+          route_id, SERVICE_WORKER_PROVIDER_FOR_WINDOW, GetNextProviderId(),
+          is_parent_frame_secure));
     } else {
       CHECK(browser_side_navigation);
       DCHECK(ServiceWorkerUtils::IsBrowserAssignedProviderId(
           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));
+      network_provider = base::WrapUnique(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());
+    network_provider = base::WrapUnique(new ServiceWorkerNetworkProvider());
   }
   return base::MakeUnique<WebServiceWorkerNetworkProviderForFrame>(
       std::move(network_provider));
 }
 
+// static
+std::unique_ptr<ServiceWorkerNetworkProvider>
+ServiceWorkerNetworkProvider::CreateForSharedWorker(int route_id) {
+  return base::WrapUnique(new ServiceWorkerNetworkProvider(
+      route_id, SERVICE_WORKER_PROVIDER_FOR_SHARED_WORKER, GetNextProviderId(),
+      true /* is_parent_frame_secure */));
+}
+
+// static
+std::unique_ptr<ServiceWorkerNetworkProvider>
+ServiceWorkerNetworkProvider::CreateForController(
+    mojom::ServiceWorkerProviderInfoForStartWorkerPtr info) {
+  return base::WrapUnique(new ServiceWorkerNetworkProvider(std::move(info)));
+}
+
 // static
 ServiceWorkerNetworkProvider*
 ServiceWorkerNetworkProvider::FromWebServiceWorkerNetworkProvider(
@@ -172,6 +184,26 @@ ServiceWorkerNetworkProvider::FromWebServiceWorkerNetworkProvider(
       ->provider();
 }
 
+ServiceWorkerNetworkProvider::~ServiceWorkerNetworkProvider() {
+  if (provider_id_ == kInvalidServiceWorkerProviderId)
+    return;
+  if (!ChildThreadImpl::current())
+    return;  // May be null in some tests.
+  provider_host_.reset();
+}
+
+bool ServiceWorkerNetworkProvider::IsControlledByServiceWorker() const {
+  if (ServiceWorkerUtils::IsServicificationEnabled()) {
+    // Interception for subresource loading is not working (yet)
+    // when servicification is enabled.
+    return false;
+  }
+  return context() && context()->controller();
+}
+
+ServiceWorkerNetworkProvider::ServiceWorkerNetworkProvider()
+    : provider_id_(kInvalidServiceWorkerProviderId) {}
+
 ServiceWorkerNetworkProvider::ServiceWorkerNetworkProvider(
     int route_id,
     ServiceWorkerProviderType provider_type,
@@ -183,6 +215,11 @@ ServiceWorkerNetworkProvider::ServiceWorkerNetworkProvider(
   if (!ChildThreadImpl::current())
     return;  // May be null in some tests.
 
+  // We don't support dedicated worker (WORKER) as an independent service
+  // worker client yet.
+  DCHECK(provider_type == SERVICE_WORKER_PROVIDER_FOR_WINDOW ||
+         provider_type == SERVICE_WORKER_PROVIDER_FOR_SHARED_WORKER);
+
   ServiceWorkerProviderHostInfo host_info(provider_id_, route_id, provider_type,
                                           is_parent_frame_secure);
   host_info.host_request = mojo::MakeRequest(&provider_host_);
@@ -200,15 +237,6 @@ ServiceWorkerNetworkProvider::ServiceWorkerNetworkProvider(
   dispatcher_host_->OnProviderCreated(std::move(host_info));
 }
 
-ServiceWorkerNetworkProvider::ServiceWorkerNetworkProvider(
-    int route_id,
-    ServiceWorkerProviderType provider_type,
-    bool is_parent_frame_secure)
-    : ServiceWorkerNetworkProvider(route_id,
-                                   provider_type,
-                                   GetNextProviderId(),
-                                   is_parent_frame_secure) {}
-
 ServiceWorkerNetworkProvider::ServiceWorkerNetworkProvider(
     mojom::ServiceWorkerProviderInfoForStartWorkerPtr info)
     : provider_id_(info->provider_id) {
@@ -233,24 +261,4 @@ ServiceWorkerNetworkProvider::ServiceWorkerNetworkProvider(
   provider_host_.Bind(std::move(info->host_ptr_info));
 }
 
-ServiceWorkerNetworkProvider::ServiceWorkerNetworkProvider()
-    : provider_id_(kInvalidServiceWorkerProviderId) {}
-
-ServiceWorkerNetworkProvider::~ServiceWorkerNetworkProvider() {
-  if (provider_id_ == kInvalidServiceWorkerProviderId)
-    return;
-  if (!ChildThreadImpl::current())
-    return;  // May be null in some tests.
-  provider_host_.reset();
-}
-
-bool ServiceWorkerNetworkProvider::IsControlledByServiceWorker() const {
-  if (ServiceWorkerUtils::IsServicificationEnabled()) {
-    // Interception for subresource loading is not working (yet)
-    // when servicification is enabled.
-    return false;
-  }
-  return context() && context()->controller();
-}
-
 }  // namespace content

content/child/service_worker/service_worker_network_provider.h

@@ -47,26 +47,21 @@ class CONTENT_EXPORT ServiceWorkerNetworkProvider {
                       blink::WebLocalFrame* frame,
                       bool content_initiated);
 
+  // Creates a ServiceWorkerNetworkProvider for a shared worker (as a
+  // non-document service worker client).
+  static std::unique_ptr<ServiceWorkerNetworkProvider> CreateForSharedWorker(
+      int route_id);
+
+  // Creates a ServiceWorkerNetworkProvider for a "controller" (i.e.
+  // a service worker execution context).
+  static std::unique_ptr<ServiceWorkerNetworkProvider> CreateForController(
+      mojom::ServiceWorkerProviderInfoForStartWorkerPtr info);
+
   // Valid only for WebServiceWorkerNetworkProvider created by
   // CreateForNavigation.
   static ServiceWorkerNetworkProvider* FromWebServiceWorkerNetworkProvider(
       blink::WebServiceWorkerNetworkProvider*);
 
-  // PlzNavigate
-  // The |browser_provider_id| is initialized by the browser for navigations.
-  ServiceWorkerNetworkProvider(int route_id,
-                               ServiceWorkerProviderType type,
-                               int browser_provider_id,
-                               bool is_parent_frame_secure);
-  // This is for service worker clients.
-  ServiceWorkerNetworkProvider(int route_id,
-                               ServiceWorkerProviderType type,
-                               bool is_parent_frame_secure);
-  // This is for controllers.
-  explicit ServiceWorkerNetworkProvider(
-      mojom::ServiceWorkerProviderInfoForStartWorkerPtr info);
-
-  ServiceWorkerNetworkProvider();
   ~ServiceWorkerNetworkProvider();
 
   int provider_id() const { return provider_id_; }
@@ -79,6 +74,23 @@ class CONTENT_EXPORT ServiceWorkerNetworkProvider {
   bool IsControlledByServiceWorker() const;
 
  private:
+  ServiceWorkerNetworkProvider();
+
+  // This is for service worker clients (used in CreateForNavigation and
+  // CreateForSharedWorker). |provider_id| is provided by the browser process
+  // for navigations (with PlzNavigate, which is default).
+  // |type| must be either one of SERVICE_WORKER_PROVIDER_FOR_{WINDOW,
+  // SHARED_WORKER,WORKER} (while currently we don't have code for WORKER).
+  // |is_parent_frame_secure| is only relevant when the |type| is WINDOW.
+  ServiceWorkerNetworkProvider(int route_id,
+                               ServiceWorkerProviderType type,
+                               int provider_id,
+                               bool is_parent_frame_secure);
+
+  // This is for controllers, used in CreateForController.
+  explicit ServiceWorkerNetworkProvider(
+      mojom::ServiceWorkerProviderInfoForStartWorkerPtr info);
+
   const int provider_id_;
   scoped_refptr<ServiceWorkerProviderContext> context_;
   mojom::ServiceWorkerDispatcherHostAssociatedPtr dispatcher_host_;

content/renderer/service_worker/service_worker_context_client.cc

@@ -615,8 +615,8 @@ ServiceWorkerContextClient::ServiceWorkerContextClient(
           std::move(instance_host), main_thread_task_runner_);
   // Create a content::ServiceWorkerNetworkProvider for this data source so
   // we can observe its requests.
-  pending_network_provider_ =
-      base::MakeUnique<ServiceWorkerNetworkProvider>(std::move(provider_info));
+  pending_network_provider_ = ServiceWorkerNetworkProvider::CreateForController(
+      std::move(provider_info));
   provider_context_ = pending_network_provider_->context();
 
   TRACE_EVENT_NESTABLE_ASYNC_BEGIN1("ServiceWorker",

content/renderer/shared_worker/embedded_shared_worker_stub.cc

@@ -233,9 +233,7 @@ EmbeddedSharedWorkerStub::CreateServiceWorkerNetworkProvider() {
   // Create a content::ServiceWorkerNetworkProvider for this data source so
   // we can observe its requests.
   std::unique_ptr<ServiceWorkerNetworkProvider> provider(
-      new ServiceWorkerNetworkProvider(
-          route_id_, SERVICE_WORKER_PROVIDER_FOR_SHARED_WORKER,
-          true /* is_parent_frame_secure */));
+      ServiceWorkerNetworkProvider::CreateForSharedWorker(route_id_));
 
   // Blink is responsible for deleting the returned object.
   return base::MakeUnique<WebServiceWorkerNetworkProviderImpl>(