ServiceWorker: Implement StartWorker by using mojo

content/browser/service_worker/embedded_worker_test_helper.cc

Index: content/browser/service_worker/embedded_worker_test_helper.cc
diff --git a/content/browser/service_worker/embedded_worker_test_helper.cc b/content/browser/service_worker/embedded_worker_test_helper.cc
index 2b05b9bb1c2c16538663d8c6c4a805a6ca229b21..da2c920cb4024626bb9f85f162af5ec3ad640f3d 100644
--- a/content/browser/service_worker/embedded_worker_test_helper.cc
+++ b/content/browser/service_worker/embedded_worker_test_helper.cc
@@ -31,6 +31,10 @@
 #include "services/shell/public/cpp/interface_registry.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using ::testing::_;
+using ::testing::Invoke;
+using ::testing::NiceMock;
+
 namespace content {
 
 namespace {
@@ -53,6 +57,41 @@ class MockMessagePortMessageFilter : public MessagePortMessageFilter {
   ScopedVector<IPC::Message> message_queue_;
 };
 
+template <typename Interface>
+void RecursiveAddInterfaces(
+    shell::InterfaceRegistry* registry,
+    base::Callback<void(mojo::InterfaceRequest<Interface>)> factory) {
+  registry->AddInterface(factory);
+}
+
+template <typename Interface, typename... Factories>
+void RecursiveAddInterfaces(
+    shell::InterfaceRegistry* registry,
+    base::Callback<void(mojo::InterfaceRequest<Interface>)> factory,
+    Factories... factories) {
+  registry->AddInterface(factory);
+  RecursiveAddInterfaces(registry, factories...);
+}
+
+template <typename... Factories>
+std::unique_ptr<shell::InterfaceRegistry> CreateInterfaceRegistry(
+    base::WeakPtr<EmbeddedWorkerTestHelper> helper,
+    MockRenderProcessHost* rph,
+    Factories... factories) {

[dcheng, 2016/09/07 07:51:09]

I think it might be clearer to just write this out rather than use a variadic
template.

[shimazu, 2016/09/12 06:28:19]

Done.

+  std::unique_ptr<shell::InterfaceRegistry> registry(
+      new shell::InterfaceRegistry);
+  RecursiveAddInterfaces(registry.get(), factories...);
+
+  shell::mojom::InterfaceProviderPtr interfaces;
+  registry->Bind(mojo::GetProxy(&interfaces));
+
+  std::unique_ptr<shell::InterfaceProvider> remote_interfaces(
+      new shell::InterfaceProvider);
+  remote_interfaces->Bind(std::move(interfaces));
+  rph->SetRemoteInterfaces(std::move(remote_interfaces));
+  return registry;
+}
+
 }  // namespace
 
 class EmbeddedWorkerTestHelper::MockEmbeddedWorkerSetup
@@ -84,13 +123,68 @@ class EmbeddedWorkerTestHelper::MockEmbeddedWorkerSetup
   mojo::StrongBinding<mojom::EmbeddedWorkerSetup> binding_;
 };
 
+EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient::
+    MockEmbeddedWorkerInstanceClient(
+        base::WeakPtr<EmbeddedWorkerTestHelper> helper)
+    : helper_(helper), binding_(this) {
+  ON_CALL(*this, MockStartWorker(_))
+      .WillByDefault(Invoke(
+          this, &EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient::
+                    DefaultStartWorker));
+}
+
+EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient::
+    ~MockEmbeddedWorkerInstanceClient() {}
+
+void EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient::
+    DefaultStartWorker(mojom::EmbeddedWorkerStartWorkerParams* params) {
+  if (!helper_)
+    return;
+
+  embedded_worker_id_ = params->embedded_worker_id;
+
+  EmbeddedWorkerInstance* worker =
+      helper_->registry()->GetWorker(params->embedded_worker_id);
+  ASSERT_TRUE(worker != NULL);
+  EXPECT_EQ(EmbeddedWorkerStatus::STARTING, worker->status());
+
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::Bind(&EmbeddedWorkerTestHelper::OnStartWorker,
+                            helper_->weak_factory_.GetWeakPtr(),
+                            params->embedded_worker_id,
+                            params->service_worker_version_id, params->scope,
+                            params->script_url, params->pause_after_download));
+}
+
+// static
+void EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient::Bind(
+    const base::WeakPtr<EmbeddedWorkerTestHelper>& helper,
+    mojom::EmbeddedWorkerInstanceClientRequest request) {
+  ASSERT_GE(helper->mock_instance_clients()->size(),
+            helper->mock_instance_clients_next_);
+  if (helper->mock_instance_clients()->size() ==
+      helper->mock_instance_clients_next_) {
+    helper->mock_instance_clients()->push_back(
+        base::MakeUnique<NiceMock<MockEmbeddedWorkerInstanceClient>>(helper));
+  }
+
+  auto& instance_client =
+      helper->mock_instance_clients_[helper->mock_instance_clients_next_++];
+  if (instance_client)
+    instance_client->binding_.Bind(std::move(request));
+}
+
 EmbeddedWorkerTestHelper::EmbeddedWorkerTestHelper(
     const base::FilePath& user_data_directory)
     : browser_context_(new TestBrowserContext),
       render_process_host_(new MockRenderProcessHost(browser_context_.get())),
