Android Notifications should be closable without a delegate.

chrome/browser/notifications/notification_ui_manager_android.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 "chrome/browser/notifications/notification_ui_manager_android.h"
 
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/logging.h"
 #include "base/pickle.h"
@@ skipping 134 matching lines @@
 
 NotificationUIManagerAndroid::~NotificationUIManagerAndroid() {
   Java_NotificationUIManager_destroy(AttachCurrentThread(),
                                      java_object_.obj());
 }
 
 bool NotificationUIManagerAndroid::OnNotificationClicked(
     JNIEnv* env,
     jobject java_object,
     jstring notification_id,
+    jint platform_id,
     jbyteArray serialized_notification_data) {
   std::string id = ConvertJavaStringToUTF8(env, notification_id);
 
   auto iter = profile_notifications_.find(id);
   if (iter != profile_notifications_.end()) {
     const Notification& notification = iter->second->notification();
     notification.delegate()->Click();
 
     return true;
   }
@@ skipping 12 matching lines @@
   content::PlatformNotificationData notification_data;
   GURL origin;
   int64 service_worker_registration_id;
 
   Pickle pickle(reinterpret_cast<const char*>(&bytes[0]), bytes.size());
   if (!UnserializePersistentNotification(pickle, &notification_data, &origin,
                                          &service_worker_registration_id)) {
     return false;
   }
 
+  // Store the platform Id of this notification so that it can be closed.
+  platform_notifications_[id] = platform_id;
+
   PlatformNotificationServiceImpl* service =
       PlatformNotificationServiceImpl::GetInstance();
 
   // TODO(peter): Rather than assuming that the last used profile is the
   // appropriate one for this notification, the used profile should be
   // stored as part of the notification's data. See https://crbug.com/437574.
   service->OnPersistentNotificationClick(
       ProfileManager::GetLastUsedProfile(),
       service_worker_registration_id,
       id,
@@ skipping 115 matching lines @@
 
   return &profile_notification->notification();
 }
 
 bool NotificationUIManagerAndroid::CancelById(const std::string& delegate_id,
                                               ProfileID profile_id) {
   std::string profile_notification_id =
       ProfileNotification::GetProfileNotificationId(delegate_id, profile_id);
   ProfileNotification* profile_notification =
       FindProfileNotification(profile_notification_id);
-  if (!profile_notification)
-    return false;
+  if (profile_notification) {
+    RemoveProfileNotification(profile_notification);
+    return true;
+  }
 
-  RemoveProfileNotification(profile_notification);
+  // On Android, it's still possible that the notification can be closed in case
+  // the platform Id is known, even if no delegate exists. This happens when the
+  // browser process is started because of interaction with a Notification.
+  PlatformCloseNotification(delegate_id);
   return true;
 }
 
 std::set<std::string>
 NotificationUIManagerAndroid::GetAllIdsByProfileAndSourceOrigin(
     Profile* profile,
     const GURL& source) {
   // |profile| may be invalid, so no calls must be made based on the instance.
   std::set<std::string> delegate_ids;
 
@@ skipping 41 matching lines @@
     }
   }
 
   return removed;
 }
 
 void NotificationUIManagerAndroid::CancelAll() {
   for (auto iterator : profile_notifications_) {
     ProfileNotification* profile_notification = iterator.second;
 
-    PlatformCloseNotification(profile_notification);
+    PlatformCloseNotification(profile_notification->notification().id());
     delete profile_notification;
   }
 
   profile_notifications_.clear();
 }
 
 bool NotificationUIManagerAndroid::RegisterNotificationUIManager(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 void NotificationUIManagerAndroid::PlatformCloseNotification(
-    ProfileNotification* profile_notification) {
-  std::string id = profile_notification->notification().id();
-
-  auto iterator = platform_notifications_.find(id);
+    const std::string& notification_id) {
+  auto iterator = platform_notifications_.find(notification_id);
   if (iterator == platform_notifications_.end())
     return;
 
   int platform_id = iterator->second;
-  platform_notifications_.erase(id);
+  platform_notifications_.erase(notification_id);
 
   Java_NotificationUIManager_closeNotification(AttachCurrentThread(),
                                                java_object_.obj(),
                                                platform_id);
 }
 
 void NotificationUIManagerAndroid::AddProfileNotification(
     ProfileNotification* profile_notification) {
   std::string id = profile_notification->notification().id();
 
   // Notification ids should be unique.
   DCHECK(profile_notifications_.find(id) == profile_notifications_.end());
 
   profile_notifications_[id] = profile_notification;
 }
 
 void NotificationUIManagerAndroid::RemoveProfileNotification(
     ProfileNotification* profile_notification) {
-  PlatformCloseNotification(profile_notification);
+  std::string notification_id = profile_notification->notification().id();
+  PlatformCloseNotification(notification_id);
 
-  std::string id = profile_notification->notification().id();
-  profile_notifications_.erase(id);
+  profile_notifications_.erase(notification_id);
   delete profile_notification;
 }
 
 ProfileNotification* NotificationUIManagerAndroid::FindProfileNotification(
     const std::string& id) const {
   auto iter = profile_notifications_.find(id);
   if (iter == profile_notifications_.end())
     return nullptr;
 
   return iter->second;
 }