Remove usage of FOR_EACH_OBSERVER macro in ui/message_center

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 <deque>
 #include <utility>
 
@@ skipping 400 matching lines @@
     // Do not call MessageCenterImpl::MarkSinglePopupAsShown() directly here
     // just for performance reason. MessageCenterImpl::MarkSinglePopupAsShown()
     // calls NotificationList::MarkSinglePopupAsShown() and then updates the
     // unread count, but the whole cache will be recreated below.
     notification_list_->MarkSinglePopupAsShown(id, true);
   }
   notification_cache_.Rebuild(
       notification_list_->GetVisibleNotifications(blockers_));
 
   for (const auto& id : blocked_ids) {
-    FOR_EACH_OBSERVER(MessageCenterObserver,
-                      observer_list_,
-                      OnNotificationUpdated(id));
+    for (auto& observer : observer_list_)
+      observer.OnNotificationUpdated(id);
   }
-  FOR_EACH_OBSERVER(MessageCenterObserver,
-                    observer_list_,
-                    OnBlockingStateChanged(blocker));
+  for (auto& observer : observer_list_)
+    observer.OnBlockingStateChanged(blocker);
 }
 
 void MessageCenterImpl::UpdateIconImage(
     const NotifierId& notifier_id, const gfx::Image& icon) {}
 
 void MessageCenterImpl::NotifierGroupChanged() {}
 
 void MessageCenterImpl::NotifierEnabledChanged(
     const NotifierId& notifier_id, bool enabled) {
   if (!enabled) {
     RemoveNotificationsForNotifierId(notifier_id);
   }
 }
 
 void MessageCenterImpl::SetVisibility(Visibility visibility) {
   visible_ = (visibility == VISIBILITY_MESSAGE_CENTER);
 
   if (visible_ && !locked_) {
     std::set<std::string> updated_ids;
     notification_list_->SetNotificationsShown(blockers_, &updated_ids);
     notification_cache_.RecountUnread();
 
     for (const auto& id : updated_ids) {
-      FOR_EACH_OBSERVER(
-          MessageCenterObserver, observer_list_, OnNotificationUpdated(id));
+      for (auto& observer : observer_list_)
+        observer.OnNotificationUpdated(id);
     }
   }
 
   if (notification_queue_ &&
       visibility == VISIBILITY_TRANSIENT) {
     notification_queue_->ApplyChanges(this);
   }
 
-  FOR_EACH_OBSERVER(MessageCenterObserver,
-                    observer_list_,
-                    OnCenterVisibilityChanged(visibility));
+  for (auto& observer : observer_list_)
+    observer.OnCenterVisibilityChanged(visibility);
 }
 
 bool MessageCenterImpl::IsMessageCenterVisible() const {
   return visible_;
 }
 
 size_t MessageCenterImpl::NotificationCount() const {
   return notification_cache_.visible_notifications.size();
 }
 
