[Extensions UI] Remove override of toolbar redesign in many tests

chrome/browser/ui/toolbar/toolbar_actions_bar_unittest.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_unittest.h"
 
 #include "base/command_line.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/extensions/api/extension_action/extension_action_api.h"
 #include "chrome/browser/extensions/extension_action.h"
 #include "chrome/browser/extensions/extension_action_manager.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/test_extension_system.h"
 #include "chrome/browser/sessions/session_tab_helper.h"
 #include "chrome/browser/ui/layout_constants.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/toolbar/toolbar_action_view_controller.h"
 #include "chrome/browser/ui/toolbar/toolbar_actions_bar.h"
 #include "chrome/browser/ui/toolbar/toolbar_actions_bar_delegate.h"
 #include "chrome/common/pref_names.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/common/extension.h"
+#include "extensions/common/feature_switch.h"
 #include "ui/base/test/material_design_controller_test_api.h"
 
 namespace {
 
 // Verifies that the toolbar order matches for the given |actions_bar|. If the
 // order matches, the return value is empty; otherwise, it contains the error.
 std::string VerifyToolbarOrderForBar(
     const ToolbarActionsBar* actions_bar,
     BrowserActionTestUtil* browser_action_test_util,
     const char* expected_names[],
@@ skipping 42 matching lines @@
     error += base::StringPrintf(
         "Incorrect visible count in view: expected %d, found %d.\n",
         static_cast<int>(visible_count), static_cast<int>(view_icon_count));
 
   return error;
 }
 
 }  // namespace
 
 ToolbarActionsBarUnitTest::ToolbarActionsBarUnitTest()
-    : toolbar_model_(nullptr),
-      use_redesign_(false) {}
-
-ToolbarActionsBarUnitTest::ToolbarActionsBarUnitTest(bool use_redesign)
-    : toolbar_model_(nullptr),
-      use_redesign_(use_redesign) {}
+    : toolbar_model_(nullptr) {}
 
 ToolbarActionsBarUnitTest::~ToolbarActionsBarUnitTest() {}
 
 void ToolbarActionsBarUnitTest::SetUp() {
-  redesign_switch_.reset(new extensions::FeatureSwitch::ScopedOverride(
-      extensions::FeatureSwitch::extension_action_redesign(), use_redesign_));
-
   BrowserWithTestWindowTest::SetUp();
   // The toolbar typically displays extension icons, so create some extension
   // test infrastructure.
   extensions::TestExtensionSystem* extension_system =
       static_cast<extensions::TestExtensionSystem*>(
           extensions::ExtensionSystem::Get(profile()));
   extension_system->CreateExtensionService(
       base::CommandLine::ForCurrentProcess(),
       base::FilePath(),
       false);
   toolbar_model_ =
       extensions::extension_action_test_util::CreateToolbarModelForProfile(
           profile());
 
   material_design_state_.reset(
       new ui::test::MaterialDesignControllerTestAPI(GetParam()));
   ToolbarActionsBar::disable_animations_for_testing_ = true;
   browser_action_test_util_.reset(new BrowserActionTestUtil(browser(), false));
 
-  if (use_redesign_) {
+  if (extensions::FeatureSwitch::extension_action_redesign()->IsEnabled()) {
     overflow_browser_action_test_util_ =
         browser_action_test_util_->CreateOverflowBar();
   }
 }
 
 void ToolbarActionsBarUnitTest::TearDown() {
   // Since the profile gets destroyed in BrowserWithTestWindowTest::TearDown(),
   // we need to delete this now.
   browser_action_test_util_.reset();
   overflow_browser_action_test_util_.reset();
   ToolbarActionsBar::disable_animations_for_testing_ = false;
-  redesign_switch_.reset();
   material_design_state_.reset();
   BrowserWithTestWindowTest::TearDown();
 }
 
 void ToolbarActionsBarUnitTest::ActivateTab(int index) {
   ASSERT_NE(nullptr, browser()->tab_strip_model()->GetWebContentsAt(index));
   browser()->tab_strip_model()->ActivateTabAt(index, true);
 }
 
 scoped_refptr<const extensions::Extension>
@@ skipping 21 matching lines @@
     const char* expected_names[],
     size_t total_size,
     size_t visible_count) {
   std::string main_bar_error =
       VerifyToolbarOrderForBar(toolbar_actions_bar(),
                                browser_action_test_util(),
                                expected_names,
                                total_size,
                                visible_count);
   std::string overflow_bar_error;
-  if (use_redesign_) {
+  if (extensions::FeatureSwitch::extension_action_redesign()->IsEnabled()) {
     overflow_bar_error =
         VerifyToolbarOrderForBar(overflow_bar(),
                                  overflow_browser_action_test_util(),
                                  expected_names,
                                  total_size,
                                  total_size - visible_count);
 
   }
 
   return main_bar_error.empty() && overflow_bar_error.empty() ?
       testing::AssertionSuccess() :
       testing::AssertionFailure() << "main bar error:\n" << main_bar_error <<
           "overflow bar error:\n" << overflow_bar_error;
 }
 
-ToolbarActionsBarRedesignUnitTest::ToolbarActionsBarRedesignUnitTest()
-    : ToolbarActionsBarUnitTest(true) {}
-
-ToolbarActionsBarRedesignUnitTest::~ToolbarActionsBarRedesignUnitTest() {}
-
 // Note: First argument is optional and intentionally left blank.
 // (it's a prefix for the generated test cases)
 INSTANTIATE_TEST_CASE_P(
     ,
     ToolbarActionsBarUnitTest,
     testing::Values(ui::MaterialDesignController::NON_MATERIAL,
                     ui::MaterialDesignController::MATERIAL_NORMAL,
                     ui::MaterialDesignController::MATERIAL_HYBRID));
 
 TEST_P(ToolbarActionsBarUnitTest, BasicToolbarActionsBarTest) {
@@ skipping 197 matching lines @@
   }
 
   toolbar_model()->StopHighlighting();
   {
     // And, again, back to normal.
     const char* expected_names[] = {kExtension0, kExtension1, kExtension2};
     EXPECT_TRUE(VerifyToolbarOrder(expected_names, 3u, 3u));
   }
 }
 
