Create ServiceWorkerProviderHost before starting worker

content/browser/service_worker/service_worker_version.cc

 // 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.
 
 #include "content/browser/service_worker/service_worker_version.h"
 
 #include <stddef.h>
 
 #include <limits>
 #include <map>
@@ skipping 829 matching lines @@
     ServiceWorkerMetrics::EventType event_type)
     : error_callback(callback),
       start_time(time),
       start_time_ticks(time_ticks),
       event_type(event_type) {}
 
 ServiceWorkerVersion::PendingRequest::~PendingRequest() {}
 
 void ServiceWorkerVersion::OnThreadStarted() {
   DCHECK_EQ(EmbeddedWorkerStatus::STARTING, running_status());
+  DCHECK(provider_host_);
+  provider_host_->SetReadyToSendMessagesToWorker(
+      embedded_worker()->thread_id());
   // Activate ping/pong now that JavaScript execution will start.
   ping_controller_->Activate();
 }
 
 void ServiceWorkerVersion::OnStarting() {
   for (auto& observer : listeners_)
     observer.OnRunningStateChanged(this);
 }
 
+void ServiceWorkerVersion::OnStartWorkerMessageSent() {
+  DCHECK(pending_provider_host_);
+  context()->AddProviderHost(std::move(pending_provider_host_));

[kinuko, 2017/06/14 08:37:40]

I have a feeling that SetHostedVersion should be called here rather than in
PreCreate method, as we're temporarily creating a cyclic reference until this
point... wdyt?

[shimazu, 2017/06/16 04:18:44]

That's good point...
I tried to fix it by 

- moving SetHostedVersionId into CompleteStartWorkerPreparation
- having the provider host in ProviderClientInfoGetter which is newly introduced
on ps#18
- passing the getter to EWInstance::Start instead of provider_host
- using AddProviderHost and CompleteStartWorkerPreparation at the same function

I hope this makes things clearer. 
EWInstance doesn't have the provider host explicitly, and SWVersion doesn't have
the strong reference to the provider host. The references are safe if
ProviderClientInfoGetter ensures the cyclic reference doesn't happen.

+}
+
 void ServiceWorkerVersion::OnStarted() {
   DCHECK_EQ(EmbeddedWorkerStatus::RUNNING, running_status());
   RestartTick(&idle_time_);
 
   // Fire all start callbacks.
   scoped_refptr<ServiceWorkerVersion> protect(this);
   FinishStartWorker(SERVICE_WORKER_OK);
   for (auto& observer : listeners_)
     observer.OnRunningStateChanged(this);
 }
@@ skipping 590 matching lines @@
   DCHECK_EQ(EmbeddedWorkerStatus::STOPPED, running_status());
 
   if (!ServiceWorkerMetrics::ShouldExcludeSiteFromHistogram(site_for_uma_)) {
     DCHECK(!event_recorder_);
     event_recorder_ =
         base::MakeUnique<ServiceWorkerMetrics::ScopedEventRecorder>();
   }
 
   StartTimeoutTimer();
 
+  DCHECK(!pending_provider_host_);
+  pending_provider_host_ =
+      ServiceWorkerProviderHost::PreCreateForWorkerContext(this, context());
+  provider_host_ = pending_provider_host_->AsWeakPtr();
+
   auto params = base::MakeUnique<EmbeddedWorkerStartParams>();
   params->service_worker_version_id = version_id_;
   params->scope = scope_;
   params->script_url = script_url_;
   params->is_installed = IsInstalled(status_);
   params->pause_after_download = pause_after_download_;
 
   embedded_worker_->Start(
-      std::move(params), mojo::MakeRequest(&event_dispatcher_),
+      std::move(params), pending_provider_host_->AsWeakPtr(),
+      mojo::MakeRequest(&event_dispatcher_),
       base::Bind(&ServiceWorkerVersion::OnStartSentAndScriptEvaluated,
                  weak_factory_.GetWeakPtr()));
   event_dispatcher_.set_connection_error_handler(base::Bind(
       &OnEventDispatcherConnectionError, embedded_worker_->AsWeakPtr()));
 }
 
 void ServiceWorkerVersion::StartTimeoutTimer() {
   DCHECK(!timeout_timer_.IsRunning());
 
   if (embedded_worker_->devtools_attached()) {
@@ skipping 371 matching lines @@
 
 void ServiceWorkerVersion::CleanUpExternalRequest(
     const std::string& request_uuid,
     ServiceWorkerStatusCode status) {
   if (status == SERVICE_WORKER_OK)
     return;
   external_request_uuid_to_request_id_.erase(request_uuid);
 }
 
 }  // namespace content