Remove InterfaceRegistry/Provider from service workers

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/fetch_event_dispatcher.mojom.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/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/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 {
@@ skipping 26 matching lines @@
   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));
   }
 
-  void ExchangeInterfaceProviders(
+  void AttachServiceWorkerEventDispatcher(
       int32_t thread_id,
-      service_manager::mojom::InterfaceProviderRequest request,
-      service_manager::mojom::InterfaceProviderPtr remote_interfaces) override {
+      mojom::ServiceWorkerEventDispatcherRequest request) override {
     if (!helper_)
       return;
-    helper_->OnSetupMojoStub(thread_id, std::move(request),
-                             std::move(remote_interfaces));
+    helper_->OnSetupMojo(thread_id, std::move(request));
   }
 
  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,
-    service_manager::mojom::InterfaceProviderPtr browser_interfaces,
-    service_manager::mojom::InterfaceProviderRequest renderer_request) {
+    mojom::ServiceWorkerEventDispatcherRequest dispatcher_request) {
   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_->AsWeakPtr(),
                  params.embedded_worker_id, params.service_worker_version_id,
                  params.scope, params.script_url, params.pause_after_download));
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::Bind(&EmbeddedWorkerTestHelper::OnSetupMojoStub,
-                            helper_->AsWeakPtr(), worker->thread_id(),
-                            base::Passed(&renderer_request),
-                            base::Passed(&browser_interfaces)));
+      FROM_HERE,
+      base::Bind(&EmbeddedWorkerTestHelper::OnSetupMojo, helper_->AsWeakPtr(),
+                 worker->thread_id(), base::Passed(&dispatcher_request)));
 }
 
 void EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient::StopWorker(
     const StopWorkerCallback& callback) {
   if (!helper_)
     return;
 
   ASSERT_TRUE(embedded_worker_id_);
   EmbeddedWorkerInstance* worker =
       helper_->registry()->GetWorker(embedded_worker_id_.value());
@@ skipping 18 matching lines @@
         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));
 }
 
-class EmbeddedWorkerTestHelper::MockFetchEventDispatcher
-    : public NON_EXPORTED_BASE(mojom::FetchEventDispatcher) {
+class EmbeddedWorkerTestHelper::MockServiceWorkerEventDispatcher
+    : public NON_EXPORTED_BASE(mojom::ServiceWorkerEventDispatcher) {
  public:
   static void Create(const base::WeakPtr<EmbeddedWorkerTestHelper>& helper,
                      int thread_id,
-                     mojom::FetchEventDispatcherRequest request) {
+                     mojom::ServiceWorkerEventDispatcherRequest request) {
     mojo::MakeStrongBinding(
-        base::MakeUnique<MockFetchEventDispatcher>(helper, thread_id),
+        base::MakeUnique<MockServiceWorkerEventDispatcher>(helper, thread_id),
         std::move(request));
   }
 
-  MockFetchEventDispatcher(
+  MockServiceWorkerEventDispatcher(
       const base::WeakPtr<EmbeddedWorkerTestHelper>& helper,
       int thread_id)
       : helper_(helper), thread_id_(thread_id) {}
 
-  ~MockFetchEventDispatcher() override {}
+  ~MockServiceWorkerEventDispatcher() override {}
 
   void DispatchFetchEvent(int fetch_event_id,
                           const ServiceWorkerFetchRequest& request,
                           mojom::FetchEventPreloadHandlePtr preload_handle,
                           const DispatchFetchEventCallback& callback) override {
     if (!helper_)
       return;
     helper_->OnFetchEventStub(thread_id_, fetch_event_id, request,
                               std::move(preload_handle), callback);
   }
 
+  void DispatchSyncEvent(
+      const std::string& tag,
+      blink::mojom::BackgroundSyncEventLastChance last_chance,
+      const DispatchSyncEventCallback& callback) override {
+    NOTIMPLEMENTED();
+  }
+
  private:
   base::WeakPtr<EmbeddedWorkerTestHelper> helper_;
   const int thread_id_;
 };
 
 EmbeddedWorkerTestHelper::EmbeddedWorkerTestHelper(
     const base::FilePath& user_data_directory)
     : browser_context_(new TestBrowserContext),
       render_process_host_(new MockRenderProcessHost(browser_context_.get())),
       new_render_process_host_(
@@ skipping 111 matching lines @@
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_PushEvent, OnPushEventStub)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   // Record all messages directed to inner script context.
   inner_sink_.OnMessageReceived(message);
   return handled;
 }
 
 void EmbeddedWorkerTestHelper::OnSetupMojo(
     int thread_id,
-    service_manager::InterfaceRegistry* interface_registry) {
-  interface_registry->AddInterface(base::Bind(&MockFetchEventDispatcher::Create,
-                                              weak_factory_.GetWeakPtr(),
-                                              thread_id));
+    mojom::ServiceWorkerEventDispatcherRequest dispatcher_request) {
+  MockServiceWorkerEventDispatcher::Create(AsWeakPtr(), thread_id,
+                                           std::move(dispatcher_request));
 }
 
 void EmbeddedWorkerTestHelper::OnActivateEvent(int embedded_worker_id,
                                                int request_id) {
   SimulateSend(new ServiceWorkerHostMsg_ActivateEventFinished(
       embedded_worker_id, request_id,
       blink::WebServiceWorkerEventResultCompleted, base::Time::Now()));
 }
 
 void EmbeddedWorkerTestHelper::OnExtendableMessageEvent(int embedded_worker_id,
@@ skipping 189 matching lines @@
 }
 
 void EmbeddedWorkerTestHelper::OnPushEventStub(
     int request_id,
     const PushEventPayload& payload) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&EmbeddedWorkerTestHelper::OnPushEvent, AsWeakPtr(),
                             current_embedded_worker_id_, request_id, payload));
 }
 
-void EmbeddedWorkerTestHelper::OnSetupMojoStub(
-    int thread_id,
-    service_manager::mojom::InterfaceProviderRequest request,
-    service_manager::mojom::InterfaceProviderPtr remote_interfaces) {
-  auto local =
-      base::MakeUnique<service_manager::InterfaceRegistry>(std::string());
-  local->Bind(std::move(request), service_manager::Identity(),
-              service_manager::InterfaceProviderSpec(),
-              service_manager::Identity(),
-              service_manager::InterfaceProviderSpec());
-
-  std::unique_ptr<service_manager::InterfaceProvider> remote(
-      new service_manager::InterfaceProvider);
-  remote->Bind(std::move(remote_interfaces));
-
-  OnSetupMojo(thread_id, local.get());
-  InterfaceRegistryAndProvider pair(std::move(local), std::move(remote));
-  thread_id_service_registry_map_[thread_id] = std::move(pair);
-}
-
 EmbeddedWorkerRegistry* EmbeddedWorkerTestHelper::registry() {
   DCHECK(context());
   return context()->embedded_worker_registry();
 }
 
 MessagePortMessageFilter*
 EmbeddedWorkerTestHelper::NewMessagePortMessageFilter() {
   scoped_refptr<MessagePortMessageFilter> filter(
       new MockMessagePortMessageFilter);
   message_port_message_filters_.push_back(filter);
@@ skipping 16 matching lines @@
                  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