Extension Toolbar redesign, part 1 (overflow)

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"
@@ skipping 24 matching lines @@
 }
 
 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, "master" (used for the toolbar) and "slave" (used in the main

[Devlin, 2014/06/23 17:55:29]

"master" and "slave" is kinda weird here, because there's not a master/slave
relationship, per se.  Master is completely unaware of slave, and slave makes
all its own decisions (admittedly based on masters behavior).  I might opt for
something more direct, like "main" and "overflow", but I don't feel strongly
about it.

[Finnur, 2014/06/25 16:18:11]

Converted to main and overflow.

+// application menu, known as the Hot Dog menu). The master container
+// supports the full functionality of a BrowserActionContainer but the slave
+// container is effectively just the overflow for the master (shows only the
+// icons that the master does not) and as such does not have an overflow itself.
+// The slave also does not support resizing. Since the master container only
+// shows icons in the Chrome toolbar, it is limited to a single row of icons.
+// The slave, however, is allowed to display icons in multiple rows.
 //
-// The BrowserActionsContainer is a container view, responsible for drawing the
-// browser action icons (extensions that add icons to the toolbar).
-//
-// The container is placed flush against the omnibox and wrench menu, and its
-// layout looks like:
+// The master container is placed flush against the omnibox and hot dog menu,
+// whereas the slave container is placed at the top of the hot dog menu. The

[Devlin, 2014/06/23 17:55:29]

nit: I would say "the slave container is placed within the hot dog menu, at the
top" or something similar to indicate it is stored |inside| the menu, rather
than, e.g., above it.

+// layout is similar to this:
 //   rI_I_IcCs
 // Where the letters are as follows:
 //   r: An invisible resize area.  This is ToolbarView::kStandardSpacing pixels
-//      wide and directly adjacent to the omnibox.
+//      wide and directly adjacent to the omnibox. Only shown for the master
+//      container.
 //   I: An icon.  This is as wide as the IDR_BROWSER_ACTION image.
 //   _: kItemSpacing pixels of empty space.
 //   c: kChevronSpacing pixels of empty space.  Only present if C is present.
 //   C: An optional chevron, visible for overflow.  As wide as the
 //      IDR_BROWSER_ACTIONS_OVERFLOW image.
 //   s: ToolbarView::kStandardSpacing pixels of empty space (before the wrench
 //      menu).
 // The reason the container contains the trailing space "s", rather than having
 // it be handled by the parent view, is so that when the chevron is invisible
 // and the user starts dragging an icon around, we have the space to draw the
 // ultimate drop indicator.  (Otherwise, we'd be trying to draw it into the
 // padding beyond our right edge, and it wouldn't appear.)
 //
-// The BrowserActionsContainer follows a few rules, in terms of user experience:
+// The BrowserActionsContainer in master mode follows a few rules, in terms of
+// user experience:
 //
 // 1) The container can never grow beyond the space needed to show all icons
 // (hereby referred to as the max width).
 // 2) The container can never shrink below the space needed to show just the
 // initial padding and the chevron (ignoring the case where there are no icons
 // to show, in which case the container won't be visible anyway).
 // 3) The container snaps into place (to the pixel count that fits the visible
 // icons) to make sure there is no wasted space at the edges of the container.
 // 4) If the user adds or removes icons (read: installs/uninstalls browser
 // actions) we grow and shrink the container as needed - but ONLY if the
 // container was at max width to begin with.
 // 5) If the container is NOT at max width (has an overflow menu), we respect
 // that size when adding and removing icons and DON'T grow/shrink the container.
 // This means that new icons (which always appear at the far right) will show up
-// in the overflow menu. The install bubble for extensions points to the chevron
+// in the overflow. The install bubble for extensions points to the chevron
 // menu in this case.
 //
 // Resizing the BrowserActionsContainer:
 //
 // The ResizeArea view sends OnResize messages to the BrowserActionsContainer
 // class as the user drags it. This modifies the value for |resize_amount_|.
 // That indicates to the container that a resize is in progress and is used to
 // calculate the size in GetPreferredSize(), though that function never exceeds
 // the defined minimum and maximum size of the container.
 //
@@ skipping 23 matching lines @@
     : public views::View,
       public views::MenuButtonListener,
       public views::ResizeAreaDelegate,
       public gfx::AnimationDelegate,
       public extensions::ExtensionToolbarModel::Observer,
       public BrowserActionOverflowMenuController::Observer,
       public views::WidgetObserver,
       public BrowserActionView::Delegate,
       public extensions::ExtensionKeybindingRegistry::Delegate {
  public:
-  BrowserActionsContainer(Browser* browser, views::View* owner_view);
+  // Constructs a BrowserActionContainer for a particular |browser| object, and
+  // specifies which view is the |owner_view|. For documentation of |master|,
+  // see class comments.
+  BrowserActionsContainer(Browser* browser,
+                          views::View* owner_view,
+                          BrowserActionsContainer* master);
   virtual ~BrowserActionsContainer();
 
   void Init();
 
   // Get the number of browser actions being displayed.
   int num_browser_actions() const { return browser_action_views_.size(); }
 
   // Whether we are performing resize animation on the container.
   bool animating() const { return animation_target_size_ > 0; }
 
@@ skipping 79 matching lines @@
       BrowserActionOverflowMenuController* controller) OVERRIDE;
 
   // Overridden from views::WidgetObserver:
   virtual void OnWidgetDestroying(views::Widget* widget) OVERRIDE;
 
   // Overridden from BrowserActionView::Delegate:
   virtual void InspectPopup(ExtensionAction* action) OVERRIDE;
   virtual int GetCurrentTabId() const OVERRIDE;
   virtual void OnBrowserActionExecuted(BrowserActionButton* button) OVERRIDE;
   virtual void OnBrowserActionVisibilityChanged() OVERRIDE;
+  virtual bool ShownInsideMenu() const OVERRIDE;
 
   // Overridden from extension::ExtensionKeybindingRegistry::Delegate:
   virtual extensions::ActiveTabPermissionGranter*
       GetActiveTabPermissionGranter() OVERRIDE;
 
   // Moves a browser action with |id| to |new_index|.
   void MoveBrowserAction(const std::string& extension_id, size_t new_index);
 
   // Shows the popup for |extension| if possible. Returns true if a new popup
   // was shown. Showing the popup will grant tab permissions if
@@ skipping 101 matching lines @@
   bool ShouldDisplayBrowserAction(const extensions::Extension* extension);
 
   // Show a popup. Returns true if a new popup was shown. Showing the popup will
   // grant tab permissions if |grant_tab_permissions| is true. Only pass true
   // for this argument for popups triggered interactively, not popups triggered
   // by an API.
   bool ShowPopup(BrowserActionButton* button,
                  ExtensionPopup::ShowAction show_action,
                  bool grant_tab_permissions);
 
+  // Whether this container is slave (See class comments for details on slave
+  // mode).
+  bool is_slave() const { return master_ != NULL; }
+
   // 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_;
 
   Profile* profile_;
 
   // The Browser object the container is associated with.
   Browser* browser_;
 
   // The view that owns us.
   views::View* owner_view_;
 
+  // The master container we are serving as overflow for, or NULL if this
+  // class is the master. See class comments for details on master/slave mode.
+  BrowserActionsContainer* master_;
+
   // The current popup and the button it came from.  NULL if no popup.
   ExtensionPopup* popup_;
 
   // The button that triggered the current popup (just a reference to a button
   // from browser_action_views_).
   BrowserActionButton* popup_button_;
 
   // 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_;
 
-  // The chevron for accessing the overflow items.
+  // The chevron for accessing the overflow items. Can be NULL if the toolbar
+  // is permanently suppressing the chevron menu.
   views::MenuButton* chevron_;
 
   // The painter used when we are highlighting a subset of extensions.
   scoped_ptr<views::Painter> highlight_painter_;
 
   // The menu to show for the overflow button (chevron). This class manages its
   // own lifetime so that it can stay alive during drag and drop operations.
   BrowserActionOverflowMenuController* overflow_menu_;
 
   // The animation that happens when the container snaps to place.
@@ skipping 21 matching lines @@
 
   // Handles delayed showing of the overflow menu when hovering.
   base::WeakPtrFactory<BrowserActionsContainer> show_menu_task_factory_;
 
   ObserverList<BrowserActionsContainerObserver> observers_;
 
   DISALLOW_COPY_AND_ASSIGN(BrowserActionsContainer);
 };
 
 #endif  // CHROME_BROWSER_UI_VIEWS_TOOLBAR_BROWSER_ACTIONS_CONTAINER_H_