Move NotificationDelegate into message_center.

ui/message_center/notification_list.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 "ui/message_center/notification_list.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/time.h"
@@ skipping 53 matching lines @@
     Notification* notification = *iter;
     notification->set_shown_as_popup(true);
     notification->set_is_read(true);
     if (updated_ids &&
         !(notification->shown_as_popup() && notification->is_read())) {
       updated_ids->insert(notification->id());
     }
   }
 }
 
-void NotificationList::AddNotification(
-    NotificationType type,
-    const std::string& id,
-    const string16& title,
-    const string16& message,
-    const string16& display_source,
-    const std::string& extension_id,
-    const DictionaryValue* optional_fields) {
-  scoped_ptr<Notification> notification(
-      new Notification(type, id, title, message, display_source, extension_id,
-          optional_fields));
+void NotificationList::AddNotification(NotificationType type,
+                                       const std::string& id,
+                                       const string16& title,
+                                       const string16& message,
+                                       const string16& display_source,
+                                       const std::string& extension_id,
+                                       const DictionaryValue* optional_fields,
+                                       NotificationDelegate* delegate) {
+  scoped_ptr<Notification> notification(new Notification(type,
+                                                         id,
+                                                         title,
+                                                         message,
+                                                         display_source,
+                                                         extension_id,
+                                                         optional_fields,
+                                                         delegate));
   PushNotification(notification.Pass());
 }
 
 void NotificationList::UpdateNotificationMessage(
     const std::string& old_id,
     const std::string& new_id,
     const string16& title,
     const string16& message,
-    const base::DictionaryValue* optional_fields) {
+    const base::DictionaryValue* optional_fields,
+    NotificationDelegate* delegate) {
   Notifications::iterator iter = GetNotification(old_id);
   if (iter == notifications_.end())
     return;
 
   // Copy and update a notification. It has an effect of setting a new timestamp
   // if not overridden by optional_fields
   scoped_ptr<Notification> notification(
       new Notification((*iter)->type(),
                        new_id,
                        title,
                        message,
                        (*iter)->display_source(),
                        (*iter)->extension_id(),
-                       optional_fields));
+                       optional_fields,
+                       delegate));
   notification->CopyState(*iter);
 
   // Handles priority promotion. If the notification is already dismissed but
   // the updated notification has higher priority, it should re-appear as a
   // toast.
   if ((*iter)->priority() < notification->priority()) {
     notification->set_is_read(false);
     notification->set_shown_as_popup(false);
   }
 
@@ skipping 160 matching lines @@
     --unread_count_;
   }
 }
 
 void NotificationList::MarkNotificationAsExpanded(const std::string& id) {
   Notifications::iterator iter = GetNotification(id);
   if (iter != notifications_.end())
     (*iter)->set_is_expanded(true);
 }
 
+NotificationDelegate* NotificationList::GetNotificationDelegate(
+    const std::string& id) {
+  Notifications::iterator iter = GetNotification(id);
+  if (iter == notifications_.end())
+    return NULL;
+  return (*iter)->delegate();
+}
+
 void NotificationList::SetQuietMode(bool quiet_mode) {
   SetQuietModeInternal(quiet_mode);
   quiet_mode_timer_.reset();
 }
 
 void NotificationList::EnterQuietModeWithExpire(
     const base::TimeDelta& expires_in) {
   if (quiet_mode_timer_.get()) {
     // Note that the capital Reset() is the method to restart the timer, not
     // scoped_ptr::reset().
@@ skipping 61 matching lines @@
     notification->set_shown_as_popup(message_center_visible_ || quiet_mode_);
     if (!quiet_mode_ && notification->priority() > MIN_PRIORITY)
         ++unread_count_;
   }
   // Take ownership. The notification can only be removed from the list
   // in EraseNotification(), which will delete it.
   notifications_.insert(notification.release());
 }
 
 }  // namespace message_center