Make //content responsible for generating notification Ids

content/browser/notifications/notification_message_filter.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_message_filter.h"
 
 #include <utility>
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "content/browser/bad_message.h"
+#include "content/browser/notifications/notification_id_generator.h"
 #include "content/browser/notifications/page_notification_delegate.h"
 #include "content/browser/notifications/platform_notification_context_impl.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/common/platform_notification_messages.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/desktop_notification_delegate.h"
 #include "content/public/browser/notification_database_data.h"
 #include "content/public/browser/platform_notification_service.h"
@@ skipping 68 matching lines @@
     : BrowserMessageFilter(PlatformNotificationMsgStart),
       process_id_(process_id),
       notification_context_(notification_context),
       resource_context_(resource_context),
       service_worker_context_(service_worker_context),
       browser_context_(browser_context),
       weak_factory_io_(this) {}
 
 NotificationMessageFilter::~NotificationMessageFilter() {}
 
-void NotificationMessageFilter::DidCloseNotification(int notification_id) {
+void NotificationMessageFilter::DidCloseNotification(
+    const std::string& notification_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-
   close_closures_.erase(notification_id);
 }
 
 void NotificationMessageFilter::OnDestruct() const {
   BrowserThread::DeleteOnIOThread::Destruct(this);
 }
 
 bool NotificationMessageFilter::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(NotificationMessageFilter, message)
@@ skipping 15 matching lines @@
 
 void NotificationMessageFilter::OverrideThreadForMessage(
     const IPC::Message& message,
     content::BrowserThread::ID* thread) {
   if (message.type() == PlatformNotificationHostMsg_Show::ID ||
       message.type() == PlatformNotificationHostMsg_Close::ID)
     *thread = BrowserThread::UI;
 }
 
 void NotificationMessageFilter::OnShowPlatformNotification(
-    int notification_id,
+    int non_persistent_notification_id,
     const GURL& origin,
     const PlatformNotificationData& notification_data,
     const NotificationResources& notification_resources) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!RenderProcessHost::FromID(process_id_))
     return;
 
   if (!ValidateNotificationResources(notification_resources)) {
     bad_message::ReceivedBadMessage(this, bad_message::NMF_INVALID_ARGUMENT);
     return;
   }
 
-  std::unique_ptr<DesktopNotificationDelegate> delegate(
-      new PageNotificationDelegate(process_id_, notification_id));
-
   PlatformNotificationService* service =
       GetContentClient()->browser()->GetPlatformNotificationService();
   DCHECK(service);
 
   if (!VerifyNotificationPermissionGranted(service, origin))
     return;
 
+  std::string notification_id =
+      GetNotificationIdGenerator()->GenerateForNonPersistentNotification(
+          origin, notification_data.tag, non_persistent_notification_id,
+          process_id_);
+
+  std::unique_ptr<DesktopNotificationDelegate> delegate(
+      new PageNotificationDelegate(process_id_, non_persistent_notification_id,
+                                   notification_id));
+
   base::Closure close_closure;
-  service->DisplayNotification(
-      browser_context_, origin, SanitizeNotificationData(notification_data),
-      notification_resources, std::move(delegate), &close_closure);
+  service->DisplayNotification(browser_context_, notification_id, origin,
+                               SanitizeNotificationData(notification_data),
+                               notification_resources, std::move(delegate),
+                               &close_closure);
 
   if (!close_closure.is_null())
     close_closures_[notification_id] = close_closure;
 }
 
 void NotificationMessageFilter::OnShowPersistentNotification(
     int request_id,
     int64_t service_worker_registration_id,
     const GURL& origin,
     const PlatformNotificationData& notification_data,
@@ skipping 11 matching lines @@
   }
 
   NotificationDatabaseData database_data;
   database_data.origin = origin;
   database_data.service_worker_registration_id = service_worker_registration_id;
 
   PlatformNotificationData sanitized_notification_data =
       SanitizeNotificationData(notification_data);
   database_data.notification_data = sanitized_notification_data;
 
