Remove many delegates, let's see what breaks

chrome/browser/notifications/stub_notification_display_service.cc

 // Copyright 2017 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/stub_notification_display_service.h"
 
 #include <algorithm>
 
 #include "base/memory/ptr_util.h"
+#include "chrome/browser/notifications/notification_handler.h"
 #include "chrome/browser/profiles/profile.h"
 
 // static
 std::unique_ptr<KeyedService> StubNotificationDisplayService::FactoryForTests(
     content::BrowserContext* context) {
   return base::MakeUnique<StubNotificationDisplayService>(
       Profile::FromBrowserContext(context));
 }
 
 StubNotificationDisplayService::StubNotificationDisplayService(Profile* profile)
-    : NotificationDisplayService(profile) {}
+    : NotificationDisplayService(profile), profile_(profile) {}
 
 StubNotificationDisplayService::~StubNotificationDisplayService() = default;
 
 void StubNotificationDisplayService::RemoveNotification(
     NotificationCommon::Type notification_type,
     const std::string& notification_id,
     bool by_user) {
   auto iter = std::find_if(
       notifications_.begin(), notifications_.end(),
       [notification_type, notification_id](const NotificationData& data) {
         return data.first == notification_type &&
                data.second.delegate_id() == notification_id;
       });
 
   if (iter == notifications_.end())
     return;
 
-  // TODO(peter): Invoke the handlers when that has been generalized.
-  iter->second.delegate()->Close(by_user);
-
+  NotificationHandler* handler = GetNotificationHandler(notification_type);
+  DCHECK(handler);
+  handler->OnClose(profile_, iter->second.origin_url().spec(), notification_id,
+                   by_user);
   notifications_.erase(iter);
 }
 
 void StubNotificationDisplayService::RemoveAllNotifications(
     NotificationCommon::Type notification_type,
     bool by_user) {
+  NotificationHandler* handler = GetNotificationHandler(notification_type);
+  DCHECK(handler);
   for (auto iter = notifications_.begin(); iter != notifications_.end();) {
     if (iter->first == notification_type) {
-      // TODO(peter): Invoke the handlers when that has been generalized.
-      iter->second.delegate()->Close(by_user);
-
+      handler->OnClose(profile_, iter->second.origin_url().spec(),
+                       iter->second.id(), by_user);
       iter = notifications_.erase(iter);
     } else {
       iter++;
     }
   }
 }
 
 void StubNotificationDisplayService::Display(
     NotificationCommon::Type notification_type,
     const std::string& notification_id,
@@ skipping 21 matching lines @@
 void StubNotificationDisplayService::GetDisplayed(
     const DisplayedNotificationsCallback& callback) {
   std::unique_ptr<std::set<std::string>> notifications =
       base::MakeUnique<std::set<std::string>>();
 
   for (const auto& notification_data : notifications_)
     notifications->insert(notification_data.second.delegate_id());
 
   callback.Run(std::move(notifications), true /* supports_synchronization */);
 }