[ServiceWorker] Mojofy PushEvent of Service Worker.

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 161 matching lines @@
 struct ServiceWorkerContextClient::WorkerContextData {
   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 SyncEventCallbacksMap = IDMap<std::unique_ptr<const SyncCallback>>;
+  using PushEventCallbacksMap =
+      IDMap<std::unique_ptr<const DispatchPushEventCallback>>;
   using FetchEventCallbacksMap = IDMap<std::unique_ptr<const FetchCallback>>;
   using ExtendableMessageEventCallbacksMap =
       IDMap<std::unique_ptr<const DispatchExtendableMessageEventCallback>>;
   using NavigationPreloadRequestsMap = IDMap<
       std::unique_ptr<ServiceWorkerContextClient::NavigationPreloadRequest>>;
 
   explicit WorkerContextData(ServiceWorkerContextClient* owner)
       : event_dispatcher_binding(owner),
         weak_factory(owner),
         proxy_weak_factory(owner->proxy_) {}
@@ skipping 12 matching lines @@
 
   // Pending callbacks for SkipWaiting().
   SkipWaitingCallbacksMap skip_waiting_callbacks;
 
   // Pending callbacks for ClaimClients().
   ClaimClientsCallbacksMap claim_clients_callbacks;
 
   // Pending callbacks for Background Sync Events.
   SyncEventCallbacksMap sync_event_callbacks;
 
+  // Pending callbacks for Push Events.
+  PushEventCallbacksMap push_event_callbacks;
+
   // Pending callbacks for Fetch Events.
   FetchEventCallbacksMap fetch_event_callbacks;
 
   // Pending callbacks for Extendable Message Events.
   ExtendableMessageEventCallbacksMap message_event_callbacks;
 
   // Pending navigation preload requests.
   NavigationPreloadRequestsMap preload_requests;
 
   base::ThreadChecker thread_checker;
@@ skipping 175 matching lines @@
     const IPC::Message& message) {
   CHECK_EQ(embedded_worker_id_, embedded_worker_id);
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ServiceWorkerContextClient, message)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ActivateEvent, OnActivateEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_InstallEvent, OnInstallEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_NotificationClickEvent,
                         OnNotificationClickEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_NotificationCloseEvent,
                         OnNotificationCloseEvent)
-    IPC_MESSAGE_HANDLER(ServiceWorkerMsg_PushEvent, OnPushEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_DidGetClient, OnDidGetClient)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_DidGetClients, OnDidGetClients)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_OpenWindowResponse,
                         OnOpenWindowResponse)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_OpenWindowError,
                         OnOpenWindowError)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_FocusClientResponse,
                         OnFocusClientResponse)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_NavigateClientResponse,
                         OnNavigateClientResponse)
@@ skipping 147 matching lines @@
   // worker_task_runner_->RunsTasksOnCurrentThread() returns false
   // (while we're still on the worker thread).
   proxy_ = NULL;
 
   // Aborts the all pending sync event callbacks.
   for (WorkerContextData::SyncEventCallbacksMap::iterator it(
            &context_->sync_event_callbacks);
        !it.IsAtEnd(); it.Advance()) {
     it.GetCurrentValue()->Run(SERVICE_WORKER_ERROR_ABORT, base::Time::Now());
   }
+  // Aborts the all pending push event callbacks.
+  for (WorkerContextData::PushEventCallbacksMap::iterator it(
+           &context_->push_event_callbacks);
+       !it.IsAtEnd(); it.Advance()) {
+    it.GetCurrentValue()->Run(SERVICE_WORKER_ERROR_ABORT, base::Time::Now());
+  }
   // Aborts the all pending fetch event callbacks.
   for (WorkerContextData::FetchEventCallbacksMap::iterator it(
            &context_->fetch_event_callbacks);
        !it.IsAtEnd(); it.Advance()) {
     it.GetCurrentValue()->Run(SERVICE_WORKER_ERROR_ABORT, base::Time::Now());
   }
   // Aborts the all pending extendable message event callbacks.
   for (WorkerContextData::ExtendableMessageEventCallbacksMap::iterator it(
            &context_->message_event_callbacks);
        !it.IsAtEnd(); it.Advance()) {
     it.GetCurrentValue()->Run(SERVICE_WORKER_ERROR_ABORT, base::Time::Now());
   }

[Peter Beverloo, 2016/12/13 13:31:32]

