Make extensions that desire to act pop out if in overflow

chrome/browser/ui/views/toolbar/browser_actions_container.cc

 // 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.
 
 #include "chrome/browser/ui/views/toolbar/browser_actions_container.h"
 
 #include "base/compiler_specific.h"
 #include "base/stl_util.h"
 #include "chrome/browser/extensions/extension_action_manager.h"
 #include "chrome/browser/extensions/tab_helper.h"
@@ skipping 42 matching lines @@
 // TODO(devlin): We should move this to the model, once it supports component
 // actions.
 ScopedVector<ToolbarActionViewController> GetToolbarActions(
     extensions::ExtensionToolbarModel* model,
     Browser* browser) {
   ScopedVector<ToolbarActionViewController> actions;
 
   // Extension actions come first.
   extensions::ExtensionActionManager* action_manager =
       extensions::ExtensionActionManager::Get(browser->profile());
-  const extensions::ExtensionList& toolbar_items = model->toolbar_items();
+  const extensions::ExtensionList& toolbar_items = model->GetItemOrderForTab(
+      browser->tab_strip_model()->GetActiveWebContents());
   for (const scoped_refptr<const Extension>& extension : toolbar_items) {
     actions.push_back(new ExtensionActionViewController(
         extension.get(),
         browser,
         action_manager->GetExtensionAction(*extension)));
   }
 
   // Component actions come second.
   ScopedVector<ToolbarActionViewController> component_actions =
       ComponentToolbarActionsFactory::GetInstance()->
@@ skipping 44 matching lines @@
     : initialized_(false),
       profile_(browser->profile()),
       browser_(browser),
       main_container_(main_container),
       popup_owner_(NULL),
       model_(extensions::ExtensionToolbarModel::Get(browser->profile())),
       container_width_(0),
       resize_area_(NULL),
       chevron_(NULL),
       suppress_chevron_(false),
+      suppress_animation_(false),
+      suppress_layout_(false),
       resize_amount_(0),
       animation_target_size_(0) {
   set_id(VIEW_ID_BROWSER_ACTION_TOOLBAR);
   if (model_)  // |model_| can be NULL in views unittests.
     model_->AddObserver(this);
 
   bool overflow_experiment =
       extensions::FeatureSwitch::extension_action_redesign()->IsEnabled();
   DCHECK(!in_overflow_mode() || overflow_experiment);
 
@@ skipping 49 matching lines @@
 ToolbarActionView* BrowserActionsContainer::GetViewForExtension(
     const Extension* extension) {
   for (ToolbarActionView* view : toolbar_action_views_) {
     if (view->view_controller()->GetId() == extension->id())
       return view;
   }
   return nullptr;
 }
 
 void BrowserActionsContainer::RefreshToolbarActionViews() {
-  for (ToolbarActionView* view : toolbar_action_views_)
-    view->UpdateState();
+  if (toolbar_action_views_.empty())
+    return;  // Nothing to do.
+
+  // When we do a bulk-refresh of views (such as when we switch tabs), we don't
+  // animate the difference. We only animate when it's a change driven by the
+  // action.
+  base::AutoReset<bool> animation_resetter(&suppress_animation_, true);
+
+  {
+    // Don't layout until the end.
+    base::AutoReset<bool> layout_resetter(&suppress_layout_, true);
+    for (ToolbarActionView* view : toolbar_action_views_)
+      view->UpdateState();
+  }
+
+  ReorderViews();  // Also triggers a layout.
 }
 
 void BrowserActionsContainer::CreateToolbarActionViews() {
   DCHECK(toolbar_action_views_.empty());
   if (!model_)
     return;
 
-  ScopedVector<ToolbarActionViewController> actions =
-      GetToolbarActions(model_, browser_);
-  for (ToolbarActionViewController* controller : actions) {
-    ToolbarActionView* view =
-        new ToolbarActionView(make_scoped_ptr(controller), browser_, this);
-    toolbar_action_views_.push_back(view);
-    AddChildView(view);
+  {
+    // We don't Layout while creating views. Instead, Layout() once at the end.
+    base::AutoReset<bool> layout_resetter(&suppress_layout_, true);
+
+    ScopedVector<ToolbarActionViewController> actions =
+        GetToolbarActions(model_, browser_);
+    for (ToolbarActionViewController* controller : actions) {
+      ToolbarActionView* view =
+          new ToolbarActionView(make_scoped_ptr(controller), browser_, this);
+      toolbar_action_views_.push_back(view);
+      AddChildView(view);
+    }
+    actions.weak_clear();
   }
-  actions.weak_clear();
+
+  Layout();
+  SchedulePaint();
 }
 
 void BrowserActionsContainer::DeleteToolbarActionViews() {
   HideActivePopup();
   STLDeleteElements(&toolbar_action_views_);
 }
 
 size_t BrowserActionsContainer::VisibleBrowserActions() const {
   size_t visible_actions = 0;
   for (const ToolbarActionView* view : toolbar_action_views_) {
@@ skipping 16 matching lines @@
   // Global commands are handled by the ExtensionCommandsGlobalRegistry
   // instance.
   DCHECK(!command.global());
   extension_keybinding_registry_->ExecuteCommand(extension->id(),
                                                  command.accelerator());
 }
 
 void BrowserActionsContainer::NotifyActionMovedToOverflow() {
   // When an action is moved to overflow, we shrink the size of the container
   // by 1.
-  int icon_count = model_->GetVisibleIconCount();
+  size_t icon_count = model_->visible_icon_count();
   // Since this happens when an icon moves from the main bar to overflow, we
   // can't possibly have had no visible icons on the main bar.
-  DCHECK_NE(0, icon_count);
-  if (icon_count == -1)
-    icon_count = toolbar_action_views_.size();
+  DCHECK_NE(0u, icon_count);
   model_->SetVisibleIconCount(icon_count - 1);
 }
 
 bool BrowserActionsContainer::ShownInsideMenu() const {
   return in_overflow_mode();
 }
 
 void BrowserActionsContainer::OnToolbarActionViewDragDone() {
   ToolbarVisibleCountChanged();
   FOR_EACH_OBSERVER(BrowserActionsContainerObserver,
@@ skipping 83 matching lines @@
     icons_per_overflow_menu_row_ = (width - kItemSpacing) / IconWidth(true);
   return GetPreferredSize().height();
 }
 
 gfx::Size BrowserActionsContainer::GetMinimumSize() const {
   int min_width = std::min(MinimumNonemptyWidth(), IconCountToWidth(-1));
   return gfx::Size(min_width, IconHeight());
 }
 
 void BrowserActionsContainer::Layout() {
+  if (suppress_layout_)
+    return;
+
   if (toolbar_action_views_.empty()) {
     SetVisible(false);
     return;
   }
 
   SetVisible(true);
   if (resize_area_)
     resize_area_->SetBounds(0, 0, kItemSpacing, height());
 
   // If the icons don't all fit, show the chevron (unless suppressed).
@@ skipping 173 matching lines @@
   // visible icons.
   bool drag_between_containers =
       !toolbar_action_views_[data.index()]->visible();
   model_->MoveExtensionIcon(GetIdAt(data.index()), i);
 
   if (drag_between_containers) {
     // Let the main container update the model.
     if (in_overflow_mode())
       main_container_->NotifyActionMovedToOverflow();
     else  // This is the main container.
-      model_->SetVisibleIconCount(model_->GetVisibleIconCount() + 1);
+      model_->SetVisibleIconCount(model_->visible_icon_count() + 1);
   }
 
   OnDragExited();  // Perform clean up after dragging.
   return ui::DragDropTypes::DRAG_MOVE;
 }
 
 void BrowserActionsContainer::GetAccessibleState(
     ui::AXViewState* state) {
   state->role = ui::AX_ROLE_GROUP;
   state->name = l10n_util::GetStringUTF16(IDS_ACCNAME_EXTENSIONS);
@@ skipping 210 matching lines @@
   AddChildViewAt(view, index);
 
   // If we are still initializing the container, don't bother animating.
   if (!model_->extensions_initialized())
     return;
 
   // If this is just an upgrade, then don't worry about resizing.
   if (!extensions::ExtensionSystem::Get(profile_)->runtime_data()->
           IsBeingUpgraded(extension)) {
     // We need to resize if either:
-    // - The container is set to display all icons (visible count = -1), or
+    // - The container is set to display all icons, or
     // - The container will need to expand to include the chevron. This can
     //   happen when the container is set to display <n> icons, where <n> is
     //   the number of icons before the new icon. With the new icon, the chevron
     //   will need to be displayed.
-    int model_icon_count = model_->GetVisibleIconCount();
-    if (model_icon_count == -1 ||
-        (static_cast<size_t>(model_icon_count) < toolbar_action_views_.size() &&
+    if (model_->all_icons_visible() ||
+        (model_->visible_icon_count() < toolbar_action_views_.size() &&
          (chevron_ && !chevron_->visible()))) {
       suppress_chevron_ = true;
       Animate(gfx::Tween::LINEAR, GetIconCount());
       return;
     }
   }
 
   // Otherwise, we don't have to resize, so just redraw the (possibly modified)
   // visible icon set.
   OnBrowserActionVisibilityChanged();
@@ skipping 71 matching lines @@
     bool grant_active_tab) {
   // Don't override another popup, and only show in the active window.
   if (popup_owner_ || !browser_->window()->IsActive())
     return false;
 
   ToolbarActionView* view = GetViewForExtension(extension);
   return view && view->view_controller()->ExecuteAction(grant_active_tab);
 }
 
 void BrowserActionsContainer::ToolbarVisibleCountChanged() {
-  if (GetPreferredWidth() != container_width_)
+  if (GetPreferredWidth() != container_width_) {
     Animate(gfx::Tween::EASE_OUT, GetIconCount());
+  } else if (animation_target_size_ != 0) {
+    // It's possible that we're right where we're supposed to be in terms of
+    // icon count, but that we're also currently resizing. If this is the case,
+    // end the current animation with the current width.
+    animation_target_size_ = container_width_;
+    resize_animation_->Reset();
+  }
 }
 
 void BrowserActionsContainer::ToolbarHighlightModeChanged(
     bool is_highlighting) {
   // The visual highlighting is done in OnPaint(). It's a bit of a pain that
   // we delete and recreate everything here, but given everything else going on
   // (the lack of highlight, n more extensions appearing, etc), it's not worth
   // the extra complexity to create and insert only the new extensions.
   DeleteToolbarActionViews();
   CreateToolbarActionViews();
   Animate(gfx::Tween::LINEAR, GetIconCount());
 }
 
+void BrowserActionsContainer::OnToolbarReorderNecessary(
+    content::WebContents* web_contents) {
+  if (GetCurrentWebContents() == web_contents)
+    ReorderViews();
+}
+
 Browser* BrowserActionsContainer::GetBrowser() {
   return browser_;
 }
 
 void BrowserActionsContainer::LoadImages() {
   if (in_overflow_mode())
     return;  // Overflow mode has neither a chevron nor highlighting.
 
   ui::ThemeProvider* tp = GetThemeProvider();
   if (tp && chevron_) {
@@ skipping 65 matching lines @@
 int BrowserActionsContainer::MinimumNonemptyWidth() const {
   if (!chevron_)
     return ToolbarView::kStandardSpacing;
   return (ToolbarView::kStandardSpacing * 2) + kChevronSpacing +
       chevron_->GetPreferredSize().width();
 }
 
 void BrowserActionsContainer::Animate(gfx::Tween::Type tween_type,
                                       size_t num_visible_icons) {
   int target_size = IconCountToWidth(num_visible_icons);
-  if (resize_animation_ && !disable_animations_during_testing_) {
+  if (resize_animation_ && !disable_animations_during_testing_ &&
+      !suppress_animation_) {
     // Animate! We have to set the animation_target_size_ after calling Reset(),
     // because that could end up calling AnimationEnded which clears the value.
     resize_animation_->Reset();
     resize_animation_->SetTweenType(tween_type);
     animation_target_size_ = target_size;
     resize_animation_->Show();
   } else {
     animation_target_size_ = target_size;
     AnimationEnded(resize_animation_.get());
   }
 }
 
+void BrowserActionsContainer::ReorderViews() {
+  extensions::ExtensionList new_order =
+      model_->GetItemOrderForTab(GetCurrentWebContents());
+  if (new_order.empty())
+    return;  // Nothing to do.
+
+#if DCHECK_IS_ON
+  // Make sure the lists are in sync. There should be a view for each action in
+  // the new order.
+  // |toolbar_action_views_| may have more views than actions are present in
+  // |new_order| if there are any component toolbar actions.
+  // TODO(devlin): Change this to DCHECK_EQ when all toolbar actions are shown
+  // in the model.
+  DCHECK_LE(new_order.size(), toolbar_action_views_.size());
+  for (const scoped_refptr<const Extension>& extension : new_order)
+    DCHECK(GetViewForExtension(extension.get()));
+#endif
+
+  // Run through the views and compare them to the desired order. If something
+  // is out of place, find the correct spot for it.
+  for (size_t i = 0; i < new_order.size() - 1; ++i) {
+    if (new_order[i]->id() !=
+            toolbar_action_views_[i]->view_controller()->GetId()) {
+      // Find where the correct view is (it's guaranteed to be after our current
+      // index, since everything up to this point is correct).
+      size_t j = i + 1;
+      while (new_order[i]->id() !=
+                 toolbar_action_views_[j]->view_controller()->GetId())
+        ++j;
+      std::swap(toolbar_action_views_[i], toolbar_action_views_[j]);
+    }
+  }
+
+  // Our visible browser actions may have changed - re-Layout() and check the
+  // size.
+  ToolbarVisibleCountChanged();
+  OnBrowserActionVisibilityChanged();
+}
+
 size_t BrowserActionsContainer::GetIconCount() const {
   if (!model_)
     return 0u;
 
   // Find the absolute value for the model's visible count.
-  int model_visible_size = model_->GetVisibleIconCount();
-  size_t absolute_model_visible_size = model_visible_size == -1 ?
-      model_->toolbar_items().size() : model_visible_size;
+  size_t model_visible_size = model_->GetVisibleIconCountForTab(
+      browser_->tab_strip_model()->GetActiveWebContents());
 
-#if !defined(NDEBUG)
+#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 (initialized_) {
+  if (initialized_ && !suppress_layout_) {
     size_t num_extension_actions = 0u;
     for (ToolbarActionView* view : toolbar_action_views_) {
       // No component action should ever have a valid extension id, so we can
       // use this to check the extension amount.
       // TODO(devlin): Fix this to just check model size when the model also
       // includes component actions.
       if (crx_file::id_util::IdIsValid(view->view_controller()->GetId()))
         ++num_extension_actions;
     }
-    DCHECK_LE(absolute_model_visible_size, num_extension_actions);
+    DCHECK_LE(model_visible_size, num_extension_actions);
     DCHECK_EQ(model_->toolbar_items().size(), num_extension_actions);
   }
 #endif
 
   // The overflow displays any icons not shown by the main bar.
   return in_overflow_mode() ?
-      model_->toolbar_items().size() - absolute_model_visible_size :
-      absolute_model_visible_size;
+      model_->toolbar_items().size() - model_visible_size : model_visible_size;
 }