Make the chevron menu button responsible for legacy overflow menu logic

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 109 matching lines @@
 // 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::MenuButtonListener,
       public views::ResizeAreaDelegate,
       public gfx::AnimationDelegate,
       public extensions::ExtensionToolbarModel::Observer,
-      public BrowserActionOverflowMenuController::Observer,
       public BrowserActionView::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, 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();
 
   void Init();
 
   // Get the number of browser actions being displayed.
   size_t 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; }
 
   // Returns the chevron, if any.
-  views::View* chevron() { return chevron_; }
-  const views::View* chevron() const { return chevron_; }
+  views::View* chevron() { return chevron_.get(); }
+  const views::View* chevron() const { return chevron_.get(); }
 
   // 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.
@@ skipping 65 matching lines @@
                                    const gfx::Point& press_pt,
                                    const gfx::Point& p) OVERRIDE;
 
   // Overridden from views::ResizeAreaDelegate:
   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 BrowserActionView::Delegate:
   virtual content::WebContents* GetCurrentWebContents() OVERRIDE;
   virtual bool ShownInsideMenu() const OVERRIDE;
   virtual void OnBrowserActionViewDragDone() OVERRIDE;
   virtual views::MenuButton* GetOverflowReferenceView() OVERRIDE;
   virtual void SetPopupOwner(BrowserActionView* popup_owner) OVERRIDE;
   virtual void HideActivePopup() OVERRIDE;
   virtual BrowserActionView* GetMainViewForExtension(
       const extensions::Extension* extension) OVERRIDE;
 
@@ skipping 54 matching lines @@
   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.
   void SetChevronVisibility();
 
-  // Closes the overflow menu if open.
-  void CloseOverflowMenu();
-
-  // Cancels the timer for showing the drop down menu.
-  void StopShowFolderDropMenuTimer();
-
-  // Show the drop down folder after a slight delay.
-  void StartShowFolderDropMenuTimer();
-
-  // Show the overflow menu.
-  void ShowDropFolder();
-
   // Given a number of |icons| and whether to |display_chevron|, returns the
   // amount of pixels needed to draw the entire container.  For convenience,
   // callers can set |icons| to -1 to mean "all icons".
   int IconCountToWidth(int icons, bool display_chevron) const;
 
   // Given a pixel width, returns the number of icons that fit.  (This
   // automatically determines whether a chevron will be needed and includes it
   // in the calculation.)
   size_t WidthToIconCount(int pixels) const;
 
@@ skipping 49 matching lines @@
   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. Can be NULL when in overflow
   // mode or if the toolbar is permanently suppressing the chevron menu.
-  views::MenuButton* chevron_;
+  scoped_ptr<ChevronMenuButton> 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.
   scoped_ptr<gfx::SlideAnimation> resize_animation_;
 
   // Don't show the chevron while animating.
   bool suppress_chevron_;
 
   // This is used while the user is resizing (and when the animations are in
   // progress) to know how wide the delta is between the current state and what
   // we should draw.
   int resize_amount_;
 
   // Keeps track of the absolute pixel width the container should have when we
   // are done animating.
   int animation_target_size_;
 
   // The DropPosition for the current drag-and-drop operation, or NULL if there
   // is none.
   scoped_ptr<DropPosition> drop_position_;
 
   // The class that registers for keyboard shortcuts for extension commands.
   scoped_ptr<ExtensionKeybindingRegistryViews> extension_keybinding_registry_;
 
   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_;
 
-  // Handles delayed showing of the overflow menu when hovering.
-  base::WeakPtrFactory<BrowserActionsContainer> show_menu_task_factory_;
-
   DISALLOW_COPY_AND_ASSIGN(BrowserActionsContainer);
 };
 
 #endif  // CHROME_BROWSER_UI_VIEWS_TOOLBAR_BROWSER_ACTIONS_CONTAINER_H_