-// Note: First argument is optional and intentionally left blank.
-// (it's a prefix for the generated test cases)
-INSTANTIATE_TEST_CASE_P(
-    ,
-    ToolbarActionsBarRedesignUnitTest,
-    testing::Values(ui::MaterialDesignController::NON_MATERIAL,
-                    ui::MaterialDesignController::MATERIAL_NORMAL,
-                    ui::MaterialDesignController::MATERIAL_HYBRID));
-
 // Test the bounds calculation for different indices.
-TEST_P(ToolbarActionsBarRedesignUnitTest, TestActionFrameBounds) {
+TEST_P(ToolbarActionsBarUnitTest, TestActionFrameBounds) {
   const int kIconWidth = ToolbarActionsBar::IconWidth(false);
   const int kIconHeight = ToolbarActionsBar::IconHeight();
   const int kIconWidthWithPadding = ToolbarActionsBar::IconWidth(true);
   const int kIconSpacing = GetLayoutConstant(TOOLBAR_STANDARD_SPACING);
   const int kIconsPerOverflowRow = 3;
   const int kNumExtensions = 7;
   const int kSpacing =
       toolbar_actions_bar()->platform_settings().item_spacing;
 
   // Initialization: 7 total extensions, with 3 visible per row in overflow.
@@ skipping 44 matching lines @@
             overflow_bar()->GetFrameForIndex(6));
 
   // Check with > 2 rows.
   toolbar_model()->SetVisibleIconCount(0);
   EXPECT_EQ(gfx::Rect(kSpacing, 0, kIconWidth, kIconHeight),
             overflow_bar()->GetFrameForIndex(0));
   EXPECT_EQ(gfx::Rect(kSpacing, kIconHeight * 2, kIconWidth, kIconHeight),
             overflow_bar()->GetFrameForIndex(6));
 }
 
-TEST_P(ToolbarActionsBarRedesignUnitTest, TestStartAndEndIndexes) {
+TEST_P(ToolbarActionsBarUnitTest, TestStartAndEndIndexes) {
   const int kIconWidthWithPadding = ToolbarActionsBar::IconWidth(true);
   const int kIconSpacing = GetLayoutConstant(TOOLBAR_STANDARD_SPACING);
 
   for (int i = 0; i < 3; ++i) {
     CreateAndAddExtension(
         base::StringPrintf("extension %d", i),
         extensions::extension_action_test_util::BROWSER_ACTION);
   }
   // At the start, all icons should be present on the main bar, and no
   // overflow should be needed.
@@ skipping 34 matching lines @@
       toolbar_actions_bar()->GetPreferredSize().width());
   EXPECT_EQ(3u, toolbar_actions_bar()->GetIconCount());
   EXPECT_EQ(0u, toolbar_actions_bar()->GetStartIndexInBounds());
   EXPECT_EQ(3u, toolbar_actions_bar()->GetEndIndexInBounds());
   EXPECT_EQ(3u, overflow_bar()->GetStartIndexInBounds());
   EXPECT_EQ(3u, overflow_bar()->GetEndIndexInBounds());
   EXPECT_FALSE(toolbar_actions_bar()->NeedsOverflow());
 }
 
 // Tests the logic for determining if the container needs an overflow menu item.
-TEST_P(ToolbarActionsBarRedesignUnitTest, TestNeedsOverflow) {
+TEST_P(ToolbarActionsBarUnitTest, TestNeedsOverflow) {
   CreateAndAddExtension(
       "extension 1",
       extensions::extension_action_test_util::BROWSER_ACTION);
   // One extension on the main bar, none overflowed. Overflow not needed.
   EXPECT_EQ(1u, toolbar_actions_bar()->GetIconCount());
   EXPECT_EQ(0u, overflow_bar()->GetIconCount());
   EXPECT_FALSE(toolbar_actions_bar()->NeedsOverflow());
 
   // Set one extension in the overflow menu, none on the main bar. Overflow
   // needed.
@@ skipping 38 matching lines @@
       extensions::extension_action_test_util::BROWSER_ACTION);
   toolbar_model()->SetVisibleIconCount(0u);
   {
     base::RunLoop run_loop;
     toolbar_actions_bar()->PopOutAction(action, true, run_loop.QuitClosure());
     run_loop.Run();
   }
   EXPECT_EQ(1u, toolbar_actions_bar()->GetIconCount());
   EXPECT_TRUE(toolbar_actions_bar()->NeedsOverflow());
 }