The 1st patch to disambiguate message center notifications

ui/message_center/message_center_impl.cc

 // Copyright (c) 2013 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/message_center_impl.h"
 
 #include <algorithm>
 
 #include "base/memory/scoped_vector.h"
 #include "base/observer_list.h"
@@ skipping 514 matching lines @@
 
 size_t MessageCenterImpl::UnreadNotificationCount() const {
   return notification_cache_.unread_count;
 }
 
 bool MessageCenterImpl::HasPopupNotifications() const {
   return !IsMessageCenterVisible() &&
       notification_list_->HasPopupNotifications(blockers_);
 }
 
-bool MessageCenterImpl::HasNotification(const std::string& id) {
-  // This will return true if the notification with |id| is hidden by the
-  // ChromeOS multi-profile feature. This would be harmless for now because
-  // this check will be used from the UI, so the |id| for hidden profile won't
-  // arrive here.
-  // TODO(mukai): fix this if necessary.
-  return notification_list_->HasNotification(id);
-}
-
 bool MessageCenterImpl::IsQuietMode() const {
   return notification_list_->quiet_mode();
 }
 
 bool MessageCenterImpl::HasClickedListener(const std::string& id) {
   scoped_refptr<NotificationDelegate> delegate =
       notification_list_->GetNotificationDelegate(id);
   return delegate.get() && delegate->HasClickedListener();
 }
 
+message_center::Notification* MessageCenterImpl::FindVisibleNotificationById(
+    const std::string& id) {
+  return notification_list_->GetNotificationById(id);
+}
+
 const NotificationList::Notifications&
 MessageCenterImpl::GetVisibleNotifications() {
   return notification_cache_.visible_notifications;
 }
 
 NotificationList::PopupNotifications
     MessageCenterImpl::GetPopupNotifications() {
   return notification_list_->GetPopupNotifications(blockers_, NULL);
 }
 
 //------------------------------------------------------------------------------
 // Client code interface.
 void MessageCenterImpl::AddNotification(scoped_ptr<Notification> notification) {
   DCHECK(notification.get());
   const std::string id = notification->id();
   for (size_t i = 0; i < blockers_.size(); ++i)
     blockers_[i]->CheckState();
 
   if (notification_list_->is_message_center_visible()) {
     notification_queue_->AddNotification(notification.Pass());
     return;
   }
 
   // Sometimes the notification can be added with the same id and the
   // |notification_list| will replace the notification instead of adding new.
   // This is essentially an update rather than addition.
-  bool already_exists = notification_list_->HasNotification(id);
+  bool already_exists = (notification_list_->GetNotificationById(id) != NULL);
   notification_list_->AddNotification(notification.Pass());
   notification_cache_.Rebuild(
       notification_list_->GetVisibleNotifications(blockers_));
 
   if (already_exists) {
     FOR_EACH_OBSERVER(
         MessageCenterObserver, observer_list_, OnNotificationUpdated(id));
   } else {
     FOR_EACH_OBSERVER(
         MessageCenterObserver, observer_list_, OnNotificationAdded(id));
@@ skipping 45 matching lines @@
   }
 }
 
 void MessageCenterImpl::RemoveNotification(const std::string& id,
                                            bool by_user) {
   if (!by_user && notification_list_->is_message_center_visible()) {
     notification_queue_->EraseNotification(id, by_user);
     return;
   }
 
-  if (!HasNotification(id))
+  if (FindVisibleNotificationById(id) == NULL)
     return;
 
   // In many cases |id| is a reference to an existing notification instance
   // but the instance can be destructed in RemoveNotification(). Hence
   // copies the id explicitly here.
   std::string copied_id(id);
 
   scoped_refptr<NotificationDelegate> delegate =
       notification_list_->GetNotificationDelegate(copied_id);
   if (delegate.get())
@@ skipping 124 matching lines @@
     Notifier notifier(notifier_id, base::string16(), true);
     settings_provider_->SetNotifierEnabled(notifier, false);
     // The settings provider will call back to remove the notifications
     // belonging to the notifier id.
   } else {
     RemoveNotificationsForNotifierId(notifier_id);
   }
 }
 
 void MessageCenterImpl::ClickOnNotification(const std::string& id) {
-  if (!HasNotification(id))
+  if (FindVisibleNotificationById(id) == NULL)
     return;
   if (HasPopupNotifications())
     MarkSinglePopupAsShown(id, true);
   scoped_refptr<NotificationDelegate> delegate =
       notification_list_->GetNotificationDelegate(id);
   if (delegate.get())
     delegate->Click();
   FOR_EACH_OBSERVER(
       MessageCenterObserver, observer_list_, OnNotificationClicked(id));
 }
 
 void MessageCenterImpl::ClickOnNotificationButton(const std::string& id,
                                               int button_index) {
-  if (!HasNotification(id))
+  if (FindVisibleNotificationById(id) == NULL)
     return;
   if (HasPopupNotifications())
     MarkSinglePopupAsShown(id, true);
   scoped_refptr<NotificationDelegate> delegate =
       notification_list_->GetNotificationDelegate(id);
   if (delegate.get())
     delegate->ButtonClick(button_index);
   FOR_EACH_OBSERVER(
       MessageCenterObserver, observer_list_, OnNotificationButtonClicked(
           id, button_index));
 }
 
 void MessageCenterImpl::MarkSinglePopupAsShown(const std::string& id,
                                                bool mark_notification_as_read) {
-  if (!HasNotification(id))
+  if (FindVisibleNotificationById(id) == NULL)
     return;
   notification_list_->MarkSinglePopupAsShown(id, mark_notification_as_read);
   notification_cache_.RecountUnread();
   FOR_EACH_OBSERVER(
       MessageCenterObserver, observer_list_, OnNotificationUpdated(id));
 }
 
 void MessageCenterImpl::DisplayedNotification(
     const std::string& id,
     const DisplaySource source) {
-  if (!HasNotification(id))
+  if (FindVisibleNotificationById(id) == NULL)
     return;
 
   if (HasPopupNotifications())
     notification_list_->MarkSinglePopupAsDisplayed(id);
   notification_cache_.RecountUnread();
   scoped_refptr<NotificationDelegate> delegate =
       notification_list_->GetNotificationDelegate(id);
   if (delegate.get())
     delegate->Display();
   FOR_EACH_OBSERVER(
@@ skipping 55 matching lines @@
 void MessageCenterImpl::PausePopupTimers() {
   if (popup_timers_controller_.get())
     popup_timers_controller_->PauseAll();
 }
 
 void MessageCenterImpl::DisableTimersForTest() {
   popup_timers_controller_.reset();
 }
 
 }  // namespace message_center