Migrate extension notifications to the new NotificationDisplayService

chrome/browser/extensions/api/notifications/notifications_api.cc

 // Copyright (c) 2012 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/extensions/api/notifications/notifications_api.h"
 
 #include <stddef.h>
 
 #include <utility>
 
 #include "base/callback.h"
 #include "base/feature_list.h"
 #include "base/guid.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
-#include "chrome/browser/browser_process.h"
+#include "chrome/browser/extensions/api/notifications/extension_notification_display_helper.h"
+#include "chrome/browser/extensions/api/notifications/extension_notification_display_helper_factory.h"
 #include "chrome/browser/notifications/notification.h"
-#include "chrome/browser/notifications/notification_ui_manager.h"
 #include "chrome/browser/notifications/notifier_state_tracker.h"
 #include "chrome/browser/notifications/notifier_state_tracker_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/api/notifications/notification_style.h"
 #include "components/keyed_service/content/browser_context_keyed_service_shutdown_notifier_factory.h"
 #include "components/keyed_service/core/keyed_service_shutdown_notifier.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/app_window/app_window.h"
@@ skipping 170 matching lines @@
 };
 
 class NotificationsApiDelegate : public NotificationDelegate {
  public:
   NotificationsApiDelegate(ChromeAsyncExtensionFunction* api_function,
                            Profile* profile,
                            const std::string& extension_id,
                            const std::string& id)
       : api_function_(api_function),
         event_router_(EventRouter::Get(profile)),
+        profile_(profile),
         extension_id_(extension_id),
         id_(id),
         scoped_id_(CreateScopedIdentifier(extension_id, id)) {
     DCHECK(api_function_);
     shutdown_notifier_subscription_ =
         ShutdownNotifierFactory::GetInstance()->Get(profile)->Subscribe(
             base::Bind(&NotificationsApiDelegate::Shutdown,
                        base::Unretained(this)));
   }
 
   void Close(bool by_user) override {
     EventRouter::UserGestureState gesture =
         by_user ? EventRouter::USER_GESTURE_ENABLED
                 : EventRouter::USER_GESTURE_NOT_ENABLED;
     std::unique_ptr<base::ListValue> args(CreateBaseEventArgs());
     args->AppendBoolean(by_user);
     SendEvent(events::NOTIFICATIONS_ON_CLOSED,
               notifications::OnClosed::kEventName, gesture, std::move(args));
+
+    DCHECK(profile_);
+    ExtensionNotificationDisplayHelperFactory::GetForProfile(profile_)
+        ->EraseDataForNotificationId(scoped_id_);
   }
 
   void Click() override {
     std::unique_ptr<base::ListValue> args(CreateBaseEventArgs());
     SendEvent(events::NOTIFICATIONS_ON_CLICKED,
               notifications::OnClicked::kEventName,
               EventRouter::USER_GESTURE_ENABLED, std::move(args));
   }
 
   bool HasClickedListener() override {
@@ skipping 52 matching lines @@
     if (!event_router_)
       return;
 
     std::unique_ptr<Event> event(
         new Event(histogram_value, name, std::move(args)));
     event->user_gesture = user_gesture;
     event_router_->DispatchEventToExtension(extension_id_, std::move(event));
   }
 
   void Shutdown() {
+    shutdown_notifier_subscription_.reset();
     event_router_ = nullptr;
-    shutdown_notifier_subscription_.reset();
+    profile_ = nullptr;
   }
 
   std::unique_ptr<base::ListValue> CreateBaseEventArgs() {
     std::unique_ptr<base::ListValue> args(new base::ListValue());
     args->AppendString(id_);
     return args;
   }
 
   scoped_refptr<ChromeAsyncExtensionFunction> api_function_;
 
   // Since this class is refcounted it may outlive the profile.  We listen for
   // profile-keyed service shutdown events and reset to nullptr at that time,
   // so make sure to check for a valid pointer before use.
   EventRouter* event_router_;
+  Profile* profile_;

[Devlin, 2017/04/10 21:23:55]

Instead of profile_, maybe store ExtensionNotificationDisplayHelper*?

[Peter Beverloo, 2017/04/11 14:19:25]

Done.

 
   const std::string extension_id_;
   const std::string id_;
   const std::string scoped_id_;
 
   std::unique_ptr<KeyedServiceShutdownNotifier::Subscription>
       shutdown_notifier_subscription_;
 
   DISALLOW_COPY_AND_ASSIGN(NotificationsApiDelegate);
 };
@@ skipping 158 matching lines @@
       type, title, message, icon,
       message_center::NotifierId(message_center::NotifierId::APPLICATION,
                                  extension_->id()),
       base::UTF8ToUTF16(extension_->name()), extension_->url(),
       api_delegate->id(), optional_fields, api_delegate);
 
   // Apply the "requireInteraction" flag. The value defaults to false.
   notification.set_never_timeout(options->require_interaction &&
                                  *options->require_interaction);
 
