[Extension Toolbar] Slide out overflowed actions for popups

chrome/browser/ui/toolbar/toolbar_actions_bar.cc

 // 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.
 
 #include "chrome/browser/ui/toolbar/toolbar_actions_bar.h"
 
 #include "base/auto_reset.h"
 #include "base/profiler/scoped_tracker.h"
 #include "chrome/browser/extensions/extension_action_manager.h"
 #include "chrome/browser/extensions/extension_message_bubble_controller.h"
@@ skipping 107 matching lines @@
       browser_(browser),
       model_(extensions::ExtensionToolbarModel::Get(browser_->profile())),
       main_bar_(main_bar),
       platform_settings_(main_bar != nullptr),
       popup_owner_(nullptr),
       model_observer_(this),
       suppress_layout_(false),
       suppress_animation_(true),
       overflowed_action_wants_to_run_(false),
       checked_extension_bubble_(false),
+      popped_out_action_(nullptr),
       weak_ptr_factory_(this) {
   if (model_)  // |model_| can be null in unittests.
     model_observer_.Add(model_);
 }
 
 ToolbarActionsBar::~ToolbarActionsBar() {
   // We don't just call DeleteActions() here because it makes assumptions about
   // the order of deletion between the views and the ToolbarActionsBar.
   DCHECK(toolbar_actions_.empty()) <<
       "Must call DeleteActions() before destruction.";
@@ skipping 83 matching lines @@
   // Now we add an extra between-item padding value so the space can be divided
   // evenly by (size of icon with padding).
   return static_cast<size_t>(std::max(
       0, available_space + platform_settings_.item_spacing) / IconWidth(true));
 }
 
 size_t ToolbarActionsBar::GetIconCount() const {
   if (!model_)
     return 0u;
 
+  // We purposefully do not account for any "popped out" actions in overflow
+  // mode. This is because the popup cannot be showing while the overflow menu
+  // is open, so there's no concern there. Also, if the user has a popped out
+  // action, and immediately opens the overflow menu, we *want* the action there
+  // (since it will close the popup, but do so asynchronously, and we don't
+  // want to "slide" the action back in.
   size_t visible_icons = in_overflow_mode() ?
-      toolbar_actions_.size() - main_bar_->GetIconCount() :
-      model_->visible_icon_count();
+      toolbar_actions_.size() - model_->visible_icon_count() :
+      model_->visible_icon_count() + (popped_out_action_ ? 1 : 0);
 
 #if DCHECK_IS_ON()
   // Good time for some sanity checks: We should never try to display more
   // icons than we have, and we should always have a view per item in the model.
   // (The only exception is if this is in initialization.)
   if (!toolbar_actions_.empty() && !suppress_layout_ &&
       model_->extensions_initialized()) {
     size_t num_extension_actions = 0u;
     for (ToolbarActionViewController* action : toolbar_actions_) {
       // No component action should ever have a valid extension id, so we can
       // use this to check the extension amount.
       if (crx_file::id_util::IdIsValid(action->GetId()))
         ++num_extension_actions;
     }
 
     int num_component_actions =
         ComponentToolbarActionsFactory::GetInstance()->
             GetNumComponentActions();
     size_t num_total_actions = num_extension_actions + num_component_actions;
 
     DCHECK_LE(visible_icons, num_total_actions);
     DCHECK_EQ(model_->toolbar_items().size(), num_extension_actions);
   }
 #endif
 
   return visible_icons;
 }
 
