Resubmit: Rename BrowserActionView to ToolbarActionView

chrome/browser/ui/views/toolbar/browser_actions_container.h

 // Copyright 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.
 
 #ifndef CHROME_BROWSER_UI_VIEWS_TOOLBAR_BROWSER_ACTIONS_CONTAINER_H_
 #define CHROME_BROWSER_UI_VIEWS_TOOLBAR_BROWSER_ACTIONS_CONTAINER_H_
 
 #include "base/observer_list.h"
 #include "chrome/browser/extensions/extension_keybinding_registry.h"
 #include "chrome/browser/extensions/extension_toolbar_model.h"
 #include "chrome/browser/ui/views/extensions/extension_keybinding_registry_views.h"
-#include "chrome/browser/ui/views/toolbar/browser_action_view.h"
 #include "chrome/browser/ui/views/toolbar/chevron_menu_button.h"
+#include "chrome/browser/ui/views/toolbar/toolbar_action_view.h"
 #include "ui/gfx/animation/animation_delegate.h"
 #include "ui/gfx/animation/tween.h"
 #include "ui/views/controls/button/menu_button_listener.h"
 #include "ui/views/controls/resize_area_delegate.h"
 #include "ui/views/drag_controller.h"
 #include "ui/views/view.h"
 
 class BrowserActionsContainerObserver;
 class ExtensionPopup;
 
 namespace extensions {
 class ActiveTabPermissionGranter;
 class Command;
 class Extension;
 }
 
 namespace gfx {
 class SlideAnimation;
 }
 
 namespace views {
 class ResizeArea;
 }
 
 // The BrowserActionsContainer is a container view, responsible for drawing the
-// browser action icons (extensions that add icons to the toolbar). It comes in
-// two flavors, a main container (when residing on the toolbar) and an overflow
-// container (that resides in the main application menu, aka the Chrome menu).
+// toolbar action icons (including extension icons and icons for component
+// toolbar actions). It comes intwo flavors, a main container (when residing on
+// the toolbar) and an overflow container (that resides in the main application
+// menu, aka the Chrome menu).
 //
 // When in 'main' mode, the container supports the full functionality of a
 // BrowserActionContainer, but in 'overflow' mode the container is effectively
 // just an overflow for the 'main' toolbar (shows only the icons that the main
 // toolbar does not) and as such does not have an overflow itself. The overflow
 // container also does not support resizing. Since the main container only shows
 // icons in the Chrome toolbar, it is limited to a single row of icons. The
 // overflow container, however, is allowed to display icons in multiple rows.
 //
 // The main container is placed flush against the omnibox and hot dog menu,
@@ skipping 67 matching lines @@
 // because we won't have enough space to show the new Browser Action until the
 // animation ends and we don't want the chevron to flash into view while we are
 // growing the container.
 //
 ////////////////////////////////////////////////////////////////////////////////
 class BrowserActionsContainer
     : public views::View,
       public views::ResizeAreaDelegate,
       public gfx::AnimationDelegate,
       public extensions::ExtensionToolbarModel::Observer,
