Move notification click event dispatching out of ServiceWorkerVersion.

content/browser/notifications/notification_event_dispatcher_impl.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/notifications/notification_event_dispatcher_impl.h"
 
 #include "base/callback.h"
 #include "build/build_config.h"
 #include "content/browser/notifications/platform_notification_context_impl.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_storage.h"
+#include "content/common/service_worker/service_worker_messages.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_database_data.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/common/platform_notification_data.h"
 
 namespace content {
 namespace {
 
 using NotificationClickDispatchCompleteCallback =
@@ skipping 42 matching lines @@
     case SERVICE_WORKER_ERROR_DISALLOWED:
     case SERVICE_WORKER_ERROR_MAX_VALUE:
       status = PERSISTENT_NOTIFICATION_STATUS_SERVICE_WORKER_ERROR;
       break;
   }
 
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(dispatch_complete_callback, status));
 }
 
+// Called when a ServiceWorkerHostMsg_NotificationClickEventFinished message is
+// received in response to an event that was dispatched.
+void OnNotificationClickEventReply(
+    const scoped_refptr<ServiceWorkerVersion>& service_worker,
+    const ServiceWorkerVersion::StatusCallback& callback,
+    int request_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  TRACE_EVENT1("ServiceWorker",
+               "NotificationEventDispatcherImpl::OnNotificationClickEventReply",
+               "Request id", request_id);
+  if (!service_worker->FinishRequest(request_id))
+    NOTREACHED() << "Should only receive one reply per event";
+  callback.Run(SERVICE_WORKER_OK);
+}
+
+// Dispatches the notificationclick event on |service_worker|. Most be called on
+// the IO thread, and with the worker running.
+void DispatchNotificationClickEventOnWorker(
+    const scoped_refptr<ServiceWorkerVersion>& service_worker,
+    const NotificationDatabaseData& notification_database_data,
+    int action_index,
+    const ServiceWorkerVersion::StatusCallback& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  int request_id = service_worker->StartRequest(
+      ServiceWorkerMetrics::EventType::NOTIFICATION_CLICK, callback);
+  service_worker
+      ->DispatchEvent<ServiceWorkerHostMsg_NotificationClickEventFinished>(
+          request_id,
+          ServiceWorkerMsg_NotificationClickEvent(
+              request_id, notification_database_data.notification_id,
+              notification_database_data.notification_data, action_index),
+          base::Bind(&OnNotificationClickEventReply, service_worker, callback));
+}
+
 // Dispatches the notificationclick on |service_worker_registration| if the
 // registration was available. Must be called on the IO thread.
 void DispatchNotificationClickEventOnRegistration(
     const NotificationDatabaseData& notification_database_data,
     int action_index,
     const NotificationClickDispatchCompleteCallback& dispatch_complete_callback,
     ServiceWorkerStatusCode service_worker_status,
     const scoped_refptr<ServiceWorkerRegistration>&
         service_worker_registration) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 #if defined(OS_ANDROID)
   // This LOG(INFO) deliberately exists to help track down the cause of
   // https://crbug.com/534537, where notifications sometimes do not react to
   // the user clicking on them. It should be removed once that's fixed.
   LOG(INFO) << "Trying to dispatch notification for SW with status: "
             << service_worker_status << " action_index: " << action_index;
 #endif
   if (service_worker_status == SERVICE_WORKER_OK) {
-    base::Callback<void(ServiceWorkerStatusCode)> dispatch_event_callback =
+    ServiceWorkerVersion::StatusCallback dispatch_event_callback =
         base::Bind(&NotificationClickEventFinished, dispatch_complete_callback,
                    service_worker_registration);
 
     DCHECK(service_worker_registration->active_version());
-    service_worker_registration->active_version()
-        ->DispatchNotificationClickEvent(
-            dispatch_event_callback, notification_database_data.notification_id,
-            notification_database_data.notification_data, action_index);
+    service_worker_registration->active_version()->RunAfterStartWorker(
+        dispatch_event_callback,
+        base::Bind(
+            &DispatchNotificationClickEventOnWorker,
+            make_scoped_refptr(service_worker_registration->active_version()),
+            notification_database_data, action_index, dispatch_event_callback));
     return;
   }
 
   PersistentNotificationStatus status = PERSISTENT_NOTIFICATION_STATUS_SUCCESS;
   switch (service_worker_status) {
     case SERVICE_WORKER_ERROR_NOT_FOUND:
       status = PERSISTENT_NOTIFICATION_STATUS_NO_SERVICE_WORKER;
       break;
     case SERVICE_WORKER_ERROR_FAILED:
     case SERVICE_WORKER_ERROR_ABORT:
@@ skipping 112 matching lines @@
           partition->GetPlatformNotificationContext());
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&ReadNotificationDatabaseData, persistent_notification_id,
                  origin, action_index, dispatch_complete_callback,
                  service_worker_context, notification_context));
 }
 
 }  // namespace content