Remove FOR_EACH_OBSERVER macro usage in chrome/browser/ui

chrome/browser/ui/toolbar/toolbar_actions_model.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/ui/toolbar/toolbar_actions_model.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/location.h"
@@ skipping 111 matching lines @@
                   iter->id),
         id);
     toolbar_items_.insert(iter, action);
   } else {
     // Otherwise, put |action| and |id| at the end.
     DCHECK_EQ(toolbar_items_.size(), index);
     toolbar_items_.push_back(action);
     last_known_positions_.push_back(id);
   }
 
-  FOR_EACH_OBSERVER(Observer, observers_, OnToolbarActionMoved(id, index));
+  for (Observer& observer : observers_)
+    observer.OnToolbarActionMoved(id, index);
   UpdatePrefs();
 }
 
 void ToolbarActionsModel::SetVisibleIconCount(size_t count) {
   visible_icon_count_ = (count >= toolbar_items_.size()) ? -1 : count;
 
   // Only set the prefs if we're not in highlight mode and the profile is not
   // incognito. Highlight mode is designed to be a transitory state, and should
   // not persist across browser restarts (though it may be re-entered), and we
   // don't store anything in incognito.
   if (!is_highlighting() && !profile_->IsOffTheRecord()) {
     prefs_->SetInteger(extensions::pref_names::kToolbarSize,
                        visible_icon_count_);
   }
 
-  FOR_EACH_OBSERVER(Observer, observers_, OnToolbarVisibleCountChanged());
+  for (Observer& observer : observers_)
+    observer.OnToolbarVisibleCountChanged();
 }
 
 void ToolbarActionsModel::OnExtensionActionUpdated(
     ExtensionAction* extension_action,
     content::WebContents* web_contents,
     content::BrowserContext* browser_context) {
   // Notify observers if the extension exists and is in the model.
   if (HasItem(
           ToolbarItem(extension_action->extension_id(), EXTENSION_ACTION))) {
-    FOR_EACH_OBSERVER(Observer, observers_,
-                      OnToolbarActionUpdated(extension_action->extension_id()));
+    for (Observer& observer : observers_)
+      observer.OnToolbarActionUpdated(extension_action->extension_id());
   }
 }
 
 ScopedVector<ToolbarActionViewController> ToolbarActionsModel::CreateActions(
     Browser* browser,
     ToolbarActionsBar* bar) {
   DCHECK(browser);
   DCHECK(bar);
   ScopedVector<ToolbarActionViewController> action_list;
 
@@ skipping 97 matching lines @@
 
 void ToolbarActionsModel::OnReady() {
   InitializeActionList();
   // Wait until the extension system is ready before observing any further
   // changes so that the toolbar buttons can be shown in their stable ordering
   // taken from prefs.
   extension_registry_observer_.Add(extension_registry_);
   extension_action_observer_.Add(extension_action_api_);
 
   actions_initialized_ = true;
-  FOR_EACH_OBSERVER(Observer, observers_, OnToolbarModelInitialized());
+  for (Observer& observer : observers_)
+    observer.OnToolbarModelInitialized();
 
   if (use_redesign_) {
     // Handle component action migrations.  We must make sure that observers are
     // notified of initialization first, so that the associated widgets are
     // created.
     ComponentToolbarActionsFactory::GetInstance()->HandleComponentMigrations(
         component_migration_helper_.get(), profile_);
   }
 }
 
@@ skipping 77 matching lines @@
   } else {
     new_index = FindNewPositionFromLastKnownGood(item);
   }
 
   toolbar_items_.insert(toolbar_items_.begin() + new_index, item);
 
   // If we're currently highlighting, then even though we add a browser action
   // to the full list (|toolbar_items_|, there won't be another *visible*
   // browser action, which was what the observers care about.
   if (!is_highlighting()) {
-    FOR_EACH_OBSERVER(Observer, observers_,
-                      OnToolbarActionAdded(item, new_index));
+    for (Observer& observer : observers_)
+      observer.OnToolbarActionAdded(item, new_index);
 
     int visible_count_delta = 0;
     if (is_new_extension && !all_icons_visible()) {
       // If this is a new extension (and not all extensions are visible), we
       // expand the toolbar out so that the new one can be seen.
       visible_count_delta = 1;
     } else if (profile_->IsOffTheRecord()) {
       // If this is an incognito profile, we also have to check to make sure the
       // overflow matches the main bar's status.
       ToolbarActionsModel* main_model =
@@ skipping 29 matching lines @@
     SetVisibleIconCount(toolbar_items_.size() - 1);
 
   toolbar_items_.erase(pos);
 
   // If we're in highlight mode, we also have to remove the action from
   // the highlighted list.
   if (is_highlighting()) {
     pos = std::find(highlighted_items_.begin(), highlighted_items_.end(), item);
     if (pos != highlighted_items_.end()) {
       highlighted_items_.erase(pos);
-      FOR_EACH_OBSERVER(Observer, observers_, OnToolbarActionRemoved(item.id));
+      for (Observer& observer : observers_)
+        observer.OnToolbarActionRemoved(item.id);
       // If the highlighted list is now empty, we stop highlighting.
       if (highlighted_items_.empty())
         StopHighlighting();
     }
   } else {
-    FOR_EACH_OBSERVER(Observer, observers_, OnToolbarActionRemoved(item.id));
+    for (Observer& observer : observers_)
+      observer.OnToolbarActionRemoved(item.id);
   }
 
   UpdatePrefs();
 }
 
 std::unique_ptr<extensions::ExtensionMessageBubbleController>
 ToolbarActionsModel::GetExtensionMessageBubbleController(Browser* browser) {
   std::unique_ptr<extensions::ExtensionMessageBubbleController> controller;
   if (has_active_bubble())
     return controller;
@@ skipping 316 matching lines @@
     if (current_pos == toolbar_items_.end())
       continue;
 
     if (current_pos != desired_pos) {
       if (current_pos < desired_pos)
         std::rotate(current_pos, current_pos + 1, desired_pos + 1);
       else
         std::rotate(desired_pos, current_pos, current_pos + 1);
       // Notify the observers to keep them up to date, unless we're highlighting
       // (in which case we're deliberately only showing a subset of actions).
-      if (!is_highlighting())
-        FOR_EACH_OBSERVER(
-            Observer, observers_,
-            OnToolbarActionMoved(id, desired_pos - toolbar_items_.begin()));
+      if (!is_highlighting()) {
+        for (Observer& observer : observers_) {
+          observer.OnToolbarActionMoved(id,
+                                        desired_pos - toolbar_items_.begin());
+        }
+      }
     }
     ++desired_pos;
   }
 
   if (last_known_positions_.size() > pref_position_size) {
     // Need to update pref because we have extra icons. But can't call
     // UpdatePrefs() directly within observation closure.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&ToolbarActionsModel::UpdatePrefs,
                               weak_ptr_factory_.GetWeakPtr()));
