Revert "Create ServiceWorkerProviderHost before starting worker"

content/browser/service_worker/service_worker_write_to_cache_job_unittest.cc

 // Copyright 2014 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 <stddef.h>
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/location.h"
@@ skipping 270 matching lines @@
   ServiceWorkerWriteToCacheJobTest(const std::string& scope,
                                    const std::string& script_url)
       : scope_(scope),
         script_url_(script_url),
         browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP),
         mock_protocol_handler_(nullptr) {}
   ~ServiceWorkerWriteToCacheJobTest() override {}
 
   base::WeakPtr<ServiceWorkerProviderHost> CreateHostForVersion(
       int process_id,
+      int provider_id,
       const scoped_refptr<ServiceWorkerVersion>& version) {
     std::unique_ptr<ServiceWorkerProviderHost> host =
         CreateProviderHostForServiceWorkerContext(
-            process_id, true /* is_parent_frame_secure */, version.get(),
+            process_id, provider_id, true /* is_parent_frame_secure */,
             context()->AsWeakPtr(), &remote_endpoint_);
-    base::WeakPtr<ServiceWorkerProviderHost> host_weakptr = host->AsWeakPtr();
+    base::WeakPtr<ServiceWorkerProviderHost> provider_host = host->AsWeakPtr();
     context()->AddProviderHost(std::move(host));
-    return host_weakptr;
+    provider_host->running_hosted_version_ = version;
+    return provider_host;
   }
 
   void SetUpScriptRequest(int process_id, int provider_id) {
     request_.reset();
     url_request_context_.reset();
     url_request_job_factory_.reset();
     mock_protocol_handler_ = nullptr;
     // URLRequestJobs may post clean-up tasks on destruction.
     base::RunLoop().RunUntilIdle();
 
     url_request_context_.reset(new net::URLRequestContext);
     mock_protocol_handler_ = new MockHttpProtocolHandler(&resource_context_);
     url_request_job_factory_.reset(new net::URLRequestJobFactoryImpl);
     url_request_job_factory_->SetProtocolHandler(
         "https", base::WrapUnique(mock_protocol_handler_));
     url_request_context_->set_job_factory(url_request_job_factory_.get());
 
     request_ = url_request_context_->CreateRequest(
         script_url_, net::DEFAULT_PRIORITY, &url_request_delegate_,
         TRAFFIC_ANNOTATION_FOR_TESTS);
     ServiceWorkerRequestHandler::InitializeHandler(
         request_.get(), context_wrapper(), &blob_storage_context_, process_id,
         provider_id, false, FETCH_REQUEST_MODE_NO_CORS,
         FETCH_CREDENTIALS_MODE_OMIT, FetchRedirectMode::FOLLOW_MODE,
         RESOURCE_TYPE_SERVICE_WORKER, REQUEST_CONTEXT_TYPE_SERVICE_WORKER,
         REQUEST_CONTEXT_FRAME_TYPE_NONE,
         scoped_refptr<ResourceRequestBodyImpl>());
   }
 
+  int NextProviderId() { return next_provider_id_++; }
   int NextVersionId() { return next_version_id_++; }
 
   void SetUp() override {
+    int provider_id = NextProviderId();
     helper_.reset(new EmbeddedWorkerTestHelper(base::FilePath()));
 
     // A new unstored registration/version.
     registration_ =
         new ServiceWorkerRegistration(scope_, 1L, context()->AsWeakPtr());
     version_ =
         new ServiceWorkerVersion(registration_.get(), script_url_,
                                  NextVersionId(), context()->AsWeakPtr());
-    base::WeakPtr<ServiceWorkerProviderHost> host =
-        CreateHostForVersion(helper_->mock_render_process_id(), version_);
+    base::WeakPtr<ServiceWorkerProviderHost> host = CreateHostForVersion(
+        helper_->mock_render_process_id(), provider_id, version_);
     ASSERT_TRUE(host);
     SetUpScriptRequest(helper_->mock_render_process_id(), host->provider_id());
 
     context()->storage()->LazyInitialize(base::Bind(&EmptyCallback));
     base::RunLoop().RunUntilIdle();
   }
 
   void TearDown() override {
     request_.reset();
     url_request_context_.reset();
@@ skipping 29 matching lines @@
   }
 
   int GetResourceId(ServiceWorkerVersion* version) {
     return version->script_cache_map()->LookupResourceId(script_url_);
   }
 
   // Performs the net request for an update of |registration_|'s incumbent
   // to the script |response|. Returns the new version.
   scoped_refptr<ServiceWorkerVersion> UpdateScript(
       const std::string& response) {
+    int provider_id = NextProviderId();
     scoped_refptr<ServiceWorkerVersion> new_version =
         new ServiceWorkerVersion(registration_.get(), script_url_,
                                  NextVersionId(), context()->AsWeakPtr());
     new_version->set_pause_after_download(true);
-    base::WeakPtr<ServiceWorkerProviderHost> host =
-        CreateHostForVersion(helper_->mock_render_process_id(), new_version);
-    EXPECT_TRUE(host);
+    base::WeakPtr<ServiceWorkerProviderHost> host = CreateHostForVersion(
+        helper_->mock_render_process_id(), provider_id, new_version);
+
     SetUpScriptRequest(helper_->mock_render_process_id(), host->provider_id());
     mock_protocol_handler_->SetCreateJobCallback(
         base::Bind(&CreateResponseJob, response));
     request_->Start();
     base::RunLoop().RunUntilIdle();
     return new_version;
   }
 
   void VerifyResource(int id, const std::string& expected) {
     ASSERT_NE(kInvalidServiceWorkerResourceId, id);
@@ skipping 16 matching lines @@
   void DisableCache() { context()->storage()->disk_cache()->Disable(); }
 
  protected:
   const GURL scope_;
   const GURL script_url_;
 
   TestBrowserThreadBundle browser_thread_bundle_;
   std::unique_ptr<EmbeddedWorkerTestHelper> helper_;
   scoped_refptr<ServiceWorkerRegistration> registration_;
   scoped_refptr<ServiceWorkerVersion> version_;
+  base::WeakPtr<ServiceWorkerProviderHost> provider_host_;
   std::unique_ptr<net::URLRequestContext> url_request_context_;
   std::unique_ptr<net::URLRequestJobFactoryImpl> url_request_job_factory_;
   std::unique_ptr<net::URLRequest> request_;
   MockHttpProtocolHandler* mock_protocol_handler_;
 
   storage::BlobStorageContext blob_storage_context_;
   content::MockResourceContext resource_context_;
   ServiceWorkerRemoteProviderEndpoint remote_endpoint_;
 
   net::TestDelegate url_request_delegate_;
@@ skipping 234 matching lines @@
   mock_protocol_handler_->SetCreateJobCallback(
       base::Bind(&CreateNormalURLRequestJob));
   DisableCache();
   request_->Start();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(net::URLRequestStatus::FAILED, request_->status().status());
   EXPECT_EQ(net::ERR_FAILED, request_->status().error());
 }
 
 }  // namespace content