Create ServiceWorkerProviderHost before starting worker

content/browser/service_worker/service_worker_dispatcher_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_DISPATCHER_HOST_H_
 #define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_DISPATCHER_HOST_H_
 
 #include <stdint.h>
 
 #include <memory>
@@ skipping 26 matching lines @@
 class ServiceWorkerProviderHost;
 class ServiceWorkerRegistration;
 class ServiceWorkerRegistrationHandle;
 class ServiceWorkerVersion;
 struct ServiceWorkerObjectInfo;
 struct ServiceWorkerRegistrationObjectInfo;
 struct ServiceWorkerVersionAttributes;
 
 // This class is bound with mojom::ServiceWorkerDispatcherHost. All
 // InterfacePtrs on the same render process are bound to the same
-// content::ServiceWorkerDispatcherHost.
+// content::ServiceWorkerDispatcherHost. This can be overridden only for
+// testing.
 class CONTENT_EXPORT ServiceWorkerDispatcherHost
     : public mojom::ServiceWorkerDispatcherHost,
       public BrowserMessageFilter {
  public:
   ServiceWorkerDispatcherHost(
       int render_process_id,
       ResourceContext* resource_context);
 
   void Init(ServiceWorkerContextWrapper* context_wrapper);
 
   // BrowserMessageFilter implementation
   void OnFilterAdded(IPC::Channel* channel) override;
   void OnFilterRemoved() override;
   void OnDestruct() const override;
   bool OnMessageReceived(const IPC::Message& message) override;
 
   // IPC::Sender implementation
 
   // Send() queues the message until the underlying sender is ready.  This
   // class assumes that Send() can only fail after that when the renderer
   // process has terminated, at which point the whole instance will eventually
   // be destroyed.
   bool Send(IPC::Message* message) override;
 
-  void RegisterServiceWorkerHandle(std::unique_ptr<ServiceWorkerHandle> handle);
-  void RegisterServiceWorkerRegistrationHandle(
+  // Virtual for testing.
+  virtual void RegisterServiceWorkerHandle(
+      std::unique_ptr<ServiceWorkerHandle> handle);
+  // Virtual for testing.
+  virtual void RegisterServiceWorkerRegistrationHandle(
       std::unique_ptr<ServiceWorkerRegistrationHandle> handle);
 
   ServiceWorkerHandle* FindServiceWorkerHandle(int provider_id,
                                                int64_t version_id);
 
+  // Gets or creates the registration and version handles appropriate for
+  // representing |registration| inside of |provider_host|. Sets |out_info| and
+  // |out_attrs| accordingly for these handles.
+  void GetRegistrationObjectInfoAndVersionAttributes(
+      base::WeakPtr<ServiceWorkerProviderHost> provider_host,
+      ServiceWorkerRegistration* registration,
+      ServiceWorkerRegistrationObjectInfo* out_info,
+      ServiceWorkerVersionAttributes* out_attrs);
+
   // Returns the existing registration handle whose reference count is
   // incremented or a newly created one if it doesn't exist.
   ServiceWorkerRegistrationHandle* GetOrCreateRegistrationHandle(
       base::WeakPtr<ServiceWorkerProviderHost> provider_host,
       ServiceWorkerRegistration* registration);
 
  protected:
   ~ServiceWorkerDispatcherHost() override;
 
  private:
   friend class BrowserThread;
   friend class base::DeleteHelper<ServiceWorkerDispatcherHost>;
   friend class ServiceWorkerDispatcherHostTest;
   friend class TestingServiceWorkerDispatcherHost;
   FRIEND_TEST_ALL_PREFIXES(ServiceWorkerDispatcherHostTest,
                            ProviderCreatedAndDestroyed);
   FRIEND_TEST_ALL_PREFIXES(ServiceWorkerDispatcherHostTest,
                            CleanupOnRendererCrash);
+  FRIEND_TEST_ALL_PREFIXES(BackgroundSyncManagerTest,
+                           RegisterWithoutLiveSWRegistration);
 
   using StatusCallback = base::Callback<void(ServiceWorkerStatusCode status)>;
   enum class ProviderStatus { OK, NO_CONTEXT, DEAD_HOST, NO_HOST, NO_URL };
 
   // Called when mojom::ServiceWorkerDispatcherHostPtr is created on the
   // renderer-side.
   void AddMojoBinding(mojo::ScopedInterfaceEndpointHandle handle);
 
   // mojom::ServiceWorkerDispatcherHost implementation
   void OnProviderCreated(ServiceWorkerProviderHostInfo info) override;
-  void OnSetHostedVersionId(int provider_id,
-                            int64_t version_id,
-                            int embedded_worker_id) override;
 
   // IPC Message handlers
   void OnRegisterServiceWorker(int thread_id,
                                int request_id,
                                int provider_id,
                                const GURL& pattern,
                                const GURL& script_url);
   void OnUpdateServiceWorker(int thread_id,
                              int request_id,
                              int provider_id,
@@ skipping 68 matching lines @@
       const SourceInfo& source_info,
       const StatusCallback& callback,
       ServiceWorkerStatusCode status);
   void ReleaseSourceInfo(const ServiceWorkerClientInfo& source_info);
   void ReleaseSourceInfo(const ServiceWorkerObjectInfo& source_info);
 
   ServiceWorkerRegistrationHandle* FindRegistrationHandle(
       int provider_id,
       int64_t registration_handle_id);
 
-  void GetRegistrationObjectInfoAndVersionAttributes(
-      base::WeakPtr<ServiceWorkerProviderHost> provider_host,
-      ServiceWorkerRegistration* registration,
-      ServiceWorkerRegistrationObjectInfo* info,
-      ServiceWorkerVersionAttributes* attrs);
-
   // Callbacks from ServiceWorkerContextCore
   void RegistrationComplete(int thread_id,
                             int provider_id,
                             int request_id,
                             ServiceWorkerStatusCode status,
                             const std::string& status_message,
                             int64_t registration_id);
   void UpdateComplete(int thread_id,
                       int provider_id,
                       int request_id,
@@ skipping 57 matching lines @@
   mojo::AssociatedBindingSet<mojom::ServiceWorkerDispatcherHost> bindings_;
 
   base::WeakPtrFactory<ServiceWorkerDispatcherHost> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerDispatcherHost);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_DISPATCHER_HOST_H_