[ServiceWorker] Associate interfaces.

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_event_dispatcher.mojom.h"
 #include "content/common/service_worker/service_worker_messages.h"
 #include "content/common/service_worker/service_worker_utils.h"
 #include "content/public/common/push_event_payload.h"
+#include "content/public/test/fake_associated_interface_provider_impl.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_associated_binding.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "services/service_manager/public/cpp/interface_provider.h"
 #include "services/service_manager/public/cpp/interface_registry.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
 namespace {
 
 class MockMessagePortMessageFilter : public MessagePortMessageFilter {
@@ skipping 17 matching lines @@
 }  // namespace
 
 class EmbeddedWorkerTestHelper::MockEmbeddedWorkerSetup
     : public mojom::EmbeddedWorkerSetup {
  public:
   explicit MockEmbeddedWorkerSetup(
       const base::WeakPtr<EmbeddedWorkerTestHelper>& helper)
       : helper_(helper) {}
 
   static void Create(const base::WeakPtr<EmbeddedWorkerTestHelper>& helper,
-                     mojom::EmbeddedWorkerSetupRequest request) {
-    mojo::MakeStrongBinding(base::MakeUnique<MockEmbeddedWorkerSetup>(helper),
-                            std::move(request));
+                     mojo::ScopedInterfaceEndpointHandle handle) {
+    mojo::MakeStrongAssociatedBinding(
+        base::MakeUnique<MockEmbeddedWorkerSetup>(helper),
+        mojo::MakeAssociatedRequest<mojom::EmbeddedWorkerSetup>(
+            std::move(handle)));
   }
 
   void AttachServiceWorkerEventDispatcher(
       int32_t thread_id,
       mojom::ServiceWorkerEventDispatcherRequest request) override {
     if (!helper_)
       return;
     helper_->OnSetupMojo(thread_id, std::move(request));
   }
 
@@ skipping 44 matching lines @@
   // |worker| is possible to be null when corresponding EmbeddedWorkerInstance
   // is removed right after sending StopWorker.
   if (worker)
     EXPECT_EQ(EmbeddedWorkerStatus::STOPPING, worker->status());
   callback.Run();
 }
 
 // static
 void EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient::Bind(
     const base::WeakPtr<EmbeddedWorkerTestHelper>& helper,
-    mojom::EmbeddedWorkerInstanceClientRequest request) {
+    mojo::ScopedInterfaceEndpointHandle handle) {
   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));
+    client->binding_.Bind(
+        mojo::MakeAssociatedRequest<mojom::EmbeddedWorkerInstanceClient>(
+            std::move(handle)));
 }
 
 class EmbeddedWorkerTestHelper::MockServiceWorkerEventDispatcher
     : public NON_EXPORTED_BASE(mojom::ServiceWorkerEventDispatcher) {
  public:
   static void Create(const base::WeakPtr<EmbeddedWorkerTestHelper>& helper,
                      int thread_id,
                      mojom::ServiceWorkerEventDispatcherRequest request) {
     mojo::MakeStrongBinding(
         base::MakeUnique<MockServiceWorkerEventDispatcher>(helper, thread_id),
@@ skipping 59 matching lines @@
   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());
+  // Override process level remote associated interfaces.
+  OverrideRemoteAssociatedInterfaces(render_process_host_.get());
+  OverrideRemoteAssociatedInterfaces(new_render_process_host_.get());
 }
 
 EmbeddedWorkerTestHelper::~EmbeddedWorkerTestHelper() {
   if (wrapper_.get())
     wrapper_->Shutdown();
 }
 
 void EmbeddedWorkerTestHelper::SimulateAddProcessToPattern(const GURL& pattern,
                                                            int process_id) {
   registry()->AddChildProcessSender(process_id, this,
@@ skipping 316 matching lines @@
 }
 
 MessagePortMessageFilter*
 EmbeddedWorkerTestHelper::NewMessagePortMessageFilter() {
   scoped_refptr<MessagePortMessageFilter> filter(
       new MockMessagePortMessageFilter);
   message_port_message_filters_.push_back(filter);
   return filter.get();
 }
 
-std::unique_ptr<service_manager::InterfaceRegistry>
-EmbeddedWorkerTestHelper::CreateInterfaceRegistry(MockRenderProcessHost* rph) {
-  auto registry =
-      base::MakeUnique<service_manager::InterfaceRegistry>(std::string());
-  registry->AddInterface(
+void EmbeddedWorkerTestHelper::OverrideRemoteAssociatedInterfaces(
+    MockRenderProcessHost* rph) {
+  AssociatedInterfaceProvider* provider =
+      rph->GetAssociatedInterfaceProviderForTesting();
+
+  provider->OverrideBinderForTesting(
+      mojom::EmbeddedWorkerInstanceClient::Name_,
+      base::Bind(&MockEmbeddedWorkerInstanceClient::Bind, AsWeakPtr()));
+  provider->OverrideBinderForTesting(
+      mojom::EmbeddedWorkerSetup::Name_,
       base::Bind(&MockEmbeddedWorkerSetup::Create, AsWeakPtr()));
-  registry->AddInterface(
-      base::Bind(&MockEmbeddedWorkerInstanceClient::Bind, AsWeakPtr()));
-
-  service_manager::mojom::InterfaceProviderPtr interfaces;
-  registry->Bind(mojo::MakeRequest(&interfaces), service_manager::Identity(),
-                 service_manager::InterfaceProviderSpec(),
-                 service_manager::Identity(),
-                 service_manager::InterfaceProviderSpec());
-
-  std::unique_ptr<service_manager::InterfaceProvider> remote_interfaces(
-      new service_manager::InterfaceProvider);
-  remote_interfaces->Bind(std::move(interfaces));
-  rph->SetRemoteInterfaces(std::move(remote_interfaces));
-  return registry;
 }
 
 }  // namespace content