[Extenisons UI] Remove extension_action_redesign logic from the toolbar

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 <set>
 #include <utility>
 
 #include "base/auto_reset.h"
@@ skipping 17 matching lines @@
 #include "chrome/browser/ui/toolbar/toolbar_actions_bar_delegate.h"
 #include "chrome/browser/ui/toolbar/toolbar_actions_bar_observer.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/grit/theme_resources.h"
 #include "components/crx_file/id_util.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/extension_util.h"
 #include "extensions/browser/runtime_data.h"
 #include "extensions/common/extension.h"
-#include "extensions/common/feature_switch.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/image/image_skia.h"
 
 namespace {
 
 using WeakToolbarActions = std::vector<ToolbarActionViewController*>;
 
 enum DimensionType { WIDTH, HEIGHT };
 
 // Takes a reference vector |reference| of length n, where n is less than or
@@ skipping 34 matching lines @@
 // How long to wait until showing an extension message bubble.
 int g_extension_bubble_appearance_wait_time_in_seconds = 5;
 
 }  // namespace
 
 // static
 bool ToolbarActionsBar::disable_animations_for_testing_ = false;
 
 ToolbarActionsBar::PlatformSettings::PlatformSettings()
     : item_spacing(GetLayoutConstant(TOOLBAR_STANDARD_SPACING)),
-      icons_per_overflow_menu_row(1),
-      chevron_enabled(!extensions::FeatureSwitch::extension_action_redesign()->
-                          IsEnabled()) {
-}
+      icons_per_overflow_menu_row(1) {}
 
 ToolbarActionsBar::ToolbarActionsBar(ToolbarActionsBarDelegate* delegate,
                                      Browser* browser,
                                      ToolbarActionsBar* main_bar)
     : delegate_(delegate),
       browser_(browser),
       model_(ToolbarActionsModel::Get(browser_->profile())),
       main_bar_(main_bar),
       platform_settings_(),
       popup_owner_(nullptr),
@@ skipping 153 matching lines @@
 }
 
 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, 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) ||
-         (popped_out_action_ && !is_popped_out_sticky_);
+         is_drag_in_progress_ || (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 225 matching lines @@
   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);
+  ResizeDelegate(gfx::Tween::LINEAR);
   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);
+  ResizeDelegate(gfx::Tween::LINEAR);
 }
 
 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;
 }
@@ skipping 80 matching lines @@
     int index) {
   CHECK(model_->actions_initialized());
   CHECK(GetActionForId(item.id) == nullptr)
       << "Asked to add a toolbar action view for an action that already "
          "exists";
 
   toolbar_actions_.insert(toolbar_actions_.begin() + index,
                           model_->CreateActionForItem(browser_, this, item));
   delegate_->AddViewForAction(toolbar_actions_[index].get(), index);
 
-  // We may need to resize (e.g. to show the new icon, or the chevron). We don't
-  // need to check if an extension is upgrading here, because ResizeDelegate()
-  // checks to see if the container is already the proper size, and because
-  // if the action is newly incognito enabled, even though it's a reload, it's
-  // a new extension to this toolbar.
-  // We suppress the chevron during animation because, if we're expanding to
-  // show a new icon, we don't want to have the chevron visible only for the
-  // duration of the animation.
-  ResizeDelegate(gfx::Tween::LINEAR, true);
+  // We may need to resize (e.g. to show the new icon). We don't need to check
+  // if an extension is upgrading here, because ResizeDelegate() checks to see
+  // if the container is already the proper size, and because if the action is
+  // newly incognito enabled, even though it's a reload, it's a new extension to
+  // this toolbar.
+  ResizeDelegate(gfx::Tween::LINEAR);
 }
 
 void ToolbarActionsBar::OnToolbarActionRemoved(const std::string& action_id) {
   ToolbarActions::iterator iter = toolbar_actions_.begin();
   while (iter != toolbar_actions_.end() && (*iter)->GetId() != action_id)
     ++iter;
 
   if (iter == toolbar_actions_.end())
     return;
 
@@ skipping 19 matching lines @@
        !extensions::util::IsIncognitoEnabled(action_id, browser_->profile()))) {
     if (toolbar_actions_.size() > model_->visible_icon_count()) {
       // If we have more icons than we can show, then we must not be changing
       // the container size (since we either removed an icon from the main
       // area and one from the overflow list will have shifted in, or we
       // removed an entry directly from the overflow list).
       delegate_->Redraw(false);
     } else {
       // Either we went from overflow to no-overflow, or we shrunk the no-
       // overflow container by 1.  Either way the size changed, so animate.
-      ResizeDelegate(gfx::Tween::EASE_OUT, false);
+      ResizeDelegate(gfx::Tween::EASE_OUT);
     }
   }
 }
 
 void ToolbarActionsBar::OnToolbarActionMoved(const std::string& action_id,
                                              int index) {
   DCHECK(index >= 0 && index < static_cast<int>(toolbar_actions_.size()));
   // Unfortunately, |index| doesn't really mean a lot to us, because this
   // window's toolbar could be different (if actions are popped out). Just
   // do a full reorder.
   ReorderActions();
 }
 
 void ToolbarActionsBar::OnToolbarActionUpdated(const std::string& action_id) {
   ToolbarActionViewController* action = GetActionForId(action_id);
   // There might not be a view in cases where we are highlighting or if we
   // haven't fully initialized the actions.
   if (action)
     action->UpdateState();
 }
 
 void ToolbarActionsBar::OnToolbarVisibleCountChanged() {
-  ResizeDelegate(gfx::Tween::EASE_OUT, false);
+  ResizeDelegate(gfx::Tween::EASE_OUT);
 }
 
