Mojoify FetchEvent of Service Worker.

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 674827f44c391eb5938cd980c8a6a082495f4c0f..2b9644ca92a59ec6e175f9ef020e6422283563be 100644
--- a/content/browser/service_worker/embedded_worker_test_helper.cc
+++ b/content/browser/service_worker/embedded_worker_test_helper.cc
@@ -22,7 +22,9 @@
 #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_messages.h"
+#include "content/common/service_worker/service_worker_status_code.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"
@@ -59,16 +61,18 @@ class MockMessagePortMessageFilter : public MessagePortMessageFilter {
 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));
   }
 
+  explicit MockEmbeddedWorkerSetup(
+      const base::WeakPtr<EmbeddedWorkerTestHelper>& helper)
+      : helper_(helper) {}
+
+  ~MockEmbeddedWorkerSetup() override {}
+
   void ExchangeInterfaceProviders(
       int32_t thread_id,
       shell::mojom::InterfaceProviderRequest request,
@@ -132,6 +136,37 @@ void EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient::Bind(
     client->binding_.Bind(std::move(request));
 }
 
+class EmbeddedWorkerTestHelper::MockFetchEventDispatcher
+    : public NON_EXPORTED_BASE(mojom::FetchEventDispatcher) {
+ public:
+  static void Create(const base::WeakPtr<EmbeddedWorkerTestHelper>& helper,
+                     int thread_id,
+                     mojom::FetchEventDispatcherRequest request) {
+    mojo::MakeStrongBinding(
+        base::MakeUnique<MockFetchEventDispatcher>(helper, thread_id),
+        std::move(request));
+  }
+
+  MockFetchEventDispatcher(
+      const base::WeakPtr<EmbeddedWorkerTestHelper>& helper,
+      int thread_id)
+      : helper_(helper), thread_id_(thread_id) {}
+
+  ~MockFetchEventDispatcher() override {}
+
+  void DispatchFetchEvent(int response_id,
+                          const ServiceWorkerFetchRequest& request,
+                          const DispatchFetchEventCallback& callback) override {
+    if (!helper_)
+      return;
+    helper_->OnFetchEventStub(thread_id_, response_id, request, callback);
+  }
+
+ private:
+  base::WeakPtr<EmbeddedWorkerTestHelper> helper_;
+  const int thread_id_;
+};
+
 EmbeddedWorkerTestHelper::EmbeddedWorkerTestHelper(
     const base::FilePath& user_data_directory)
     : browser_context_(new TestBrowserContext),
@@ -243,7 +278,6 @@ bool EmbeddedWorkerTestHelper::OnMessageToWorker(int thread_id,
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ExtendableMessageEvent,
                         OnExtendableMessageEventStub)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_InstallEvent, OnInstallEventStub)
-    IPC_MESSAGE_HANDLER(ServiceWorkerMsg_FetchEvent, OnFetchEventStub)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_PushEvent, OnPushEventStub)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
@@ -253,7 +287,12 @@ bool EmbeddedWorkerTestHelper::OnMessageToWorker(int thread_id,
 }
 
 void EmbeddedWorkerTestHelper::OnSetupMojo(
-    shell::InterfaceRegistry* interface_registry) {}
+    int thread_id,
+    shell::InterfaceRegistry* interface_registry) {
+  interface_registry->AddInterface(base::Bind(&MockFetchEventDispatcher::Create,
+                                              weak_factory_.GetWeakPtr(),
+                                              thread_id));
+}
 
 void EmbeddedWorkerTestHelper::OnActivateEvent(int embedded_worker_id,
                                                int request_id) {
@@ -282,8 +321,8 @@ void EmbeddedWorkerTestHelper::OnInstallEvent(int embedded_worker_id,
 void EmbeddedWorkerTestHelper::OnFetchEvent(
     int embedded_worker_id,
     int response_id,
-    int event_finish_id,
-    const ServiceWorkerFetchRequest& request) {
+    const ServiceWorkerFetchRequest& request,
+    const FetchCallback& callback) {
   SimulateSend(new ServiceWorkerHostMsg_FetchEventResponse(
       embedded_worker_id, response_id,
       SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE,
@@ -295,9 +334,7 @@ void EmbeddedWorkerTestHelper::OnFetchEvent(
           std::string() /* cache_storage_cache_name */,
           ServiceWorkerHeaderList() /* cors_exposed_header_names */),
       base::Time::Now()));
-  SimulateSend(new ServiceWorkerHostMsg_FetchEventFinished(
-      embedded_worker_id, event_finish_id,
-      blink::WebServiceWorkerEventResultCompleted, base::Time::Now()));
+  callback.Run(SERVICE_WORKER_OK, base::Time::Now());
 }
 
 void EmbeddedWorkerTestHelper::OnPushEvent(int embedded_worker_id,
@@ -342,6 +379,7 @@ void EmbeddedWorkerTestHelper::SimulateWorkerScriptLoaded(
 void EmbeddedWorkerTestHelper::SimulateWorkerThreadStarted(
     int thread_id,
     int embedded_worker_id) {
+  thread_id_embedded_worker_id_map_[thread_id] = embedded_worker_id;
   EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id);
   ASSERT_TRUE(worker != NULL);
   registry()->OnWorkerThreadStarted(worker->process_id(), thread_id,
@@ -443,14 +481,15 @@ void EmbeddedWorkerTestHelper::OnInstallEventStub(int request_id) {
 }
 
 void EmbeddedWorkerTestHelper::OnFetchEventStub(
+    int thread_id,
     int response_id,
-    int event_finish_id,
-    const ServiceWorkerFetchRequest& request) {
+    const ServiceWorkerFetchRequest& request,
+    const FetchCallback& callback) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE,
-      base::Bind(&EmbeddedWorkerTestHelper::OnFetchEvent,
-                 weak_factory_.GetWeakPtr(), current_embedded_worker_id_,
-                 response_id, event_finish_id, request));
+      FROM_HERE, base::Bind(&EmbeddedWorkerTestHelper::OnFetchEvent,
+                            weak_factory_.GetWeakPtr(),
+                            thread_id_embedded_worker_id_map_[thread_id],
+                            response_id, request, callback));
 }
 
 void EmbeddedWorkerTestHelper::OnPushEventStub(
@@ -474,7 +513,7 @@ void EmbeddedWorkerTestHelper::OnSetupMojoStub(
       new shell::InterfaceProvider);
   remote->Bind(std::move(remote_interfaces));
 
-  OnSetupMojo(local.get());
+  OnSetupMojo(thread_id, local.get());
   InterfaceRegistryAndProvider pair(std::move(local), std::move(remote));
   thread_id_service_registry_map_[thread_id] = std::move(pair);
 }