[ash-md] Erases the pre-MD code path for Overview Mode

ash/wm/overview/window_selector_unittest.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 <algorithm>
 #include <vector>
 
 #include "ash/aura/wm_window_aura.h"
 #include "ash/common/accessibility_delegate.h"
 #include "ash/common/accessibility_types.h"
 #include "ash/common/ash_switches.h"
-#include "ash/common/material_design/material_design_controller.h"
 #include "ash/common/shelf/shelf_widget.h"
 #include "ash/common/shelf/wm_shelf.h"
 #include "ash/common/shell_window_ids.h"
 #include "ash/common/system/tray/system_tray.h"
-#include "ash/common/test/material_design_controller_test_api.h"
 #include "ash/common/wm/dock/docked_window_layout_manager.h"
 #include "ash/common/wm/maximize_mode/maximize_mode_controller.h"
 #include "ash/common/wm/mru_window_tracker.h"
 #include "ash/common/wm/overview/scoped_transform_overview_window.h"
 #include "ash/common/wm/overview/window_grid.h"
 #include "ash/common/wm/overview/window_selector.h"
 #include "ash/common/wm/overview/window_selector_controller.h"
 #include "ash/common/wm/overview/window_selector_item.h"
 #include "ash/common/wm/panels/panel_layout_manager.h"
 #include "ash/common/wm/window_state.h"
@@ skipping 41 matching lines @@
 #include "ui/views/controls/button/image_button.h"
 #include "ui/views/controls/button/label_button.h"
 #include "ui/views/widget/native_widget_aura.h"
 #include "ui/views/widget/widget_delegate.h"
 #include "ui/wm/core/window_util.h"
 #include "ui/wm/public/activation_delegate.h"
 
 namespace ash {
 namespace {
 
-// With Material Design the label covers selector item windows with a padding
-// in order to prevent them from receiving user input events while in overview.
-static const int kWindowMarginMD = 5;
+// The label covers selector item windows with a padding in order to prevent
+// them from receiving user input events while in overview.
+static const int kWindowMargin = 5;
 
-// With Material Design the overview mode header overlaps original window
-// header. This value is used to set top inset property on the windows.
+// The overview mode header overlaps original window header. This value is used
+// to set top inset property on the windows.
 static const int kHeaderHeight = 32;
 
 const char kActiveWindowChangedFromOverview[] =
     "WindowSelector_ActiveWindowChanged";
 
 class NonActivatableActivationDelegate
     : public aura::client::ActivationDelegate {
  public:
   bool ShouldActivate() const override { return false; }
 };
@@ skipping 10 matching lines @@
                    int top_view_inset,
                    int title_height) {
   return ScopedTransformOverviewWindow::GetItemScale(
       source.size(), target.size(), top_view_inset, title_height);
 }
 
 }  // namespace
 
 // TODO(bruthig): Move all non-simple method definitions out of class
 // declaration.
-class WindowSelectorTest
-    : public test::AshTestBase,
-      public testing::WithParamInterface<ash::MaterialDesignController::Mode> {
+class WindowSelectorTest : public test::AshTestBase {
  public:
   WindowSelectorTest() {}
   ~WindowSelectorTest() override {}
 
   void SetUp() override {
-    set_material_mode(GetParam());
     test::AshTestBase::SetUp();
-    if (!ash::MaterialDesignController::IsOverviewMaterial()) {
-      base::CommandLine::ForCurrentProcess()->AppendSwitch(
-          switches::kAshEnableStableOverviewOrder);
-    }
     ASSERT_TRUE(test::TestShelfDelegate::instance());
 
     shelf_view_test_.reset(new test::ShelfViewTestAPI(
         GetPrimaryShelf()->GetShelfViewForTesting()));
     shelf_view_test_->SetAnimationDuration(1);
     ScopedTransformOverviewWindow::SetImmediateCloseForTests();
   }
 
   aura::Window* CreateWindow(const gfx::Rect& bounds) {
     aura::Window* window =
@@ skipping 214 matching lines @@
   }
 
  private:
   aura::test::TestWindowDelegate delegate_;
   NonActivatableActivationDelegate non_activatable_activation_delegate_;
   std::unique_ptr<test::ShelfViewTestAPI> shelf_view_test_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowSelectorTest);
 };
 
-// Note: First argument is optional and intentionally left blank.
-// (it's a prefix for the generated test cases)
-INSTANTIATE_TEST_CASE_P(
-    ,
-    WindowSelectorTest,
-    testing::Values(ash::MaterialDesignController::NON_MATERIAL,
-                    ash::MaterialDesignController::MATERIAL_NORMAL,
-                    ash::MaterialDesignController::MATERIAL_EXPERIMENTAL));
-
 #if !defined(OS_WIN) || defined(USE_ASH)
 // TODO(msw): Broken on Windows. http://crbug.com/584038
 // Tests that the text field in the overview menu is repositioned and resized
 // after a screen rotation.
