Service Worker event dispatcher for Background Fetch

content/renderer/service_worker/service_worker_context_client.cc

 // Copyright 2015 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/renderer/service_worker/service_worker_context_client.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/lazy_instance.h"
@@ skipping 168 matching lines @@
   using ClientsCallbacksMap =
       IDMap<std::unique_ptr<blink::WebServiceWorkerClientsCallbacks>>;
   using ClaimClientsCallbacksMap =
       IDMap<std::unique_ptr<blink::WebServiceWorkerClientsClaimCallbacks>>;
   using ClientCallbacksMap =
       IDMap<std::unique_ptr<blink::WebServiceWorkerClientCallbacks>>;
   using SkipWaitingCallbacksMap =
       IDMap<std::unique_ptr<blink::WebServiceWorkerSkipWaitingCallbacks>>;
   using ActivateEventCallbacksMap =
       IDMap<std::unique_ptr<const DispatchActivateEventCallback>>;
+  using BackgroundFetchAbortEventCallbacksMap =
+      IDMap<std::unique_ptr<const DispatchBackgroundFetchAbortEventCallback>>;
+  using BackgroundFetchClickEventCallbacksMap =
+      IDMap<std::unique_ptr<const DispatchBackgroundFetchClickEventCallback>>;
   using SyncEventCallbacksMap = IDMap<std::unique_ptr<const SyncCallback>>;
   using PaymentRequestEventCallbacksMap =
       IDMap<std::unique_ptr<const PaymentRequestEventCallback>>;
   using NotificationClickEventCallbacksMap =
       IDMap<std::unique_ptr<const DispatchNotificationClickEventCallback>>;
   using NotificationCloseEventCallbacksMap =
       IDMap<std::unique_ptr<const DispatchNotificationCloseEventCallback>>;
   using PushEventCallbacksMap =
       IDMap<std::unique_ptr<const DispatchPushEventCallback>>;
   using FetchEventCallbacksMap = IDMap<std::unique_ptr<const FetchCallback>>;
@@ skipping 21 matching lines @@
 
   // Pending callbacks for SkipWaiting().
   SkipWaitingCallbacksMap skip_waiting_callbacks;
 
   // Pending callbacks for ClaimClients().
   ClaimClientsCallbacksMap claim_clients_callbacks;
 
   // Pending callbacks for Activate Events.
   ActivateEventCallbacksMap activate_event_callbacks;
 
+  // Pending callbacks for Background Fetch Abort Events.
+  BackgroundFetchAbortEventCallbacksMap background_fetch_abort_event_callbacks;
+
+  // Pending callbacks for Background Fetch Click Events.
+  BackgroundFetchClickEventCallbacksMap background_fetch_click_event_callbacks;
+
   // Pending callbacks for Background Sync Events.
   SyncEventCallbacksMap sync_event_callbacks;
 
   // Pending callbacks for Payment Request Events.
   PaymentRequestEventCallbacksMap payment_request_event_callbacks;
 
   // Pending callbacks for Notification Click Events.
   NotificationClickEventCallbacksMap notification_click_event_callbacks;
 
   // Pending callbacks for Notification Close Events.
@@ skipping 320 matching lines @@
 
 void ServiceWorkerContextClient::willDestroyWorkerContext(
     v8::Local<v8::Context> context) {
   // At this point WillStopCurrentWorkerThread is already called, so
   // worker_task_runner_->RunsTasksOnCurrentThread() returns false
   // (while we're still on the worker thread).
   proxy_ = NULL;
 
   // Aborts all the pending events callbacks.
   AbortPendingEventCallbacks(context_->activate_event_callbacks);
+  AbortPendingEventCallbacks(context_->background_fetch_abort_event_callbacks);
+  AbortPendingEventCallbacks(context_->background_fetch_click_event_callbacks);
   AbortPendingEventCallbacks(context_->sync_event_callbacks);
   AbortPendingEventCallbacks(context_->notification_click_event_callbacks);
   AbortPendingEventCallbacks(context_->notification_close_event_callbacks);
   AbortPendingEventCallbacks(context_->push_event_callbacks);
   AbortPendingEventCallbacks(context_->fetch_event_callbacks);
   AbortPendingEventCallbacks(context_->message_event_callbacks);
 
   // We have to clear callbacks now, as they need to be freed on the
   // same thread.
   context_.reset();
@@ skipping 81 matching lines @@
     blink::WebServiceWorkerEventResult result,
     double event_dispatch_time) {
   const DispatchActivateEventCallback* callback =
       context_->activate_event_callbacks.Lookup(request_id);
   DCHECK(callback);
   callback->Run(EventResultToStatus(result),
                 base::Time::FromDoubleT(event_dispatch_time));
   context_->activate_event_callbacks.Remove(request_id);
 }
 