@@ skipping 63 matching lines @@
 
   // 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_->GetNotificationById(id) != NULL);
   notification_list_->AddNotification(std::move(notification));
   notification_cache_.Rebuild(
       notification_list_->GetVisibleNotifications(blockers_));
 
   if (already_exists) {
-    FOR_EACH_OBSERVER(
-        MessageCenterObserver, observer_list_, OnNotificationUpdated(id));
+    for (auto& observer : observer_list_)
+      observer.OnNotificationUpdated(id);
   } else {
-    FOR_EACH_OBSERVER(
-        MessageCenterObserver, observer_list_, OnNotificationAdded(id));
+    for (auto& observer : observer_list_)
+      observer.OnNotificationAdded(id);
   }
 }
 
 void MessageCenterImpl::UpdateNotification(
     const std::string& old_id,
     std::unique_ptr<Notification> new_notification) {
   for (size_t i = 0; i < blockers_.size(); ++i)
     blockers_[i]->CheckState();
 
   if (notification_queue_ && visible_) {
@@ skipping 25 matching lines @@
 
 void MessageCenterImpl::UpdateNotificationImmediately(
     const std::string& old_id,
     std::unique_ptr<Notification> new_notification) {
   std::string new_id = new_notification->id();
   notification_list_->UpdateNotificationMessage(old_id,
                                                 std::move(new_notification));
   notification_cache_.Rebuild(
      notification_list_->GetVisibleNotifications(blockers_));
   if (old_id == new_id) {
-    FOR_EACH_OBSERVER(
-        MessageCenterObserver, observer_list_, OnNotificationUpdated(new_id));
+    for (auto& observer : observer_list_)
+      observer.OnNotificationUpdated(new_id);
   } else {
-    FOR_EACH_OBSERVER(MessageCenterObserver, observer_list_,
-                      OnNotificationRemoved(old_id, false));
-    FOR_EACH_OBSERVER(MessageCenterObserver, observer_list_,
-                      OnNotificationAdded(new_id));
+    for (auto& observer : observer_list_)
+      observer.OnNotificationRemoved(old_id, false);
+    for (auto& observer : observer_list_)
+      observer.OnNotificationAdded(new_id);
   }
 }
 
 void MessageCenterImpl::RemoveNotification(const std::string& id,
                                            bool by_user) {
   if (notification_queue_ && !by_user && visible_) {
     notification_queue_->EraseNotification(id, by_user);
     return;
   }
 
@@ skipping 15 matching lines @@
   std::string copied_id(id);
 
   scoped_refptr<NotificationDelegate> delegate =
       notification_list_->GetNotificationDelegate(copied_id);
   if (delegate.get())
     delegate->Close(by_user);
 
   notification_list_->RemoveNotification(copied_id);
   notification_cache_.Rebuild(
       notification_list_->GetVisibleNotifications(blockers_));
-  FOR_EACH_OBSERVER(MessageCenterObserver,
-                    observer_list_,
-                    OnNotificationRemoved(copied_id, by_user));
+  for (auto& observer : observer_list_)
+    observer.OnNotificationRemoved(copied_id, by_user);
 }
 
 void MessageCenterImpl::RemoveNotificationsForNotifierId(
     const NotifierId& notifier_id) {
   NotificationList::Notifications notifications =
       notification_list_->GetNotificationsByNotifierId(notifier_id);
   for (auto* notification : notifications)
     RemoveNotification(notification->id(), false);
   if (!notifications.empty()) {
     notification_cache_.Rebuild(
@@ skipping 20 matching lines @@
     if (delegate.get())
       delegate->Close(by_user);
     notification_list_->RemoveNotification(notification->id());
   }
 
   if (!ids.empty()) {
     notification_cache_.Rebuild(
         notification_list_->GetVisibleNotifications(blockers_));
   }
   for (const auto& id : ids) {
-    FOR_EACH_OBSERVER(MessageCenterObserver,
-                      observer_list_,
-                      OnNotificationRemoved(id, by_user));
+    for (auto& observer : observer_list_)
+      observer.OnNotificationRemoved(id, by_user);
   }
 }
 
 void MessageCenterImpl::SetNotificationIcon(const std::string& notification_id,
                                             const gfx::Image& image) {
   bool updated = false;
   Notification* queue_notification =
       notification_queue_
           ? notification_queue_->GetLatestNotification(notification_id)
           : NULL;
 
   if (queue_notification) {
     queue_notification->set_icon(image);
     updated = true;
   } else {
     updated = notification_list_->SetNotificationIcon(notification_id, image);
   }
 
   if (updated) {
-    FOR_EACH_OBSERVER(MessageCenterObserver, observer_list_,
-                      OnNotificationUpdated(notification_id));
+    for (auto& observer : observer_list_)
+      observer.OnNotificationUpdated(notification_id);
   }
 }
 
 void MessageCenterImpl::SetNotificationImage(const std::string& notification_id,
                                              const gfx::Image& image) {
   bool updated = false;
   Notification* queue_notification =
       notification_queue_
           ? notification_queue_->GetLatestNotification(notification_id)
           : NULL;
 
   if (queue_notification) {
     queue_notification->set_image(image);
     updated = true;
   } else {
     updated = notification_list_->SetNotificationImage(notification_id, image);
   }
 
   if (updated) {
-    FOR_EACH_OBSERVER(MessageCenterObserver, observer_list_,
-                      OnNotificationUpdated(notification_id));
+    for (auto& observer : observer_list_)
+      observer.OnNotificationUpdated(notification_id);
   }
 }
 
 void MessageCenterImpl::SetNotificationButtonIcon(
     const std::string& notification_id, int button_index,
     const gfx::Image& image) {
   bool updated = false;
   Notification* queue_notification =
       notification_queue_
           ? notification_queue_->GetLatestNotification(notification_id)
           : NULL;
 
   if (queue_notification) {
     queue_notification->SetButtonIcon(button_index, image);
     updated = true;
   } else {
     updated = notification_list_->SetNotificationButtonIcon(
         notification_id, button_index, image);
   }
 
   if (updated) {
-    FOR_EACH_OBSERVER(MessageCenterObserver, observer_list_,
-                      OnNotificationUpdated(notification_id));
+    for (auto& observer : observer_list_)
+      observer.OnNotificationUpdated(notification_id);
   }
 }
 
 void MessageCenterImpl::DisableNotificationsByNotifier(
     const NotifierId& notifier_id) {
   if (settings_provider_) {
     // TODO(mukai): SetNotifierEnabled can just accept notifier_id?
     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 (FindVisibleNotificationById(id) == NULL)
     return;
 #if defined(OS_CHROMEOS)
   if (HasPopupNotifications())
     MarkSinglePopupAsShown(id, true);
 #endif
   scoped_refptr<NotificationDelegate> delegate =
       notification_list_->GetNotificationDelegate(id);
   if (delegate.get())
     delegate->Click();
-  FOR_EACH_OBSERVER(
-      MessageCenterObserver, observer_list_, OnNotificationClicked(id));
+  for (auto& observer : observer_list_)
+    observer.OnNotificationClicked(id);
 }
 
 void MessageCenterImpl::ClickOnNotificationButton(const std::string& id,
                                                   int button_index) {
   if (FindVisibleNotificationById(id) == NULL)
     return;
 #if defined(OS_CHROMEOS)
   if (HasPopupNotifications())
     MarkSinglePopupAsShown(id, true);
 #endif
   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));
+  for (auto& observer : observer_list_)
+    observer.OnNotificationButtonClicked(id, button_index);
 }
 
 void MessageCenterImpl::ClickOnSettingsButton(const std::string& id) {
   scoped_refptr<NotificationDelegate> delegate =
       notification_list_->GetNotificationDelegate(id);
   if (delegate.get())
     delegate->SettingsClick();
-  FOR_EACH_OBSERVER(MessageCenterObserver, observer_list_,
-                    OnNotificationSettingsClicked());
+  for (auto& observer : observer_list_)
+    observer.OnNotificationSettingsClicked();
 }
 
 void MessageCenterImpl::MarkSinglePopupAsShown(const std::string& id,
                                                bool mark_notification_as_read) {
   if (FindVisibleNotificationById(id) == NULL)
     return;
 #if !defined(OS_CHROMEOS)
   return this->RemoveNotification(id, false);
 #else
   notification_list_->MarkSinglePopupAsShown(id, mark_notification_as_read);
   notification_cache_.RecountUnread();
-  FOR_EACH_OBSERVER(
-      MessageCenterObserver, observer_list_, OnNotificationUpdated(id));
+  for (auto& observer : observer_list_)
+    observer.OnNotificationUpdated(id);
 #endif  // defined(OS_CHROMEOS)
 }
 
 void MessageCenterImpl::DisplayedNotification(
     const std::string& id,
     const DisplaySource source) {
   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(
-      MessageCenterObserver,
-      observer_list_,
-      OnNotificationDisplayed(id, source));
+  for (auto& observer : observer_list_)
+    observer.OnNotificationDisplayed(id, source);
 }
 
 void MessageCenterImpl::SetNotifierSettingsProvider(
     NotifierSettingsProvider* provider) {
   if (settings_provider_) {
     settings_provider_->RemoveObserver(this);
     settings_provider_ = NULL;
   }
   settings_provider_ = provider;
   if (settings_provider_)
     settings_provider_->AddObserver(this);
 }
 
 NotifierSettingsProvider* MessageCenterImpl::GetNotifierSettingsProvider() {
   return settings_provider_;
 }
 
 void MessageCenterImpl::SetQuietMode(bool in_quiet_mode) {
   if (in_quiet_mode != notification_list_->quiet_mode()) {
     notification_list_->SetQuietMode(in_quiet_mode);
-    FOR_EACH_OBSERVER(MessageCenterObserver,
-                      observer_list_,
-                      OnQuietModeChanged(in_quiet_mode));
+    for (auto& observer : observer_list_)
+      observer.OnQuietModeChanged(in_quiet_mode);
   }
   quiet_mode_timer_.reset();
 }
 
 void MessageCenterImpl::SetLockedState(bool locked) {
   if (locked != locked_) {
     locked_ = locked;
-    FOR_EACH_OBSERVER(MessageCenterObserver, observer_list_,
-                      OnLockedStateChanged(locked));
+    for (auto& observer : observer_list_)
+      observer.OnLockedStateChanged(locked);
   }
 }
 
 void MessageCenterImpl::EnterQuietModeWithExpire(
     const base::TimeDelta& expires_in) {
   if (quiet_mode_timer_) {
     // Note that the capital Reset() is the method to restart the timer, not
     // scoped_ptr::reset().
     quiet_mode_timer_->Reset();
   } else {
     notification_list_->SetQuietMode(true);
-    FOR_EACH_OBSERVER(
-        MessageCenterObserver, observer_list_, OnQuietModeChanged(true));
+    for (auto& observer : observer_list_)
+      observer.OnQuietModeChanged(true);
 
     quiet_mode_timer_.reset(new base::OneShotTimer);
     quiet_mode_timer_->Start(
         FROM_HERE,
         expires_in,
         base::Bind(
             &MessageCenterImpl::SetQuietMode, base::Unretained(this), false));
   }
 }
 
@@ skipping 12 matching lines @@
 }
 
 void MessageCenterImpl::EnableChangeQueueForTest(bool enable) {
   if (enable)
     notification_queue_.reset(new internal::ChangeQueue());
   else
     notification_queue_.reset();
 }
 
 }  // namespace message_center