-  // TODO(peter): Significantly reduce the amount of information we need to
-  // retain outside of the database for displaying notifications.
   notification_context_->WriteNotificationData(
       origin, database_data,
       base::Bind(&NotificationMessageFilter::DidWritePersistentNotificationData,
                  weak_factory_io_.GetWeakPtr(), request_id,
                  service_worker_registration_id, origin,
                  sanitized_notification_data, notification_resources));
 }
 
 void NotificationMessageFilter::DidWritePersistentNotificationData(
     int request_id,
     int64_t service_worker_registration_id,
     const GURL& origin,
     const PlatformNotificationData& notification_data,
     const NotificationResources& notification_resources,
     bool success,
-    int64_t persistent_notification_id) {
+    const std::string& notification_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!success) {
     Send(new PlatformNotificationMsg_DidShowPersistent(request_id, false));
     return;
   }
 
   // Get the service worker scope.
   service_worker_context_->FindReadyRegistrationForId(
       service_worker_registration_id, origin,
       base::Bind(&NotificationMessageFilter::DidFindServiceWorkerRegistration,
                  weak_factory_io_.GetWeakPtr(), request_id, origin,
-                 notification_data, notification_resources,
-                 persistent_notification_id));
+                 notification_data, notification_resources, notification_id));
 }
 
 void NotificationMessageFilter::DidFindServiceWorkerRegistration(
     int request_id,
     const GURL& origin,
     const PlatformNotificationData& notification_data,
     const NotificationResources& notification_resources,
-    int64_t persistent_notification_id,
+    const std::string& notification_id,
     content::ServiceWorkerStatusCode service_worker_status,
     scoped_refptr<content::ServiceWorkerRegistration> registration) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (service_worker_status != SERVICE_WORKER_OK) {
     Send(new PlatformNotificationMsg_DidShowPersistent(request_id, false));
     LOG(ERROR) << "Registration not found for " << origin.spec();
     // TODO(peter): Add UMA to track how often this occurs.
     return;
   }
 
   PlatformNotificationService* service =
       GetContentClient()->browser()->GetPlatformNotificationService();
   DCHECK(service);
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&PlatformNotificationService::DisplayPersistentNotification,
                  base::Unretained(service),  // The service is a singleton.
-                 browser_context_, persistent_notification_id,
-                 registration->pattern(), origin, notification_data,
-                 notification_resources));
+                 browser_context_, notification_id, registration->pattern(),
+                 origin, notification_data, notification_resources));
 
   Send(new PlatformNotificationMsg_DidShowPersistent(request_id, true));
 }
 
 void NotificationMessageFilter::OnGetNotifications(
     int request_id,
     int64_t service_worker_registration_id,
     const GURL& origin,
     const std::string& filter_tag) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
@@ skipping 28 matching lines @@
 
     persistent_notifications.push_back(std::make_pair(
         database_data.notification_id, database_data.notification_data));
   }
 
   Send(new PlatformNotificationMsg_DidGetNotifications(
       request_id, persistent_notifications));
 }
 
 void NotificationMessageFilter::OnClosePlatformNotification(
-    int notification_id) {
+    const GURL& origin,
+    const std::string& tag,
+    int non_persistent_notification_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!RenderProcessHost::FromID(process_id_))
     return;
 
+  std::string notification_id =
+      GetNotificationIdGenerator()->GenerateForNonPersistentNotification(
+          origin, tag, non_persistent_notification_id, process_id_);
+
   if (!close_closures_.count(notification_id))
     return;
 
   close_closures_[notification_id].Run();
   close_closures_.erase(notification_id);
 }
 
 void NotificationMessageFilter::OnClosePersistentNotification(
     const GURL& origin,
+    const std::string& tag,
     int64_t persistent_notification_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (GetPermissionForOriginOnIO(origin) !=
       blink::mojom::PermissionStatus::GRANTED) {
     bad_message::ReceivedBadMessage(this, bad_message::NMF_NO_PERMISSION_CLOSE);
     return;
   }
 
   PlatformNotificationService* service =
       GetContentClient()->browser()->GetPlatformNotificationService();
   DCHECK(service);
 
+  // TODO(peter): Plumb the |notification_id| string all the way through to
+  // Blink, removing additional branches there.
+  std::string notification_id =
+      GetNotificationIdGenerator()->GenerateForPersistentNotification(
+          origin, tag, persistent_notification_id);
+
   // There's no point in waiting until the database data has been removed before
   // closing the notification presented to the user. Post that task immediately.
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&PlatformNotificationService::ClosePersistentNotification,
                  base::Unretained(service),  // The service is a singleton.
-                 browser_context_, persistent_notification_id));
+                 browser_context_, notification_id));
 
   notification_context_->DeleteNotificationData(
-      persistent_notification_id, origin,
+      notification_id, origin,
       base::Bind(
           &NotificationMessageFilter::DidDeletePersistentNotificationData,
           weak_factory_io_.GetWeakPtr()));
 }
 
 void NotificationMessageFilter::DidDeletePersistentNotificationData(
     bool success) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // TODO(peter): Consider feeding back to the renderer that the notification
   // has been closed.
@@ skipping 21 matching lines @@
   blink::mojom::PermissionStatus permission_status =
       service->CheckPermissionOnUIThread(browser_context_, origin, process_id_);
 
   if (permission_status == blink::mojom::PermissionStatus::GRANTED)
     return true;
 
   bad_message::ReceivedBadMessage(this, bad_message::NMF_NO_PERMISSION_VERIFY);
   return false;
 }
 
+NotificationIdGenerator* NotificationMessageFilter::GetNotificationIdGenerator()
+    const {
+  return notification_context_->notification_id_generator();
+}
+
 }  // namespace content