+      new_render_process_host_(
+          new MockRenderProcessHost(browser_context_.get())),
       wrapper_(new ServiceWorkerContextWrapper(browser_context_.get())),
+      mock_instance_clients_next_(0),
       next_thread_id_(0),
       mock_render_process_id_(render_process_host_->GetID()),
+      new_mock_render_process_id_(new_render_process_host_->GetID()),
       weak_factory_(this) {
   std::unique_ptr<MockServiceWorkerDatabaseTaskManager> database_task_manager(
       new MockServiceWorkerDatabaseTaskManager(
@@ -103,16 +197,16 @@ EmbeddedWorkerTestHelper::EmbeddedWorkerTestHelper(
                                     NewMessagePortMessageFilter());
 
   // Setup process level interface registry.
-  render_process_interface_registry_.reset(new shell::InterfaceRegistry);
-  render_process_interface_registry_->AddInterface(
-      base::Bind(&MockEmbeddedWorkerSetup::Create, weak_factory_.GetWeakPtr()));
-  shell::mojom::InterfaceProviderPtr interfaces;
-  render_process_interface_registry_->Bind(mojo::GetProxy(&interfaces));
-
-  std::unique_ptr<shell::InterfaceProvider> host_remote_interfaces(
-      new shell::InterfaceProvider);
-  host_remote_interfaces->Bind(std::move(interfaces));
-  render_process_host_->SetRemoteInterfaces(std::move(host_remote_interfaces));
+  auto embedded_worker_setup_factory =
+      base::Bind(&MockEmbeddedWorkerSetup::Create, weak_factory_.GetWeakPtr());
+  auto embedded_worker_instance_client_factory = base::Bind(
+      &MockEmbeddedWorkerInstanceClient::Bind, weak_factory_.GetWeakPtr());
+  render_process_interface_registry_ = CreateInterfaceRegistry(
+      weak_factory_.GetWeakPtr(), render_process_host_.get(),
+      embedded_worker_setup_factory, embedded_worker_instance_client_factory);
+  new_render_process_interface_registry_ = CreateInterfaceRegistry(
+      weak_factory_.GetWeakPtr(), new_render_process_host_.get(),
+      embedded_worker_setup_factory, embedded_worker_instance_client_factory);
 }
 
 EmbeddedWorkerTestHelper::~EmbeddedWorkerTestHelper() {
@@ -153,6 +247,17 @@ bool EmbeddedWorkerTestHelper::OnMessageReceived(const IPC::Message& message) {
   return handled;
 }
 
+void EmbeddedWorkerTestHelper::PrepareMockInstanceClients(
+    int number_of_clients) {
+  mock_instance_clients_.clear();
+  mock_instance_clients_next_ = 0;
+  for (int i = 0; i < number_of_clients; i++) {
+    mock_instance_clients_.push_back(
+        base::MakeUnique<NiceMock<MockEmbeddedWorkerInstanceClient>>(
+            weak_factory_.GetWeakPtr()));
+  }
+}
+
 ServiceWorkerContextCore* EmbeddedWorkerTestHelper::context() {
   return wrapper_->context();
 }