Make //content responsible for generating notification Ids

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"
@@ skipping 160 matching lines @@
     return;
   }
 
   service_worker_context->FindReadyRegistrationForId(
       notification_database_data.service_worker_registration_id, origin,
       base::Bind(&DispatchNotificationEventOnRegistration,
                  notification_database_data, notification_context,
                  notification_action_callback, dispatch_error_callback));
 }
 
-// Reads the data associated with the |persistent_notification_id| belonging to
-// |origin| from the notification context.
+// Reads the data associated with the |notification_id| belonging to |origin|
+// from the notification context.
 void ReadNotificationDatabaseData(
-    int64_t persistent_notification_id,
+    const std::string& notification_id,
     const GURL& origin,
     const scoped_refptr<ServiceWorkerContextWrapper>& service_worker_context,
     const scoped_refptr<PlatformNotificationContext>& notification_context,
     const NotificationOperationCallback& notification_read_callback,
     const NotificationDispatchCompleteCallback& dispatch_error_callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   notification_context->ReadNotificationData(
-      persistent_notification_id, origin,
+      notification_id, origin,
       base::Bind(&FindServiceWorkerRegistration, origin, service_worker_context,
                  notification_context, notification_read_callback,
                  dispatch_error_callback));
 }
 
 // -----------------------------------------------------------------------------
 
 // Dispatches the notificationclick event on |service_worker|. Must be called on
 // the IO thread, and with the worker running.
 void DispatchNotificationClickEventOnWorker(
@@ skipping 45 matching lines @@
   }
   NotificationEventFinished(
       dispatch_complete_callback,
       success ? PERSISTENT_NOTIFICATION_STATUS_SUCCESS
               : PERSISTENT_NOTIFICATION_STATUS_DATABASE_ERROR);
 }
 
 // Called when the persistent notification close event has been handled
 // to remove the notification from the database.
 void DeleteNotificationDataFromDatabase(
-    const int64_t notification_id,
+    const std::string& notification_id,
     const GURL& origin,
     const scoped_refptr<PlatformNotificationContext>& notification_context,
     const NotificationDispatchCompleteCallback& dispatch_complete_callback,
     ServiceWorkerStatusCode status_code) {
   notification_context->DeleteNotificationData(
       notification_id, origin,
       base::Bind(&OnPersistentNotificationDataDeleted, status_code,
                  dispatch_complete_callback));
 }
 
 // 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));
 }
 
 // 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,
     const NotificationDatabaseData& notification_database_data) {
   const ServiceWorkerVersion::StatusCallback dispatch_event_callback =
-      base::Bind(&DeleteNotificationDataFromDatabase,
-                 notification_database_data.notification_id,
+      base::Bind(&DeleteNotificationDataFromDatabase, notification_id,
                  notification_database_data.origin, notification_context,
                  dispatch_complete_callback);
   if (by_user) {
     service_worker_registration->active_version()->RunAfterStartWorker(
         ServiceWorkerMetrics::EventType::NOTIFICATION_CLOSE,
         base::Bind(
             &DispatchNotificationCloseEventOnWorker,
             make_scoped_refptr(service_worker_registration->active_version()),
             notification_database_data, dispatch_event_callback),
         dispatch_event_callback);
   } else {
     dispatch_event_callback.Run(ServiceWorkerStatusCode::SERVICE_WORKER_OK);
   }
 }
 
 // Dispatches any notification event. The actual, specific event dispatch should
 // be done by the |notification_action_callback|.
 void DispatchNotificationEvent(
     BrowserContext* browser_context,
-    int64_t persistent_notification_id,
+    const std::string& notification_id,
     const GURL& origin,
     const NotificationOperationCallbackWithContext&
         notification_action_callback,
     const NotificationDispatchCompleteCallback& notification_error_callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  DCHECK_GT(persistent_notification_id, 0);
+  DCHECK(!notification_id.empty());
   DCHECK(origin.is_valid());
 
   StoragePartition* partition =
       BrowserContext::GetStoragePartitionForSite(browser_context, origin);
 
   scoped_refptr<ServiceWorkerContextWrapper> service_worker_context =
       static_cast<ServiceWorkerContextWrapper*>(
           partition->GetServiceWorkerContext());
   scoped_refptr<PlatformNotificationContext> notification_context =
       partition->GetPlatformNotificationContext();
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&ReadNotificationDatabaseData, persistent_notification_id,
-                 origin, service_worker_context, notification_context,
+      base::Bind(&ReadNotificationDatabaseData, notification_id, origin,
+                 service_worker_context, notification_context,
                  base::Bind(notification_action_callback, notification_context),
                  notification_error_callback));
 }
 
 }  // namespace
 
 // static
 NotificationEventDispatcher* NotificationEventDispatcher::GetInstance() {
   return NotificationEventDispatcherImpl::GetInstance();
 }
 
 NotificationEventDispatcherImpl*
 NotificationEventDispatcherImpl::GetInstance() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return base::Singleton<NotificationEventDispatcherImpl>::get();
 }
 
 NotificationEventDispatcherImpl::NotificationEventDispatcherImpl() {}
 
 NotificationEventDispatcherImpl::~NotificationEventDispatcherImpl() {}
 
 void NotificationEventDispatcherImpl::DispatchNotificationClickEvent(
     BrowserContext* browser_context,
-    int64_t persistent_notification_id,
+    const std::string& notification_id,
     const GURL& origin,
     int action_index,
     const NotificationDispatchCompleteCallback& dispatch_complete_callback) {
   DispatchNotificationEvent(
-      browser_context, persistent_notification_id, origin,
+      browser_context, notification_id, origin,
       base::Bind(&DoDispatchNotificationClickEvent, action_index,
                  dispatch_complete_callback),
       dispatch_complete_callback);
 }
 
 void NotificationEventDispatcherImpl::DispatchNotificationCloseEvent(
     BrowserContext* browser_context,
-    int64_t persistent_notification_id,
+    const std::string& notification_id,
     const GURL& origin,
     bool by_user,
     const NotificationDispatchCompleteCallback& dispatch_complete_callback) {
-  DispatchNotificationEvent(browser_context, persistent_notification_id, origin,
-                            base::Bind(&DoDispatchNotificationCloseEvent,
-                                       by_user, dispatch_complete_callback),
-                            dispatch_complete_callback);
+  DispatchNotificationEvent(
+      browser_context, notification_id, origin,
+      base::Bind(&DoDispatchNotificationCloseEvent, notification_id, by_user,
+                 dispatch_complete_callback),
+      dispatch_complete_callback);
 }
 
 }  // namespace content