@@ skipping 10 matching lines @@
         highlighted_items_.push_back(item);
     }
   }
 
   // If we have any items in |highlighted_items_|, then we entered highlighting
   // mode.
   if (highlighted_items_.size()) {
     // It's important that is_highlighting_ is changed immediately before the
     // observers are notified since it changes the result of toolbar_items().
     highlight_type_ = highlight_type;
-    FOR_EACH_OBSERVER(Observer, observers_,
-                      OnToolbarHighlightModeChanged(true));
+    for (Observer& observer : observers_)
+      observer.OnToolbarHighlightModeChanged(true);
 
     // We set the visible icon count after the highlight mode change because
     // the UI actions are created/destroyed during highlight, and doing that
     // prior to changing the size allows us to still have smooth animations.
     if (visible_icon_count() < ids.size())
       SetVisibleIconCount(ids.size());
 
     return true;
   }
 
   // Otherwise, we didn't enter highlighting mode (and, in fact, exited it if
   // we were otherwise in it).
   if (is_highlighting())
     StopHighlighting();
   return false;
 }
 
 void ToolbarActionsModel::StopHighlighting() {
   if (is_highlighting()) {
     // It's important that is_highlighting_ is changed immediately before the
     // observers are notified since it changes the result of toolbar_items().
     highlight_type_ = HIGHLIGHT_NONE;
-    FOR_EACH_OBSERVER(Observer, observers_,
-                      OnToolbarHighlightModeChanged(false));
+    for (Observer& observer : observers_)
+      observer.OnToolbarHighlightModeChanged(false);
 
     // For the same reason, we don't clear highlighted_items_ until after the
     // mode changed.
     highlighted_items_.clear();
 
     // We set the visible icon count after the highlight mode change because
     // the UI actions are created/destroyed during highlight, and doing that
     // prior to changing the size allows us to still have smooth animations.
     int saved_icon_count =
         prefs_->GetInteger(extensions::pref_names::kToolbarSize);
     if (saved_icon_count != visible_icon_count_)
       SetVisibleIconCount(saved_icon_count);
   }
 }
 
 const extensions::Extension* ToolbarActionsModel::GetExtensionById(
     const std::string& id) const {
   return extension_registry_->enabled_extensions().GetByID(id);
 }