[ServiceWorker] Mojofy InstallEvent of Service Worker

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 <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.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/browser/service_worker/service_worker_dispatcher_host.h"
 #include "content/browser/service_worker/service_worker_test_utils.h"
 #include "content/common/background_fetch/background_fetch_types.h"
 #include "content/common/service_worker/embedded_worker_messages.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/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 "services/service_manager/public/interfaces/interface_provider.mojom.h"
@@ skipping 111 matching lines @@
         std::move(request));
   }
 
   MockServiceWorkerEventDispatcher(
       const base::WeakPtr<EmbeddedWorkerTestHelper>& helper,
       int thread_id)
       : helper_(helper), thread_id_(thread_id) {}
 
   ~MockServiceWorkerEventDispatcher() override {}
 
+  void DispatchInstallEvent(
+      mojom::ServiceWorkerInstallEventMethodsAssociatedPtrInfo client,

[shimazu, 2017/04/27 02:36:44]

Can we have a test for SWInstannEventMethods?

[xiaofengzhang, 2017/04/27 05:15:32]

Sure, I will try do it.

[xiaofengzhang, 2017/04/28 08:20:17]

Done.

+      DispatchInstallEventCallback callback) override {
+    if (!helper_)
+      return;
+    helper_->OnInstallEventStub(std::move(callback));
+  }
+
   void DispatchActivateEvent(DispatchActivateEventCallback callback) override {
     if (!helper_)
       return;
     helper_->OnActivateEventStub(std::move(callback));
   }
 
   void DispatchBackgroundFetchAbortEvent(
       const std::string& tag,
       DispatchBackgroundFetchAbortEventCallback callback) override {
     if (!helper_)
@@ skipping 238 matching lines @@
                               GetNextProviderId());
   SimulateWorkerScriptEvaluated(embedded_worker_id, true /* success */);
   SimulateWorkerStarted(embedded_worker_id);
 }
 
 void EmbeddedWorkerTestHelper::OnStopWorker(int embedded_worker_id) {
   // By default just notify the sender that the worker is stopped.
   SimulateWorkerStopped(embedded_worker_id);
 }
 
-bool EmbeddedWorkerTestHelper::OnMessageToWorker(int thread_id,
-                                                 int embedded_worker_id,
-                                                 const IPC::Message& message) {
-  bool handled = true;
-  current_embedded_worker_id_ = embedded_worker_id;
-  IPC_BEGIN_MESSAGE_MAP(EmbeddedWorkerTestHelper, message)
-    IPC_MESSAGE_HANDLER(ServiceWorkerMsg_InstallEvent, OnInstallEventStub)
-    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::OnActivateEvent(
     mojom::ServiceWorkerEventDispatcher::DispatchActivateEventCallback
         callback) {
   dispatched_events()->push_back(Event::Activate);
   std::move(callback).Run(SERVICE_WORKER_OK, base::Time::Now());
 }
 
 void EmbeddedWorkerTestHelper::OnBackgroundFetchAbortEvent(
     const std::string& tag,
     mojom::ServiceWorkerEventDispatcher::
@@ skipping 25 matching lines @@
   std::move(callback).Run(SERVICE_WORKER_OK, base::Time::Now());
 }
 
 void EmbeddedWorkerTestHelper::OnExtendableMessageEvent(
     mojom::ExtendableMessageEventPtr event,
     mojom::ServiceWorkerEventDispatcher::DispatchExtendableMessageEventCallback
         callback) {
   std::move(callback).Run(SERVICE_WORKER_OK, base::Time::Now());
 }
 
-void EmbeddedWorkerTestHelper::OnInstallEvent(int embedded_worker_id,
-                                              int request_id) {
-  // The installing worker may have been doomed and terminated.
-  if (!registry()->GetWorker(embedded_worker_id))
-    return;
-  SimulateSend(new ServiceWorkerHostMsg_InstallEventFinished(
-      embedded_worker_id, request_id,
-      blink::kWebServiceWorkerEventResultCompleted, true, base::Time::Now()));
+void EmbeddedWorkerTestHelper::OnInstallEvent(
+    mojom::ServiceWorkerEventDispatcher::DispatchInstallEventCallback
+        callback) {
+  dispatched_events()->push_back(Event::Install);
+  std::move(callback).Run(SERVICE_WORKER_OK, true /* has_fetch_handler */,
+                          base::Time::Now());
 }
 
 void EmbeddedWorkerTestHelper::OnFetchEvent(
     int /* embedded_worker_id */,
     int /* fetch_event_id */,
     const ServiceWorkerFetchRequest& /* request */,
     mojom::FetchEventPreloadHandlePtr /* preload_handle */,
     mojom::ServiceWorkerFetchResponseCallbackPtr response_callback,
     FetchCallback finish_callback) {
   response_callback->OnResponse(
@@ skipping 167 matching lines @@
                             AsWeakPtr(), embedded_worker_id));
 }
 
 void EmbeddedWorkerTestHelper::OnMessageToWorkerStub(
     int thread_id,
     int embedded_worker_id,
     const IPC::Message& message) {
   EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id);
   ASSERT_TRUE(worker);
   EXPECT_EQ(worker->thread_id(), thread_id);
-  base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE,
-      base::Bind(
-          base::IgnoreResult(&EmbeddedWorkerTestHelper::OnMessageToWorker),
-          AsWeakPtr(), thread_id, embedded_worker_id, message));
 }
 
 void EmbeddedWorkerTestHelper::OnActivateEventStub(
     mojom::ServiceWorkerEventDispatcher::DispatchActivateEventCallback
         callback) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&EmbeddedWorkerTestHelper::OnActivateEvent,
                             AsWeakPtr(), base::Passed(&callback)));
 }
 
@@ skipping 43 matching lines @@
 void EmbeddedWorkerTestHelper::OnExtendableMessageEventStub(
     mojom::ExtendableMessageEventPtr event,
     mojom::ServiceWorkerEventDispatcher::DispatchExtendableMessageEventCallback
         callback) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&EmbeddedWorkerTestHelper::OnExtendableMessageEvent,
                  AsWeakPtr(), base::Passed(&event), base::Passed(&callback)));
 }
 
-void EmbeddedWorkerTestHelper::OnInstallEventStub(int request_id) {
+void EmbeddedWorkerTestHelper::OnInstallEventStub(
+    mojom::ServiceWorkerEventDispatcher::DispatchInstallEventCallback
+        callback) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE,
-      base::Bind(&EmbeddedWorkerTestHelper::OnInstallEvent, AsWeakPtr(),
-                 current_embedded_worker_id_, request_id));
+      FROM_HERE, base::Bind(&EmbeddedWorkerTestHelper::OnInstallEvent,
+                            AsWeakPtr(), base::Passed(&callback)));
 }
 
 void EmbeddedWorkerTestHelper::OnFetchEventStub(
     int thread_id,
     int fetch_event_id,
     const ServiceWorkerFetchRequest& request,
     mojom::FetchEventPreloadHandlePtr preload_handle,
     mojom::ServiceWorkerFetchResponseCallbackPtr response_callback,
     FetchCallback finish_callback) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
@@ skipping 48 matching lines @@
                  base::Passed(&app_request), base::Passed(&response_callback),
                  base::Passed(&callback)));
 }
 
 EmbeddedWorkerRegistry* EmbeddedWorkerTestHelper::registry() {
   DCHECK(context());
   return context()->embedded_worker_registry();
 }
 
 }  // namespace content