ServiceWorker: Move worker candidate process knowledge to ServiceWorkerProcessManager.

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 101 matching lines @@
 }  // namespace
 
 class ServiceWorkerVersionTest : public testing::Test {
  protected:
   ServiceWorkerVersionTest()
       : thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP) {}
 
   virtual void SetUp() OVERRIDE {
     helper_.reset(new MessageReceiver());
 
+    scope_ = GURL("http://www.example.com/*");

[dominicc (has gone to gerrit), 2014/08/06 06:48:18]

Here too.

[xiang, 2014/08/11 04:50:55]

Done.

     registration_ = new ServiceWorkerRegistration(
-        GURL("http://www.example.com/*"),
+        scope_,
         GURL("http://www.example.com/service_worker.js"),
         1L,
         helper_->context()->AsWeakPtr());
     version_ = new ServiceWorkerVersion(
         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());
+    // Simulate adding one process to the scope.
+    helper_->SimulateAddProcessToScope(scope_, kRenderProcessId);
+    ASSERT_TRUE(HasProcessToRun());
   }
 
   virtual void TearDown() OVERRIDE {
     version_ = 0;
     registration_ = 0;
     helper_.reset();
   }
 
+  bool HasProcessToRun() const {
+    return helper_->context()->process_manager()->ScopeHasProcessToRun(scope_);
+  }
+
   TestBrowserThreadBundle thread_bundle_;
   scoped_ptr<MessageReceiver> helper_;
   scoped_refptr<ServiceWorkerRegistration> registration_;
   scoped_refptr<ServiceWorkerVersion> version_;
+  GURL scope_;
 
  private:
   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;
@@ skipping 164 matching lines @@
   ASSERT_EQ(5U, statuses.size());
   ASSERT_EQ(ServiceWorkerVersion::INSTALLING, statuses[0]);
   ASSERT_EQ(ServiceWorkerVersion::INSTALLED, statuses[1]);
   ASSERT_EQ(ServiceWorkerVersion::ACTIVATING, statuses[2]);
   ASSERT_EQ(ServiceWorkerVersion::ACTIVATED, statuses[3]);
   ASSERT_EQ(ServiceWorkerVersion::REDUNDANT, statuses[4]);
 }
 
 TEST_F(ServiceWorkerVersionTest, AddAndRemoveProcesses) {
   // Preparation (to reset the process count to 0).
-  ASSERT_TRUE(version_->HasProcessToRun());
+  ASSERT_TRUE(HasProcessToRun());
   version_->RemoveProcessFromWorker(kRenderProcessId);
-  ASSERT_FALSE(version_->HasProcessToRun());
+  ASSERT_FALSE(HasProcessToRun());
 
   // Add another process to the worker twice, and then remove process once.
   const int another_process_id = kRenderProcessId + 1;
   version_->AddProcessToWorker(another_process_id);
   version_->AddProcessToWorker(another_process_id);
   version_->RemoveProcessFromWorker(another_process_id);
 
   // We're ref-counting the process internally, so adding the same process
   // multiple times should be handled correctly.
-  ASSERT_TRUE(version_->HasProcessToRun());
+  ASSERT_TRUE(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());
+  ASSERT_FALSE(HasProcessToRun());
 }
 
 TEST_F(ServiceWorkerVersionTest, ScheduleStopWorker) {
   // Verify the timer is not running when version initializes its status.
   version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
   EXPECT_FALSE(version_->stop_worker_timer_.IsRunning());
 
   // Verify the timer is running when version status changes frome ACTIVATING
   // to ACTIVATED.
   ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
@@ skipping 23 matching lines @@
                                     NULL));
   version_->AddControllee(host.get());
   EXPECT_FALSE(version_->stop_worker_timer_.IsRunning());
 
   // The timer should be running if the controllee is removed.
   version_->RemoveControllee(host.get());
   EXPECT_TRUE(version_->stop_worker_timer_.IsRunning());
 }
 
 }  // namespace content