DevTools Support for ServiceWoker.

content/browser/service_worker/embedded_worker_instance_unittest.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 "base/basictypes.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "content/browser/service_worker/embedded_worker_instance.h"
 #include "content/browser/service_worker/embedded_worker_registry.h"
 #include "content/browser/service_worker/embedded_worker_test_helper.h"
@@ skipping 37 matching lines @@
 
 static void SaveStatusAndCall(ServiceWorkerStatusCode* out,
                               const base::Closure& callback,
                               ServiceWorkerStatusCode status) {
   *out = status;
   callback.Run();
 }
 
 TEST_F(EmbeddedWorkerInstanceTest, StartAndStop) {
   scoped_ptr<EmbeddedWorkerInstance> worker =
-      embedded_worker_registry()->CreateWorker();
+      embedded_worker_registry()->CreateWorker(GURL("http://example.com/*"));
   EXPECT_EQ(EmbeddedWorkerInstance::STOPPED, worker->status());
 
   const int embedded_worker_id = worker->embedded_worker_id();
   const int64 service_worker_version_id = 55L;
-  const GURL scope("http://example.com/*");
   const GURL url("http://example.com/worker.js");
 
   // Simulate adding one process to the worker.
   helper_->SimulateAddProcessToWorker(embedded_worker_id, kRenderProcessId);
 
   // Start should succeed.
   ServiceWorkerStatusCode status;
   base::RunLoop run_loop;
   worker->Start(
       service_worker_version_id,
-      scope,
       url,
       std::vector<int>(),
       base::Bind(&SaveStatusAndCall, &status, run_loop.QuitClosure()));
   run_loop.Run();
   EXPECT_EQ(SERVICE_WORKER_OK, status);
   EXPECT_EQ(EmbeddedWorkerInstance::STARTING, worker->status());
   base::RunLoop().RunUntilIdle();
 
   // Worker started message should be notified (by EmbeddedWorkerTestHelper).
   EXPECT_EQ(EmbeddedWorkerInstance::RUNNING, worker->status());
   EXPECT_EQ(kRenderProcessId, worker->process_id());
 
   // Stop the worker.
   EXPECT_EQ(SERVICE_WORKER_OK, worker->Stop());
   EXPECT_EQ(EmbeddedWorkerInstance::STOPPING, worker->status());
   base::RunLoop().RunUntilIdle();
 
   // Worker stopped message should be notified (by EmbeddedWorkerTestHelper).
   EXPECT_EQ(EmbeddedWorkerInstance::STOPPED, worker->status());
 
   // Verify that we've sent two messages to start and terminate the worker.
   ASSERT_TRUE(ipc_sink()->GetUniqueMessageMatching(
       EmbeddedWorkerMsg_StartWorker::ID));
   ASSERT_TRUE(ipc_sink()->GetUniqueMessageMatching(
       EmbeddedWorkerMsg_StopWorker::ID));
 }
 
 TEST_F(EmbeddedWorkerInstanceTest, InstanceDestroyedBeforeStartFinishes) {
   scoped_ptr<EmbeddedWorkerInstance> worker =
-      embedded_worker_registry()->CreateWorker();
+      embedded_worker_registry()->CreateWorker(GURL("http://example.com/*"));
   EXPECT_EQ(EmbeddedWorkerInstance::STOPPED, worker->status());
 
   const int64 service_worker_version_id = 55L;
-  const GURL scope("http://example.com/*");
   const GURL url("http://example.com/worker.js");
 
   ServiceWorkerStatusCode status;
   base::RunLoop run_loop;
   // Begin starting the worker.
   std::vector<int> available_process;
   available_process.push_back(kRenderProcessId);
   worker->Start(
       service_worker_version_id,
-      scope,
       url,
       available_process,
       base::Bind(&SaveStatusAndCall, &status, run_loop.QuitClosure()));
   // But destroy it before it gets a chance to complete.
   worker.reset();
   run_loop.Run();
   EXPECT_EQ(SERVICE_WORKER_ERROR_ABORT, status);
 
   // Verify that we didn't send the message to start the worker.
   ASSERT_FALSE(
       ipc_sink()->GetUniqueMessageMatching(EmbeddedWorkerMsg_StartWorker::ID));
 }
 
 TEST_F(EmbeddedWorkerInstanceTest, ChooseProcess) {
   scoped_ptr<EmbeddedWorkerInstance> worker =
-      embedded_worker_registry()->CreateWorker();
+      embedded_worker_registry()->CreateWorker(GURL("http://example.com/*"));
   EXPECT_EQ(EmbeddedWorkerInstance::STOPPED, worker->status());
 
   // Simulate adding processes to the worker.
   // Process 1 has 1 ref, 2 has 2 refs and 3 has 3 refs.
   const int embedded_worker_id = worker->embedded_worker_id();
   helper_->SimulateAddProcessToWorker(embedded_worker_id, 1);
   helper_->SimulateAddProcessToWorker(embedded_worker_id, 2);
   helper_->SimulateAddProcessToWorker(embedded_worker_id, 2);
   helper_->SimulateAddProcessToWorker(embedded_worker_id, 3);
   helper_->SimulateAddProcessToWorker(embedded_worker_id, 3);
   helper_->SimulateAddProcessToWorker(embedded_worker_id, 3);
 
   // Process 3 has the biggest # of references and it should be chosen.
   ServiceWorkerStatusCode status;
   base::RunLoop run_loop;
   worker->Start(
       1L,
-      GURL("http://example.com/*"),
       GURL("http://example.com/worker.js"),
       std::vector<int>(),
       base::Bind(&SaveStatusAndCall, &status, run_loop.QuitClosure()));
   run_loop.Run();
   EXPECT_EQ(SERVICE_WORKER_OK, status) << ServiceWorkerStatusToString(status);
   EXPECT_EQ(EmbeddedWorkerInstance::STARTING, worker->status());
   EXPECT_EQ(3, worker->process_id());
 
   // Wait until started message is sent back.
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(EmbeddedWorkerInstance::RUNNING, worker->status());
 }
 
 }  // namespace content