-void ToolbarActionsBar::ResizeDelegate(gfx::Tween::Type tween_type,
-                                       bool suppress_chevron) {
+void ToolbarActionsBar::ResizeDelegate(gfx::Tween::Type tween_type) {
   int desired_width = GetFullSize().width();
   if (desired_width !=
       delegate_->GetWidth(ToolbarActionsBarDelegate::GET_WIDTH_CURRENT)) {
     delegate_->ResizeAndAnimate(tween_type, desired_width);
   } else if (delegate_->IsAnimating()) {
     // It's possible that we're right where we're supposed to be in terms of
     // width, but that we're also currently resizing. If this is the case, end
     // the current animation with the current width.
     delegate_->StopAnimating();
   } else {
@@ skipping 53 matching lines @@
 void ToolbarActionsBar::OnToolbarModelInitialized() {
   // We shouldn't have any actions before the model is initialized.
   CHECK(toolbar_actions_.empty());
   CreateActions();
 
   // TODO(robliao): Remove ScopedTracker below once https://crbug.com/463337 is
   // fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "ToolbarActionsBar::OnToolbarModelInitialized"));
-  ResizeDelegate(gfx::Tween::EASE_OUT, false);
+  ResizeDelegate(gfx::Tween::EASE_OUT);
 }
 
 void ToolbarActionsBar::TabInsertedAt(TabStripModel* tab_strip_model,
                                       content::WebContents* contents,
                                       int index,
                                       bool foreground) {
   if (foreground)
     extensions::MaybeShowExtensionControlledNewTabPage(browser_, contents);
 }
 
 void ToolbarActionsBar::ReorderActions() {
   if (toolbar_actions_.empty())
     return;
 
   // First, reset the order to that of the model.
   auto compare = [](ToolbarActionViewController* const& action,
                     const ToolbarActionsModel::ToolbarItem& item) {
     return action->GetId() == item.id;
   };
   SortContainer(&toolbar_actions_, model_->toolbar_items(), compare);
 
   // Our visible browser actions may have changed - re-Layout() and check the
   // size (if we aren't suppressing the layout).
   if (!suppress_layout_) {
-    ResizeDelegate(gfx::Tween::EASE_OUT, false);
+    ResizeDelegate(gfx::Tween::EASE_OUT);
     delegate_->Redraw(true);
   }
 }
 
 ToolbarActionViewController* ToolbarActionsBar::GetActionForId(
     const std::string& action_id) {
   for (const auto& action : toolbar_actions_) {
     if (action->GetId() == action_id)
       return action.get();
   }
   return nullptr;
 }
 
 content::WebContents* ToolbarActionsBar::GetCurrentWebContents() {
   return browser_->tab_strip_model()->GetActiveWebContents();
 }