Teach EmbeddedWorkerInstance to create a process when it needs one.

content/browser/service_worker/service_worker_version_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 "base/basictypes.h"
 #include "base/run_loop.h"
 #include "content/browser/service_worker/embedded_worker_registry.h"
 #include "content/browser/service_worker/embedded_worker_test_helper.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_registration.h"
@@ skipping 15 matching lines @@
 // ---------------------------------------------------------------------------
 
 namespace content {
 
 namespace {
 
 static const int kRenderProcessId = 1;
 
 class MessageReceiver : public EmbeddedWorkerTestHelper {
  public:
-  MessageReceiver(ServiceWorkerContextCore* context)
-      : EmbeddedWorkerTestHelper(context, kRenderProcessId),
+  MessageReceiver()
+      : EmbeddedWorkerTestHelper(kRenderProcessId),
         current_embedded_worker_id_(0) {}
   virtual ~MessageReceiver() {}
 
   virtual bool OnMessageToWorker(int thread_id,
                                  int embedded_worker_id,
                                  const IPC::Message& message) OVERRIDE {
     if (EmbeddedWorkerTestHelper::OnMessageToWorker(
             thread_id, embedded_worker_id, message)) {
       return true;
     }
@@ skipping 62 matching lines @@
 };
 
 }  // namespace
 
 class ServiceWorkerVersionTest : public testing::Test {
  protected:
   ServiceWorkerVersionTest()
       : thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP) {}
 
   virtual void SetUp() OVERRIDE {
-    context_.reset(new ServiceWorkerContextCore(base::FilePath(), NULL, NULL));
-    helper_.reset(new MessageReceiver(context_.get()));
+    helper_.reset(new MessageReceiver());
 
     registration_ = new ServiceWorkerRegistration(
         GURL("http://www.example.com/*"),
         GURL("http://www.example.com/service_worker.js"),
-        1L, context_->AsWeakPtr());
+        1L,
+        helper_->context()->AsWeakPtr());
     version_ = new ServiceWorkerVersion(
-        registration_,
-        1L, context_->AsWeakPtr());
+        registration_, 1L, helper_->context()->AsWeakPtr());
 
     // Simulate adding one process to the worker.
     int embedded_worker_id = version_->embedded_worker()->embedded_worker_id();
     helper_->SimulateAddProcessToWorker(embedded_worker_id, kRenderProcessId);
     ASSERT_TRUE(version_->HasProcessToRun());
   }
 
   virtual void TearDown() OVERRIDE {
     version_ = 0;
     registration_ = 0;
     helper_.reset();
-    context_.reset();
   }
 
   TestBrowserThreadBundle thread_bundle_;
-  scoped_ptr<ServiceWorkerContextCore> context_;
   scoped_ptr<MessageReceiver> helper_;
   scoped_refptr<ServiceWorkerRegistration> registration_;
   scoped_refptr<ServiceWorkerVersion> version_;
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerVersionTest);
 };
 
 TEST_F(ServiceWorkerVersionTest, ConcurrentStartAndStop) {
   // Call StartWorker() multiple times.
   ServiceWorkerStatusCode status1 = SERVICE_WORKER_ERROR_FAILED;
   ServiceWorkerStatusCode status2 = SERVICE_WORKER_ERROR_FAILED;
   ServiceWorkerStatusCode status3 = SERVICE_WORKER_ERROR_FAILED;
-  version_->StartWorker(CreateReceiverOnCurrentThread(&status1));
-  version_->StartWorker(CreateReceiverOnCurrentThread(&status2));
+  const std::vector<int> no_processes;
+  version_->StartWorker(CreateReceiverOnCurrentThread(&status1), no_processes);
+  version_->StartWorker(CreateReceiverOnCurrentThread(&status2), no_processes);
 
   EXPECT_EQ(ServiceWorkerVersion::STARTING, version_->running_status());
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status());
 
   // Call StartWorker() after it's started.
-  version_->StartWorker(CreateReceiverOnCurrentThread(&status3));
+  version_->StartWorker(CreateReceiverOnCurrentThread(&status3), no_processes);
   base::RunLoop().RunUntilIdle();
 
   // All should just succeed.
   EXPECT_EQ(SERVICE_WORKER_OK, status1);
   EXPECT_EQ(SERVICE_WORKER_OK, status2);
   EXPECT_EQ(SERVICE_WORKER_OK, status3);
 
   // Call StopWorker() multiple times.
   status1 = SERVICE_WORKER_ERROR_FAILED;
   status2 = SERVICE_WORKER_ERROR_FAILED;
   status3 = SERVICE_WORKER_ERROR_FAILED;
   version_->StopWorker(CreateReceiverOnCurrentThread(&status1));
   version_->StopWorker(CreateReceiverOnCurrentThread(&status2));
 
   // Also try calling StartWorker while StopWorker is in queue.
-  version_->StartWorker(CreateReceiverOnCurrentThread(&status3));
+  version_->StartWorker(CreateReceiverOnCurrentThread(&status3), no_processes);
 
   EXPECT_EQ(ServiceWorkerVersion::STOPPING, version_->running_status());
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status());
 
   // All StopWorker should just succeed, while StartWorker fails.
   EXPECT_EQ(SERVICE_WORKER_OK, status1);
   EXPECT_EQ(SERVICE_WORKER_OK, status2);
   EXPECT_EQ(SERVICE_WORKER_ERROR_START_WORKER_FAILED, status3);
 }
@@ skipping 23 matching lines @@
   // SendMessage should return START_WORKER_FAILED error since it tried to
   // start a worker while it was stopping.
   EXPECT_EQ(SERVICE_WORKER_ERROR_START_WORKER_FAILED, msg_status);
 }
 
 TEST_F(ServiceWorkerVersionTest, ReSendMessageAfterStop) {
   EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status());
 
   // Start the worker.
   ServiceWorkerStatusCode start_status = SERVICE_WORKER_ERROR_FAILED;
-  version_->StartWorker(CreateReceiverOnCurrentThread(&start_status));
+  version_->StartWorker(CreateReceiverOnCurrentThread(&start_status),
+                        std::vector<int>());
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(SERVICE_WORKER_OK, start_status);
   EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status());
 
   // Stop the worker, and then send the message immediately.
   ServiceWorkerStatusCode msg_status = SERVICE_WORKER_ERROR_FAILED;
   ServiceWorkerStatusCode stop_status = SERVICE_WORKER_ERROR_FAILED;
   version_->StopWorker(CreateReceiverOnCurrentThread(&stop_status));
   version_->SendMessage(TestMsg_Message(),
                        CreateReceiverOnCurrentThread(&msg_status));
@@ skipping 113 matching lines @@
   // multiple times should be handled correctly.
   ASSERT_TRUE(version_->HasProcessToRun());
 
   // Removing the process again (so that # of AddProcess == # of RemoveProcess
   // for the process) should remove all process references.
   version_->RemoveProcessFromWorker(another_process_id);
   ASSERT_FALSE(version_->HasProcessToRun());
 }
 
 }  // namespace content