Move ShowPopup logic from BrowserActionsContainer to BrowserActionView

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/chrome_views_export.h"
 #include "chrome/browser/ui/views/extensions/browser_action_overflow_menu_controller.h"
-#include "chrome/browser/ui/views/extensions/extension_keybinding_registry_views.h"
-#include "chrome/browser/ui/views/extensions/extension_popup.h"
 #include "chrome/browser/ui/views/toolbar/browser_action_view.h"
-#include "chrome/browser/ui/views/toolbar/browser_actions_container_observer.h"
 #include "content/public/browser/notification_observer.h"
 #include "ui/gfx/animation/animation_delegate.h"
 #include "ui/gfx/animation/tween.h"
-#include "ui/views/controls/button/menu_button.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"
-#include "ui/views/widget/widget_observer.h"
 
-class BrowserActionButton;
+class BrowserActionsContainerObserver;
 class ExtensionKeybindingRegistryViews;
 class ExtensionPopup;
 
 namespace extensions {
 class ActiveTabPermissionGranter;
 class Command;
 class Extension;
 }
 
 namespace gfx {
@@ skipping 90 matching lines @@
 // growing the container.
 //
 ////////////////////////////////////////////////////////////////////////////////
 class BrowserActionsContainer
     : 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:
   // Constructs a BrowserActionContainer for a particular |browser| object, and
   // specifies which view is the |owner_view|. For documentation of
   // |main_container|, see class comments.
   BrowserActionsContainer(Browser* browser,
                           views::View* owner_view,
                           BrowserActionsContainer* main_container);
   virtual ~BrowserActionsContainer();
@@ skipping 80 matching lines @@
   virtual void OnResize(int resize_amount, bool done_resizing) OVERRIDE;
 
   // Overridden from gfx::AnimationDelegate:
   virtual void AnimationProgressed(const gfx::Animation* animation) OVERRIDE;
   virtual void AnimationEnded(const gfx::Animation* animation) OVERRIDE;
 
   // Overridden from BrowserActionOverflowMenuController::Observer:
   virtual void NotifyMenuDeleted(
       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;
   virtual void OnBrowserActionViewDragDone() OVERRIDE;
+  virtual views::View* GetOverflowReferenceView() OVERRIDE;
+  virtual void SetPopupOwner(BrowserActionButton* popup_owner) OVERRIDE;
+  virtual void HideActivePopup() OVERRIDE;
+  virtual extensions::ExtensionToolbarModel* GetModel() 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

[Yoyo Zhou, 2014/07/30 01:46:33]

Should this say active tab permissions?

[Devlin, 2014/07/30 16:14:26]

For clarity, probably.  Done.

   // |grant_tab_permissions| is true. Only pass true for this argument for
   // popups triggered interactively, not popups triggered by an API.
-  bool ShowPopup(const extensions::Extension* extension,
-                 bool grant_tab_permissions);
-
-  // Hide the current popup.
-  void HidePopup();
-
-  // Simulate a click on a browser action button.  This should only be
-  // used by unit tests.
-  void TestExecuteBrowserAction(int index);
+  // If |can_override| is true, this popup can override other popups (hiding
+  // them) and does not have to be in the active window.
+  bool ShowPopupForExtension(const extensions::Extension* extension,
+                             bool grant_tab_permissions,
+                             bool can_override);
 
   // Retrieve the current popup.  This should only be used by unit tests.
-  ExtensionPopup* TestGetPopup() { return popup_; }
+  ExtensionPopup* TestGetPopup();
 
   // Set how many icons the container should show. This should only be used by
   // unit tests.
   void TestSetIconVisibilityCount(size_t icons);
 
   // During testing we can disable animations by setting this flag to true,
   // so that the bar resizes instantly, instead of having to poll it while it
   // animates to open/closed status.
   static bool disable_animations_during_testing_;
 
@@ skipping 16 matching lines @@
   // Returns the height of an icon.
   static int IconHeight();
 
   // extensions::ExtensionToolbarModel::Observer implementation.
   virtual void BrowserActionAdded(const extensions::Extension* extension,
                                   int index) OVERRIDE;
   virtual void BrowserActionRemoved(
       const extensions::Extension* extension) OVERRIDE;
   virtual void BrowserActionMoved(const extensions::Extension* extension,
                                   int index) OVERRIDE;
-  virtual bool BrowserActionShowPopup(
-      const extensions::Extension* extension) OVERRIDE;
   virtual void VisibleCountChanged() OVERRIDE;
   virtual void HighlightModeChanged(bool is_highlighting) OVERRIDE;
 
   void LoadImages();
 
   // Sets the initial container width.
   void SetContainerWidth();
 
   // Closes the overflow menu if open.
   void CloseOverflowMenu();
@@ skipping 31 matching lines @@
   // the target size).  This also saves the target number of visible icons in
   // the pref if we're not incognito.
   void SaveDesiredSizeAndAnimate(gfx::Tween::Type type,
                                  size_t num_visible_icons);
 
   // Returns true if this extension should be shown in this toolbar. This can
   // return false if we are in an incognito window and the extension is disabled
   // for incognito.
   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 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; }
 
   // 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 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 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_;
+  BrowserActionButton* 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 33 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_