Rename BrowserActionView to ToolbarActionView

chrome/browser/ui/views/toolbar/chevron_menu_button.cc

 // Copyright 2014 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/views/toolbar/chevron_menu_button.h"
 
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/extensions/extension_action.h"
 #include "chrome/browser/extensions/extension_action_icon_factory.h"
 #include "chrome/browser/extensions/extension_context_menu_model.h"
 #include "chrome/browser/extensions/extension_toolbar_model.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/views/extensions/browser_action_drag_data.h"
 #include "chrome/browser/ui/views/extensions/extension_action_view_controller.h"
-#include "chrome/browser/ui/views/toolbar/browser_action_view.h"
 #include "chrome/browser/ui/views/toolbar/browser_actions_container.h"
+#include "chrome/browser/ui/views/toolbar/toolbar_action_view.h"
 #include "extensions/common/extension.h"
 #include "ui/views/border.h"
 #include "ui/views/controls/button/label_button_border.h"
 #include "ui/views/controls/menu/menu_delegate.h"
 #include "ui/views/controls/menu/menu_item_view.h"
 #include "ui/views/controls/menu/menu_runner.h"
 #include "ui/views/metrics.h"
 
 namespace {
 
 // In the browser actions container's chevron menu, a menu item view's icon
-// comes from BrowserActionView::GetIconWithBadge() when the menu item view is
+// comes from ToolbarActionView::GetIconWithBadge() when the menu item view is
 // created. But, the browser action's icon may not be loaded in time because it
 // is read from file system in another thread.
 // The IconUpdater will update the menu item view's icon when the browser
 // action's icon has been updated.
 class IconUpdater : public ExtensionActionIconFactory::Observer {
  public:
   IconUpdater(views::MenuItemView* menu_item_view,
               ExtensionActionViewController* view_controller)
       : menu_item_view_(menu_item_view),
         view_controller_(view_controller) {
     DCHECK(menu_item_view);
     DCHECK(view_controller);
     view_controller->set_icon_observer(this);
   }
   virtual ~IconUpdater() {
     view_controller_->set_icon_observer(NULL);
   }
 
-  // BrowserActionView::IconObserver:
+  // ExtensionActionIconFactory::Observer:
   virtual void OnIconUpdated() override {
     menu_item_view_->SetIcon(view_controller_->GetIconWithBadge());
   }
 
  private:
   // The menu item view whose icon might be updated.
   views::MenuItemView* menu_item_view_;
 
   // The view controller to be observed. When its icon changes, update the
   // corresponding menu item view's icon.
@@ skipping 57 matching lines @@
 
   // A pointer to the browser action container.
   BrowserActionsContainer* browser_actions_container_;
 
   // The overflow menu for the menu button. Owned by |menu_runner_|.
   views::MenuItemView* menu_;
 
   // Resposible for running the menu.
   scoped_ptr<views::MenuRunner> menu_runner_;
 
-  // The index into the BrowserActionView vector, indicating where to start
+  // The index into the ToolbarActionView vector, indicating where to start
   // picking browser actions to draw.
   int start_index_;
 
   // Whether this controller is being used for drop.
   bool for_drop_;
 
   // The vector keeps all icon updaters associated with menu item views in the
   // controller. The icon updater will update the menu item view's icon when
   // the browser action view's icon has been updated.
   ScopedVector<IconUpdater> icon_updaters_;
@@ skipping 11 matching lines @@
       start_index_(
           browser_actions_container_->VisibleBrowserActionsAfterAnimation()),
       for_drop_(for_drop) {
   menu_ = new views::MenuItemView(this);
   menu_runner_.reset(new views::MenuRunner(
       menu_, for_drop_ ? views::MenuRunner::FOR_DROP : 0));
   menu_->set_has_icons(true);
 
   size_t command_id = 1;  // Menu id 0 is reserved, start with 1.
   for (size_t i = start_index_;
-       i < browser_actions_container_->num_browser_actions(); ++i) {
-    BrowserActionView* view =
-        browser_actions_container_->GetBrowserActionViewAt(i);
+       i < browser_actions_container_->num_toolbar_actions(); ++i) {
+    ToolbarActionView* view =
+        browser_actions_container_->GetToolbarActionViewAt(i);
     ExtensionActionViewController* view_controller =
         static_cast<ExtensionActionViewController*>(view->view_controller());
     views::MenuItemView* menu_item = menu_->AppendMenuItemWithIcon(
         command_id,
         base::UTF8ToUTF16(view_controller->extension()->name()),
         view_controller->GetIconWithBadge());
 
     // Set the tooltip for this item.
     menu_->SetTooltip(
         view_controller->GetTooltip(view->GetCurrentWebContents()),
@@ skipping 31 matching lines @@
         base::Bind(&ChevronMenuButton::MenuDone,
                    owner_->weak_factory_.GetWeakPtr()));
   }
 }
 
 void ChevronMenuButton::MenuController::CloseMenu() {
   menu_->Cancel();
 }
 
 bool ChevronMenuButton::MenuController::IsCommandEnabled(int id) const {
-  BrowserActionView* view =
-      browser_actions_container_->GetBrowserActionViewAt(start_index_ + id - 1);
+  ToolbarActionView* view =
+      browser_actions_container_->GetToolbarActionViewAt(start_index_ + id - 1);
   return view->view_controller()->IsEnabled(view->GetCurrentWebContents());
 }
 
 void ChevronMenuButton::MenuController::ExecuteCommand(int id) {
-  browser_actions_container_->GetBrowserActionViewAt(start_index_ + id - 1)->
+  browser_actions_container_->GetToolbarActionViewAt(start_index_ + id - 1)->
       view_controller()->ExecuteAction(true);
 }
 
 bool ChevronMenuButton::MenuController::ShowContextMenu(
     views::MenuItemView* source,
     int id,
     const gfx::Point& p,
     ui::MenuSourceType source_type) {
-  BrowserActionView* view = browser_actions_container_->GetBrowserActionViewAt(
+  ToolbarActionView* view = browser_actions_container_->GetToolbarActionViewAt(
       start_index_ + id - 1);
   ExtensionActionViewController* view_controller =
       static_cast<ExtensionActionViewController*>(view->view_controller());
   if (!view_controller->extension()->ShowConfigureContextMenus())
     return false;
 
   scoped_refptr<ExtensionContextMenuModel> context_menu_contents =
       new ExtensionContextMenuModel(view_controller->extension(),
                                     view->browser(),
                                     view_controller);
@@ skipping 190 matching lines @@
 void ChevronMenuButton::ShowOverflowMenu(bool for_drop) {
   DCHECK(!menu_controller_);
   menu_controller_.reset(new MenuController(
       this, browser_actions_container_, for_drop));
   menu_controller_->RunMenu(GetWidget());
 }
 
 void ChevronMenuButton::MenuDone() {
   menu_controller_.reset();
 }