[Extension Toolbar] Slide out overflowed actions for popups

chrome/browser/ui/toolbar/toolbar_actions_bar.h

 // 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.
 
 #ifndef CHROME_BROWSER_UI_TOOLBAR_TOOLBAR_ACTIONS_BAR_H_
 #define CHROME_BROWSER_UI_TOOLBAR_TOOLBAR_ACTIONS_BAR_H_
 
+#include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "base/scoped_observer.h"
 #include "chrome/browser/extensions/extension_toolbar_model.h"
 #include "chrome/browser/ui/toolbar/toolbar_actions_bar_bubble_delegate.h"
 #include "ui/gfx/animation/tween.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace extensions {
@@ skipping 72 matching lines @@
 
   // Returns the width for the given number of icons.
   int IconCountToWidth(int icons) const;
 
   // Returns the number of icons that can fit within the given width.
   size_t WidthToIconCount(int width) const;
 
   // Returns the number of icons that should be displayed.
   size_t GetIconCount() const;
 
+  // Returns the actions in the proper order; this may differ from the
+  // underlying order in the case of actions being popped out to show a popup.
+  std::vector<ToolbarActionViewController*> GetActions() const;
+
   // Creates the toolbar actions.
   void CreateActions();
 
   // Deletes all toolbar actions.
   void DeleteActions();
 
   // Updates all the toolbar actions.
   void Update();
 
   // Sets the width for the overflow menu rows.
   void SetOverflowRowWidth(int width);
 
   // Notifies the ToolbarActionsBar that a user completed a resize gesture, and
   // the new width is |width|.
   void OnResizeComplete(int width);
 
   // Notifies the ToolbarActionsBar that a user completed a drag and drop event,
   // and dragged the view from |dragged_index| to |dropped_index|.
   // |drag_type| indicates whether or not the icon was dragged between the
   // overflow and main containers.
   // The main container should handle all drag/drop notifications.
   void OnDragDrop(int dragged_index,
                   int dropped_index,
                   DragType drag_type);
 
+  // Notifies the ToolbarActionsBar that the delegate finished animating.
+  void OnAnimationEnded();
+
+  // Returns true if the given |action| is visible.
+  bool IsActionVisible(const ToolbarActionViewController* action) const;
+
+  // Pops out a given |action|, ensuring it is visible.
+  // |closure| will be called once any animation is complete.
+  void PopOutAction(ToolbarActionViewController* action,
+                    const base::Closure& closure);
+
+  // Undoes the current "pop out"; i.e., moves the popped out action back into
+  // overflow.
+  void UndoPopOut();
+
   // Sets the active popup owner to be |popup_owner|.
   void SetPopupOwner(ToolbarActionViewController* popup_owner);
 
   // Hides the actively showing popup, if any.
   void HideActivePopup();
 
   // Returns the main (i.e., not overflow) controller for the given action.
   ToolbarActionViewController* GetMainControllerForAction(
       ToolbarActionViewController* action);
 
-  const std::vector<ToolbarActionViewController*>& toolbar_actions() const {
+  // Returns the underlying toolbar actions, but does not order them. Primarily
+  // for use in testing.
+  const std::vector<ToolbarActionViewController*>& toolbar_actions_unordered()
+      const {
     return toolbar_actions_.get();
   }
   bool enabled() const { return model_ != nullptr; }
   bool suppress_layout() const { return suppress_layout_; }
   bool suppress_animation() const {
     return suppress_animation_ || disable_animations_for_testing_;
   }
   bool is_highlighting() const { return model_ && model_->is_highlighting(); }
   const PlatformSettings& platform_settings() const {
     return platform_settings_;
   }
   ToolbarActionViewController* popup_owner() { return popup_owner_; }
+  ToolbarActionViewController* popped_out_action() {
+    return popped_out_action_;
+  }
   bool in_overflow_mode() const { return main_bar_ != nullptr; }
 
   ToolbarActionsBarDelegate* delegate_for_test() { return delegate_; }
 
   static void set_send_overflowed_action_changes_for_testing(
       bool send_overflowed_action_changes) {
     send_overflowed_action_changes_ = send_overflowed_action_changes;
   }
 
   // During testing we can disable animations by setting this flag to true,
@@ skipping 85 matching lines @@
   // alter.
   static bool send_overflowed_action_changes_;
 
   // True if an action in the overflow menu wants to run.
   bool overflowed_action_wants_to_run_;
 
   // True if we have checked to see if there is an extension bubble that should
   // be displayed, and, if there is, shown that bubble.
   bool checked_extension_bubble_;
 
+  // The action, if any, which is currently "popped out" of the overflow in
+  // order to show a popup.
+  ToolbarActionViewController* popped_out_action_;
+
+  // The task to alert the |popped_out_action_| that animation has finished, and
+  // it is fully popped out.
+  base::Closure popped_out_closure_;
+
   base::WeakPtrFactory<ToolbarActionsBar> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ToolbarActionsBar);
 };
 
 #endif  // CHROME_BROWSER_UI_TOOLBAR_TOOLBAR_ACTIONS_BAR_H_