Mojoify the notificationclick and notificationclose events

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 "base/optional.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/storage_partition.h"
 #include "content/public/common/platform_notification_data.h"
 
 namespace content {
 namespace {
 
 using NotificationDispatchCompleteCallback =
     NotificationEventDispatcher::NotificationDispatchCompleteCallback;
@@ skipping 177 matching lines @@
 // 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 base::NullableString16& reply,
     const ServiceWorkerVersion::StatusCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   int request_id = service_worker->StartRequest(
       ServiceWorkerMetrics::EventType::NOTIFICATION_CLICK, callback);
-  service_worker->DispatchSimpleEvent<
-      ServiceWorkerHostMsg_NotificationClickEventFinished>(
-      request_id,
-      ServiceWorkerMsg_NotificationClickEvent(
-          request_id, notification_database_data.notification_id,
-          notification_database_data.notification_data, action_index, reply));
+
+  base::Optional<base::string16> optional_reply;

[awdf, 2017/02/13 07:04:42]

Is Optional<string> preferable to NullableString in general or just necessary
for mojo conversions? I'm curious.

[Peter Beverloo, 2017/02/13 14:14:33]

It's necessary for Mojo, but since base::Optional is a generalized container
based on an upcoming STL type I'd say that it's preferred going forward.

+  if (!reply.is_null())
+    optional_reply = reply.string();
+
+  service_worker->event_dispatcher()->DispatchNotificationClickEvent(
+      notification_database_data.notification_id,
+      notification_database_data.notification_data, action_index,
+      optional_reply, base::Bind(&ServiceWorkerVersion::OnSimpleEventFinished,
+                                 service_worker, request_id));

[Peter Beverloo, 2017/02/10 03:21:28]

Err, this and line 288 need to use base::Unretained(service_worker.get()).
Consider it changed :>. Will send a patch for PushEvent too.

[Peter Beverloo, 2017/02/10 16:41:06]

Done.

 }
 
 // Dispatches the notification click event on the |service_worker_registration|.
 void DoDispatchNotificationClickEvent(
     int action_index,
     const base::NullableString16& reply,
     const NotificationDispatchCompleteCallback& dispatch_complete_callback,
     const scoped_refptr<PlatformNotificationContext>& notification_context,
     const ServiceWorkerRegistration* service_worker_registration,
     const NotificationDatabaseData& notification_database_data) {
@@ skipping 43 matching lines @@
 
 // Dispatches the notificationclose event on |service_worker|. Must be called on
 // the IO thread, and with the worker running.
 void DispatchNotificationCloseEventOnWorker(
     const scoped_refptr<ServiceWorkerVersion>& service_worker,
     const NotificationDatabaseData& notification_database_data,
     const ServiceWorkerVersion::StatusCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   int request_id = service_worker->StartRequest(
       ServiceWorkerMetrics::EventType::NOTIFICATION_CLOSE, callback);
-  service_worker->DispatchSimpleEvent<
-      ServiceWorkerHostMsg_NotificationCloseEventFinished>(
-      request_id, ServiceWorkerMsg_NotificationCloseEvent(
-                      request_id, notification_database_data.notification_id,
-                      notification_database_data.notification_data));
+
+  service_worker->event_dispatcher()->DispatchNotificationCloseEvent(
+      notification_database_data.notification_id,
+      notification_database_data.notification_data,
+      base::Bind(&ServiceWorkerVersion::OnSimpleEventFinished, service_worker,
+                 request_id));
 }
 
 // Actually dispatches the notification close event on the service worker
 // registration.
 void DoDispatchNotificationCloseEvent(
     const std::string& notification_id,
     bool by_user,
     const NotificationDispatchCompleteCallback& dispatch_complete_callback,
     const scoped_refptr<PlatformNotificationContext>& notification_context,
     const ServiceWorkerRegistration* service_worker_registration,
@@ skipping 83 matching lines @@
     bool by_user,
     const NotificationDispatchCompleteCallback& dispatch_complete_callback) {
   DispatchNotificationEvent(
       browser_context, notification_id, origin,
       base::Bind(&DoDispatchNotificationCloseEvent, notification_id, by_user,
                  dispatch_complete_callback),
       dispatch_complete_callback);
 }
 
 }  // namespace content