Revert of ServiceWorker: Implement StartWorker by using mojo

content/browser/service_worker/embedded_worker_test_helper.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 "content/browser/service_worker/embedded_worker_test_helper.h"
 
 #include <map>
 #include <string>
 #include <utility>
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/memory/scoped_vector.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "content/browser/message_port_message_filter.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_status.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #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"
 #include "content/public/test/test_browser_context.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "services/shell/public/cpp/interface_provider.h"
 #include "services/shell/public/cpp/interface_registry.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 41 matching lines @@
     if (!helper_)
       return;
     helper_->OnSetupMojoStub(thread_id, std::move(request),
                              std::move(remote_interfaces));
   }
 
  private:
   base::WeakPtr<EmbeddedWorkerTestHelper> helper_;
 };
 
-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) {
-  std::vector<std::unique_ptr<MockEmbeddedWorkerInstanceClient>>* clients =
-      helper->mock_instance_clients();
-  size_t next_client_index = helper->mock_instance_clients_next_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->at(next_client_index);
-  helper->mock_instance_clients_next_index_ = next_client_index + 1;
-  if (client)
-    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_index_(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(
           base::ThreadTaskRunnerHandle::Get()));
   wrapper_->InitInternal(user_data_directory, std::move(database_task_manager),
                          base::ThreadTaskRunnerHandle::Get(), nullptr, nullptr);
   wrapper_->process_manager()->SetProcessIdForTest(mock_render_process_id());
   wrapper_->process_manager()->SetNewProcessIdForTest(new_render_process_id());
   registry()->AddChildProcessSender(mock_render_process_id_, this,
                                     NewMessagePortMessageFilter());
 
   // Setup process level interface registry.
-  render_process_interface_registry_ =
-      CreateInterfaceRegistry(render_process_host_.get());
-  new_render_process_interface_registry_ =
-      CreateInterfaceRegistry(new_render_process_host_.get());
+  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));
 }
 
 EmbeddedWorkerTestHelper::~EmbeddedWorkerTestHelper() {
   if (wrapper_.get())
     wrapper_->Shutdown();
 }
 
 void EmbeddedWorkerTestHelper::SimulateAddProcessToPattern(const GURL& pattern,
                                                            int process_id) {
   registry()->AddChildProcessSender(process_id, this,
@@ skipping 196 matching lines @@
   if (worker != NULL)
     registry()->OnWorkerStopped(worker->process_id(), embedded_worker_id);
 }
 
 void EmbeddedWorkerTestHelper::SimulateSend(IPC::Message* message) {
   registry()->OnMessageReceived(*message, mock_render_process_id_);
   delete message;
 }
 
 void EmbeddedWorkerTestHelper::OnStartWorkerStub(
-    const EmbeddedWorkerStartParams& params) {
+    const EmbeddedWorkerMsg_StartWorker_Params& params) {
   EmbeddedWorkerInstance* worker =
       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,
                  weak_factory_.GetWeakPtr(), params.embedded_worker_id,
                  params.service_worker_version_id, params.scope,
                  params.script_url, params.pause_after_download));
@@ skipping 96 matching lines @@
 }
 
 MessagePortMessageFilter*
 EmbeddedWorkerTestHelper::NewMessagePortMessageFilter() {
   scoped_refptr<MessagePortMessageFilter> filter(
       new MockMessagePortMessageFilter);
   message_port_message_filters_.push_back(filter);
   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