Mojoify FetchEvent of Service Worker.

I'd like to use Mojo to send navigation preload response (crbug.com/649558) from
the browser process to the service worker. But currently we are using the legacy
IPC when the browser process sends the FetchEvent to the service worker. There
will be an ordering issue if we use both the legacy IPC and Mojo IPC.

To avoid the ordering issue, this CL changes the FetchEvent IPC to use Mojo.

BUG=629701,649558

Review-Url: https://codereview.chromium.org/2352173004
Cr-Commit-Position: refs/heads/master@{#422996}

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);
 }

content/browser/service_worker/embedded_worker_test_helper.h

@@ -16,7 +16,9 @@
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/optional.h"
+#include "base/time/time.h"
 #include "content/common/service_worker/embedded_worker.mojom.h"
+#include "content/common/service_worker/service_worker_status_code.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_test_sink.h"
 #include "mojo/public/cpp/bindings/binding.h"
@@ -63,6 +65,10 @@ struct ServiceWorkerFetchRequest;
 class EmbeddedWorkerTestHelper : public IPC::Sender,
                                  public IPC::Listener {
  public:
+  using FetchCallback =
+      base::Callback<void(ServiceWorkerStatusCode,
+                          base::Time /* dispatch_event_time */)>;
+
   class MockEmbeddedWorkerInstanceClient
       : public mojom::EmbeddedWorkerInstanceClient {
    public:
@@ -150,7 +156,8 @@ class EmbeddedWorkerTestHelper : public IPC::Sender,
 
   // Called to setup mojo for a new embedded worker. Override to register
   // interfaces the worker should expose to the browser.
-  virtual void OnSetupMojo(shell::InterfaceRegistry* interface_registry);
+  virtual void OnSetupMojo(int thread_id,
+                           shell::InterfaceRegistry* interface_registry);
 
   // On*Event handlers. Called by the default implementation of
   // OnMessageToWorker when events are sent to the embedded
@@ -161,8 +168,8 @@ class EmbeddedWorkerTestHelper : public IPC::Sender,
   virtual void OnInstallEvent(int embedded_worker_id, int request_id);
   virtual void OnFetchEvent(int embedded_worker_id,
                             int response_id,
-                            int event_finish_id,
-                            const ServiceWorkerFetchRequest& request);
+                            const ServiceWorkerFetchRequest& request,
+                            const FetchCallback& callback);
   virtual void OnPushEvent(int embedded_worker_id,
                            int request_id,
                            const PushEventPayload& payload);
@@ -186,6 +193,7 @@ class EmbeddedWorkerTestHelper : public IPC::Sender,
                 std::unique_ptr<shell::InterfaceProvider>>;
 
   class MockEmbeddedWorkerSetup;
+  class MockFetchEventDispatcher;
 
   void OnStartWorkerStub(const EmbeddedWorkerStartParams& params);
   void OnResumeAfterDownloadStub(int embedded_worker_id);
@@ -198,9 +206,10 @@ class EmbeddedWorkerTestHelper : public IPC::Sender,
       int request_id,
       const ServiceWorkerMsg_ExtendableMessageEvent_Params& params);
   void OnInstallEventStub(int request_id);
