Plumbing in notification replies: PlatformNotificationService -> SW

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/strings/nullable_string16.h"
+#include "base/strings/utf_string_conversions.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"
@@ skipping 178 matching lines @@
 }
 
 // -----------------------------------------------------------------------------
 
 // Dispatches the notificationclick event on |service_worker|. Must 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 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));
+          notification_database_data.notification_data, action_index,
+          reply.is_null() ? base::ASCIIToUTF16("") : reply.string()));

[Peter Beverloo, 2016/10/11 14:22:56]

Why don't we just pass the NullableString16 over IPC (it has IPC traits defined
in ipc_message_utils.h)? I thought that we decided that the difference between a
NULL string and an empty string was significant, how would you achieve that with
just base::string16?

[awdf, 2016/10/11 15:51:27]

Thinking about it, I'm not 100% sure the difference between NULL & empty string
*is* significant, although maybe it's elegant to send null if the action wasn't
a text action, and empty string if it was but no text entered. Let's discuss on
this design doc thread
https://docs.google.com/document/d/1cWGf1HpuOsRklsC4lZ9uUVxq0yedRT1JhpUn8sIJZ...


(You might be recalling the discussion we had re: whether the distinction
between empty & no placeholder was significant which we decided it was)

[awdf, 2016/10/12 13:26:42]

Done (As discussed on the doc, the difference can be significant).

 }
 
 // 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) {
   ServiceWorkerVersion::StatusCallback status_callback = base::Bind(
       &ServiceWorkerNotificationEventFinished, dispatch_complete_callback);
   service_worker_registration->active_version()->RunAfterStartWorker(
       ServiceWorkerMetrics::EventType::NOTIFICATION_CLICK,
       base::Bind(
           &DispatchNotificationClickEventOnWorker,
           make_scoped_refptr(service_worker_registration->active_version()),
-          notification_database_data, action_index, status_callback),
+          notification_database_data, action_index, reply, status_callback),
       status_callback);
 }
 
 // -----------------------------------------------------------------------------
 
 // Called when the notification data has been deleted to finish the notification
 // close event.
 void OnPersistentNotificationDataDeleted(
     ServiceWorkerStatusCode service_worker_status,
     const NotificationDispatchCompleteCallback& dispatch_complete_callback,
@@ skipping 110 matching lines @@
 
 NotificationEventDispatcherImpl::NotificationEventDispatcherImpl() {}
 
 NotificationEventDispatcherImpl::~NotificationEventDispatcherImpl() {}
 
 void NotificationEventDispatcherImpl::DispatchNotificationClickEvent(
     BrowserContext* browser_context,
     const std::string& notification_id,
     const GURL& origin,
     int action_index,
+    const base::NullableString16& reply,
     const NotificationDispatchCompleteCallback& dispatch_complete_callback) {
   DispatchNotificationEvent(
       browser_context, notification_id, origin,
-      base::Bind(&DoDispatchNotificationClickEvent, action_index,
+      base::Bind(&DoDispatchNotificationClickEvent, action_index, reply,
                  dispatch_complete_callback),
       dispatch_complete_callback);
 }
 
 void NotificationEventDispatcherImpl::DispatchNotificationCloseEvent(
     BrowserContext* browser_context,
     const std::string& notification_id,
     const GURL& origin,
     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