Make //content responsible for generating notification Ids

content/child/notifications/notification_manager.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/child/notifications/notification_manager.h"
 
 #include <utility>
 
 #include "base/lazy_instance.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 25 matching lines @@
   for (const auto& action_icon : web_resources->actionIcons)
     resources.action_icons.push_back(action_icon);
   return resources;
 }
 
 }  // namespace
 
 static base::LazyInstance<base::ThreadLocalPointer<NotificationManager>>::Leaky
     g_notification_manager_tls = LAZY_INSTANCE_INITIALIZER;
 
+NotificationManager::ActiveNotificationData::ActiveNotificationData(
+    blink::WebNotificationDelegate* delegate,
+    const GURL& origin,
+    const std::string& tag)
+    : delegate(delegate), origin(origin), tag(tag) {}
+
+NotificationManager::ActiveNotificationData::~ActiveNotificationData() {}
+
 NotificationManager::NotificationManager(
     ThreadSafeSender* thread_safe_sender,
     NotificationDispatcher* notification_dispatcher)
     : thread_safe_sender_(thread_safe_sender),
       notification_dispatcher_(notification_dispatcher) {
   g_notification_manager_tls.Pointer()->Set(this);
 }
 
 NotificationManager::~NotificationManager() {
   g_notification_manager_tls.Pointer()->Set(nullptr);
@@ skipping 17 matching lines @@
 }
 
 void NotificationManager::show(
     const blink::WebSecurityOrigin& origin,
     const blink::WebNotificationData& notification_data,
     std::unique_ptr<blink::WebNotificationResources> notification_resources,
     blink::WebNotificationDelegate* delegate) {
   DCHECK_EQ(0u, notification_data.actions.size());
   DCHECK_EQ(0u, notification_resources->actionIcons.size());
 
+  GURL origin_gurl = blink::WebStringToGURL(origin.toString());
+
   int notification_id =
       notification_dispatcher_->GenerateNotificationId(CurrentWorkerId());
 
-  active_page_notifications_[notification_id] = delegate;
+  active_page_notifications_[notification_id] = ActiveNotificationData(
+      delegate, origin_gurl,
+      base::UTF16ToUTF8(base::StringPiece16(notification_data.tag)));
+
   // TODO(mkwst): This is potentially doing the wrong thing with unique
   // origins. Perhaps also 'file:', 'blob:' and 'filesystem:'. See
   // https://crbug.com/490074 for detail.
   thread_safe_sender_->Send(new PlatformNotificationHostMsg_Show(
-      notification_id, blink::WebStringToGURL(origin.toString()),
+      notification_id, origin_gurl,
       ToPlatformNotificationData(notification_data),
       ToNotificationResources(std::move(notification_resources))));
 }
 
 void NotificationManager::showPersistent(
     const blink::WebSecurityOrigin& origin,
     const blink::WebNotificationData& notification_data,
     std::unique_ptr<blink::WebNotificationResources> notification_resources,
     blink::WebServiceWorkerRegistration* service_worker_registration,
     blink::WebNotificationShowCallbacks* callbacks) {
@@ skipping 66 matching lines @@
 
   pending_get_notification_requests_.AddWithID(callbacks, request_id);
 
   thread_safe_sender_->Send(new PlatformNotificationHostMsg_GetNotifications(
       request_id, service_worker_registration_id, origin,
       base::UTF16ToUTF8(base::StringPiece16(filter_tag))));
 }
 
 void NotificationManager::close(blink::WebNotificationDelegate* delegate) {
   for (auto& iter : active_page_notifications_) {
-    if (iter.second != delegate)
+    if (iter.second.delegate != delegate)
       continue;
 
-    thread_safe_sender_->Send(
-        new PlatformNotificationHostMsg_Close(iter.first));
+    thread_safe_sender_->Send(new PlatformNotificationHostMsg_Close(
+        iter.second.origin, iter.second.tag, iter.first));
     active_page_notifications_.erase(iter.first);
     return;
   }
 
   // It should not be possible for Blink to call close() on a Notification which
   // does not exist in either the pending or active notification lists.
   NOTREACHED();
 }
 
 void NotificationManager::closePersistent(
     const blink::WebSecurityOrigin& origin,
-    int64_t persistent_notification_id) {
+    const blink::WebString& tag,
+    const blink::WebString& notification_id) {
   thread_safe_sender_->Send(new PlatformNotificationHostMsg_ClosePersistent(
       // TODO(mkwst): This is potentially doing the wrong thing with unique
       // origins. Perhaps also 'file:', 'blob:' and 'filesystem:'. See
       // https://crbug.com/490074 for detail.
-      blink::WebStringToGURL(origin.toString()), persistent_notification_id));
+      blink::WebStringToGURL(origin.toString()),
+      base::UTF16ToUTF8(base::StringPiece16(tag)),
+      base::UTF16ToUTF8(base::StringPiece16(notification_id))));
 }
 
 void NotificationManager::notifyDelegateDestroyed(
     blink::WebNotificationDelegate* delegate) {
   for (auto& iter : active_page_notifications_) {
-    if (iter.second != delegate)
+    if (iter.second.delegate != delegate)
       continue;
 
     active_page_notifications_.erase(iter.first);
     return;
   }
 }
 
 bool NotificationManager::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(NotificationManager, message)
     IPC_MESSAGE_HANDLER(PlatformNotificationMsg_DidShow, OnDidShow);
     IPC_MESSAGE_HANDLER(PlatformNotificationMsg_DidShowPersistent,
                         OnDidShowPersistent)
     IPC_MESSAGE_HANDLER(PlatformNotificationMsg_DidClose, OnDidClose);
     IPC_MESSAGE_HANDLER(PlatformNotificationMsg_DidClick, OnDidClick);
     IPC_MESSAGE_HANDLER(PlatformNotificationMsg_DidGetNotifications,
                         OnDidGetNotifications)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
 
 void NotificationManager::OnDidShow(int notification_id) {
   const auto& iter = active_page_notifications_.find(notification_id);
   if (iter == active_page_notifications_.end())
     return;
 
-  iter->second->dispatchShowEvent();
+  iter->second.delegate->dispatchShowEvent();
 }
 
 void NotificationManager::OnDidShowPersistent(int request_id, bool success) {
   blink::WebNotificationShowCallbacks* callbacks =
       pending_show_notification_requests_.Lookup(request_id);
   DCHECK(callbacks);
 
   if (!callbacks)
     return;
 
   if (success)
     callbacks->onSuccess();
   else
     callbacks->onError();
 
   pending_show_notification_requests_.Remove(request_id);
 }
 
 void NotificationManager::OnDidClose(int notification_id) {
   const auto& iter = active_page_notifications_.find(notification_id);
   if (iter == active_page_notifications_.end())
     return;
 
-  iter->second->dispatchCloseEvent();
+  iter->second.delegate->dispatchCloseEvent();
+
   active_page_notifications_.erase(iter);
 }
 
 void NotificationManager::OnDidClick(int notification_id) {
   const auto& iter = active_page_notifications_.find(notification_id);
   if (iter == active_page_notifications_.end())
     return;
 
-  iter->second->dispatchClickEvent();
+  iter->second.delegate->dispatchClickEvent();
 }
 
 void NotificationManager::OnDidGetNotifications(
     int request_id,
     const std::vector<PersistentNotificationInfo>& notification_infos) {
   blink::WebNotificationGetCallbacks* callbacks =
       pending_get_notification_requests_.Lookup(request_id);
   DCHECK(callbacks);
   if (!callbacks)
     return;
 
   blink::WebVector<blink::WebPersistentNotificationInfo> notifications(
       notification_infos.size());
 
   for (size_t i = 0; i < notification_infos.size(); ++i) {
     blink::WebPersistentNotificationInfo web_notification_info;
-    web_notification_info.persistentId = notification_infos[i].first;
+    web_notification_info.notificationId =
+        blink::WebString::fromUTF8(notification_infos[i].first);
     web_notification_info.data =
         ToWebNotificationData(notification_infos[i].second);
 
     notifications[i] = web_notification_info;
   }
 
   callbacks->onSuccess(notifications);
 
   pending_get_notification_requests_.Remove(request_id);
 }
 
 }  // namespace content