-TEST_P(WindowSelectorTest, OverviewScreenRotation) {
+TEST_F(WindowSelectorTest, OverviewScreenRotation) {
   gfx::Rect bounds(0, 0, 400, 300);
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   std::unique_ptr<aura::Window> panel1(CreatePanelWindow(bounds));
 
   // In overview mode the windows should no longer overlap and the text filter
   // widget should be focused.
   ToggleOverview();
 
   views::Widget* text_filter = text_filter_widget();
   UpdateDisplay("400x300");
 
-  // Formula for initial placement found in window_selector.cc using
-  // width = 400, height = 300:
-  // x: 0.5 * root_window->bounds().width() * (1 - kTextFilterScreenProportion).
+  // The text filter position is calculated as:
+  // x: 0.5 * (total_bounds.width() -
+  //           std::min(kTextFilterWidth, total_bounds.width())).
   // y: -kTextFilterHeight (since there's no text in the filter).
-  // w: root_window->bounds().width() * kTextFilterScreenProportion.
+  // w: std::min(kTextFilterWidth, total_bounds.width()).
   // h: kTextFilterHeight.
-  //
-  // With Material Design the text filter position is calculated as:
-  // x: 0.5 * (total_bounds.width() -
-  //           std::min(kTextFilterWidthMD, total_bounds.width())).
-  // y: -kTextFilterHeightMD (since there's no text in the filter).
-  // w: std::min(kTextFilterWidthMD, total_bounds.width()).
-  // h: kTextFilterHeightMD.
-  const bool material = ash::MaterialDesignController::IsOverviewMaterial();
-  gfx::Rect expected_bounds(150, -32, 100, 32);
-  gfx::Rect expected_bounds_MD(60, -40, 280, 40);
-  EXPECT_EQ((material ? expected_bounds_MD : expected_bounds).ToString(),
+  gfx::Rect expected_bounds(60, -40, 280, 40);
+  EXPECT_EQ(expected_bounds.ToString(),
             text_filter->GetClientAreaBoundsInScreen().ToString());
 
   // Rotates the display, which triggers the WindowSelector's
   // RepositionTextFilterOnDisplayMetricsChange method.
   UpdateDisplay("400x300/r");
 
   // Uses the same formulas as above using width = 300, height = 400.
-  expected_bounds = gfx::Rect(112, -32, 75, 32);
-  expected_bounds_MD = gfx::Rect(10, -40, 280, 40);
-  EXPECT_EQ((material ? expected_bounds_MD : expected_bounds).ToString(),
+  expected_bounds = gfx::Rect(10, -40, 280, 40);
+  EXPECT_EQ(expected_bounds.ToString(),
             text_filter->GetClientAreaBoundsInScreen().ToString());
 }
 #endif
 
 // Tests that an a11y alert is sent on entering overview mode.
-TEST_P(WindowSelectorTest, A11yAlertOnOverviewMode) {
+TEST_F(WindowSelectorTest, A11yAlertOnOverviewMode) {
   gfx::Rect bounds(0, 0, 400, 400);
   AccessibilityDelegate* delegate = WmShell::Get()->accessibility_delegate();
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   EXPECT_NE(delegate->GetLastAccessibilityAlert(),
             A11Y_ALERT_WINDOW_OVERVIEW_MODE_ENTERED);
   ToggleOverview();
   EXPECT_EQ(delegate->GetLastAccessibilityAlert(),
             A11Y_ALERT_WINDOW_OVERVIEW_MODE_ENTERED);
 }
 
 // Tests that there are no crashes when there is not enough screen space
 // available to show all of the windows.
-TEST_P(WindowSelectorTest, SmallDisplay) {
+TEST_F(WindowSelectorTest, SmallDisplay) {
   UpdateDisplay("3x1");
   gfx::Rect bounds(0, 0, 1, 1);
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
   std::unique_ptr<aura::Window> window3(CreateWindow(bounds));
   std::unique_ptr<aura::Window> window4(CreateWindow(bounds));
   window1->SetProperty(aura::client::kTopViewInset, 0);
   window2->SetProperty(aura::client::kTopViewInset, 0);
   window3->SetProperty(aura::client::kTopViewInset, 0);
   window4->SetProperty(aura::client::kTopViewInset, 0);
   ToggleOverview();
 }
 
 // Tests entering overview mode with two windows and selecting one by clicking.
-TEST_P(WindowSelectorTest, Basic) {
+TEST_F(WindowSelectorTest, Basic) {
   gfx::Rect bounds(0, 0, 400, 400);
   aura::Window* root_window = Shell::GetPrimaryRootWindow();
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
   std::unique_ptr<aura::Window> panel1(CreatePanelWindow(bounds));
   std::unique_ptr<aura::Window> panel2(CreatePanelWindow(bounds));
 
   EXPECT_TRUE(WindowsOverlapping(window1.get(), window2.get()));
   EXPECT_TRUE(WindowsOverlapping(panel1.get(), panel2.get()));
   wm::ActivateWindow(window2.get());
@@ skipping 16 matching lines @@
   EXPECT_TRUE(wm::IsActiveWindow(window1.get()));
   EXPECT_FALSE(wm::IsActiveWindow(window2.get()));
   EXPECT_EQ(window1.get(), GetFocusedWindow());
 
   // Cursor should have been unlocked.
   EXPECT_FALSE(aura::client::GetCursorClient(root_window)->IsCursorLocked());
 }
 
 // Tests that entering overview mode with an App-list active properly focuses
 // and activates the overview text filter window.
-TEST_P(WindowSelectorTest, TextFilterActive) {
+TEST_F(WindowSelectorTest, TextFilterActive) {
   gfx::Rect bounds(0, 0, 400, 400);
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   wm::ActivateWindow(window1.get());
 
   EXPECT_TRUE(wm::IsActiveWindow(window1.get()));
   EXPECT_EQ(window1.get(), GetFocusedWindow());
 
   WmShell::Get()->ToggleAppList();
 
   // Activating overview cancels the App-list which normally would activate the
   // previously active |window1|. Overview mode should properly transfer focus
   // and activation to the text filter widget.
   ToggleOverview();
   EXPECT_FALSE(wm::IsActiveWindow(window1.get()));
   EXPECT_TRUE(wm::IsActiveWindow(GetFocusedWindow()));
   EXPECT_EQ(text_filter_widget()->GetNativeWindow(), GetFocusedWindow());
 }
 
-// Tests that the ordering of windows is near the windows' original positions.
-TEST_P(WindowSelectorTest, MinimizeMovement) {
-  // With Material Design the order of windows in overview mode is MRU.
-  if (ash::MaterialDesignController::IsOverviewMaterial())
-    return;
-  aura::Window* root_window = Shell::GetPrimaryRootWindow();
-  gfx::Rect left_bounds(0, 0, root_window->bounds().width() / 2,
-                        root_window->bounds().height());
-  gfx::Rect right_bounds(root_window->bounds().width() / 2, 0,
-                         root_window->bounds().width() / 2,
-                         root_window->bounds().height());
-  std::unique_ptr<aura::Window> left_window(CreateWindow(left_bounds));
-  WmWindow* left_window_wm = WmWindowAura::Get(left_window.get());
-  std::unique_ptr<aura::Window> right_window(CreateWindow(right_bounds));
-  WmWindow* right_window_wm = WmWindowAura::Get(right_window.get());
-
-  // The window should stay on the same side of the screen regardless of which
-  // one was active on entering overview mode.
-  wm::GetWindowState(left_window.get())->Activate();
-  ToggleOverview();
-  const std::vector<WindowSelectorItem*>& overview1(GetWindowItemsForRoot(0));
-  EXPECT_EQ(overview1[0]->GetWindow(), left_window_wm);
-  EXPECT_EQ(overview1[1]->GetWindow(), right_window_wm);
-  ToggleOverview();
-
-  // Active the right window, the order should be the same.
-  wm::GetWindowState(right_window.get())->Activate();
-  ToggleOverview();
-  const std::vector<WindowSelectorItem*>& overview2(GetWindowItemsForRoot(0));
-  EXPECT_EQ(overview2[0]->GetWindow(), left_window_wm);
-  EXPECT_EQ(overview2[1]->GetWindow(), right_window_wm);
-  ToggleOverview();
-
-  // Switch the window positions, and the order should be switched.
-  left_window->SetBounds(right_bounds);
-  right_window->SetBounds(left_bounds);
-  ToggleOverview();
-  const std::vector<WindowSelectorItem*>& overview3(GetWindowItemsForRoot(0));
-  EXPECT_EQ(overview3[0]->GetWindow(), right_window_wm);
-  EXPECT_EQ(overview3[1]->GetWindow(), left_window_wm);
-  ToggleOverview();
-}
-
-// Tests that the ordering of windows is near the windows' original positions
-// on a second display.
-TEST_P(WindowSelectorTest, MinimizeMovementSecondDisplay) {
-  // With Material Design the order of windows in overview mode is MRU.
-  if (ash::MaterialDesignController::IsOverviewMaterial() ||
-      !SupportsMultipleDisplays()) {
-    return;
-  }
-  // Verify the same works on the second display
-  UpdateDisplay("400x400,400x400");
-  gfx::Rect left_bounds(400, 0, 200, 400);
-  gfx::Rect right_bounds(600, 0, 200, 400);
-  std::unique_ptr<aura::Window> left_window(CreateWindow(left_bounds));
-  WmWindow* left_window_wm = WmWindowAura::Get(left_window.get());
-  std::unique_ptr<aura::Window> right_window(CreateWindow(right_bounds));
-  WmWindow* right_window_wm = WmWindowAura::Get(right_window.get());
-
-  aura::Window::Windows root_windows = Shell::GetAllRootWindows();
-  EXPECT_EQ(root_windows[1], left_window->GetRootWindow());
-  EXPECT_EQ(root_windows[1], right_window->GetRootWindow());
-
-  wm::GetWindowState(left_window.get())->Activate();
-  ToggleOverview();
-  const std::vector<WindowSelectorItem*>& overview1(GetWindowItemsForRoot(0));
-  EXPECT_EQ(overview1[0]->GetWindow(), left_window_wm);
-  EXPECT_EQ(overview1[1]->GetWindow(), right_window_wm);
-  ToggleOverview();
-
-  // Active the right window, the order should be the same.
-  wm::GetWindowState(right_window.get())->Activate();
-  ToggleOverview();
-  const std::vector<WindowSelectorItem*>& overview2(GetWindowItemsForRoot(0));
-  EXPECT_EQ(overview2[0]->GetWindow(), left_window_wm);
-  EXPECT_EQ(overview2[1]->GetWindow(), right_window_wm);
-  ToggleOverview();
-}
-
 // Tests that the ordering of windows is stable across different overview
 // sessions even when the windows have the same bounds.
-TEST_P(WindowSelectorTest, WindowsOrder) {
+TEST_F(WindowSelectorTest, WindowsOrder) {
   gfx::Rect bounds(0, 0, 400, 400);
   std::unique_ptr<aura::Window> window1(CreateWindowWithId(bounds, 1));
   std::unique_ptr<aura::Window> window2(CreateWindowWithId(bounds, 2));
   std::unique_ptr<aura::Window> window3(CreateWindowWithId(bounds, 3));
 
-  // Before Material Design the initial ordering is not defined, but should
-  // remain consistent the next time overview is started.
-  // With Material Design the order of windows in overview mode is MRU.
+  // The order of windows in overview mode is MRU.
   wm::GetWindowState(window1.get())->Activate();
   ToggleOverview();
   const std::vector<WindowSelectorItem*>& overview1(GetWindowItemsForRoot(0));
-  int initial_order[3] = {overview1[0]->GetWindow()->GetShellWindowId(),
-                          overview1[1]->GetWindow()->GetShellWindowId(),
-                          overview1[2]->GetWindow()->GetShellWindowId()};
-  if (ash::MaterialDesignController::IsOverviewMaterial()) {
-    // With Material Design the order should be MRU.
-    EXPECT_EQ(1, overview1[0]->GetWindow()->GetShellWindowId());
-    EXPECT_EQ(3, overview1[1]->GetWindow()->GetShellWindowId());
-    EXPECT_EQ(2, overview1[2]->GetWindow()->GetShellWindowId());
-  }
+  EXPECT_EQ(1, overview1[0]->GetWindow()->GetShellWindowId());
+  EXPECT_EQ(3, overview1[1]->GetWindow()->GetShellWindowId());
+  EXPECT_EQ(2, overview1[2]->GetWindow()->GetShellWindowId());
   ToggleOverview();
 
   // Activate the second window.
   wm::GetWindowState(window2.get())->Activate();
   ToggleOverview();
   const std::vector<WindowSelectorItem*>& overview2(GetWindowItemsForRoot(0));
 
-  if (ash::MaterialDesignController::IsOverviewMaterial()) {
-    // With Material Design the order should be MRU.
-    EXPECT_EQ(2, overview2[0]->GetWindow()->GetShellWindowId());
-    EXPECT_EQ(1, overview2[1]->GetWindow()->GetShellWindowId());
-    EXPECT_EQ(3, overview2[2]->GetWindow()->GetShellWindowId());
-  } else {
-    // Before Material Design the order should be the same as the first time.
-    EXPECT_EQ(initial_order[0], overview2[0]->GetWindow()->GetShellWindowId());
-    EXPECT_EQ(initial_order[1], overview2[1]->GetWindow()->GetShellWindowId());
-    EXPECT_EQ(initial_order[2], overview2[2]->GetWindow()->GetShellWindowId());
-  }
+  // The order should be MRU.
+  EXPECT_EQ(2, overview2[0]->GetWindow()->GetShellWindowId());
+  EXPECT_EQ(1, overview2[1]->GetWindow()->GetShellWindowId());
+  EXPECT_EQ(3, overview2[2]->GetWindow()->GetShellWindowId());
   ToggleOverview();
 }
 
 // Tests entering overview mode with docked windows
-TEST_P(WindowSelectorTest, BasicWithDocked) {
+TEST_F(WindowSelectorTest, BasicWithDocked) {
   // aura::Window* root_window = Shell::GetPrimaryRootWindow();
   gfx::Rect bounds(300, 0, 200, 200);
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
   std::unique_ptr<aura::Window> docked1(CreateWindow(bounds));
   std::unique_ptr<aura::Window> docked2(CreateWindow(bounds));
 
   wm::WMEvent dock_event(wm::WM_EVENT_DOCK);
   wm::GetWindowState(docked1.get())->OnWMEvent(&dock_event);
 
@@ skipping 17 matching lines @@
 
   ToggleOverview();
 
   EXPECT_FALSE(WindowsOverlapping(window1.get(), window2.get()));
 
   gfx::Rect container_bounds = docked1->parent()->bounds();
   ShelfWidget* shelf = GetPrimaryShelf()->shelf_widget();
   DockedWindowLayoutManager* manager =
       DockedWindowLayoutManager::Get(WmWindowAura::Get(docked1.get()));
 
-  if (ash::MaterialDesignController::IsOverviewMaterial()) {
-    // Docked windows get shown and transformed.
-    EXPECT_TRUE(docked2->IsVisible());
+  // Docked windows get shown and transformed.
+  EXPECT_TRUE(docked2->IsVisible());
 
-    // Docked area shrinks.
-    DockedWindowLayoutManager* manager =
-        DockedWindowLayoutManager::Get(WmWindowAura::Get(docked1.get()));
-    EXPECT_EQ(0, manager->docked_bounds().width());
+  // Docked area shrinks.
+  EXPECT_EQ(0, manager->docked_bounds().width());
 
-    // Work area takes the whole screen minus the shelf.
-    gfx::Rect work_area = display::Screen::GetScreen()
-                              ->GetDisplayNearestWindow(docked1.get())
-                              .work_area();
-    gfx::Size expected_work_area_bounds(container_bounds.size());
-    expected_work_area_bounds.Enlarge(
-        0, -shelf->GetWindowBoundsInScreen().height());
-    EXPECT_EQ(expected_work_area_bounds.ToString(),
-              work_area.size().ToString());
-  } else {
-    // Docked windows stays the same.
-    EXPECT_EQ(docked_bounds.ToString(),
-              docked1->GetBoundsInScreen().ToString());
-    EXPECT_FALSE(docked2->IsVisible());
-  }
+  // Work area takes the whole screen minus the shelf.
+  gfx::Rect work_area = display::Screen::GetScreen()
+                            ->GetDisplayNearestWindow(docked1.get())
+                            .work_area();
+  gfx::Size expected_work_area_bounds(container_bounds.size());
+  expected_work_area_bounds.Enlarge(0,
+                                    -shelf->GetWindowBoundsInScreen().height());
+  EXPECT_EQ(expected_work_area_bounds.ToString(), work_area.size().ToString());
+
   // Docked window can still be activated, which will exit the overview mode.
   ClickWindow(docked1.get());
   EXPECT_TRUE(wm::IsActiveWindow(docked1.get()));
   EXPECT_FALSE(window_selector_controller()->IsSelecting());
 
   // Docked area has a window in it.
   EXPECT_GT(manager->docked_bounds().width(), 0);
 
   // Work area takes the whole screen minus the shelf and the docked area.
-  gfx::Rect work_area = display::Screen::GetScreen()
-                            ->GetDisplayNearestWindow(docked1.get())
-                            .work_area();
-  gfx::Size expected_work_area_bounds(container_bounds.size());
+  work_area = display::Screen::GetScreen()
+                  ->GetDisplayNearestWindow(docked1.get())
+                  .work_area();
+  expected_work_area_bounds = container_bounds.size();
   expected_work_area_bounds.Enlarge(-manager->docked_bounds().width(),
                                     -shelf->GetWindowBoundsInScreen().height());
   EXPECT_EQ(expected_work_area_bounds.ToString(), work_area.size().ToString());
 }
 
 // Tests that selecting a docked window updates docked layout pushing another
 // window to get docked-minimized.
-TEST_P(WindowSelectorTest, ActivateDockedWindow) {
-  if (!ash::MaterialDesignController::IsOverviewMaterial())
-    return;
-
+TEST_F(WindowSelectorTest, ActivateDockedWindow) {
   // aura::Window* root_window = Shell::GetPrimaryRootWindow();
   gfx::Rect bounds(300, 0, 200, 200);
   std::unique_ptr<views::Widget> widget1 = CreateWindowWidget(bounds);
   std::unique_ptr<views::Widget> widget2 = CreateWindowWidget(bounds);
 
   aura::test::TestWindowDelegate delegate;
   delegate.set_minimum_size(gfx::Size(200, 500));
   std::unique_ptr<aura::Window> docked_window1(
       CreateTestWindowInShellWithDelegate(&delegate, -1, bounds));
   docked_window1->SetProperty(aura::client::kTopViewInset, kHeaderHeight);
@@ skipping 35 matching lines @@
 
   // |docked_window1| is docked-minimized and hidden.
   EXPECT_FALSE(docked_window1->IsVisible());
   EXPECT_EQ(wm::WINDOW_STATE_TYPE_DOCKED_MINIMIZED, state1->GetStateType());
   // |docked_window2| is docked and visible.
   EXPECT_TRUE(docked_window2->IsVisible());
   EXPECT_EQ(wm::WINDOW_STATE_TYPE_DOCKED, state2->GetStateType());
 }
 
 // Tests that clicking on the close button closes the docked window.
-TEST_P(WindowSelectorTest, CloseDockedWindow) {
-  if (!ash::MaterialDesignController::IsOverviewMaterial())
-    return;
-
+TEST_F(WindowSelectorTest, CloseDockedWindow) {
   // aura::Window* root_window = Shell::GetPrimaryRootWindow();
   gfx::Rect bounds(300, 0, 200, 200);
   std::unique_ptr<views::Widget> widget1 = CreateWindowWidget(bounds);
   std::unique_ptr<views::Widget> widget2 = CreateWindowWidget(bounds);
 
   aura::test::TestWindowDelegate delegate;
   delegate.set_minimum_size(gfx::Size(200, 500));
   std::unique_ptr<aura::Window> docked_window1(
       CreateTestWindowInShellWithDelegate(&delegate, -1, bounds));
   docked_window1->SetProperty(aura::client::kTopViewInset, kHeaderHeight);
@@ skipping 38 matching lines @@
 
   // Window bounds are still the same.
   EXPECT_EQ(expected_bounds1.ToString(), docked_window1->bounds().ToString());
 
   // |docked_window1| returns to docked-minimized and hidden state.
   EXPECT_FALSE(docked_window1->IsVisible());
   EXPECT_EQ(wm::WINDOW_STATE_TYPE_DOCKED_MINIMIZED, state1->GetStateType());
 }
 
 // Tests that clicking on the close button closes the docked-minimized window.
-TEST_P(WindowSelectorTest, CloseDockedMinimizedWindow) {
-  if (!ash::MaterialDesignController::IsOverviewMaterial())
-    return;
-
+TEST_F(WindowSelectorTest, CloseDockedMinimizedWindow) {
   // aura::Window* root_window = Shell::GetPrimaryRootWindow();
   gfx::Rect bounds(300, 0, 200, 200);
   std::unique_ptr<views::Widget> widget1 = CreateWindowWidget(bounds);
   std::unique_ptr<views::Widget> widget2 = CreateWindowWidget(bounds);
 
   aura::test::TestWindowDelegate delegate;
   delegate.set_minimum_size(gfx::Size(200, 500));
   std::unique_ptr<aura::Window> docked_window1(
       CreateTestWindowInShellWithDelegate(&delegate, -1, bounds));
   docked_window1->SetProperty(aura::client::kTopViewInset, kHeaderHeight);
@@ skipping 39 matching lines @@
   // Window bounds are still the same.
   EXPECT_EQ(expected_bounds1.ToString(),
             docked_window1->GetTargetBounds().ToString());
 
   // |docked_window1| returns to docked and visible state.
   EXPECT_TRUE(docked_window1->IsVisible());
   EXPECT_EQ(wm::WINDOW_STATE_TYPE_DOCKED, state1->GetStateType());
 }
 
 // Tests selecting a window by tapping on it.
-TEST_P(WindowSelectorTest, BasicGesture) {
+TEST_F(WindowSelectorTest, BasicGesture) {
   gfx::Rect bounds(0, 0, 400, 400);
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
   wm::ActivateWindow(window1.get());
   EXPECT_EQ(window1.get(), GetFocusedWindow());
   ToggleOverview();
   EXPECT_EQ(text_filter_widget()->GetNativeWindow(), GetFocusedWindow());
   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
                                      window2.get());
   generator.GestureTapAt(
       gfx::ToEnclosingRect(GetTransformedTargetBounds(window2.get()))
           .CenterPoint());
   EXPECT_EQ(window2.get(), GetFocusedWindow());
 }
 
 // Tests that the user action WindowSelector_ActiveWindowChanged is
 // recorded when the mouse/touchscreen/keyboard are used to select a window
 // in overview mode which is different from the previously-active window.
-TEST_P(WindowSelectorTest, ActiveWindowChangedUserActionRecorded) {
+TEST_F(WindowSelectorTest, ActiveWindowChangedUserActionRecorded) {
   base::UserActionTester user_action_tester;
   gfx::Rect bounds(0, 0, 400, 400);
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
 
   // Tap on |window2| to activate it and exit overview.
   wm::ActivateWindow(window1.get());
   ToggleOverview();
   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
                                      window2.get());
@@ skipping 17 matching lines @@
   ASSERT_TRUE(SelectWindow(window2.get()));
   SendKey(ui::VKEY_RETURN);
   EXPECT_EQ(
       3, user_action_tester.GetActionCount(kActiveWindowChangedFromOverview));
 }
 
 // Tests that the user action WindowSelector_ActiveWindowChanged is not
 // recorded when the mouse/touchscreen/keyboard are used to select the
 // already-active window from overview mode. Also verifies that entering and
 // exiting overview without selecting a window does not record the action.
-TEST_P(WindowSelectorTest, ActiveWindowChangedUserActionNotRecorded) {
+TEST_F(WindowSelectorTest, ActiveWindowChangedUserActionNotRecorded) {
   base::UserActionTester user_action_tester;
   gfx::Rect bounds(0, 0, 400, 400);
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
 
   // Set |window1| to be initially active.
   wm::ActivateWindow(window1.get());
   ToggleOverview();
 
   // Tap on |window1| to exit overview.
@@ skipping 23 matching lines @@
   // Entering and exiting overview without user input should not record
   // the action.
   ToggleOverview();
   ToggleOverview();
   EXPECT_EQ(
       0, user_action_tester.GetActionCount(kActiveWindowChangedFromOverview));
 }
 
 // Tests that the user action WindowSelector_ActiveWindowChanged is not
 // recorded when overview mode exits as a result of closing its only window.
-TEST_P(WindowSelectorTest, ActiveWindowChangedUserActionWindowClose) {
+TEST_F(WindowSelectorTest, ActiveWindowChangedUserActionWindowClose) {
   base::UserActionTester user_action_tester;
   std::unique_ptr<views::Widget> widget =
       CreateWindowWidget(gfx::Rect(0, 0, 400, 400));
 
   ToggleOverview();
 
   aura::Window* window = widget->GetNativeWindow();
   gfx::RectF bounds = GetTransformedBoundsInRootWindow(window);
   gfx::Point point(bounds.top_right().x() - 1, bounds.top_right().y() + 5);
   ui::test::EventGenerator event_generator(window->GetRootWindow(), point);
 
   ASSERT_FALSE(widget->IsClosed());
   event_generator.ClickLeftButton();
   ASSERT_TRUE(widget->IsClosed());
   EXPECT_EQ(
       0, user_action_tester.GetActionCount(kActiveWindowChangedFromOverview));
 }
 
 // Tests that we do not crash and overview mode remains engaged if the desktop
 // is tapped while a finger is already down over a window.
-TEST_P(WindowSelectorTest, NoCrashWithDesktopTap) {
+TEST_F(WindowSelectorTest, NoCrashWithDesktopTap) {
   std::unique_ptr<aura::Window> window(
       CreateWindow(gfx::Rect(200, 300, 250, 450)));
 
   ToggleOverview();
 
   gfx::Rect bounds =
       gfx::ToEnclosingRect(GetTransformedBoundsInRootWindow(window.get()));
   ui::test::EventGenerator event_generator(window->GetRootWindow(),
                                            bounds.CenterPoint());
 
   // Press down on the window.
   const int kTouchId = 19;
   event_generator.PressTouchId(kTouchId);
 
   // Tap on the desktop, which should not cause a crash. Overview mode should
   // be disengaged.
   event_generator.GestureTapAt(gfx::Point(0, 0));
   EXPECT_FALSE(IsSelecting());
 
   event_generator.ReleaseTouchId(kTouchId);
 }
 
 // Tests that we do not crash and a window is selected when appropriate when
 // we click on a window during touch.
-TEST_P(WindowSelectorTest, ClickOnWindowDuringTouch) {
+TEST_F(WindowSelectorTest, ClickOnWindowDuringTouch) {
   gfx::Rect bounds(0, 0, 400, 400);
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
   wm::ActivateWindow(window2.get());
   EXPECT_FALSE(wm::IsActiveWindow(window1.get()));
   EXPECT_TRUE(wm::IsActiveWindow(window2.get()));
 
   ToggleOverview();
 
   gfx::Rect window1_bounds =
@@ skipping 19 matching lines @@
   event_generator.MoveMouseToCenterOf(window1.get());
   event_generator.PressTouchId(kTouchId);
   event_generator.ClickLeftButton();
   EXPECT_FALSE(IsSelecting());
   EXPECT_TRUE(wm::IsActiveWindow(window1.get()));
   EXPECT_FALSE(wm::IsActiveWindow(window2.get()));
   event_generator.ReleaseTouchId(kTouchId);
 }
 
 // Tests that a window does not receive located events when in overview mode.
-TEST_P(WindowSelectorTest, WindowDoesNotReceiveEvents) {
+TEST_F(WindowSelectorTest, WindowDoesNotReceiveEvents) {
   gfx::Rect window_bounds(20, 10, 200, 300);
   aura::Window* root_window = Shell::GetPrimaryRootWindow();
   std::unique_ptr<aura::Window> window(CreateWindow(window_bounds));
 
   gfx::Point point1(window_bounds.x() + 10, window_bounds.y() + 10);
 
   ui::MouseEvent event1(ui::ET_MOUSE_PRESSED, point1, point1,
                         ui::EventTimeForNow(), ui::EF_NONE, ui::EF_NONE);
 
   ui::EventTarget* root_target = root_window;
   ui::EventTargeter* targeter = root_target->GetEventTargeter();
 
   // The event should target the window because we are still not in overview
   // mode.
   EXPECT_EQ(window.get(), targeter->FindTargetForEvent(root_target, &event1));
 
   ToggleOverview();
 
   // The bounds have changed, take that into account.
   gfx::RectF bounds = GetTransformedBoundsInRootWindow(window.get());
   gfx::Point point2(bounds.x() + 10, bounds.y() + 10);
   ui::MouseEvent event2(ui::ET_MOUSE_PRESSED, point2, point2,
                         ui::EventTimeForNow(), ui::EF_NONE, ui::EF_NONE);
 
   // Now the transparent window should be intercepting this event.
   EXPECT_NE(window.get(), targeter->FindTargetForEvent(root_target, &event2));
 }
 
 // Tests that clicking on the close button effectively closes the window.
-TEST_P(WindowSelectorTest, CloseButton) {
+TEST_F(WindowSelectorTest, CloseButton) {
   std::unique_ptr<views::Widget> widget =
       CreateWindowWidget(gfx::Rect(0, 0, 400, 400));
 
   ToggleOverview();
 
   aura::Window* window = widget->GetNativeWindow();
   gfx::RectF bounds = GetTransformedBoundsInRootWindow(window);
   gfx::Point point(bounds.top_right().x() - 1, bounds.top_right().y() + 5);
   ui::test::EventGenerator event_generator(window->GetRootWindow(), point);
 
   EXPECT_FALSE(widget->IsClosed());
   event_generator.ClickLeftButton();
   EXPECT_TRUE(widget->IsClosed());
 }
 
 // Tests that clicking on the close button on a secondary display effectively
 // closes the window.
-TEST_P(WindowSelectorTest, CloseButtonOnMultipleDisplay) {
+TEST_F(WindowSelectorTest, CloseButtonOnMultipleDisplay) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("600x400,600x400");
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 
   std::unique_ptr<aura::Window> window1(
       CreateWindow(gfx::Rect(650, 300, 250, 450)));
 
   // We need a widget for the close button to work because windows are closed
@@ skipping 18 matching lines @@
   gfx::RectF bounds = GetTransformedBoundsInRootWindow(window2);
   gfx::Point point(bounds.top_right().x() - 1, bounds.top_right().y() + 5);
   ui::test::EventGenerator event_generator(window2->GetRootWindow(), point);
 
   EXPECT_FALSE(widget->IsClosed());
   event_generator.ClickLeftButton();
   EXPECT_TRUE(widget->IsClosed());
 }
 
 // Tests entering overview mode with two windows and selecting one.
-TEST_P(WindowSelectorTest, FullscreenWindow) {
+TEST_F(WindowSelectorTest, FullscreenWindow) {
   gfx::Rect bounds(0, 0, 400, 400);
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
   std::unique_ptr<aura::Window> panel1(CreatePanelWindow(bounds));
   wm::ActivateWindow(window1.get());
 
   const wm::WMEvent toggle_fullscreen_event(wm::WM_EVENT_TOGGLE_FULLSCREEN);
   wm::GetWindowState(window1.get())->OnWMEvent(&toggle_fullscreen_event);
   // The panel is hidden in fullscreen mode.
   EXPECT_FALSE(panel1->IsVisible());
@@ skipping 15 matching lines @@
   // fullscreen.
   // TODO(flackr): Currently the panel remains hidden, but should become visible
   // again.
   ToggleOverview();
   ClickWindow(window2.get());
   EXPECT_TRUE(wm::GetWindowState(window1.get())->IsFullscreen());
 }
 
 // Tests that the shelf dimming state is removed while in overview and restored
 // on exiting overview.
-TEST_P(WindowSelectorTest, OverviewUndimsShelf) {
+TEST_F(WindowSelectorTest, OverviewUndimsShelf) {
   gfx::Rect bounds(0, 0, 400, 400);
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   wm::WindowState* window_state = wm::GetWindowState(window1.get());
   window_state->Maximize();
   ShelfWidget* shelf = GetPrimaryShelf()->shelf_widget();
   EXPECT_TRUE(shelf->GetDimsShelf());
   ToggleOverview();
   EXPECT_FALSE(shelf->GetDimsShelf());
   ToggleOverview();
   EXPECT_TRUE(shelf->GetDimsShelf());
 }
 
 // Tests that entering overview when a fullscreen window is active in maximized
 // mode correctly applies the transformations to the window and correctly
 // updates the window bounds on exiting overview mode: http://crbug.com/401664.
-TEST_P(WindowSelectorTest, FullscreenWindowMaximizeMode) {
+TEST_F(WindowSelectorTest, FullscreenWindowMaximizeMode) {
   gfx::Rect bounds(0, 0, 400, 400);
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
   WmShell::Get()->maximize_mode_controller()->EnableMaximizeModeWindowManager(
       true);
   wm::ActivateWindow(window2.get());
   wm::ActivateWindow(window1.get());
   gfx::Rect normal_window_bounds(window1->bounds());
   const wm::WMEvent toggle_fullscreen_event(wm::WM_EVENT_TOGGLE_FULLSCREEN);
   wm::GetWindowState(window1.get())->OnWMEvent(&toggle_fullscreen_event);
@@ skipping 17 matching lines @@
 
   // Enter overview again and select window 2. Selecting window 2 should show
   // the shelf bringing window2 back to the normal bounds.
   ToggleOverview();
   ClickWindow(window2.get());
   EXPECT_EQ(normal_window_bounds.ToString(),
             window2->GetTargetBounds().ToString());
 }
 
 // Tests that beginning window selection hides the app list.
-TEST_P(WindowSelectorTest, SelectingHidesAppList) {
+TEST_F(WindowSelectorTest, SelectingHidesAppList) {
   gfx::Rect bounds(0, 0, 400, 400);
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
   WmShell::Get()->ShowAppList();
   EXPECT_TRUE(WmShell::Get()->GetAppListTargetVisibility());
   ToggleOverview();
   EXPECT_FALSE(WmShell::Get()->GetAppListTargetVisibility());
   ToggleOverview();
 }
 
 // Tests that a minimized window's visibility and layer visibility is correctly
 // changed when entering overview and restored when leaving overview mode.
 // Crashes after the skia roll in http://crrev.com/274114.
 // http://crbug.com/379570
-TEST_P(WindowSelectorTest, DISABLED_MinimizedWindowVisibility) {
+TEST_F(WindowSelectorTest, DISABLED_MinimizedWindowVisibility) {
   gfx::Rect bounds(0, 0, 400, 400);
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   wm::WindowState* window_state = wm::GetWindowState(window1.get());
   window_state->Minimize();
   EXPECT_FALSE(window1->IsVisible());
   EXPECT_FALSE(window1->layer()->GetTargetVisibility());
   {
     ui::ScopedAnimationDurationScaleMode test_duration_mode(
         ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
     ToggleOverview();
     EXPECT_TRUE(window1->IsVisible());
     EXPECT_TRUE(window1->layer()->GetTargetVisibility());
   }
   {
     ui::ScopedAnimationDurationScaleMode test_duration_mode(
         ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
     ToggleOverview();
     EXPECT_FALSE(window1->IsVisible());
     EXPECT_FALSE(window1->layer()->GetTargetVisibility());
   }
 }
 
 // Tests that it is safe to destroy a window while the overview header animation
 // is still active. See http://crbug.com/646350.
-TEST_P(WindowSelectorTest, SafeToDestroyWindowDuringAnimation) {
+TEST_F(WindowSelectorTest, SafeToDestroyWindowDuringAnimation) {
   gfx::Rect bounds(0, 0, 400, 400);
   {
     // Quickly enter and exit overview mode to activate header animations.
     std::unique_ptr<aura::Window> window(CreateWindow(bounds));
     ui::ScopedAnimationDurationScaleMode test_duration_mode(
         ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
     ToggleOverview();
     EXPECT_TRUE(IsSelecting());
 
     gfx::SlideAnimation* animation =
         GetBackgroundViewAnimationForWindow(0, window.get());
-    if (ash::MaterialDesignController::IsOverviewMaterial())
-      ASSERT_NE(nullptr, animation);
+    ASSERT_NE(nullptr, animation);
     ToggleOverview();
     EXPECT_FALSE(IsSelecting());
     if (animation)
       EXPECT_TRUE(animation->is_animating());
 
     // Close the window while the overview header animation is active.
     window.reset();
 
     // Progress animation to the end - should not crash.
     if (animation) {
       animation->SetCurrentValue(1.0);
       animation->Reset(1.0);
     }
   }
 }
 
 // Tests that a bounds change during overview is corrected for.
-TEST_P(WindowSelectorTest, BoundsChangeDuringOverview) {
+TEST_F(WindowSelectorTest, BoundsChangeDuringOverview) {
   std::unique_ptr<aura::Window> window(CreateWindow(gfx::Rect(0, 0, 400, 400)));
   // Use overview headers above the window in this test.
   window->SetProperty(aura::client::kTopViewInset, 0);
   ToggleOverview();
   gfx::Rect overview_bounds =
       ToEnclosingRect(GetTransformedTargetBounds(window.get()));
   window->SetBounds(gfx::Rect(200, 0, 200, 200));
   gfx::Rect new_overview_bounds =
       ToEnclosingRect(GetTransformedTargetBounds(window.get()));
   EXPECT_EQ(overview_bounds.x(), new_overview_bounds.x());
   EXPECT_EQ(overview_bounds.y(), new_overview_bounds.y());
   EXPECT_EQ(overview_bounds.width(), new_overview_bounds.width());
   EXPECT_EQ(overview_bounds.height(), new_overview_bounds.height());
   ToggleOverview();
 }
 
 // Tests that a newly created window aborts overview.
-TEST_P(WindowSelectorTest, NewWindowCancelsOveriew) {
+TEST_F(WindowSelectorTest, NewWindowCancelsOveriew) {
   gfx::Rect bounds(0, 0, 400, 400);
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
   ToggleOverview();
   EXPECT_TRUE(IsSelecting());
 
   // A window being created should exit overview mode.
   std::unique_ptr<aura::Window> window3(CreateWindow(bounds));
   EXPECT_FALSE(IsSelecting());
 }
 
 // Tests that a window activation exits overview mode.
-TEST_P(WindowSelectorTest, ActivationCancelsOveriew) {
+TEST_F(WindowSelectorTest, ActivationCancelsOveriew) {
   gfx::Rect bounds(0, 0, 400, 400);
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
   window2->Focus();
   ToggleOverview();
   EXPECT_TRUE(IsSelecting());
 
   // A window being activated should exit overview mode.
   window1->Focus();
   EXPECT_FALSE(IsSelecting());
 
   // window1 should be focused after exiting even though window2 was focused on
   // entering overview because we exited due to an activation.
   EXPECT_EQ(window1.get(), GetFocusedWindow());
 }
 
 // Tests that exiting overview mode without selecting a window restores focus
 // to the previously focused window.
-TEST_P(WindowSelectorTest, CancelRestoresFocus) {
+TEST_F(WindowSelectorTest, CancelRestoresFocus) {
   gfx::Rect bounds(0, 0, 400, 400);
   std::unique_ptr<aura::Window> window(CreateWindow(bounds));
   wm::ActivateWindow(window.get());
   EXPECT_EQ(window.get(), GetFocusedWindow());
 
   // In overview mode, the text filter widget should be focused.
   ToggleOverview();
   EXPECT_EQ(text_filter_widget()->GetNativeWindow(), GetFocusedWindow());
 
   // If canceling overview mode, focus should be restored.
   ToggleOverview();
   EXPECT_EQ(window.get(), GetFocusedWindow());
 }
 
 // Tests that overview mode is exited if the last remaining window is destroyed.
-TEST_P(WindowSelectorTest, LastWindowDestroyed) {
+TEST_F(WindowSelectorTest, LastWindowDestroyed) {
   gfx::Rect bounds(0, 0, 400, 400);
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
   ToggleOverview();
 
   window1.reset();
   window2.reset();
   EXPECT_FALSE(IsSelecting());
 }
 
 // Tests that entering overview mode restores a window to its original
 // target location.
-TEST_P(WindowSelectorTest, QuickReentryRestoresInitialTransform) {
+TEST_F(WindowSelectorTest, QuickReentryRestoresInitialTransform) {
   gfx::Rect bounds(0, 0, 400, 400);
   std::unique_ptr<aura::Window> window(CreateWindow(bounds));
   gfx::Rect initial_bounds =
       ToEnclosingRect(GetTransformedBounds(window.get()));
   ToggleOverview();
   // Quickly exit and reenter overview mode. The window should still be
   // animating when we reenter. We cannot short circuit animations for this but
   // we also don't have to wait for them to complete.
   {
     ui::ScopedAnimationDurationScaleMode test_duration_mode(
         ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
     ToggleOverview();
     ToggleOverview();
   }
   EXPECT_NE(initial_bounds,
             ToEnclosingRect(GetTransformedTargetBounds(window.get())));
   ToggleOverview();
   EXPECT_FALSE(IsSelecting());
   EXPECT_EQ(initial_bounds,
             ToEnclosingRect(GetTransformedTargetBounds(window.get())));
 }
 
 // Tests that windows with modal child windows are transformed with the modal
 // child even though not activatable themselves.
-TEST_P(WindowSelectorTest, ModalChild) {
+TEST_F(WindowSelectorTest, ModalChild) {
   gfx::Rect bounds(0, 0, 400, 400);
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   std::unique_ptr<aura::Window> child1(CreateWindow(bounds));
   child1->SetProperty(aura::client::kModalKey, ui::MODAL_TYPE_WINDOW);
   ::wm::AddTransientChild(window1.get(), child1.get());
   EXPECT_EQ(window1->parent(), child1->parent());
   ToggleOverview();
   EXPECT_TRUE(window1->IsVisible());
   EXPECT_TRUE(child1->IsVisible());
   EXPECT_EQ(ToEnclosingRect(GetTransformedTargetBounds(child1.get())),
             ToEnclosingRect(GetTransformedTargetBounds(window1.get())));
   ToggleOverview();
 }
 
 // Tests that clicking a modal window's parent activates the modal window in
 // overview.
-TEST_P(WindowSelectorTest, ClickModalWindowParent) {
+TEST_F(WindowSelectorTest, ClickModalWindowParent) {
   std::unique_ptr<aura::Window> window1(
       CreateWindow(gfx::Rect(0, 0, 180, 180)));
   std::unique_ptr<aura::Window> child1(
       CreateWindow(gfx::Rect(200, 0, 180, 180)));
   child1->SetProperty(aura::client::kModalKey, ui::MODAL_TYPE_WINDOW);
   ::wm::AddTransientChild(window1.get(), child1.get());
   EXPECT_FALSE(WindowsOverlapping(window1.get(), child1.get()));
   EXPECT_EQ(window1->parent(), child1->parent());
   ToggleOverview();
   // Given that their relative positions are preserved, the windows should still
   // not overlap.
   EXPECT_FALSE(WindowsOverlapping(window1.get(), child1.get()));
   ClickWindow(window1.get());
   EXPECT_FALSE(IsSelecting());
 
   // Clicking on window1 should activate child1.
   EXPECT_TRUE(wm::IsActiveWindow(child1.get()));
 }
 
 // Tests that windows remain on the display they are currently on in overview
 // mode, and that the close buttons are on matching displays.
-TEST_P(WindowSelectorTest, MultipleDisplays) {
+TEST_F(WindowSelectorTest, MultipleDisplays) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("600x400,600x400");
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
   gfx::Rect bounds1(0, 0, 400, 400);
   gfx::Rect bounds2(650, 0, 400, 400);
 
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds1));
   std::unique_ptr<aura::Window> window2(CreateWindow(bounds1));
@@ skipping 38 matching lines @@
                                  GetWindowItemForWindow(0, panel1.get()));
   IsWindowAndCloseButtonInScreen(panel2.get(),
                                  GetWindowItemForWindow(0, panel2.get()));
   IsWindowAndCloseButtonInScreen(panel3.get(),
                                  GetWindowItemForWindow(1, panel3.get()));
   IsWindowAndCloseButtonInScreen(panel4.get(),
                                  GetWindowItemForWindow(1, panel4.get()));
 }
 
 // Tests shutting down during overview.
-TEST_P(WindowSelectorTest, Shutdown) {
+TEST_F(WindowSelectorTest, Shutdown) {
   gfx::Rect bounds(0, 0, 400, 400);
   // These windows will be deleted when the test exits and the Shell instance
   // is shut down.
   aura::Window* window1(CreateWindow(bounds));
   aura::Window* window2(CreateWindow(bounds));
   aura::Window* window3(CreatePanelWindow(bounds));
   aura::Window* window4(CreatePanelWindow(bounds));
 
   wm::ActivateWindow(window4);
   wm::ActivateWindow(window3);
   wm::ActivateWindow(window2);
   wm::ActivateWindow(window1);
 
   ToggleOverview();
 }
 
 // Tests removing a display during overview.
-TEST_P(WindowSelectorTest, RemoveDisplay) {
+TEST_F(WindowSelectorTest, RemoveDisplay) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("400x400,400x400");
   gfx::Rect bounds1(0, 0, 100, 100);
   gfx::Rect bounds2(450, 0, 100, 100);
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds1));
   std::unique_ptr<aura::Window> window2(CreateWindow(bounds2));
   std::unique_ptr<aura::Window> window3(CreatePanelWindow(bounds1));
   std::unique_ptr<aura::Window> window4(CreatePanelWindow(bounds2));
@@ skipping 11 matching lines @@
 
   ToggleOverview();
   EXPECT_TRUE(IsSelecting());
   UpdateDisplay("400x400");
   EXPECT_FALSE(IsSelecting());
 }
 
 // Tests starting overview during a drag and drop tracking operation.
 // TODO(flackr): Fix memory corruption crash when running locally (not failing
 // on bots). See http://crbug.com/342528.
-TEST_P(WindowSelectorTest, DISABLED_DragDropInProgress) {
+TEST_F(WindowSelectorTest, DISABLED_DragDropInProgress) {
   bool drag_canceled_by_test = false;
   gfx::Rect bounds(0, 0, 400, 400);
   std::unique_ptr<aura::Window> window(CreateWindow(bounds));
   test::ShellTestApi shell_test_api(Shell::GetInstance());
   DragDropController* drag_drop_controller =
       shell_test_api.drag_drop_controller();
   ui::OSExchangeData data;
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&WindowSelectorTest::ToggleOverview, base::Unretained(this)));
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&CancelDrag, drag_drop_controller, &drag_canceled_by_test));
   data.SetString(base::UTF8ToUTF16("I am being dragged"));
   drag_drop_controller->StartDragAndDrop(
       data, window->GetRootWindow(), window.get(), gfx::Point(5, 5),
       ui::DragDropTypes::DRAG_MOVE, ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE);
   RunAllPendingInMessageLoop();
   EXPECT_FALSE(drag_canceled_by_test);
   ASSERT_TRUE(IsSelecting());
   RunAllPendingInMessageLoop();
 }
 
 // Test that a label is created under the window on entering overview mode.
-TEST_P(WindowSelectorTest, CreateLabelUnderWindow) {
+TEST_F(WindowSelectorTest, CreateLabelUnderWindow) {
   std::unique_ptr<aura::Window> window(CreateWindow(gfx::Rect(0, 0, 300, 500)));
   base::string16 window_title = base::UTF8ToUTF16("My window");
   window->SetTitle(window_title);
   ToggleOverview();
   WindowSelectorItem* window_item = GetWindowItemsForRoot(0).back();
   views::LabelButton* label = GetLabelButtonView(window_item);
   // Has the label view been created?
   ASSERT_TRUE(label);
 
   // Verify the label matches the window title.
   EXPECT_EQ(label->GetText(), window_title);
 
   // Update the window title and check that the label is updated, too.
   base::string16 updated_title = base::UTF8ToUTF16("Updated title");
   window->SetTitle(updated_title);
   EXPECT_EQ(label->GetText(), updated_title);
 
   // Labels are located based on target_bounds, not the actual window item
   // bounds.
   gfx::Rect label_bounds = label->GetWidget()->GetWindowBoundsInScreen();
-  if (ash::MaterialDesignController::IsOverviewMaterial())
-    label_bounds.Inset(kWindowMarginMD, kWindowMarginMD);
+  label_bounds.Inset(kWindowMargin, kWindowMargin);
   EXPECT_EQ(window_item->target_bounds(), label_bounds);
 }
 
 // Tests that overview updates the window positions if the display orientation
 // changes.
-TEST_P(WindowSelectorTest, DisplayOrientationChanged) {
+TEST_F(WindowSelectorTest, DisplayOrientationChanged) {
   aura::Window* root_window = Shell::GetInstance()->GetPrimaryRootWindow();
   UpdateDisplay("600x200");
   EXPECT_EQ("0,0 600x200", root_window->bounds().ToString());
   gfx::Rect window_bounds(0, 0, 150, 150);
   ScopedVector<aura::Window> windows;
   for (int i = 0; i < 3; i++) {
     windows.push_back(CreateWindow(window_bounds));
   }
 
   ToggleOverview();
   for (ScopedVector<aura::Window>::iterator iter = windows.begin();
        iter != windows.end(); ++iter) {
     EXPECT_TRUE(root_window->bounds().Contains(
         ToEnclosingRect(GetTransformedTargetBounds(*iter))));
   }
 
   // Rotate the display, windows should be repositioned to be within the screen
   // bounds.
   UpdateDisplay("600x200/r");
   EXPECT_EQ("0,0 200x600", root_window->bounds().ToString());
   for (ScopedVector<aura::Window>::iterator iter = windows.begin();
        iter != windows.end(); ++iter) {
     EXPECT_TRUE(root_window->bounds().Contains(
         ToEnclosingRect(GetTransformedTargetBounds(*iter))));
   }
 }
 
 // Tests traversing some windows in overview mode with the tab key.
-TEST_P(WindowSelectorTest, BasicTabKeyNavigation) {
+TEST_F(WindowSelectorTest, BasicTabKeyNavigation) {
   gfx::Rect bounds(0, 0, 100, 100);
   std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   ToggleOverview();
 
   const std::vector<WindowSelectorItem*>& overview_windows =
       GetWindowItemsForRoot(0);
   SendKey(ui::VKEY_TAB);
   EXPECT_EQ(GetSelectedWindow(),
             WmWindowAura::GetAuraWindow(overview_windows[0]->GetWindow()));
   SendKey(ui::VKEY_TAB);
   EXPECT_EQ(GetSelectedWindow(),
             WmWindowAura::GetAuraWindow(overview_windows[1]->GetWindow()));
   SendKey(ui::VKEY_TAB);
   EXPECT_EQ(GetSelectedWindow(),
             WmWindowAura::GetAuraWindow(overview_windows[0]->GetWindow()));
 }
 
 // Tests that pressing Ctrl+W while a window is selected in overview closes it.
-TEST_P(WindowSelectorTest, CloseWindowWithKey) {
+TEST_F(WindowSelectorTest, CloseWindowWithKey) {
   gfx::Rect bounds(0, 0, 100, 100);
   std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
   std::unique_ptr<views::Widget> widget =
       CreateWindowWidget(gfx::Rect(0, 0, 400, 400));
   aura::Window* window1 = widget->GetNativeWindow();
   ToggleOverview();
 
   SendKey(ui::VKEY_RIGHT);
   EXPECT_EQ(window1, GetSelectedWindow());
   SendCtrlKey(ui::VKEY_W);
   EXPECT_TRUE(widget->IsClosed());
 }
 
 // Tests traversing some windows in overview mode with the arrow keys in every
 // possible direction.
-TEST_P(WindowSelectorTest, BasicArrowKeyNavigation) {
+TEST_F(WindowSelectorTest, BasicArrowKeyNavigation) {
   const size_t test_windows = 9;
   UpdateDisplay("800x600");
   ScopedVector<aura::Window> windows;
   for (size_t i = test_windows; i > 0; i--)
     windows.push_back(CreateWindowWithId(gfx::Rect(0, 0, 100, 100), i));
 
   ui::KeyboardCode arrow_keys[] = {ui::VKEY_RIGHT, ui::VKEY_DOWN, ui::VKEY_LEFT,
                                    ui::VKEY_UP};
-  // Expected window layout, assuming that the text filtering feature is
-  // enabled by default (i.e., --ash-disable-text-filtering-in-overview-mode
-  // is not being used).
-  // +-------+  +-------+  +-------+  +-------+
-  // |   1   |  |   2   |  |   3   |  |   4   |
-  // +-------+  +-------+  +-------+  +-------+
-  // +-------+  +-------+  +-------+  +-------+
-  // |   5   |  |   6   |  |   7   |  |   8   |
-  // +-------+  +-------+  +-------+  +-------+
-  // +-------+
-  // |   9   |
-  // +-------+
-  // Index for each window during a full loop plus wrapping around.
+  // The rows contain variable number of items making vertical navigation not
+  // feasible. [Down] is equivalent to [Right] and [Up] is equivalent to [Left].
   int index_path_for_direction[][test_windows + 1] = {
       {1, 2, 3, 4, 5, 6, 7, 8, 9, 1},  // Right
-      {1, 5, 9, 2, 6, 3, 7, 4, 8, 1},  // Down
-      {9, 8, 7, 6, 5, 4, 3, 2, 1, 9},  // Left
-      {8, 4, 7, 3, 6, 2, 9, 5, 1, 8}   // Up
-  };
-  // With Material Design the rows contain variable number of items making
-  // vertical navigation not feasible. [Down] key is equivalent to [Right].
-  // [Up] is equivalent to [Left].
-  int index_path_for_direction_MD[][test_windows + 1] = {
-      {1, 2, 3, 4, 5, 6, 7, 8, 9, 1},  // Right
       {1, 2, 3, 4, 5, 6, 7, 8, 9, 1},  // Down (same as Right)
       {9, 8, 7, 6, 5, 4, 3, 2, 1, 9},  // Left
       {9, 8, 7, 6, 5, 4, 3, 2, 1, 9}   // Up (same as Left)
   };
 
   for (size_t key_index = 0; key_index < arraysize(arrow_keys); key_index++) {
     ToggleOverview();
     const std::vector<WindowSelectorItem*>& overview_windows =
         GetWindowItemsForRoot(0);
     for (size_t i = 0; i < test_windows + 1; i++) {
       SendKey(arrow_keys[key_index]);
       // TODO(flackr): Add a more readable error message by constructing a
       // string from the window IDs.
-      const int index = ash::MaterialDesignController::IsOverviewMaterial()
-                            ? index_path_for_direction_MD[key_index][i]
-                            : index_path_for_direction[key_index][i];
+      const int index = index_path_for_direction[key_index][i];
       EXPECT_EQ(GetSelectedWindow()->id(),
                 overview_windows[index - 1]->GetWindow()->GetShellWindowId());
     }
     ToggleOverview();
   }
 }
 
 // Tests basic selection across multiple monitors.
-TEST_P(WindowSelectorTest, BasicMultiMonitorArrowKeyNavigation) {
+TEST_F(WindowSelectorTest, BasicMultiMonitorArrowKeyNavigation) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("400x400,400x400");
   gfx::Rect bounds1(0, 0, 100, 100);
   gfx::Rect bounds2(450, 0, 100, 100);
   std::unique_ptr<aura::Window> window4(CreateWindow(bounds2));
   std::unique_ptr<aura::Window> window3(CreateWindow(bounds2));
   std::unique_ptr<aura::Window> window2(CreateWindow(bounds1));
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds1));
@@ skipping 13 matching lines @@
   SendKey(ui::VKEY_RIGHT);
   EXPECT_EQ(GetSelectedWindow(),
             WmWindowAura::GetAuraWindow(overview_root2[0]->GetWindow()));
   SendKey(ui::VKEY_RIGHT);
   EXPECT_EQ(GetSelectedWindow(),
             WmWindowAura::GetAuraWindow(overview_root2[1]->GetWindow()));
 }
 
 // Tests first monitor when display order doesn't match left to right screen
 // positions.
-TEST_P(WindowSelectorTest, MultiMonitorReversedOrder) {
+TEST_F(WindowSelectorTest, MultiMonitorReversedOrder) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("400x400,400x400");
   Shell::GetInstance()->display_manager()->SetLayoutForCurrentDisplays(
       test::CreateDisplayLayout(display::DisplayPlacement::LEFT, 0));
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
   gfx::Rect bounds1(-350, 0, 100, 100);
   gfx::Rect bounds2(0, 0, 100, 100);
   std::unique_ptr<aura::Window> window2(CreateWindow(bounds2));
@@ skipping 11 matching lines @@
   ToggleOverview();
   ToggleOverview();
 
   // Coming from right to left, we should select window2 first being on the
   // display on the right.
   SendKey(ui::VKEY_LEFT);
   EXPECT_EQ(GetSelectedWindow(), window2.get());
 }
 
 // Tests three monitors where the grid becomes empty on one of the monitors.
-TEST_P(WindowSelectorTest, ThreeMonitor) {
+TEST_F(WindowSelectorTest, ThreeMonitor) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("400x400,400x400,400x400");
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
   gfx::Rect bounds1(0, 0, 100, 100);
   gfx::Rect bounds2(400, 0, 100, 100);
   gfx::Rect bounds3(800, 0, 100, 100);
   std::unique_ptr<aura::Window> window3(CreateWindow(bounds3));
   std::unique_ptr<aura::Window> window2(CreateWindow(bounds2));
@@ skipping 22 matching lines @@
   SendKey(ui::VKEY_RIGHT);
 
   // If the window on the second display is removed, the selected window should
   // remain window3.
   EXPECT_EQ(GetSelectedWindow(), window3.get());
   window2.reset();
   EXPECT_EQ(GetSelectedWindow(), window3.get());
 }
 
 // Tests selecting a window in overview mode with the return key.
-TEST_P(WindowSelectorTest, SelectWindowWithReturnKey) {
+TEST_F(WindowSelectorTest, SelectWindowWithReturnKey) {
   gfx::Rect bounds(0, 0, 100, 100);
   std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   ToggleOverview();
 
   // Pressing the return key without a selection widget should not do anything.
   SendKey(ui::VKEY_RETURN);
   EXPECT_TRUE(IsSelecting());
 
   // Select the first window.
   ASSERT_TRUE(SelectWindow(window1.get()));
   SendKey(ui::VKEY_RETURN);
   ASSERT_FALSE(IsSelecting());
   EXPECT_TRUE(wm::IsActiveWindow(window1.get()));
 
   // Select the second window.
   ToggleOverview();
   ASSERT_TRUE(SelectWindow(window2.get()));
   SendKey(ui::VKEY_RETURN);
   EXPECT_FALSE(IsSelecting());
   EXPECT_TRUE(wm::IsActiveWindow(window2.get()));
 }
 
 // Tests that overview mode hides the callout widget.
-TEST_P(WindowSelectorTest, WindowOverviewHidesCalloutWidgets) {
+TEST_F(WindowSelectorTest, WindowOverviewHidesCalloutWidgets) {
   std::unique_ptr<aura::Window> panel1(
       CreatePanelWindow(gfx::Rect(0, 0, 100, 100)));
   WmWindow* wm_panel1 = WmWindowAura::Get(panel1.get());
   std::unique_ptr<aura::Window> panel2(
       CreatePanelWindow(gfx::Rect(0, 0, 100, 100)));
   WmWindow* wm_panel2 = WmWindowAura::Get(panel2.get());
   PanelLayoutManager* panel_manager = PanelLayoutManager::Get(wm_panel1);
 
   // By default, panel callout widgets are visible.
   EXPECT_TRUE(panel_manager->GetCalloutWidgetForPanel(wm_panel1)->IsVisible());
   EXPECT_TRUE(panel_manager->GetCalloutWidgetForPanel(wm_panel2)->IsVisible());
 
   // Toggling the overview should hide the callout widgets.
   ToggleOverview();
   EXPECT_FALSE(panel_manager->GetCalloutWidgetForPanel(wm_panel1)->IsVisible());
   EXPECT_FALSE(panel_manager->GetCalloutWidgetForPanel(wm_panel2)->IsVisible());
 
   // Ending the overview should show them again.
   ToggleOverview();
   EXPECT_TRUE(panel_manager->GetCalloutWidgetForPanel(wm_panel1)->IsVisible());
   EXPECT_TRUE(panel_manager->GetCalloutWidgetForPanel(wm_panel2)->IsVisible());
 }
 
 // Creates three windows and tests filtering them by title.
-TEST_P(WindowSelectorTest, BasicTextFiltering) {
+TEST_F(WindowSelectorTest, BasicTextFiltering) {
   gfx::Rect bounds(0, 0, 100, 100);
   std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   std::unique_ptr<aura::Window> window0(CreateWindow(bounds));
   base::string16 window2_title = base::UTF8ToUTF16("Highway to test");
   base::string16 window1_title = base::UTF8ToUTF16("For those about to test");
   base::string16 window0_title = base::UTF8ToUTF16("We salute you");
   window0->SetTitle(window0_title);
   window1->SetTitle(window1_title);
   window2->SetTitle(window2_title);
@@ skipping 26 matching lines @@
   // All the items should match the empty string. The filter widget should also
   // disappear.
   FilterItems("");
   EXPECT_FALSE(showing_filter_widget());
   EXPECT_FALSE(GetWindowItemForWindow(grid_index, window0.get())->dimmed());
   EXPECT_FALSE(GetWindowItemForWindow(grid_index, window1.get())->dimmed());
   EXPECT_FALSE(GetWindowItemForWindow(grid_index, window2.get())->dimmed());
 }
 
 // Tests selecting in the overview with dimmed and undimmed items.
-TEST_P(WindowSelectorTest, TextFilteringSelection) {
+TEST_F(WindowSelectorTest, TextFilteringSelection) {
   gfx::Rect bounds(0, 0, 100, 100);
   std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   std::unique_ptr<aura::Window> window0(CreateWindow(bounds));
   base::string16 window2_title = base::UTF8ToUTF16("Rock and roll");
   base::string16 window1_title = base::UTF8ToUTF16("Rock and");
   base::string16 window0_title = base::UTF8ToUTF16("Rock");
   window0->SetTitle(window0_title);
   window1->SetTitle(window1_title);
   window2->SetTitle(window2_title);
@@ skipping 13 matching lines @@
   FilterItems("Pop");
   EXPECT_FALSE(selection_widget_active());
 
   // Undimming one window should automatically select it.
   FilterItems("Rock and roll");
   EXPECT_EQ(GetSelectedWindow(), window2.get());
 }
 
 // Tests that transferring focus from the text filter to a window that is not a
 // top level window does not cancel overview mode.
-TEST_P(WindowSelectorTest, ShowTextFilterMenu) {
+TEST_F(WindowSelectorTest, ShowTextFilterMenu) {
   gfx::Rect bounds(0, 0, 100, 100);
   std::unique_ptr<aura::Window> window0(CreateWindow(bounds));
   base::string16 window0_title = base::UTF8ToUTF16("Test");
   window0->SetTitle(window0_title);
   wm::GetWindowState(window0.get())->Minimize();
   ToggleOverview();
 
   EXPECT_FALSE(selection_widget_active());
   EXPECT_FALSE(showing_filter_widget());
   FilterItems("Test");
@@ skipping 18 matching lines @@
   generator.MoveMouseTo(point_in_text_filter);
   generator.ClickLeftButton();
   EXPECT_TRUE(IsSelecting());
 
   // Cancel overview mode.
   ToggleOverview();
   ASSERT_FALSE(IsSelecting());
 }
 
 // Tests clicking on the desktop itself to cancel overview mode.
-TEST_P(WindowSelectorTest, CancelOverviewOnMouseClick) {
+TEST_F(WindowSelectorTest, CancelOverviewOnMouseClick) {
   // Overview disabled by default.
   EXPECT_FALSE(IsSelecting());
 
   // Point and bounds selected so that they don't intersect. This causes
   // events located at the point to be passed to WallpaperController,
   // and not the window.
   gfx::Point point_in_background_page(0, 0);
   gfx::Rect bounds(10, 10, 100, 100);
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   ui::test::EventGenerator& generator = GetEventGenerator();
   // Move mouse to point in the background page. Sending an event here will pass
   // it to the WallpaperController in both regular and overview mode.
   generator.MoveMouseTo(point_in_background_page);
 
   // Clicking on the background page while not in overview should not toggle
   // overview.
   generator.ClickLeftButton();
   EXPECT_FALSE(IsSelecting());
 
   // Switch to overview mode.
   ToggleOverview();
   ASSERT_TRUE(IsSelecting());
 
   // Click should now exit overview mode.
   generator.ClickLeftButton();
   EXPECT_FALSE(IsSelecting());
 }
 
 // Tests tapping on the desktop itself to cancel overview mode.
-TEST_P(WindowSelectorTest, CancelOverviewOnTap) {
+TEST_F(WindowSelectorTest, CancelOverviewOnTap) {
   // Overview disabled by default.
   EXPECT_FALSE(IsSelecting());
 
   // Point and bounds selected so that they don't intersect. This causes
   // events located at the point to be passed to WallpaperController,
   // and not the window.
   gfx::Point point_in_background_page(0, 0);
   gfx::Rect bounds(10, 10, 100, 100);
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   ui::test::EventGenerator& generator = GetEventGenerator();
 
   // Tapping on the background page while not in overview should not toggle
   // overview.
   generator.GestureTapAt(point_in_background_page);
   EXPECT_FALSE(IsSelecting());
 
   // Switch to overview mode.
   ToggleOverview();
   ASSERT_TRUE(IsSelecting());
 
   // Tap should now exit overview mode.
   generator.GestureTapAt(point_in_background_page);
   EXPECT_FALSE(IsSelecting());
 }
 
 // Tests that transformed Rect scaling preserves its aspect ratio.
-// With Material Design the window scale is determined by the target height and
-// so the test is actually testing that the width is calculated correctly.
-// Since all calculations are done with floating point values and then safely
-// converted to integers (using ceiled and floored values where appropriate),
-// the expectations are forgiving (use *_NEAR) within a single pixel.
-TEST_P(WindowSelectorTest, TransformedRectMaintainsAspect) {
+// The window scale is determined by the target height and so the test is
+// actually testing that the width is calculated correctly. Since all
+// calculations are done with floating point values and then safely converted to
+// integers (using ceiled and floored values where appropriate), the
+// expectations are forgiving (use *_NEAR) within a single pixel.
+TEST_F(WindowSelectorTest, TransformedRectMaintainsAspect) {
   gfx::Rect rect(50, 50, 200, 400);
   gfx::Rect bounds(100, 100, 50, 50);
   gfx::Rect transformed_rect =
       ScopedTransformOverviewWindow::ShrinkRectToFitPreservingAspectRatio(
           rect, bounds, 0, 0);
   float scale = GetItemScale(rect, bounds, 0, 0);
   EXPECT_NEAR(scale * rect.width(), transformed_rect.width(), 1);
   EXPECT_NEAR(scale * rect.height(), transformed_rect.height(), 1);
 
   rect = gfx::Rect(50, 50, 400, 200);
@@ skipping 23 matching lines @@
   rect = gfx::Rect(50, 50, 50, 25);
   scale = GetItemScale(rect, bounds, 0, 0);
   transformed_rect =
       ScopedTransformOverviewWindow::ShrinkRectToFitPreservingAspectRatio(
           rect, bounds, 0, 0);
   EXPECT_NEAR(scale * rect.width(), transformed_rect.width(), 1);
   EXPECT_NEAR(scale * rect.height(), transformed_rect.height(), 1);
 }
 
 // Tests that transformed Rect fits in target bounds and is vertically centered.
-TEST_P(WindowSelectorTest, TransformedRectIsCentered) {
+TEST_F(WindowSelectorTest, TransformedRectIsCentered) {
   gfx::Rect rect(50, 50, 200, 400);
   gfx::Rect bounds(100, 100, 50, 50);
   gfx::Rect transformed_rect =
       ScopedTransformOverviewWindow::ShrinkRectToFitPreservingAspectRatio(
           rect, bounds, 0, 0);
   EXPECT_GE(transformed_rect.x(), bounds.x());
   EXPECT_LE(transformed_rect.right(), bounds.right());
   EXPECT_GE(transformed_rect.y(), bounds.y());
   EXPECT_LE(transformed_rect.bottom(), bounds.bottom());
   EXPECT_NEAR(transformed_rect.x() - bounds.x(),
               bounds.right() - transformed_rect.right(), 1);
   EXPECT_NEAR(transformed_rect.y() - bounds.y(),
               bounds.bottom() - transformed_rect.bottom(), 1);
 }
 
 // Tests that transformed Rect fits in target bounds and is vertically centered
 // when inset and header height are specified.
-TEST_P(WindowSelectorTest, TransformedRectIsCenteredWithInset) {
+TEST_F(WindowSelectorTest, TransformedRectIsCenteredWithInset) {
   gfx::Rect rect(50, 50, 400, 200);
   gfx::Rect bounds(100, 100, 50, 50);
   const int inset = 20;
   const int header_height = 10;
   const float scale = GetItemScale(rect, bounds, inset, header_height);
   gfx::Rect transformed_rect =
       ScopedTransformOverviewWindow::ShrinkRectToFitPreservingAspectRatio(
           rect, bounds, inset, header_height);
-  if (ash::MaterialDesignController::IsOverviewMaterial()) {
-    // With Material Design the |rect| width does not fit and therefore it gets
-    // centered outside |bounds| starting before |bounds.x()| and ending after
-    // |bounds.right()|.
-    EXPECT_LE(transformed_rect.x(), bounds.x());
-    EXPECT_GE(transformed_rect.right(), bounds.right());
-  } else {
-    EXPECT_GE(transformed_rect.x(), bounds.x());
-    EXPECT_LE(transformed_rect.right(), bounds.right());
-  }
+  // The |rect| width does not fit and therefore it gets centered outside
+  // |bounds| starting before |bounds.x()| and ending after |bounds.right()|.
+  EXPECT_LE(transformed_rect.x(), bounds.x());
+  EXPECT_GE(transformed_rect.right(), bounds.right());
   EXPECT_GE(
       transformed_rect.y() + gfx::ToCeiledInt(scale * inset) - header_height,
       bounds.y());
   EXPECT_LE(transformed_rect.bottom(), bounds.bottom());
   EXPECT_NEAR(transformed_rect.x() - bounds.x(),
               bounds.right() - transformed_rect.right(), 1);
   EXPECT_NEAR(
       transformed_rect.y() + (int)(scale * inset) - header_height - bounds.y(),
       bounds.bottom() - transformed_rect.bottom(), 1);
 }
 
 }  // namespace ash