fwiw, since this is now repeated four times, consider having an anonymous,
templatized function that reduces the duplication.

 
   // We have to clear callbacks now, as they need to be freed on the
   // same thread.
   context_.reset();
 
   // This also lets the message filter stop dispatching messages to
   // this client.
   g_worker_client_tls.Pointer()->Set(NULL);
 
   GetContentClient()->renderer()->WillDestroyServiceWorkerContextOnWorkerThread(
@@ skipping 155 matching lines @@
     double event_dispatch_time) {
   Send(new ServiceWorkerHostMsg_NotificationCloseEventFinished(
       GetRoutingID(), request_id, result,
       base::Time::FromDoubleT(event_dispatch_time)));
 }
 
 void ServiceWorkerContextClient::didHandlePushEvent(
     int request_id,
     blink::WebServiceWorkerEventResult result,
     double event_dispatch_time) {
-  Send(new ServiceWorkerHostMsg_PushEventFinished(
-      GetRoutingID(), request_id, result,
-      base::Time::FromDoubleT(event_dispatch_time)));
+  const DispatchPushEventCallback* callback =
+      context_->push_event_callbacks.Lookup(request_id);
+  if (!callback)
+    return;

[Peter Beverloo, 2016/12/13 13:31:32]

Should this have a LOG(WARN)? Maybe even a DCHECK? In which scenario would we
end up acknowledging that a push event that doesn't exist anymore has finished?

[xiaofengzhang, 2016/12/15 01:30:49]

Done.

+  if (result == blink::WebServiceWorkerEventResultCompleted) {

[Peter Beverloo, 2016/12/13 13:31:32]

I notice that this reverses the logic for determining the |status|.
Previously[1] we would always return |SERVICE_WORKER_OK|, and only return
|SERVICE_WORKER_ERROR_EVENT_WAITUNTIL_REJECTED| when the |result| was set to
|blink::WebServiceWorkerEventResultRejected|.

Since there are only two entries in the |WebServiceWorkerEventResult| enum
that's probably OK, but it becomes significant if a third entry ever gets added.
The best option would be to use a switch() so that we get compile time
verification, but that may end up being verbose. I'll defer to the OWNERS of
this file.

[1]
https://cs.chromium.org/chromium/src/content/browser/service_worker/service_w...

+    callback->Run(SERVICE_WORKER_OK,
+                  base::Time::FromDoubleT(event_dispatch_time));
+  } else {
+    callback->Run(SERVICE_WORKER_ERROR_EVENT_WAITUNTIL_REJECTED,
+                  base::Time::FromDoubleT(event_dispatch_time));

[Peter Beverloo, 2016/12/13 13:31:32]

nit: prefer avoiding multiple calls to the same method. Something like the
following ought to work:

    ServiceWorkerStatusCode status =
        result == blink::WebServiceWorkerEventResultCompleted
            ? SERVICE_WORKER_OK
            : SERVICE_WORKER_ERROR_EVENT_WAITUNTIL_REJECTED;

    callback->Run(status, ...);

[xiaofengzhang, 2016/12/15 01:30:49]

Done. Thanks :-)

+  }
+  context_->push_event_callbacks.Remove(request_id);
 }
 
 void ServiceWorkerContextClient::didHandleSyncEvent(
     int request_id,
     blink::WebServiceWorkerEventResult result,
     double event_dispatch_time) {
   const SyncCallback* callback =
       context_->sync_event_callbacks.Lookup(request_id);
   if (!callback)
     return;
@@ skipping 279 matching lines @@
     int request_id,
     const std::string& notification_id,
     const PlatformNotificationData& notification_data) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerContextClient::OnNotificationCloseEvent");
   proxy_->dispatchNotificationCloseEvent(
       request_id, blink::WebString::fromUTF8(notification_id),
       ToWebNotificationData(notification_data));
 }
 
-void ServiceWorkerContextClient::OnPushEvent(int request_id,
-                                             const PushEventPayload& payload) {
+void ServiceWorkerContextClient::DispatchPushEvent(
+    const PushEventPayload& payload,
+    const DispatchPushEventCallback& callback) {
   TRACE_EVENT0("ServiceWorker",
-               "ServiceWorkerContextClient::OnPushEvent");
+               "ServiceWorkerContextClient::DispatchPushEvent");
+  int request_id = context_->push_event_callbacks.Add(
+      base::MakeUnique<DispatchPushEventCallback>(callback));
+
   // Only set data to be a valid string if the payload had decrypted data.
   blink::WebString data;
   if (!payload.is_null)
     data.assign(blink::WebString::fromUTF8(payload.data));
   proxy_->dispatchPushEvent(request_id, data);
 }
 
 void ServiceWorkerContextClient::OnDidGetClient(
     int request_id,
     const ServiceWorkerClientInfo& client) {
@@ skipping 203 matching lines @@
 }
 
 base::WeakPtr<ServiceWorkerContextClient>
 ServiceWorkerContextClient::GetWeakPtr() {
   DCHECK(worker_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(context_);
   return context_->weak_factory.GetWeakPtr();
 }
 
 }  // namespace content