-      public BrowserActionView::Delegate,
+      public ToolbarActionView::Delegate,
       public extensions::ExtensionKeybindingRegistry::Delegate {
  public:
   // Horizontal spacing between most items in the container, as well as after
   // the last item or chevron (if visible).
   static const int kItemSpacing;
 
   // Constructs a BrowserActionContainer for a particular |browser| object. For
   // documentation of |main_container|, see class comments.
   BrowserActionsContainer(Browser* browser,
                           BrowserActionsContainer* main_container);
   ~BrowserActionsContainer() override;
 
   void Init();
 
-  // Get the number of browser actions being displayed.
-  size_t num_browser_actions() const { return browser_action_views_.size(); }
+  // Get the number of toolbar actions being displayed.
+  size_t num_toolbar_actions() const { return toolbar_action_views_.size(); }
 
   // Whether we are performing resize animation on the container.
   bool animating() const { return animation_target_size_ > 0; }
 
   // Returns the chevron, if any.
   views::View* chevron() { return chevron_; }
   const views::View* chevron() const { return chevron_; }
 
   // Returns the profile this container is associated with.
   Profile* profile() const { return profile_; }
 
   // The class that registers for keyboard shortcuts for extension commands.
   extensions::ExtensionKeybindingRegistry* extension_keybinding_registry() {
     return extension_keybinding_registry_.get();
   }
 
-  // Get a particular browser action view.
-  BrowserActionView* GetBrowserActionViewAt(int index) {
-    return browser_action_views_[index];
+  // Get a particular toolbar action view.
+  ToolbarActionView* GetToolbarActionViewAt(int index) {
+    return toolbar_action_views_[index];
   }
 
   // Returns the ID of the action represented by the view at |index|.
   const std::string& GetIdAt(size_t index);
 
-  // Returns the BrowserActionView* associated with the given |extension|, or
+  // Returns the ToolbarActionView* associated with the given |extension|, or
   // NULL if none exists.
-  BrowserActionView* GetViewForExtension(
+  ToolbarActionView* GetViewForExtension(
       const extensions::Extension* extension);
 
-  // Update the views to reflect the state of the browser action icons.
-  void RefreshBrowserActionViews();
+  // Update the views to reflect the state of the toolbar actions.
+  void RefreshToolbarActionViews();
 
-  // Sets up the browser action view vector.
-  void CreateBrowserActionViews();
+  // Sets up the toolbar action view vector.
+  void CreateToolbarActionViews();
 
-  // Delete all browser action views.
-  void DeleteBrowserActionViews();
+  // Delete all toolbar action views.
+  void DeleteToolbarActionViews();
 
-  // Returns how many browser actions are currently visible. If the intent is
-  // to find how many are visible once the container finishes animation, see
+  // Returns how many actions are currently visible. If the intent is to find
+  // how many are visible once the container finishes animation, see
   // VisibleBrowserActionsAfterAnimation() below.
   size_t VisibleBrowserActions() const;
 
-  // Returns how many browser actions will be visible once the container
-  // finishes animating to a new size, or (if not animating) the currently
-  // visible icons.
+  // Returns how many actions will be visible once the container finishes
+  // animating to a new size, or (if not animating) the currently visible icons.
   size_t VisibleBrowserActionsAfterAnimation() const;
 
   // Executes |command| registered by |extension|.
   void ExecuteExtensionCommand(const extensions::Extension* extension,
                                const extensions::Command& command);
 
-  // Notify the browser action container that an extension has been moved to
-  // the overflow container.
+  // Notify the container that an extension has been moved to the overflow
+  // container.
   void NotifyActionMovedToOverflow();
 
   // Add or remove an observer.
   void AddObserver(BrowserActionsContainerObserver* observer);
   void RemoveObserver(BrowserActionsContainerObserver* observer);
 
   // Overridden from views::View:
   gfx::Size GetPreferredSize() const override;
   int GetHeightForWidth(int width) const override;
   gfx::Size GetMinimumSize() const override;
@@ skipping 17 matching lines @@
                            const gfx::Point& press_pt,
                            const gfx::Point& p) override;
 
   // Overridden from views::ResizeAreaDelegate:
   void OnResize(int resize_amount, bool done_resizing) override;
 
   // Overridden from gfx::AnimationDelegate:
   void AnimationProgressed(const gfx::Animation* animation) override;
   void AnimationEnded(const gfx::Animation* animation) override;
 
-  // Overridden from BrowserActionView::Delegate:
+  // Overridden from ToolbarActionView::Delegate:
   content::WebContents* GetCurrentWebContents() override;
   bool ShownInsideMenu() const override;
-  void OnBrowserActionViewDragDone() override;
+  void OnToolbarActionViewDragDone() override;
   views::MenuButton* GetOverflowReferenceView() override;
-  void SetPopupOwner(BrowserActionView* popup_owner) override;
+  void SetPopupOwner(ToolbarActionView* popup_owner) override;
   void HideActivePopup() override;
-  BrowserActionView* GetMainViewForAction(BrowserActionView* view) override;
+  ToolbarActionView* GetMainViewForAction(ToolbarActionView* view) override;
 
   // Overridden from extension::ExtensionKeybindingRegistry::Delegate:
   extensions::ActiveTabPermissionGranter* GetActiveTabPermissionGranter()
       override;
 
   // Retrieve the current popup.  This should only be used by unit tests.
   gfx::NativeView TestGetPopup();
 
   // Returns the width of an icon, optionally with its padding.
   static int IconWidth(bool include_padding);
@@ skipping 10 matching lines @@
   // Overridden from views::View:
   void ViewHierarchyChanged(
       const ViewHierarchyChangedDetails& details) override;
   void OnPaint(gfx::Canvas* canvas) override;
   void OnThemeChanged() override;
 
  private:
   // A struct representing the position at which an action will be dropped.
   struct DropPosition;
 
-  typedef std::vector<BrowserActionView*> BrowserActionViews;
+  typedef std::vector<ToolbarActionView*> ToolbarActionViews;
 
   // extensions::ExtensionToolbarModel::Observer implementation.
   void ToolbarExtensionAdded(const extensions::Extension* extension,
                              int index) override;
   void ToolbarExtensionRemoved(const extensions::Extension* extension) override;
   void ToolbarExtensionMoved(const extensions::Extension* extension,
                              int index) override;
   void ToolbarExtensionUpdated(const extensions::Extension* extension) override;
   bool ShowExtensionActionPopup(const extensions::Extension* extension,
                                 bool grant_active_tab) override;
   void ToolbarVisibleCountChanged() override;
   void ToolbarHighlightModeChanged(bool is_highlighting) override;
   Browser* GetBrowser() override;
 
   void LoadImages();
 
-  // Called when a browser action's visibility may have changed.
+  // Called when an action's visibility may have changed.
   void OnBrowserActionVisibilityChanged();
 
   // Returns the preferred width of the container in order to show all icons
   // that should be visible and, optionally, the chevron.
   int GetPreferredWidth();
 
-  // Sets the chevron to be visible or not based on whether all browser actions
-  // are displayed.
+  // Sets the chevron to be visible or not based on whether all actions are
+  // displayed.
   void SetChevronVisibility();
 
   // Given a number of |icons|, returns the pixels needed to draw the entire
   // container (including the chevron if the number of icons is not all the
   // icons and there's not a separate overflow container). For convenience,
   // callers can set |icons| to -1 to mean "all icons".
   int IconCountToWidth(int icons) const;
 
   // Given a pixel width, returns the number of icons that fit.  (This
   // automatically determines whether a chevron will be needed and includes it
@@ skipping 16 matching lines @@
   // from the model's GetVisibleIconCount if this container is for the overflow.
   size_t GetIconCount() const;
 
   // Whether this container is in overflow mode (as opposed to in 'main'
   // mode). See class comments for details on the difference.
   bool in_overflow_mode() const { return main_container_ != NULL; }
 
   // Whether or not the container has been initialized.
   bool initialized_;
 
-  // The vector of browser actions (icons/image buttons for each action). Note
-  // that not every BrowserAction in the ToolbarModel will necessarily be in
-  // this collection. Some extensions may be disabled in incognito windows.
-  BrowserActionViews browser_action_views_;
+  // The vector of toolbar actions (icons/image buttons for each action).
+  ToolbarActionViews toolbar_action_views_;
 
   Profile* profile_;
 
   // The Browser object the container is associated with.
   Browser* browser_;
 
   // The main container we are serving as overflow for, or NULL if this
   // class is the the main container. See class comments for details on
   // the difference between main and overflow.
   BrowserActionsContainer* main_container_;
 
   // The view that triggered the current popup (just a reference to a view
-  // from browser_action_views_).
-  BrowserActionView* popup_owner_;
+  // from toolbar_action_views_).
+  ToolbarActionView* popup_owner_;
 
   // The model that tracks the order of the toolbar icons.
   extensions::ExtensionToolbarModel* model_;
 
   // The current width of the container.
   int container_width_;
 
   // The resize area for the container.
   views::ResizeArea* resize_area_;
 
@@ skipping 29 matching lines @@
   ObserverList<BrowserActionsContainerObserver> observers_;
 
   // The maximum number of icons to show per row when in overflow mode (showing
   // icons in the application menu).
   static int icons_per_overflow_menu_row_;
 
   DISALLOW_COPY_AND_ASSIGN(BrowserActionsContainer);
 };
 
 #endif  // CHROME_BROWSER_UI_VIEWS_TOOLBAR_BROWSER_ACTIONS_CONTAINER_H_