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..727e5e93635d73f66eeb4c0253c67358e5a1cff0 100644
--- a/content/browser/service_worker/embedded_worker_test_helper.cc
+++ b/content/browser/service_worker/embedded_worker_test_helper.cc
@@ -21,6 +21,7 @@
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/common/service_worker/embedded_worker_messages.h"
 #include "content/common/service_worker/embedded_worker_setup.mojom.h"
+#include "content/common/service_worker/embedded_worker_start_params.h"
 #include "content/common/service_worker/service_worker_messages.h"
 #include "content/public/common/push_event_payload.h"
 #include "content/public/test/mock_render_process_host.h"
@@ -84,13 +85,63 @@ class EmbeddedWorkerTestHelper::MockEmbeddedWorkerSetup
   mojo::StrongBinding<mojom::EmbeddedWorkerSetup> binding_;
 };
 
+EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient::
+    MockEmbeddedWorkerInstanceClient(
+        base::WeakPtr<EmbeddedWorkerTestHelper> helper)
+    : helper_(helper), binding_(this) {}
+
+EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient::
+    ~MockEmbeddedWorkerInstanceClient() {}
+
+void EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient::StartWorker(
+    const EmbeddedWorkerStartParams& 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<MockEmbeddedWorkerInstanceClient>(helper));
+  }
+
+  auto& instance_client =
+      helper->mock_instance_clients_[helper->mock_instance_clients_next_++];

[falken, 2016/09/13 05:48:02]

Is the |next_| thing really needed? It's possible for size() to not equal
|next_|? Looking at the code now it looks like mock_instance_clients_ is only
mutated by Bind(), in which case you shouldn't need this complexity.

If it is needed, I'd recommend some refactoring so
"helper->mock_instance_clients" isn't repeated so much. Something like

std::vector<std::unique_ptr<MockEmbeddedWorkerInstanceClient>>* clients =
helper->mock_instance_clients_;
size_t next_client_index = helper->next_mock_instance_client_index_;

ASSERT_GE(clients->size(), next_client_index);
if (clients->size() == next_client_index) {
 
clients->push_back(base::MakeUnique<MockEmbeddedWorkerInstanceClient>(helper));
}

std::unique_ptr<MockEmbeddedWorkerInstanceClient> client =
clients[next_client_index];
helper->next_mock_instance_client_index_ = next_client_index + 1;
if (client)
  client->binding_.Bind(std::move(request));

[shimazu, 2016/09/15 03:24:42]

Sorry for confusing you... This will be used in later patch. [1] is where it's
used to simulate failure of the connection.
Updated.

[1]
https://codereview.chromium.org/2307543002/diff/60001/content/browser/service...

+  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 +154,10 @@ 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));
+  render_process_interface_registry_ =
+      CreateInterfaceRegistry(render_process_host_.get());
+  new_render_process_interface_registry_ =
+      CreateInterfaceRegistry(new_render_process_host_.get());
 }
 
 EmbeddedWorkerTestHelper::~EmbeddedWorkerTestHelper() {
@@ -329,7 +374,7 @@ void EmbeddedWorkerTestHelper::SimulateSend(IPC::Message* message) {
 }
 
 void EmbeddedWorkerTestHelper::OnStartWorkerStub(
-    const EmbeddedWorkerMsg_StartWorker_Params& params) {
+    const EmbeddedWorkerStartParams& params) {
   EmbeddedWorkerInstance* worker =
       registry()->GetWorker(params.embedded_worker_id);
   ASSERT_TRUE(worker != NULL);
@@ -446,4 +491,23 @@ EmbeddedWorkerTestHelper::NewMessagePortMessageFilter() {
   return filter.get();
 }
 
+std::unique_ptr<shell::InterfaceRegistry>
+EmbeddedWorkerTestHelper::CreateInterfaceRegistry(MockRenderProcessHost* rph) {
+  std::unique_ptr<shell::InterfaceRegistry> registry(
+      new shell::InterfaceRegistry);
+  registry->AddInterface(
+      base::Bind(&MockEmbeddedWorkerSetup::Create, weak_factory_.GetWeakPtr()));
+  registry->AddInterface(base::Bind(&MockEmbeddedWorkerInstanceClient::Bind,
+                                    weak_factory_.GetWeakPtr()));
+
+  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 content