[Extensions UI] Update ToolbarActionsBar::NeedsOverflow() for popped out actions

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 <utility>
 
 #include "base/auto_reset.h"
 #include "base/location.h"
@@ skipping 106 matching lines @@
       model_(ToolbarActionsModel::Get(browser_->profile())),
       main_bar_(main_bar),
       platform_settings_(),
       popup_owner_(nullptr),
       model_observer_(this),
       suppress_layout_(false),
       suppress_animation_(true),
       checked_extension_bubble_(false),
       is_drag_in_progress_(false),
       popped_out_action_(nullptr),
+      is_popped_out_sticky_(false),
       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 139 matching lines @@
   // animations are small and fast enough that this doesn't cause problems).
   return in_overflow_mode()
              ? toolbar_actions_.size()
              : WidthToIconCount(delegate_->GetWidth(
                    ToolbarActionsBarDelegate::GET_WIDTH_AFTER_ANIMATION));
 }
 
 bool ToolbarActionsBar::NeedsOverflow() const {
   DCHECK(!in_overflow_mode());
   // We need an overflow view if either the end index is less than the number of
-  // icons, or if a drag is in progress with the redesign turned on (since the
-  // user can drag an icon into the app menu).
+  // icons, if a drag is in progress with the redesign turned on (since the
+  // user can drag an icon into the app menu), or if there is a non-sticky
+  // popped out action (because the action will pop back into overflow when the
+  // menu opens).
   return GetEndIndexInBounds() != toolbar_actions_.size() ||
-         (is_drag_in_progress_ && !platform_settings_.chevron_enabled);
+         (is_drag_in_progress_ && !platform_settings_.chevron_enabled) ||
+         (popped_out_action_ && !is_popped_out_sticky_);
 }
 
 gfx::Rect ToolbarActionsBar::GetFrameForIndex(
     size_t index) const {
   size_t start_index = GetStartIndexInBounds();
 
   // If the index is for an action that is before range we show (i.e., is for
   // a button that's on the main bar, and this is the overflow), send back an
   // empty rect.
   if (index < start_index)
@@ skipping 200 matching lines @@
   if (in_overflow_mode())
     return main_bar_->IsActionVisibleOnMainBar(action);
 
   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,
+                                     bool is_sticky,
                                      const base::Closure& closure) {
   DCHECK(!in_overflow_mode()) << "Only the main bar can pop out actions.";
   DCHECK(!popped_out_action_) << "Only one action can be popped out at a time!";
   bool needs_redraw = !IsActionVisibleOnMainBar(controller);
   popped_out_action_ = controller;
+  is_popped_out_sticky_ = is_sticky;
   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::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, closure);
   } else {
     popped_out_closure_ = closure;
   }
 }
 
 void ToolbarActionsBar::UndoPopOut() {
   DCHECK(!in_overflow_mode()) << "Only the main bar can pop out actions.";
   DCHECK(popped_out_action_);
   ToolbarActionViewController* controller = popped_out_action_;
   popped_out_action_ = nullptr;
+  is_popped_out_sticky_ = false;
   popped_out_closure_.Reset();
   if (!IsActionVisibleOnMainBar(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.
@@ skipping 230 matching lines @@
   for (ToolbarActionViewController* action : toolbar_actions_) {
     if (action->GetId() == action_id)
       return action;
   }
   return nullptr;
 }
 
 content::WebContents* ToolbarActionsBar::GetCurrentWebContents() {
   return browser_->tab_strip_model()->GetActiveWebContents();
 }