[CLEANUP] Rename some methods of ExtensionToolbarModel to be OnFoo

chrome/browser/extensions/extension_toolbar_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/extensions/extension_toolbar_model.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/message_loop/message_loop.h"
@@ skipping 97 matching lines @@
                                  id);
     toolbar_items_.insert(iter, extension);
   } else {
     // Otherwise, put |extension| at the end.
     DCHECK_EQ(toolbar_items_.size(), index);
     index = toolbar_items_.size();
     toolbar_items_.push_back(extension);
     last_known_positions_.push_back(id);
   }
 
-  FOR_EACH_OBSERVER(
-      Observer, observers_, ToolbarExtensionMoved(extension.get(), index));
+  FOR_EACH_OBSERVER(Observer, observers_,
+                    OnToolbarExtensionMoved(extension.get(), index));
   MaybeUpdateVisibilityPref(extension.get(), index);
   UpdatePrefs();
 }
 
 void ExtensionToolbarModel::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()) {
     // Additionally, if we are using the new toolbar, any icons which are in the
     // overflow menu are considered "hidden". But it so happens that the times
     // we are likely to call SetVisibleIconCount() are also those when we are
     // in flux. So wait for things to cool down before setting the prefs.
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&ExtensionToolbarModel::MaybeUpdateVisibilityPrefs,
                    weak_ptr_factory_.GetWeakPtr()));
     prefs_->SetInteger(pref_names::kToolbarSize, visible_icon_count_);
   }
 
-  FOR_EACH_OBSERVER(Observer, observers_, ToolbarVisibleCountChanged());
+  FOR_EACH_OBSERVER(Observer, observers_, OnToolbarVisibleCountChanged());
 }
 
 void ExtensionToolbarModel::OnExtensionActionUpdated(
     ExtensionAction* extension_action,
     content::WebContents* web_contents,
     content::BrowserContext* browser_context) {
   const Extension* extension =
       ExtensionRegistry::Get(profile_)->enabled_extensions().GetByID(
           extension_action->extension_id());
   // Notify observers if the extension exists and is in the model.
   if (std::find(toolbar_items_.begin(), toolbar_items_.end(), extension) !=
           toolbar_items_.end()) {
-    FOR_EACH_OBSERVER(
-        Observer, observers_, ToolbarExtensionUpdated(extension));
+    FOR_EACH_OBSERVER(Observer, observers_,
+                      OnToolbarExtensionUpdated(extension));
   }
 }
 
 void ExtensionToolbarModel::OnExtensionLoaded(
     content::BrowserContext* browser_context,
     const Extension* extension) {
   // We don't want to add the same extension twice. It may have already been
   // added by EXTENSION_BROWSER_ACTION_VISIBILITY_CHANGED below, if the user
   // hides the browser action and then disables and enables the extension.
   for (size_t i = 0; i < toolbar_items_.size(); i++) {
@@ skipping 172 matching lines @@
   } else {
     new_index = FindNewPositionFromLastKnownGood(extension);
   }
 
   toolbar_items_.insert(toolbar_items_.begin() + new_index, extension);
 
   // 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_, ToolbarExtensionAdded(extension, new_index));
+    FOR_EACH_OBSERVER(Observer, observers_,
+                      OnToolbarExtensionAdded(extension, 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.
       ExtensionToolbarModel* main_model =
@@ skipping 33 matching lines @@
   toolbar_items_.erase(pos);
 
   // If we're in highlight mode, we also have to remove the extension from
   // the highlighted list.
   if (is_highlighting_) {
     pos = std::find(highlighted_items_.begin(),
                     highlighted_items_.end(),
                     extension);
     if (pos != highlighted_items_.end()) {
       highlighted_items_.erase(pos);
-      FOR_EACH_OBSERVER(
-          Observer, observers_, ToolbarExtensionRemoved(extension));
+      FOR_EACH_OBSERVER(Observer, observers_,
+                        OnToolbarExtensionRemoved(extension));
       // If the highlighted list is now empty, we stop highlighting.
       if (highlighted_items_.empty())
         StopHighlighting();
     }
   } else {
-    FOR_EACH_OBSERVER(Observer, observers_, ToolbarExtensionRemoved(extension));
+    FOR_EACH_OBSERVER(Observer, observers_,
+                      OnToolbarExtensionRemoved(extension));
   }
 
   UpdatePrefs();
 }
 
 // Combine the currently enabled extensions that have browser actions (which
 // we get from the ExtensionRegistry) with the ordering we get from the
 // pref service. For robustness we use a somewhat inefficient process:
 // 1. Create a vector of extensions sorted by their pref values. This vector may
 // have holes.
@@ skipping 164 matching lines @@
                   last_known_positions_[i]) == pref_positions.end()) {
       pref_positions.push_back(last_known_positions_[i]);
     }
   }
   last_known_positions_.swap(pref_positions);
 
   // Clear out the old...
   while (!toolbar_items_.empty()) {
     scoped_refptr<const Extension> extension = toolbar_items_.back();
     toolbar_items_.pop_back();
-    FOR_EACH_OBSERVER(
-        Observer, observers_, ToolbarExtensionRemoved(extension.get()));
+    FOR_EACH_OBSERVER(Observer, observers_,
+                      OnToolbarExtensionRemoved(extension.get()));
   }
   DCHECK(toolbar_items_.empty());
 
   // ...Add the new...
   Populate(&last_known_positions_);
 
   // ...And notify.
   for (size_t i = 0; i < toolbar_items().size(); ++i) {
-    FOR_EACH_OBSERVER(Observer,
-                      observers_,
-                      ToolbarExtensionAdded(toolbar_items()[i].get(), i));
+    FOR_EACH_OBSERVER(Observer, observers_,
+                      OnToolbarExtensionAdded(toolbar_items()[i].get(), i));
   }
 
   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::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&ExtensionToolbarModel::UpdatePrefs,
                    weak_ptr_factory_.GetWeakPtr()));
   }
@@ skipping 67 matching lines @@
   }
 
   // If we have any items in |highlighted_items_|, then we entered highlighting
   // mode.
   if (highlighted_items_.size()) {
     old_visible_icon_count_ = visible_icon_count_;
     is_highlighting_ = true;
     if (visible_icon_count() < extension_ids.size())
       SetVisibleIconCount(extension_ids.size());
 
-    FOR_EACH_OBSERVER(Observer, observers_, ToolbarHighlightModeChanged(true));
+    FOR_EACH_OBSERVER(Observer, observers_,
+                      OnToolbarHighlightModeChanged(true));
     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 ExtensionToolbarModel::StopHighlighting() {
   if (is_highlighting_) {
     highlighted_items_.clear();
     is_highlighting_ = false;
     if (old_visible_icon_count_ != visible_icon_count_)
       SetVisibleIconCount(old_visible_icon_count_);
-    FOR_EACH_OBSERVER(Observer, observers_, ToolbarHighlightModeChanged(false));
+    FOR_EACH_OBSERVER(Observer, observers_,
+                      OnToolbarHighlightModeChanged(false));
   }
 }
 
 }  // namespace extensions