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() {
+    // Make a copy of |profile_| so that the member can be nulled out.
+    Profile* profile = profile_;
+
+    shutdown_notifier_subscription_.reset();
     event_router_ = nullptr;
-    shutdown_notifier_subscription_.reset();
+    profile_ = nullptr;
+
+    // The following call will result in deleting |this|. Do not access members
+    // after this, as you will be accessing invalid memory.
+    ExtensionNotificationDisplayHelperFactory::GetForProfile(profile)->Close(

[Miguel Garcia, 2017/02/21 10:56:43]

Wouldn't it be safer to post it as a task then?

[Peter Beverloo, 2017/02/21 17:23:50]

The issue there is that Shutdown() will be called when the profile is being shut
down. ExtensionNotificationDisplayHelperFactory requires *the profile*, so we
are unlikely to be able to access it when the task is ready to execute.

However, if we move this logic to the shutdown method of the
ExtensionNotificationDisplayHelper we avoid this problem entirely. Done.

+        scoped_id_);
   }
 
   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_;
 
   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::FundamentalValue>(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 16 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::FundamentalValue>(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::StringValue>(
       api::notifications::ToString(result)));
   SendResponse(true);
 
   return true;
 }
 
 }  // namespace extensions