Revert "Create ServiceWorkerProviderHost before starting worker"

content/browser/service_worker/service_worker_provider_host.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_provider_host.h"
 
 #include <utility>
 
 #include "base/feature_list.h"
 #include "base/guid.h"
@@ skipping 18 matching lines @@
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_features.h"
 #include "content/public/common/origin_util.h"
 #include "mojo/public/cpp/bindings/strong_associated_binding.h"
 #include "net/base/url_util.h"
 
 namespace content {
 
 namespace {
 
-// Provider host for navigation with PlzNavigate or when service worker's
-// context is created on the browser side. This function provides the next
-// ServiceWorkerProviderHost ID for them, starts at -2 and keeps going down.
-int NextBrowserProvidedProviderId() {
-  static int g_next_browser_provided_provider_id = -2;
-  return g_next_browser_provided_provider_id--;
-}
+// PlzNavigate
+// Next ServiceWorkerProviderHost ID for navigations, starts at -2 and keeps
+// going down.
+int g_next_navigation_provider_id = -2;
 
 // A request handler derivative used to handle navigation requests when
 // skip_service_worker flag is set. It tracks the document URL and sets the url
 // to the provider host.
 class ServiceWorkerURLTrackingRequestHandler
     : public ServiceWorkerRequestHandler {
  public:
   ServiceWorkerURLTrackingRequestHandler(
       base::WeakPtr<ServiceWorkerContextCore> context,
       base::WeakPtr<ServiceWorkerProviderHost> provider_host,
       base::WeakPtr<storage::BlobStorageContext> blob_storage_context,
       ResourceType resource_type)
       : ServiceWorkerRequestHandler(context,
                                     provider_host,
                                     blob_storage_context,
                                     resource_type) {}
   ~ServiceWorkerURLTrackingRequestHandler() override {}
 
   // Called via custom URLRequestJobFactory.
-  net::URLRequestJob* MaybeCreateJob(net::URLRequest* request,
-                                     net::NetworkDelegate*,
-                                     ResourceContext*) override {
+  net::URLRequestJob* MaybeCreateJob(
+      net::URLRequest* request,
+      net::NetworkDelegate* /* network_delegate */,
+      ResourceContext* /* resource_context */) override {
     // |provider_host_| may have been deleted when the request is resumed.
     if (!provider_host_)
       return nullptr;
     const GURL stripped_url = net::SimplifyUrlForRequest(request->url());
     provider_host_->SetDocumentUrl(stripped_url);
     provider_host_->SetTopmostFrameUrl(request->first_party_for_cookies());
     return nullptr;
   }
 
  private:
@@ skipping 31 matching lines @@
 ServiceWorkerProviderHost::OneShotGetReadyCallback::~OneShotGetReadyCallback() {
 }
 
 // static
 std::unique_ptr<ServiceWorkerProviderHost>
 ServiceWorkerProviderHost::PreCreateNavigationHost(
     base::WeakPtr<ServiceWorkerContextCore> context,
     bool are_ancestors_secure,
     const WebContentsGetter& web_contents_getter) {
   CHECK(IsBrowserSideNavigationEnabled());
+  // Generate a new browser-assigned id for the host.
+  int provider_id = g_next_navigation_provider_id--;
   auto host = base::WrapUnique(new ServiceWorkerProviderHost(
       ChildProcessHost::kInvalidUniqueID,
-      ServiceWorkerProviderHostInfo(
-          NextBrowserProvidedProviderId(), MSG_ROUTING_NONE,
-          SERVICE_WORKER_PROVIDER_FOR_WINDOW, are_ancestors_secure),
+      ServiceWorkerProviderHostInfo(provider_id, MSG_ROUTING_NONE,
+                                    SERVICE_WORKER_PROVIDER_FOR_WINDOW,
+                                    are_ancestors_secure),
       context, nullptr));
   host->web_contents_getter_ = web_contents_getter;
   return host;
 }
 
 // static
-std::unique_ptr<ServiceWorkerProviderHost>
-ServiceWorkerProviderHost::PreCreateForController(
-    base::WeakPtr<ServiceWorkerContextCore> context) {
-  auto host = base::WrapUnique(new ServiceWorkerProviderHost(
-      ChildProcessHost::kInvalidUniqueID,
-      ServiceWorkerProviderHostInfo(NextBrowserProvidedProviderId(),
-                                    MSG_ROUTING_NONE,
-                                    SERVICE_WORKER_PROVIDER_FOR_CONTROLLER,
-                                    true /* is_parent_frame_secure */),
-      std::move(context), nullptr));
-  return host;
-}
-
-// static
 std::unique_ptr<ServiceWorkerProviderHost> ServiceWorkerProviderHost::Create(
     int process_id,
     ServiceWorkerProviderHostInfo info,
     base::WeakPtr<ServiceWorkerContextCore> context,
     ServiceWorkerDispatcherHost* dispatcher_host) {
   return base::WrapUnique(new ServiceWorkerProviderHost(
       process_id, std::move(info), context, dispatcher_host));
 }
 
 void ServiceWorkerProviderHost::BindWorkerFetchContext(
@@ skipping 30 matching lines @@
       create_time_(base::TimeTicks::Now()),
       render_process_id_(render_process_id),
       render_thread_id_(kDocumentMainThreadId),
       info_(std::move(info)),
       context_(context),
       dispatcher_host_(dispatcher_host),
       allow_association_(true),
       binding_(this) {
   DCHECK_NE(SERVICE_WORKER_PROVIDER_UNKNOWN, info_.type);
 
+  // PlzNavigate
+  CHECK(render_process_id != ChildProcessHost::kInvalidUniqueID ||
+        IsBrowserSideNavigationEnabled());
 
   if (info_.type == SERVICE_WORKER_PROVIDER_FOR_CONTROLLER) {
-    // Actual |render_process_id| will be set after choosing a process for the
-    // controller, and |render_thread id| will be set when the service worker
-    // context gets started.
-    DCHECK_EQ(ChildProcessHost::kInvalidUniqueID, render_process_id);
+    // Actual thread id is set when the service worker context gets started.
     render_thread_id_ = kInvalidEmbeddedWorkerThreadId;
-  } else {
-    // PlzNavigate
-    DCHECK(render_process_id != ChildProcessHost::kInvalidUniqueID ||
-           IsBrowserSideNavigationEnabled());
   }
-
   context_->RegisterProviderHostByClientID(client_uuid_, this);
 
-  // |client_| and |binding_| will be bound on CompleteNavigationInitialized
-  // (PlzNavigate) or on CompleteStartWorkerPreparation (providers for
-  // controller).
-  if (!info_.client_ptr_info.is_valid() && !info_.host_request.is_pending()) {
-    DCHECK(IsBrowserSideNavigationEnabled() ||
-           info_.type == SERVICE_WORKER_PROVIDER_FOR_CONTROLLER);
+  // PlzNavigate
+  // |provider_| and |binding_| will be bound on CompleteNavigationInitialized.
+  if (IsBrowserSideNavigationEnabled()) {
+    DCHECK(!info.client_ptr_info.is_valid() && !info.host_request.is_pending());
     return;
   }
 
   provider_.Bind(std::move(info_.client_ptr_info));
   binding_.Bind(std::move(info_.host_request));
   binding_.set_connection_error_handler(base::Bind(
       &RemoveProviderHost, context_, render_process_id, info_.provider_id));
 }
 
 ServiceWorkerProviderHost::~ServiceWorkerProviderHost() {
@@ skipping 113 matching lines @@
     return;  // Could be NULL in some tests.
 
   // SetController message should be sent only for controllees.
   DCHECK(IsProviderForClient());
   Send(new ServiceWorkerMsg_SetControllerServiceWorker(
       render_thread_id_, provider_id(), GetOrCreateServiceWorkerHandle(version),
       notify_controllerchange,
       version ? version->used_features() : std::set<uint32_t>()));
 }
 
+void ServiceWorkerProviderHost::SetHostedVersion(
+    ServiceWorkerVersion* version) {
+  DCHECK(!IsProviderForClient());
+  DCHECK_EQ(EmbeddedWorkerStatus::STARTING, version->running_status());
+  DCHECK_EQ(render_process_id_, version->embedded_worker()->process_id());
+  running_hosted_version_ = version;
+}
+
 bool ServiceWorkerProviderHost::IsProviderForClient() const {
   switch (info_.type) {
     case SERVICE_WORKER_PROVIDER_FOR_WINDOW:
     case SERVICE_WORKER_PROVIDER_FOR_WORKER:
     case SERVICE_WORKER_PROVIDER_FOR_SHARED_WORKER:
       return true;
     case SERVICE_WORKER_PROVIDER_FOR_CONTROLLER:
       return false;
     case SERVICE_WORKER_PROVIDER_UNKNOWN:
       NOTREACHED() << info_.type;
@@ skipping 307 matching lines @@
   // Increase the references because the process which this provider host will
   // host has been decided.
   for (const GURL& pattern : associated_patterns_)
     IncreaseProcessReference(pattern);
   for (auto& key_registration : matching_registrations_)
     IncreaseProcessReference(key_registration.second->pattern());
 
   NotifyControllerToAssociatedProvider();
 }
 
-mojom::ServiceWorkerProviderInfoForStartWorkerPtr
-ServiceWorkerProviderHost::CompleteStartWorkerPreparation(
-    int process_id,
-    scoped_refptr<ServiceWorkerVersion> hosted_version) {
-  DCHECK(context_);
-  DCHECK_EQ(kInvalidEmbeddedWorkerThreadId, render_thread_id_);
-  DCHECK_EQ(ChildProcessHost::kInvalidUniqueID, render_process_id_);
-  DCHECK_EQ(SERVICE_WORKER_PROVIDER_FOR_CONTROLLER, provider_type());
-  DCHECK(!running_hosted_version_);
-
-  DCHECK_NE(ChildProcessHost::kInvalidUniqueID, process_id);
-
-  running_hosted_version_ = std::move(hosted_version);
-
-  ServiceWorkerDispatcherHost* dispatcher_host =
-      context_->GetDispatcherHost(process_id);
-  DCHECK(dispatcher_host);
-  render_process_id_ = process_id;
-  dispatcher_host_ = dispatcher_host;
-
-  // Retrieve the registration associated with |version|. The registration
-  // must be alive because the version keeps it during starting worker.
-  ServiceWorkerRegistration* registration = context_->GetLiveRegistration(
-      running_hosted_version()->registration_id());
-  DCHECK(registration);
-  ServiceWorkerRegistrationObjectInfo info;
-  ServiceWorkerVersionAttributes attrs;
-  dispatcher_host->GetRegistrationObjectInfoAndVersionAttributes(
-      AsWeakPtr(), registration, &info, &attrs);
-
-  // Initialize provider_info.
-  mojom::ServiceWorkerProviderInfoForStartWorkerPtr provider_info =
-      mojom::ServiceWorkerProviderInfoForStartWorker::New();
-  provider_info->provider_id = provider_id();
-  provider_info->attributes = std::move(attrs);
-  provider_info->registration = std::move(info);
-  provider_info->client_request = mojo::MakeRequest(&provider_);
-  binding_.Bind(mojo::MakeRequest(&provider_info->host_ptr_info));
-  binding_.set_connection_error_handler(
-      base::Bind(&RemoveProviderHost, context_, process_id, provider_id()));
-
-  // Set the document URL to the script url in order to allow
-  // register/unregister/getRegistration on ServiceWorkerGlobalScope.
-  SetDocumentUrl(running_hosted_version()->script_url());
-
-  return provider_info;
-}
-
 void ServiceWorkerProviderHost::SendUpdateFoundMessage(
     int registration_handle_id) {
   if (!dispatcher_host_)
     return;  // Could be nullptr in some tests.
 
   if (!IsReadyToSendMessages()) {
     queued_events_.push_back(
         base::Bind(&ServiceWorkerProviderHost::SendUpdateFoundMessage,
                    AsWeakPtr(), registration_handle_id));
     return;
@@ skipping 159 matching lines @@
           render_thread_id_, provider_id(),
           GetOrCreateServiceWorkerHandle(
               associated_registration_->active_version()),
           false /* shouldNotifyControllerChange */,
           associated_registration_->active_version()->used_features()));
     }
   }
 }
 
 }  // namespace content