+void ServiceWorkerContextClient::didHandleBackgroundFetchAbortEvent(
+    int request_id,
+    blink::WebServiceWorkerEventResult result,
+    double event_dispatch_time) {
+  const DispatchBackgroundFetchAbortEventCallback* callback =
+      context_->background_fetch_abort_event_callbacks.Lookup(request_id);
+  DCHECK(callback);
+  callback->Run(EventResultToStatus(result),
+                base::Time::FromDoubleT(event_dispatch_time));
+  context_->background_fetch_abort_event_callbacks.Remove(request_id);
+}
+
+void ServiceWorkerContextClient::didHandleBackgroundFetchClickEvent(
+    int request_id,
+    blink::WebServiceWorkerEventResult result,
+    double event_dispatch_time) {
+  const DispatchBackgroundFetchClickEventCallback* callback =
+      context_->background_fetch_click_event_callbacks.Lookup(request_id);
+  DCHECK(callback);
+  callback->Run(EventResultToStatus(result),
+                base::Time::FromDoubleT(event_dispatch_time));
+  context_->background_fetch_click_event_callbacks.Remove(request_id);
+}
+
 void ServiceWorkerContextClient::didHandleExtendableMessageEvent(
     int request_id,
     blink::WebServiceWorkerEventResult result,
     double event_dispatch_time) {
   const DispatchExtendableMessageEventCallback* callback =
       context_->message_event_callbacks.Lookup(request_id);
   DCHECK(callback);
   callback->Run(EventResultToStatus(result),
                 base::Time::FromDoubleT(event_dispatch_time));
   context_->message_event_callbacks.Remove(request_id);
@@ skipping 245 matching lines @@
 
 void ServiceWorkerContextClient::DispatchActivateEvent(
     const DispatchActivateEventCallback& callback) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerContextClient::DispatchActivateEvent");
   int request_id = context_->activate_event_callbacks.Add(
       base::MakeUnique<DispatchActivateEventCallback>(callback));
   proxy_->dispatchActivateEvent(request_id);
 }
 
+void ServiceWorkerContextClient::DispatchBackgroundFetchAbortEvent(
+    const std::string& tag,
+    const DispatchBackgroundFetchAbortEventCallback& callback) {
+  TRACE_EVENT0("ServiceWorker",
+               "ServiceWorkerContextClient::DispatchBackgroundFetchAbortEvent");
+  int request_id = context_->background_fetch_abort_event_callbacks.Add(
+      base::MakeUnique<DispatchBackgroundFetchAbortEventCallback>(callback));
+
+  proxy_->dispatchBackgroundFetchAbortEvent(request_id,
+                                            blink::WebString::fromUTF8(tag));
+}
+
+void ServiceWorkerContextClient::DispatchBackgroundFetchClickEvent(
+    const std::string& tag,
+    mojom::BackgroundFetchState state,
+    const DispatchBackgroundFetchClickEventCallback& callback) {
+  TRACE_EVENT0("ServiceWorker",
+               "ServiceWorkerContextClient::DispatchBackgroundFetchClickEvent");
+  int request_id = context_->background_fetch_click_event_callbacks.Add(
+      base::MakeUnique<DispatchBackgroundFetchClickEventCallback>(callback));
+
+  // TODO(peter): Use typemap when this is moved to blink-side.
+  blink::WebServiceWorkerContextProxy::BackgroundFetchState web_state =
+      mojo::ConvertTo<
+          blink::WebServiceWorkerContextProxy::BackgroundFetchState>(state);
+
+  proxy_->dispatchBackgroundFetchClickEvent(
+      request_id, blink::WebString::fromUTF8(tag), web_state);
+}
+
 void ServiceWorkerContextClient::DispatchExtendableMessageEvent(
     mojom::ExtendableMessageEventPtr event,
     const DispatchExtendableMessageEventCallback& callback) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerContextClient::DispatchExtendableMessageEvent");
   int request_id = context_->message_event_callbacks.Add(
       base::MakeUnique<DispatchExtendableMessageEventCallback>(callback));
 
   blink::WebMessagePortChannelArray ports =
       WebMessagePortChannelImpl::CreateFromMessagePipeHandles(
@@ skipping 342 matching lines @@
 }
 
 base::WeakPtr<ServiceWorkerContextClient>
 ServiceWorkerContextClient::GetWeakPtr() {
   DCHECK(worker_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(context_);
   return context_->weak_factory.GetWeakPtr();
 }
 
 }  // namespace content