Create ServiceWorkerProviderHost before starting worker

content/browser/service_worker/service_worker_version.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_VERSION_H_
 #define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_VERSION_H_
 
 #include <stdint.h>
 
 #include <functional>
@@ skipping 285 matching lines @@
   // Adds and removes |provider_host| as a controllee of this ServiceWorker.
   void AddControllee(ServiceWorkerProviderHost* provider_host);
   void RemoveControllee(ServiceWorkerProviderHost* provider_host);
 
   // Returns if it has controllee.
   bool HasControllee() const { return !controllee_map_.empty(); }
   std::map<std::string, ServiceWorkerProviderHost*> controllee_map() {
     return controllee_map_;
   }
 
+  ServiceWorkerProviderHost* running_controller() {

[falken, 2017/06/01 08:12:35]

// The provider host hosting this version. Only valid while the version is
running.
provider_host()

[shimazu, 2017/06/06 04:16:56]

Done.

+    return running_controller_provider_.get();
+  }
+
   base::WeakPtr<ServiceWorkerContextCore> context() const { return context_; }
 
   // Adds and removes |request_job| as a dependent job not to stop the
   // ServiceWorker while |request_job| is reading the stream of the fetch event
   // response from the ServiceWorker.
   void AddStreamingURLRequestJob(const ServiceWorkerURLRequestJob* request_job);
   void RemoveStreamingURLRequestJob(
       const ServiceWorkerURLRequestJob* request_job);
 
   // Adds and removes Listeners.
@@ skipping 232 matching lines @@
 
   // The following methods all rely on the internal |tick_clock_| for the
   // current time.
   void RestartTick(base::TimeTicks* time) const;
   bool RequestExpired(const base::TimeTicks& expiration) const;
   base::TimeDelta GetTickDuration(const base::TimeTicks& time) const;
 
   // EmbeddedWorkerInstance::Listener overrides:
   void OnThreadStarted() override;
   void OnStarting() override;
+  void OnStartWorkerMessageSent() override;
   void OnStarted() override;
   void OnStopping() override;
   void OnStopped(EmbeddedWorkerStatus old_status) override;
   void OnDetached(EmbeddedWorkerStatus old_status) override;
   void OnScriptLoaded() override;
   void OnScriptLoadFailed() override;
   void OnRegisteredToDevToolsManager() override;
   void OnReportException(const base::string16& error_message,
                          int line_number,
                          int column_number,
@@ skipping 148 matching lines @@
   // Container for pending external requests for this service worker.
   // (key, value): (request uuid, request id).
   using RequestUUIDToRequestIDMap = std::map<std::string, int>;
   RequestUUIDToRequestIDMap external_request_uuid_to_request_id_;
 
   // Connected to ServiceWorkerContextClient while the worker is running.
   mojom::ServiceWorkerEventDispatcherPtr event_dispatcher_;
 
   std::set<const ServiceWorkerURLRequestJob*> streaming_url_request_jobs_;
 
+  // Keeps track of the provider hosting worker's context for this version.
+  // |pending_controller_provider_| is valid from StartWorkerInternal to
+  // OnStartWorkerMessageSent. On OnStartWorkerMessageSent, the ownership will
+  // be passed to the context.

[falken, 2017/06/01 08:12:34]

does "context" here mean ServiceWorkerContextCore? It reads like the "worker's
context" mentioned above.

[shimazu, 2017/06/06 04:16:56]

Done.

+  // |running_controller_provider_| is always valid as long as this version has
+  // the running context.
+  std::unique_ptr<ServiceWorkerProviderHost> pending_controller_provider_;
+  base::WeakPtr<ServiceWorkerProviderHost> running_controller_provider_;

[falken, 2017/06/01 08:12:35]

How about just pending_provider_host_ and provider_host_

[shimazu, 2017/06/06 04:16:56]

Done.

+
   std::map<std::string, ServiceWorkerProviderHost*> controllee_map_;
   // Will be null while shutting down.
   base::WeakPtr<ServiceWorkerContextCore> context_;
   base::ObserverList<Listener> listeners_;
   ServiceWorkerScriptCacheMap script_cache_map_;
   base::OneShotTimer update_timer_;
 
   // Starts running in StartWorker and continues until the worker is stopped.
   base::RepeatingTimer timeout_timer_;
   // Holds the time the worker last started being considered idle.
@@ skipping 92 matching lines @@
 
   // At this point |this| can have been deleted, so don't do anything other
   // than returning.
 
   return true;
 }
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_VERSION_H_