-  void OnFetchEventStub(int response_id,
-                        int event_finish_id,
-                        const ServiceWorkerFetchRequest& request);
+  void OnFetchEventStub(int thread_id,
+                        int response_id,
+                        const ServiceWorkerFetchRequest& request,
+                        const FetchCallback& callback);
   void OnPushEventStub(int request_id, const PushEventPayload& payload);
   void OnSetupMojoStub(int thread_id,
                        shell::mojom::InterfaceProviderRequest services,
@@ -233,6 +242,8 @@ class EmbeddedWorkerTestHelper : public IPC::Sender,
       new_render_process_interface_registry_;
 
   std::map<int, int64_t> embedded_worker_id_service_worker_version_id_map_;
+  std::map<int /* thread_id */, int /* embedded_worker_id */>
+      thread_id_embedded_worker_id_map_;
 
   // Stores the InterfaceRegistry/InterfaceProviders that are associated with
   // each individual service worker.

content/browser/service_worker/service_worker_fetch_dispatcher.cc

@@ -12,7 +12,9 @@
 #include "base/trace_event/trace_event.h"
 #include "content/browser/service_worker/embedded_worker_status.h"
 #include "content/browser/service_worker/service_worker_version.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/common/service_worker/service_worker_utils.h"
 #include "net/log/net_log.h"
 #include "net/log/net_log_capture_mode.h"
@@ -74,6 +76,14 @@ ServiceWorkerMetrics::EventType FetchTypeToWaitUntilEventType(
   return ServiceWorkerMetrics::EventType::FETCH_WAITUNTIL;
 }
 
+void OnFetchEventFinished(ServiceWorkerVersion* version,
+                          int event_finish_id,
+                          ServiceWorkerStatusCode status,
+                          base::Time dispatch_event_time) {
+  version->FinishRequest(event_finish_id, status != SERVICE_WORKER_ERROR_ABORT,
+                         dispatch_event_time);
+}
+
 }  // namespace
 
 // Helper to receive the fetch event response even if
@@ -211,11 +221,16 @@ void ServiceWorkerFetchDispatcher::DispatchFetchEvent() {
       response_id,
       base::Bind(&ServiceWorkerFetchDispatcher::ResponseCallback::Run,
                  base::Owned(response_callback)));
