Manage ServiceWorkerDispatcherHost in ServiceWorkerContextCore

content/browser/service_worker/service_worker_provider_host.h

 // Copyright 2013 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.
 
 #ifndef CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_PROVIDER_HOST_H_
 #define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_PROVIDER_HOST_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/common/content_export.h"
+#include "content/common/service_worker/service_worker_provider.h"
 #include "content/common/service_worker/service_worker_types.h"
 #include "content/public/common/request_context_frame_type.h"
 #include "content/public/common/request_context_type.h"
 #include "content/public/common/resource_type.h"
 
 namespace storage {
 class BlobStorageContext;
 }
 
 namespace content {
@@ skipping 31 matching lines @@
   // ServiceWorkerNetworkProvider will later be created in the renderer, should
   // the navigation succeed. |is_parent_frame_is_secure| should be true for main
   // frames. Otherwise it is true iff all ancestor frames of this frame have a
   // secure origin. |web_contents_getter| indicates the tab where the navigation
   // is occurring.
   static std::unique_ptr<ServiceWorkerProviderHost> PreCreateNavigationHost(
       base::WeakPtr<ServiceWorkerContextCore> context,
       bool are_ancestors_secure,
       const WebContentsGetter& web_contents_getter);
 
+  // Used to create a ServiceWorkerProviderHost when the renderer-side provider
+  // is created. This ProviderHost will be created for the process specified by
+  // |process_id|.
+  static std::unique_ptr<ServiceWorkerProviderHost> Create(
+      int process_id,
+      ServiceWorkerProviderHostInfo info,
+      base::WeakPtr<ServiceWorkerContextCore> context,
+      ServiceWorkerDispatcherHost* dispatcher_host);
+
+  static std::unique_ptr<ServiceWorkerProviderHost> CreateForTesting(

[horo, 2017/01/26 02:40:23]

How about adding "bool is_parent_frame_secure" argument?
You can remove FrameSecurityLevel::UNINITIALIZED and make
|parent_frame_security_level_| const, and remove set_parent_frame_secure().

[falken, 2017/01/26 05:15:43]

Can this be moved to a file like
service_worker/test/service_worker_test_utils.h? I'd like to avoid test-only
code in the release binary.

[shimazu, 2017/01/26 09:27:23]

Acknowledged.

[shimazu, 2017/02/07 08:47:02]

Done.

+      int process_id,
+      int provider_id,
+      ServiceWorkerProviderType type,
+      base::WeakPtr<ServiceWorkerContextCore> context,
+      int route_id = MSG_ROUTING_NONE,
+      ServiceWorkerDispatcherHost* dispatcher_host = nullptr);

[falken, 2017/01/26 05:15:43]

The style guide discourages default arguments. Could we possibly avoid them here
with better named functions (CreateForServiceWorkerContext,
CreateWithDispatcherHost, etc?). Or should everyone just pass
ServiceWorkerProviderHostInfo struct, and we have helpers for creating that Info
struct?

[shimazu, 2017/01/26 09:27:23]

Acknowledged.

[shimazu, 2017/02/07 08:47:02]

I've tried to add CreateForXXX to test_utils and used
ServcieWorkerProviderHostInfo everywhere.

+
   enum class FrameSecurityLevel { UNINITIALIZED, INSECURE, SECURE };
 
-  // When this provider host is for a Service Worker context, |route_id| is
-  // MSG_ROUTING_NONE. When this provider host is for a Document,
-  // |route_id| is the frame ID of the Document. When this provider host is for
-  // a Shared Worker, |route_id| is the Shared Worker route ID.
-  // |provider_type| gives additional information whether the provider is
-  // created for controller (ServiceWorker) or controllee (Document or
-  // SharedWorker).
-  ServiceWorkerProviderHost(int render_process_id,
-                            int route_id,
-                            int provider_id,
-                            ServiceWorkerProviderType provider_type,
-                            FrameSecurityLevel parent_frame_security_level,
-                            base::WeakPtr<ServiceWorkerContextCore> context,
-                            ServiceWorkerDispatcherHost* dispatcher_host);
   virtual ~ServiceWorkerProviderHost();
 
   const std::string& client_uuid() const { return client_uuid_; }
   int process_id() const { return render_process_id_; }
   int provider_id() const { return provider_id_; }
   int frame_id() const;
   int route_id() const { return route_id_; }
   const WebContentsGetter& web_contents_getter() const {
     return web_contents_getter_;
   }
@@ skipping 140 matching lines @@
 
   // |registration| claims the document to be controlled.
   void ClaimedByRegistration(ServiceWorkerRegistration* registration);
 
   // Called by dispatcher host to get the registration for the "ready" property.
   // Returns false if there's a completed or ongoing request for the document.
   // https://slightlyoff.github.io/ServiceWorker/spec/service_worker/#navigator-service-worker-ready
   bool GetRegistrationForReady(const GetRegistrationForReadyCallback& callback);
 
   // Methods to support cross site navigations.
-  void PrepareForCrossSiteTransfer();
+  std::unique_ptr<ServiceWorkerProviderHost> PrepareForCrossSiteTransfer();
   void CompleteCrossSiteTransfer(
       int new_process_id,
       int new_frame_id,
       int new_provider_id,
       ServiceWorkerProviderType new_provider_type,
       ServiceWorkerDispatcherHost* dispatcher_host);
   ServiceWorkerDispatcherHost* dispatcher_host() const {
     return dispatcher_host_;
   }
 
@@ skipping 56 matching lines @@
 
   struct OneShotGetReadyCallback {
     GetRegistrationForReadyCallback callback;
     bool called;
 
     explicit OneShotGetReadyCallback(
         const GetRegistrationForReadyCallback& callback);
     ~OneShotGetReadyCallback();
   };
 
+  ServiceWorkerProviderHost(int render_process_id,
+                            int route_id,
+                            int provider_id,
+                            ServiceWorkerProviderType provider_type,
+                            FrameSecurityLevel parent_frame_security_level,
+                            base::WeakPtr<ServiceWorkerContextCore> context,
+                            ServiceWorkerDispatcherHost* dispatcher_host);
+
   // ServiceWorkerRegistration::Listener overrides.
   void OnVersionAttributesChanged(
       ServiceWorkerRegistration* registration,
       ChangedVersionAttributesMask changed_mask,
       const ServiceWorkerRegistrationInfo& info) override;
   void OnRegistrationFailed(ServiceWorkerRegistration* registration) override;
   void OnRegistrationFinishedUninstalling(
       ServiceWorkerRegistration* registration) override;
   void OnSkippedWaiting(ServiceWorkerRegistration* registration) override;
 
@@ skipping 69 matching lines @@
   bool allow_association_;
 
   std::vector<base::Closure> queued_events_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerProviderHost);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_PROVIDER_HOST_H_