+std::vector<ToolbarActionViewController*>
+ToolbarActionsBar::GetActions() const {
+  std::vector<ToolbarActionViewController*> actions = toolbar_actions_.get();
+
+  // If there is an action that should be popped out, and it's not visible by
+  // default, make it the final action in the list.
+  if (popped_out_action_) {
+    size_t index =
+        std::find(actions.begin(), actions.end(), popped_out_action_) -
+        actions.begin();
+    DCHECK_NE(actions.size(), index);
+    size_t visible = GetIconCount();
+    if (index >= visible) {
+      size_t rindex = actions.size() - index - 1;
+      std::rotate(actions.rbegin() + rindex,
+                  actions.rbegin() + rindex + 1,
+                  actions.rend() - visible + 1);
+    }
+  }
+
+  return actions;
+}
+
 void ToolbarActionsBar::CreateActions() {
   DCHECK(toolbar_actions_.empty());
   // We wait for the extension system to be initialized before we add any
   // actions, as they rely on the extension system to function.
   if (!model_ || !model_->extensions_initialized())
     return;
 
   {
     // TODO(robliao): Remove ScopedTracker below once https://crbug.com/463337
     // is fixed.
@@ skipping 115 matching lines @@
   if (drag_type == DRAG_TO_OVERFLOW)
     delta = -1;
   else if (drag_type == DRAG_TO_MAIN)
     delta = 1;
   model_->MoveExtensionIcon(toolbar_actions_[dragged_index]->GetId(),
                             dropped_index);
   if (delta)
     model_->SetVisibleIconCount(model_->visible_icon_count() + delta);
 }
 
+void ToolbarActionsBar::OnAnimationEnded() {
+  // Check if we were waiting for animation to finish to run a popup.
+  if (!popped_out_closure_.is_null()) {
+    popped_out_closure_.Run();
+    popped_out_closure_.Reset();
+  }
+}
+
+bool ToolbarActionsBar::IsActionVisible(
+    const ToolbarActionViewController* action) const {
+  size_t index = std::find(toolbar_actions_.begin(),
+                           toolbar_actions_.end(),
+                           action) - toolbar_actions_.begin();
+  return index < GetIconCount() || action == popped_out_action_;
+}
+
+void ToolbarActionsBar::PopOutAction(ToolbarActionViewController* controller,
+                                     const base::Closure& closure) {
+  DCHECK(!popped_out_action_) << "Only one action can be popped out at a time!";
+  bool needs_redraw = !IsActionVisible(controller);
+  popped_out_action_ = controller;
+  if (needs_redraw) {
+    // We suppress animation for this draw, because we need the action to get
+    // into position immediately, since it's about to show its popup.
+    base::AutoReset<bool> layout_resetter(&suppress_animation_, false);
+    delegate_->Redraw(true);
+  }
+
+  ResizeDelegate(gfx::Tween::LINEAR, false);
+  if (!delegate_->IsAnimating()) {
+    // Don't call the closure re-entrantly.
+    base::MessageLoop::current()->PostTask(FROM_HERE, closure);
+  } else {
+    popped_out_closure_ = closure;
+  }
+}
+
+void ToolbarActionsBar::UndoPopOut() {
+  DCHECK(popped_out_action_);
+  ToolbarActionViewController* controller = popped_out_action_;
+  popped_out_action_ = nullptr;
+  popped_out_closure_.Reset();
+  if (!IsActionVisible(controller))
+    delegate_->Redraw(true);
+  ResizeDelegate(gfx::Tween::LINEAR, false);
+}
+
 void ToolbarActionsBar::SetPopupOwner(
     ToolbarActionViewController* popup_owner) {
   // We should never be setting a popup owner when one already exists, and
   // never unsetting one when one wasn't set.
   DCHECK((!popup_owner_ && popup_owner) ||
          (popup_owner_ && !popup_owner));
   popup_owner_ = popup_owner;
 }
 
 void ToolbarActionsBar::HideActivePopup() {
@@ skipping 222 matching lines @@
   for (ToolbarActionViewController* action : toolbar_actions_) {
     if (action->GetId() == id)
       return action;
   }
   return nullptr;
 }
 
 content::WebContents* ToolbarActionsBar::GetCurrentWebContents() {
   return browser_->tab_strip_model()->GetActiveWebContents();
 }