-  version_->RegisterSimpleRequest<ServiceWorkerHostMsg_FetchEventFinished>(
-      event_finish_id);
-  version_->DispatchEvent({response_id, event_finish_id},
-                          ServiceWorkerMsg_FetchEvent(
-                              response_id, event_finish_id, *request_.get()));
+
+  base::WeakPtr<mojom::FetchEventDispatcher> dispatcher =
+      version_->GetMojoServiceForRequest<mojom::FetchEventDispatcher>(
+          event_finish_id);
+  // |dispatcher| is owned by |version_|. So it is safe to pass the unretained
+  // raw pointer of |version_| to OnFetchEventFinished callback.
+  dispatcher->DispatchFetchEvent(
+      response_id, *request_,
+      base::Bind(&OnFetchEventFinished, base::Unretained(version_.get()),
+                 event_finish_id));
 }
 
 void ServiceWorkerFetchDispatcher::DidFailToDispatch(

content/browser/service_worker/service_worker_url_request_job_unittest.cc

@@ -33,6 +33,7 @@
 #include "content/browser/streams/stream_registry.h"
 #include "content/common/resource_request_body_impl.h"
 #include "content/common/service_worker/service_worker_messages.h"
+#include "content/common/service_worker/service_worker_status_code.h"
 #include "content/public/browser/blob_handle.h"
 #include "content/public/common/request_context_frame_type.h"
 #include "content/public/common/request_context_type.h"
@@ -363,8 +364,8 @@ class ProviderDeleteHelper : public EmbeddedWorkerTestHelper {
  protected:
   void OnFetchEvent(int embedded_worker_id,
                     int response_id,
-                    int event_finish_id,
-                    const ServiceWorkerFetchRequest& request) override {
+                    const ServiceWorkerFetchRequest& request,
+                    const FetchCallback& callback) override {
     context()->RemoveProviderHost(mock_render_process_id(), kProviderID);
     SimulateSend(new ServiceWorkerHostMsg_FetchEventResponse(
         embedded_worker_id, response_id,
@@ -377,9 +378,7 @@ class ProviderDeleteHelper : public EmbeddedWorkerTestHelper {
             std::string() /* response_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());
   }
 
  private:
@@ -448,8 +447,8 @@ class BlobResponder : public EmbeddedWorkerTestHelper {
  protected:
   void OnFetchEvent(int embedded_worker_id,
                     int response_id,
-                    int event_finish_id,
-                    const ServiceWorkerFetchRequest& request) override {
+                    const ServiceWorkerFetchRequest& request,
+                    const FetchCallback& callback) override {
     SimulateSend(new ServiceWorkerHostMsg_FetchEventResponse(
         embedded_worker_id, response_id,
         SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE,
@@ -461,9 +460,7 @@ class BlobResponder : public EmbeddedWorkerTestHelper {
             std::string() /* response_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());
   }
 
   std::string blob_uuid_;
@@ -532,8 +529,8 @@ class StreamResponder : public EmbeddedWorkerTestHelper {
  protected:
   void OnFetchEvent(int embedded_worker_id,
                     int response_id,
-                    int event_finish_id,
-                    const ServiceWorkerFetchRequest& request) override {
+                    const ServiceWorkerFetchRequest& request,
+                    const FetchCallback& callback) override {
     SimulateSend(new ServiceWorkerHostMsg_FetchEventResponse(
         embedded_worker_id, response_id,
         SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE,
@@ -545,9 +542,7 @@ class StreamResponder : public EmbeddedWorkerTestHelper {
             std::string() /* response_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());
   }
 
   const GURL stream_url_;
@@ -847,9 +842,10 @@ class FailFetchHelper : public EmbeddedWorkerTestHelper {
  protected:
   void OnFetchEvent(int embedded_worker_id,
                     int response_id,
-                    int event_finish_id,
-                    const ServiceWorkerFetchRequest& request) override {
+                    const ServiceWorkerFetchRequest& request,
+                    const FetchCallback& callback) override {
     SimulateWorkerStopped(embedded_worker_id);
+    callback.Run(SERVICE_WORKER_ERROR_ABORT, base::Time::Now());
   }
 
  private:
@@ -952,18 +948,15 @@ class EarlyResponseHelper : public EmbeddedWorkerTestHelper {
   ~EarlyResponseHelper() override {}
 
   void FinishWaitUntil() {
-    SimulateSend(new ServiceWorkerHostMsg_FetchEventFinished(
-        embedded_worker_id_, event_finish_id_,
-        blink::WebServiceWorkerEventResultCompleted, base::Time::Now()));
+    callback_.Run(SERVICE_WORKER_OK, base::Time::Now());
   }
 
  protected:
   void OnFetchEvent(int embedded_worker_id,
                     int response_id,
-                    int event_finish_id,
-                    const ServiceWorkerFetchRequest& request) override {
-    embedded_worker_id_ = embedded_worker_id;
-    event_finish_id_ = event_finish_id;
+                    const ServiceWorkerFetchRequest& request,
+                    const FetchCallback& callback) override {
+    callback_ = callback;
     SimulateSend(new ServiceWorkerHostMsg_FetchEventResponse(
         embedded_worker_id, response_id,
         SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE,
@@ -978,8 +971,7 @@ class EarlyResponseHelper : public EmbeddedWorkerTestHelper {
   }
 
  private:
-  int embedded_worker_id_ = 0;
-  int event_finish_id_ = 0;
+  FetchCallback callback_;
   DISALLOW_COPY_AND_ASSIGN(EarlyResponseHelper);
 };
 
@@ -1008,6 +1000,7 @@ TEST_F(ServiceWorkerURLRequestJobTest, EarlyResponse) {
 
   EXPECT_TRUE(version_->HasWork());
   helper->FinishWaitUntil();
+  base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(version_->HasWork());
 }
 
@@ -1029,25 +1022,23 @@ class DelayedResponseHelper : public EmbeddedWorkerTestHelper {
             std::string() /* response_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());
   }
 
  protected:
   void OnFetchEvent(int embedded_worker_id,
                     int response_id,
-                    int event_finish_id,
-                    const ServiceWorkerFetchRequest& request) override {
+                    const ServiceWorkerFetchRequest& request,
+                    const FetchCallback& callback) override {
     embedded_worker_id_ = embedded_worker_id;
     response_id_ = response_id;
-    event_finish_id_ = event_finish_id;
+    callback_ = callback;
   }
 
  private:
   int embedded_worker_id_ = 0;
   int response_id_ = 0;
-  int event_finish_id_ = 0;
+  FetchCallback callback_;
   DISALLOW_COPY_AND_ASSIGN(DelayedResponseHelper);
 };
 

content/browser/service_worker/service_worker_version_unittest.cc

@@ -374,7 +374,7 @@ class MessageReceiverMojoTestService : public MessageReceiver {
   MessageReceiverMojoTestService() : MessageReceiver() {}
   ~MessageReceiverMojoTestService() override {}
 
-  void OnSetupMojo(shell::InterfaceRegistry* registry) override {
+  void OnSetupMojo(int thread_id, shell::InterfaceRegistry* registry) override {
     registry->AddInterface(base::Bind(&TestMojoServiceImpl::Create));
   }
 

content/common/BUILD.gn

@@ -569,6 +569,7 @@ mojom("mojo_bindings") {
     "renderer.mojom",
     "service_worker/embedded_worker.mojom",
     "service_worker/embedded_worker_setup.mojom",
+    "service_worker/fetch_event_dispatcher.mojom",
     "storage_partition_service.mojom",
     "url_loader.mojom",
     "url_loader_factory.mojom",
@@ -581,6 +582,7 @@ mojom("mojo_bindings") {
     "//content/public/common:interfaces",
     "//device/sensors/public/interfaces",
     "//ipc:mojom",
+    "//mojo/common:common_custom_types",
     "//services/shell/public/interfaces",
     "//services/ui/public/interfaces",
     "//skia/public/interfaces",

content/common/service_worker/fetch_event_dispatcher.mojom

+// Copyright 2016 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.
+
+module content.mojom;
+
+import "mojo/common/common_custom_types.mojom";
+import "third_party/WebKit/public/platform/modules/serviceworker/service_worker_event_status.mojom";
+
+[Native]
+struct ServiceWorkerFetchRequest;
+
+interface FetchEventDispatcher {
+  DispatchFetchEvent(int32 response_id, ServiceWorkerFetchRequest request)
+      => (blink.mojom.ServiceWorkerEventStatus status,
+          mojo.common.mojom.Time dispatch_event_time);
+};

content/common/service_worker/fetch_event_dispatcher.typemap

+# Copyright 2016 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.
+
+mojom = "//content/common/service_worker/fetch_event_dispatcher.mojom"
+public_headers = [
+  "//content/common/service_worker/service_worker_status_code.h",
+  "//content/common/service_worker/service_worker_types.h",
+]
+sources = [
+  "//content/common/service_worker/service_worker_status_code_traits.cc",
+]
+traits_headers = [
+  "//content/common/service_worker/service_worker_messages.h",
+  "//content/common/service_worker/service_worker_status_code_traits.h",
+]
+type_mappings = [
+  "content.mojom.ServiceWorkerFetchRequest=::content::ServiceWorkerFetchRequest",
+  "blink.mojom.ServiceWorkerEventStatus=::content::ServiceWorkerStatusCode",
+]

content/common/service_worker/service_worker_messages.h

@@ -275,10 +275,6 @@ IPC_MESSAGE_ROUTED4(ServiceWorkerHostMsg_FetchEventResponse,
                     content::ServiceWorkerFetchEventResult,
                     content::ServiceWorkerResponse,
                     base::Time /* dispatch_event_time */)
-IPC_MESSAGE_ROUTED3(ServiceWorkerHostMsg_FetchEventFinished,
-                    int /* event_finish_id */,
-                    blink::WebServiceWorkerEventResult,
-                    base::Time /* dispatch_event_time */)
 IPC_MESSAGE_ROUTED3(ServiceWorkerHostMsg_NotificationClickEventFinished,
                     int /* request_id */,
                     blink::WebServiceWorkerEventResult,
@@ -491,10 +487,6 @@ IPC_MESSAGE_CONTROL1(ServiceWorkerMsg_ActivateEvent,
 IPC_MESSAGE_CONTROL2(ServiceWorkerMsg_ExtendableMessageEvent,
                      int /* request_id */,
                      ServiceWorkerMsg_ExtendableMessageEvent_Params)
-IPC_MESSAGE_CONTROL3(ServiceWorkerMsg_FetchEvent,
-                     int /* response_id */,
-                     int /* event_finish_id */,
-                     content::ServiceWorkerFetchRequest)
 IPC_MESSAGE_CONTROL4(ServiceWorkerMsg_NotificationClickEvent,
                      int /* request_id */,
                      std::string /* notification_id */,

content/common/service_worker/service_worker_status_code_traits.cc

+// Copyright 2016 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/common/service_worker/service_worker_status_code_traits.h"
+
+#include "base/logging.h"
+#include "content/common/service_worker/service_worker_status_code.h"
+#include "third_party/WebKit/public/platform/modules/serviceworker/service_worker_event_status.mojom.h"
+
+namespace mojo {
+
+// static
+blink::mojom::ServiceWorkerEventStatus EnumTraits<
+    blink::mojom::ServiceWorkerEventStatus,
+    content::ServiceWorkerStatusCode>::ToMojom(content::ServiceWorkerStatusCode
+                                                   input) {
+  switch (input) {
+    case content::SERVICE_WORKER_OK:
+      return blink::mojom::ServiceWorkerEventStatus::COMPLETED;
+    case content::SERVICE_WORKER_ERROR_EVENT_WAITUNTIL_REJECTED:
+      return blink::mojom::ServiceWorkerEventStatus::REJECTED;
+    case content::SERVICE_WORKER_ERROR_ABORT:
+      return blink::mojom::ServiceWorkerEventStatus::ABORTED;
+    default:
+      NOTREACHED() << "Unexpected ServiceWorkerStatusCode: " << input;
+      return blink::mojom::ServiceWorkerEventStatus::ABORTED;
+  }
+}
+
+// static
+bool EnumTraits<blink::mojom::ServiceWorkerEventStatus,
+                content::ServiceWorkerStatusCode>::
+    FromMojom(blink::mojom::ServiceWorkerEventStatus input,
+              content::ServiceWorkerStatusCode* out) {
+  switch (input) {
+    case blink::mojom::ServiceWorkerEventStatus::COMPLETED:
+      *out = content::SERVICE_WORKER_OK;
+      return true;
+    case blink::mojom::ServiceWorkerEventStatus::REJECTED:
+      *out = content::SERVICE_WORKER_ERROR_EVENT_WAITUNTIL_REJECTED;
+      return true;
+    case blink::mojom::ServiceWorkerEventStatus::ABORTED:
+      *out = content::SERVICE_WORKER_ERROR_ABORT;
+      return true;
+  }
+  NOTREACHED();
+  return false;
+}
+
+}  // namespace content

content/common/service_worker/service_worker_status_code_traits.h

+// Copyright 2016 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.
+
+#ifndef CONTENT_COMMON_SERVICE_WORKER_SERVICE_WORKER_STATUS_CODE_TRAITS_H_
+#define CONTENT_COMMON_SERVICE_WORKER_SERVICE_WORKER_STATUS_CODE_TRAITS_H_
+
+#include "content/common/service_worker/service_worker_status_code.h"
+#include "third_party/WebKit/public/platform/modules/serviceworker/service_worker_event_status.mojom.h"
+
+namespace mojo {
+
+template <>
+struct EnumTraits<blink::mojom::ServiceWorkerEventStatus,
+                  content::ServiceWorkerStatusCode> {
+  static blink::mojom::ServiceWorkerEventStatus ToMojom(
+      content::ServiceWorkerStatusCode input);
+
+  static bool FromMojom(blink::mojom::ServiceWorkerEventStatus input,
+                        content::ServiceWorkerStatusCode* out);
+};
+
+}  // namespace mojo
+
+#endif  // CONTENT_COMMON_SERVICE_WORKER_SERVICE_WORKER_STATUS_CODE_TRAITS_H_

content/common/typemaps.gni

@@ -5,6 +5,7 @@
 typemaps = [
   "//content/common/native_types.typemap",
   "//content/common/service_worker/embedded_worker.typemap",
+  "//content/common/service_worker/fetch_event_dispatcher.typemap",
   "//content/common/url_loader_status.typemap",
   "//content/common/url_request.typemap",
   "//content/common/url_response_head.typemap",

content/renderer/service_worker/service_worker_context_client.cc

@@ -31,7 +31,9 @@
 #include "content/common/devtools_messages.h"
 #include "content/common/message_port_messages.h"
 #include "content/common/service_worker/embedded_worker_messages.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/common/referrer.h"
 #include "content/public/renderer/content_renderer_client.h"
@@ -44,6 +46,7 @@
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_macros.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 "third_party/WebKit/public/platform/URLConversion.h"
@@ -180,6 +183,10 @@ struct ServiceWorkerContextClient::WorkerContextData {
       IDMap<const base::Callback<void(blink::mojom::ServiceWorkerEventStatus,
                                       base::Time /* dispatch_event_time */)>,
             IDMapOwnPointer>;
+  using FetchEventCallbacksMap =
+      IDMap<const base::Callback<void(ServiceWorkerStatusCode,
+                                      base::Time /* dispatch_event_time */)>,
+            IDMapOwnPointer>;
 
   explicit WorkerContextData(ServiceWorkerContextClient* owner)
       : weak_factory(owner), proxy_weak_factory(owner->proxy_) {}
@@ -203,6 +210,9 @@ struct ServiceWorkerContextClient::WorkerContextData {
   // Pending callbacks for Background Sync Events
   SyncEventCallbacksMap sync_event_callbacks;
 
+  // Pending callbacks for Fetch Events
+  FetchEventCallbacksMap fetch_event_callbacks;
+
   shell::InterfaceRegistry interface_registry;
   shell::InterfaceProvider remote_interfaces;
 
@@ -211,6 +221,34 @@ struct ServiceWorkerContextClient::WorkerContextData {
   base::WeakPtrFactory<blink::WebServiceWorkerContextProxy> proxy_weak_factory;
 };
 
+class ServiceWorkerContextClient::FetchEventDispatcherImpl
+    : public NON_EXPORTED_BASE(mojom::FetchEventDispatcher) {
+ public:
+  static void Create(mojom::FetchEventDispatcherRequest request) {
+    mojo::MakeStrongBinding(base::MakeUnique<FetchEventDispatcherImpl>(),
+                            std::move(request));
+  }
+
+  FetchEventDispatcherImpl() {}
+
+  ~FetchEventDispatcherImpl() override {}
+
+  void DispatchFetchEvent(int response_id,
+                          const ServiceWorkerFetchRequest& request,
+                          const DispatchFetchEventCallback& callback) override {
+    ServiceWorkerContextClient* client =
+        ServiceWorkerContextClient::ThreadSpecificInstance();
+    if (!client) {
+      callback.Run(SERVICE_WORKER_ERROR_ABORT, base::Time::Now());
+      return;
+    }
+    client->DispatchFetchEvent(response_id, request, callback);
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(FetchEventDispatcherImpl);
+};
+
 ServiceWorkerContextClient*
 ServiceWorkerContextClient::ThreadSpecificInstance() {
   return g_worker_client_tls.Pointer()->Get();
@@ -252,7 +290,6 @@ void ServiceWorkerContextClient::OnMessageReceived(
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ActivateEvent, OnActivateEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ExtendableMessageEvent,
                         OnExtendableMessageEvent)
-    IPC_MESSAGE_HANDLER(ServiceWorkerMsg_FetchEvent, OnFetchEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_InstallEvent, OnInstallEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_NotificationClickEvent,
                         OnNotificationClickEvent)
@@ -385,6 +422,8 @@ void ServiceWorkerContextClient::workerContextStarted(
   // Register Mojo interfaces.
   context_->interface_registry.AddInterface(
       base::Bind(&BackgroundSyncClientImpl::Create));
+  context_->interface_registry.AddInterface(
+      base::Bind(&FetchEventDispatcherImpl::Create));
 
   SetRegistrationInServiceWorkerGlobalScope(registration_info, version_attrs);
 
@@ -552,9 +591,16 @@ void ServiceWorkerContextClient::didHandleFetchEvent(
     int event_finish_id,
     blink::WebServiceWorkerEventResult result,
     double event_dispatch_time) {
-  Send(new ServiceWorkerHostMsg_FetchEventFinished(
-      GetRoutingID(), event_finish_id, result,
-      base::Time::FromDoubleT(event_dispatch_time)));
+  const FetchCallback* callback =
+      context_->fetch_event_callbacks.Lookup(event_finish_id);
+  if (!callback)
+    return;
+
+  callback->Run(result == blink::WebServiceWorkerEventResultCompleted
+                    ? SERVICE_WORKER_OK
+                    : SERVICE_WORKER_ERROR_EVENT_WAITUNTIL_REJECTED,
+                base::Time::FromDoubleT(event_dispatch_time));
+  context_->fetch_event_callbacks.Remove(event_finish_id);
 }
 
 void ServiceWorkerContextClient::didHandleNotificationClickEvent(
@@ -794,13 +840,16 @@ void ServiceWorkerContextClient::OnInstallEvent(int request_id) {
   proxy_->dispatchInstallEvent(request_id);
 }
 
-void ServiceWorkerContextClient::OnFetchEvent(
+void ServiceWorkerContextClient::DispatchFetchEvent(
     int response_id,
-    int event_finish_id,
-    const ServiceWorkerFetchRequest& request) {
+    const ServiceWorkerFetchRequest& request,
+    const FetchCallback& callback) {
   blink::WebServiceWorkerRequest webRequest;
   TRACE_EVENT0("ServiceWorker",
-               "ServiceWorkerContextClient::OnFetchEvent");
+               "ServiceWorkerContextClient::DispatchFetchEvent");
+  int event_finish_id =
+      context_->fetch_event_callbacks.Add(new FetchCallback(callback));
+
   webRequest.setURL(blink::WebURL(request.url));
   webRequest.setMethod(blink::WebString::fromUTF8(request.method));
   for (ServiceWorkerHeaderMap::const_iterator it = request.headers.begin();

content/renderer/service_worker/service_worker_context_client.h

@@ -20,6 +20,7 @@
 #include "base/strings/string16.h"
 #include "base/time/time.h"
 #include "content/child/webmessageportchannel_impl.h"
+#include "content/common/service_worker/service_worker_status_code.h"
 #include "content/common/service_worker/service_worker_types.h"
 #include "ipc/ipc_listener.h"
 #include "services/shell/public/interfaces/interface_provider.mojom.h"
@@ -67,6 +68,9 @@ class ServiceWorkerContextClient
   using SyncCallback =
       base::Callback<void(blink::mojom::ServiceWorkerEventStatus,
                           base::Time /* dispatch_event_time */)>;
+  using FetchCallback =
+      base::Callback<void(ServiceWorkerStatusCode,
+                          base::Time /* dispatch_event_time */)>;
 
   // Returns a thread-specific client instance.  This does NOT create a
   // new instance.
@@ -194,6 +198,7 @@ class ServiceWorkerContextClient
 
  private:
   struct WorkerContextData;
+  class FetchEventDispatcherImpl;
 
   // Get routing_id for sending message to the ServiceWorkerVersion
   // in the browser process.
@@ -210,9 +215,9 @@ class ServiceWorkerContextClient
       int request_id,
       const ServiceWorkerMsg_ExtendableMessageEvent_Params& params);
   void OnInstallEvent(int request_id);
-  void OnFetchEvent(int response_id,
-                    int event_finish_id,
-                    const ServiceWorkerFetchRequest& request);
+  void DispatchFetchEvent(int response_id,
+                          const ServiceWorkerFetchRequest& request,
+                          const FetchCallback& callback);
   void OnNotificationClickEvent(
       int request_id,
       const std::string& notification_id,