-  g_browser_process->notification_ui_manager()->Add(notification, GetProfile());
+  GetDisplayHelper()->Display(notification);
   return true;
 }
 
 bool NotificationsApiFunction::UpdateNotification(
     const std::string& id,
     api::notifications::NotificationOptions* options,
     Notification* notification) {
 #if !defined(OS_CHROMEOS)
   if (options->priority &&
       *options->priority < message_center::DEFAULT_PRIORITY) {
@@ skipping 113 matching lines @@
           base::UTF8ToUTF16(api_item.title),
           base::UTF8ToUTF16(api_item.message)));
     }
     notification->set_items(items);
   }
 
   // Then override if it's already set.
   if (options->is_clickable.get())
     notification->set_clickable(*options->is_clickable);
 
-  g_browser_process->notification_ui_manager()->Update(*notification,
-                                                       GetProfile());
+  // It's safe to follow the regular path for adding a new notification as it's
+  // already been verified that there is a notification that can be updated.
+  GetDisplayHelper()->Display(*notification);
+
   return true;
 }
 
 bool NotificationsApiFunction::AreExtensionNotificationsAllowed() const {
   NotifierStateTracker* notifier_state_tracker =
       NotifierStateTrackerFactory::GetForProfile(GetProfile());
 
   return notifier_state_tracker->IsNotifierEnabled(
       message_center::NotifierId(message_center::NotifierId::APPLICATION,
                                  extension_->id()));
 }
 
 bool NotificationsApiFunction::IsNotificationsApiEnabled() const {
   return CanRunWhileDisabled() || AreExtensionNotificationsAllowed();
 }
 
 bool NotificationsApiFunction::CanRunWhileDisabled() const {
   return false;
 }
 
+ExtensionNotificationDisplayHelper* NotificationsApiFunction::GetDisplayHelper()
+    const {
+  return ExtensionNotificationDisplayHelperFactory::GetForProfile(GetProfile());
+}
+
 bool NotificationsApiFunction::RunAsync() {
   if (IsNotificationsApiAvailable() && IsNotificationsApiEnabled()) {
     return RunNotificationsApi();
   } else {
     SendResponse(false);
     return true;
   }
 }
 
 message_center::NotificationType
@@ skipping 56 matching lines @@
 NotificationsUpdateFunction::~NotificationsUpdateFunction() {
 }
 
 bool NotificationsUpdateFunction::RunNotificationsApi() {
   params_ = api::notifications::Update::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
   // We are in update.  If the ID doesn't exist, succeed but call the callback
   // with "false".
   const Notification* matched_notification =
-      g_browser_process->notification_ui_manager()->FindById(
-          CreateScopedIdentifier(extension_->id(), params_->notification_id),
-          NotificationUIManager::GetProfileID(GetProfile()));
+      GetDisplayHelper()->GetByNotificationId(
+          CreateScopedIdentifier(extension_->id(), params_->notification_id));
+
   if (!matched_notification) {
     SetResult(base::MakeUnique<base::Value>(false));
     SendResponse(true);
     return true;
   }
 
   // Copy the existing notification to get a writable version of it.
   Notification notification = *matched_notification;
 
   // If we have trouble updating the notification (could be improper use of API
@@ skipping 15 matching lines @@
 NotificationsClearFunction::NotificationsClearFunction() {
 }
 
 NotificationsClearFunction::~NotificationsClearFunction() {
 }
 
 bool NotificationsClearFunction::RunNotificationsApi() {
   params_ = api::notifications::Clear::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
-  bool cancel_result = g_browser_process->notification_ui_manager()->CancelById(
-      CreateScopedIdentifier(extension_->id(), params_->notification_id),
-      NotificationUIManager::GetProfileID(GetProfile()));
+  bool cancel_result = GetDisplayHelper()->Close(
+      CreateScopedIdentifier(extension_->id(), params_->notification_id));
 
   SetResult(base::MakeUnique<base::Value>(cancel_result));
   SendResponse(true);
 
   return true;
 }
 
 NotificationsGetAllFunction::NotificationsGetAllFunction() {}
 
 NotificationsGetAllFunction::~NotificationsGetAllFunction() {}
 
 bool NotificationsGetAllFunction::RunNotificationsApi() {
-  NotificationUIManager* notification_ui_manager =
-      g_browser_process->notification_ui_manager();
   std::set<std::string> notification_ids =
-      notification_ui_manager->GetAllIdsByProfileAndSourceOrigin(
-          NotificationUIManager::GetProfileID(GetProfile()), extension_->url());
+      GetDisplayHelper()->GetNotificationIdsForExtension(extension_->url());
 
   std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue());
 
   for (std::set<std::string>::iterator iter = notification_ids.begin();
        iter != notification_ids.end(); iter++) {
     result->SetBooleanWithoutPathExpansion(
         StripScopeFromIdentifier(extension_->id(), *iter), true);
   }
 
   SetResult(std::move(result));
@@ skipping 19 matching lines @@
           : api::notifications::PERMISSION_LEVEL_DENIED;
 
   SetResult(
       base::MakeUnique<base::Value>(api::notifications::ToString(result)));
   SendResponse(true);
 
   return true;
 }
 
 }  // namespace extensions