Handle notification preferences intent from gear icon.

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 <utility>
+
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/logging.h"
 #include "base/pickle.h"
-#include "base/strings/string16.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/notifications/persistent_notification_delegate.h"
 #include "chrome/browser/notifications/platform_notification_service_impl.h"
 #include "chrome/browser/notifications/profile_notification.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "content/public/common/persistent_notification_status.h"
 #include "content/public/common/platform_notification_data.h"
 #include "jni/NotificationUIManager_jni.h"
 #include "ui/gfx/android/java_bitmap.h"
 #include "ui/gfx/image/image.h"
@@ skipping 156 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;
+  // Store the platform id, tag, and origin of this notification so that it can
+  // be closed.
+  RegeneratedNotificationInfo notification_info(notification_data.tag,
+                                                platform_id, origin.spec());
+  regenerated_notification_infos_.insert(std::make_pair(id, notification_info));
 
   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,
@@ skipping 24 matching lines @@
     return;
 
   ProfileNotification* profile_notification =
       new ProfileNotification(profile, notification);
 
   // Takes ownership of |profile_notification|.
   AddProfileNotification(profile_notification);
 
   JNIEnv* env = AttachCurrentThread();
 
+  ScopedJavaLocalRef<jstring> tag =
+      ConvertUTF16ToJavaString(env, notification.replace_id());
   ScopedJavaLocalRef<jstring> id = ConvertUTF8ToJavaString(
       env, profile_notification->notification().id());
   ScopedJavaLocalRef<jstring> title = ConvertUTF16ToJavaString(
       env, notification.title());
   ScopedJavaLocalRef<jstring> body = ConvertUTF16ToJavaString(
       env, notification.message());
   ScopedJavaLocalRef<jstring> origin = ConvertUTF8ToJavaString(
       env, notification.origin_url().GetOrigin().spec());
 
   ScopedJavaLocalRef<jobject> icon;
@@ skipping 16 matching lines @@
           "Unable to serialize the notification, payload too large (max 1MB).";
       RemoveProfileNotification(profile_notification);
       return;
     }
 
     notification_data = base::android::ToJavaByteArray(
         env, static_cast<const uint8*>(pickle->data()), pickle->size());
   }
 
   int platform_id = Java_NotificationUIManager_displayNotification(
-      env, java_object_.obj(), id.obj(), title.obj(), body.obj(), icon.obj(),
-      origin.obj(), notification_data.obj());
+      env, java_object_.obj(), tag.obj(), id.obj(), title.obj(), body.obj(),
+      icon.obj(), origin.obj(), notification_data.obj());
 
-  std::string notification_id = profile_notification->notification().id();
-  platform_notifications_[notification_id] = platform_id;
+  RegeneratedNotificationInfo notification_info(
+      notification.replace_id(), platform_id,
+      notification.origin_url().GetOrigin().spec());
+  regenerated_notification_infos_.insert(std::make_pair(
+      profile_notification->notification().id(), notification_info));
 
   notification.delegate()->Display();
 }
 
 bool NotificationUIManagerAndroid::Update(const Notification& notification,
                                           Profile* profile) {
   const base::string16& replace_id = notification.replace_id();
   if (replace_id.empty())
     return false;
 
@@ skipping 114 matching lines @@
 
   profile_notifications_.clear();
 }
 
 bool NotificationUIManagerAndroid::RegisterNotificationUIManager(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 void NotificationUIManagerAndroid::PlatformCloseNotification(
     const std::string& notification_id) {
-  auto iterator = platform_notifications_.find(notification_id);
-  if (iterator == platform_notifications_.end())
+  auto iterator = regenerated_notification_infos_.find(notification_id);
+  if (iterator == regenerated_notification_infos_.end())
     return;
 
-  int platform_id = iterator->second;
-  platform_notifications_.erase(notification_id);
+  RegeneratedNotificationInfo notification_info = iterator->second;
+  int platform_id = notification_info.platform_id;
+  JNIEnv* env = AttachCurrentThread();
 
-  Java_NotificationUIManager_closeNotification(AttachCurrentThread(),
-                                               java_object_.obj(),
-                                               platform_id);
+  ScopedJavaLocalRef<jstring> tag =
+      ConvertUTF16ToJavaString(env, notification_info.tag);
+  ScopedJavaLocalRef<jstring> origin =
+      ConvertUTF8ToJavaString(env, notification_info.origin);
+
+  regenerated_notification_infos_.erase(notification_id);
+
+  Java_NotificationUIManager_closeNotification(
+      env, java_object_.obj(), tag.obj(), platform_id, origin.obj());
 }
 
 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;
@@ skipping 10 matching lines @@
 
 ProfileNotification* NotificationUIManagerAndroid::FindProfileNotification(
     const std::string& id) const {
   auto iter = profile_notifications_.find(id);
   if (iter == profile_notifications_.end())
     return nullptr;
 
   return iter->second;
 }