Gut ash::MaterialDesignController, and remove the about:flags entry.

ash/display/window_tree_host_manager_unittest.cc

 // Copyright (c) 2012 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 "ash/display/window_tree_host_manager.h"
 
 #include <memory>
 
-#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/wm/window_state.h"
 #include "ash/common/wm/wm_event.h"
 #include "ash/common/wm/wm_screen_util.h"
 #include "ash/common/wm_window.h"
 #include "ash/display/display_util.h"
 #include "ash/screen_util.h"
 #include "ash/shell.h"
-#include "ash/test/ash_md_test_base.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/test/ash_test_helper.h"
 #include "ash/test/cursor_manager_test_api.h"
 #include "ash/test/test_shell_delegate.h"
 #include "ash/wm/window_state_aura.h"
 #include "base/command_line.h"
 #include "ui/aura/client/focus_change_observer.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window_observer.h"
@@ skipping 368 matching lines @@
 
  private:
   // views::MouseWatcherListener:
   void MouseMovedOutOfHost() override {}
 
   DISALLOW_COPY_AND_ASSIGN(TestMouseWatcherListener);
 };
 
 }  // namespace
 
-class WindowTreeHostManagerTest : public test::AshMDTestBase,
-                                  public TestHelper {
+class WindowTreeHostManagerTest : public test::AshTestBase, public TestHelper {
  public:
   WindowTreeHostManagerTest() : TestHelper(this){};
   ~WindowTreeHostManagerTest() override{};
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WindowTreeHostManagerTest);
 };
 
-INSTANTIATE_TEST_CASE_P(
-    /* prefix intentionally left blank due to only one parameterization */,
-    WindowTreeHostManagerTest,
-    testing::Values(MaterialDesignController::NON_MATERIAL,
-                    MaterialDesignController::MATERIAL_NORMAL,
-                    MaterialDesignController::MATERIAL_EXPERIMENTAL));
-
 TEST_F(WindowTreeHostManagerShutdownTest, Shutdown) {
   UpdateDisplay("444x333, 200x200");
 }
 
 TEST_F(WindowTreeHostManagerStartupTest, Startup) {
   EXPECT_TRUE(startup_helper()->displays_initialized());
 }
 
-TEST_P(WindowTreeHostManagerTest, SecondaryDisplayLayout) {
+TEST_F(WindowTreeHostManagerTest, SecondaryDisplayLayout) {
   // Creates windows to catch activation change event.
   std::unique_ptr<aura::Window> w1(CreateTestWindowInShellWithId(1));
   w1->Focus();
 
   TestObserver observer;
   UpdateDisplay("500x500,400x400");
   EXPECT_EQ(1, observer.CountAndReset());  // resize and add
   EXPECT_EQ(1, observer.GetBoundsChangedCountAndReset());
   EXPECT_EQ(2, observer.GetWorkareaChangedCountAndReset());
   EXPECT_EQ(0, observer.GetFocusChangedCountAndReset());
@@ skipping 141 matching lines @@
     int64_t id,
     float device_scale_factor) {
   display::ManagedDisplayInfo info =
       CreateDisplayInfo(id, 0, display::Display::ROTATE_0);
   info.set_device_scale_factor(device_scale_factor);
   return info;
 }
 
 }  // namespace
 
-TEST_P(WindowTreeHostManagerTest, MirrorToDockedWithFullscreen) {
+TEST_F(WindowTreeHostManagerTest, MirrorToDockedWithFullscreen) {
   // Creates windows to catch activation change event.
   std::unique_ptr<aura::Window> w1(CreateTestWindowInShellWithId(1));
   w1->Focus();
 
   // Docked mode.
 
   const display::ManagedDisplayInfo internal_display_info =
       CreateMirroredDisplayInfo(1, 2.0f);
   const display::ManagedDisplayInfo external_display_info =
       CreateMirroredDisplayInfo(2, 1.0f);
@@ skipping 28 matching lines @@
   EXPECT_EQ(1, observer.GetWorkareaChangedCountAndReset());
   EXPECT_EQ(1, observer.GetPrimaryChangedCountAndReset());
   EXPECT_EQ(1, observer.CountAndReset());
   EXPECT_EQ(0, observer.GetFocusChangedCountAndReset());
   EXPECT_EQ(0, observer.GetActivationChangedCountAndReset());
 
   EXPECT_TRUE(window_state->IsFullscreen());
   EXPECT_EQ("0,0 500x500", w1->bounds().ToString());
 }
 
-TEST_P(WindowTreeHostManagerTest, BoundsUpdated) {
+TEST_F(WindowTreeHostManagerTest, BoundsUpdated) {
   // Creates windows to catch activation change event.
   std::unique_ptr<aura::Window> w1(CreateTestWindowInShellWithId(1));
   w1->Focus();
 
   TestObserver observer;
   SetDefaultDisplayLayout(display::DisplayPlacement::BOTTOM);
   UpdateDisplay("200x200,300x300");  // layout, resize and add.
   EXPECT_EQ(1, observer.CountAndReset());
   EXPECT_EQ(0, observer.GetFocusChangedCountAndReset());
   EXPECT_EQ(0, observer.GetActivationChangedCountAndReset());
@@ skipping 89 matching lines @@
   EXPECT_EQ(0, observer.CountAndReset());
   EXPECT_EQ(0, observer.GetFocusChangedCountAndReset());
   EXPECT_EQ(0, observer.GetActivationChangedCountAndReset());
   display::test::DisplayManagerTestApi(display_manager())
       .SetDisplayUIScale(primary_id, 1.125f);
   EXPECT_EQ(0, observer.CountAndReset());
   EXPECT_EQ(0, observer.GetFocusChangedCountAndReset());
   EXPECT_EQ(0, observer.GetActivationChangedCountAndReset());
 }
 
-TEST_P(WindowTreeHostManagerTest, FindNearestDisplay) {
+TEST_F(WindowTreeHostManagerTest, FindNearestDisplay) {
   WindowTreeHostManager* window_tree_host_manager =
       Shell::GetInstance()->window_tree_host_manager();
 
   UpdateDisplay("200x200,300x300");
   display_manager()->SetLayoutForCurrentDisplays(
       display::test::CreateDisplayLayout(display_manager(),
                                          display::DisplayPlacement::RIGHT, 50));
 
   display::Display primary_display =
       display::Screen::GetScreen()->GetPrimaryDisplay();
@@ skipping 38 matching lines @@
   EXPECT_EQ(secondary_display.id(),
             display::Screen::GetScreen()
                 ->GetDisplayNearestPoint(gfx::Point(176, 225))
                 .id());
   EXPECT_EQ(secondary_display.id(),
             display::Screen::GetScreen()
                 ->GetDisplayNearestPoint(gfx::Point(300, 400))
                 .id());
 }
 
-TEST_P(WindowTreeHostManagerTest, SwapPrimaryById) {
-  const int height_offset = GetMdMaximizedWindowHeightOffset();
-
+TEST_F(WindowTreeHostManagerTest, SwapPrimaryById) {
   WindowTreeHostManager* window_tree_host_manager =
       Shell::GetInstance()->window_tree_host_manager();
 
   UpdateDisplay("200x200,300x300");
   display::Display primary_display =
       display::Screen::GetScreen()->GetPrimaryDisplay();
   display::Display secondary_display = display_manager()->GetSecondaryDisplay();
 
   display_manager()->SetLayoutForCurrentDisplays(
       display::test::CreateDisplayLayout(display_manager(),
@@ skipping 12 matching lines @@
   EXPECT_NE(primary_root, secondary_root);
   EXPECT_EQ(primary_display.id(),
             display::Screen::GetScreen()
                 ->GetDisplayNearestPoint(gfx::Point(-100, -100))
                 .id());
   EXPECT_EQ(
       primary_display.id(),
       display::Screen::GetScreen()->GetDisplayNearestWindow(nullptr).id());
 
   EXPECT_EQ("0,0 200x200", primary_display.bounds().ToString());
-  EXPECT_EQ(gfx::Rect(0, 0, 200, 153 + height_offset).ToString(),
+  EXPECT_EQ(gfx::Rect(0, 0, 200, 152).ToString(),
             primary_display.work_area().ToString());
   EXPECT_EQ("200,0 300x300", secondary_display.bounds().ToString());
-  EXPECT_EQ(gfx::Rect(200, 0, 300, 253 + height_offset).ToString(),
+  EXPECT_EQ(gfx::Rect(200, 0, 300, 252).ToString(),
             secondary_display.work_area().ToString());
   EXPECT_EQ("id=2200000001, parent=2200000000, right, 50",
             display_manager()
                 ->GetCurrentDisplayLayout()
                 .placement_list[0]
                 .ToString());
 
   // Switch primary and secondary by display ID.
   TestObserver observer;
   window_tree_host_manager->SetPrimaryDisplayId(secondary_display.id());
@@ skipping 13 matching lines @@
   const display::DisplayLayout& inverted_layout =
       display_manager()->GetCurrentDisplayLayout();
 
   EXPECT_EQ("id=2200000000, parent=2200000001, left, -50",
             inverted_layout.placement_list[0].ToString());
   // Test if the bounds are correctly swapped.
   display::Display swapped_primary =
       display::Screen::GetScreen()->GetPrimaryDisplay();
   display::Display swapped_secondary = display_manager()->GetSecondaryDisplay();
   EXPECT_EQ("0,0 300x300", swapped_primary.bounds().ToString());
-  EXPECT_EQ(gfx::Rect(0, 0, 300, 253 + height_offset).ToString(),
+  EXPECT_EQ(gfx::Rect(0, 0, 300, 252).ToString(),
             swapped_primary.work_area().ToString());
   EXPECT_EQ("-200,-50 200x200", swapped_secondary.bounds().ToString());
-  EXPECT_EQ(gfx::Rect(-200, -50, 200, 153 + height_offset).ToString(),
+  EXPECT_EQ(gfx::Rect(-200, -50, 200, 152).ToString(),
             swapped_secondary.work_area().ToString());
 
   // Calling the same ID don't do anything.
   window_tree_host_manager->SetPrimaryDisplayId(secondary_display.id());
   EXPECT_EQ(0, observer.CountAndReset());
 
   aura::WindowTracker tracker;
   tracker.Add(primary_root);
   tracker.Add(secondary_root);
 
@@ skipping 54 matching lines @@
             display::Screen::GetScreen()->GetPrimaryDisplay().id());
   EXPECT_EQ(third_display_info.id(),
             display_manager()->GetSecondaryDisplay().id());
   EXPECT_EQ(primary_root, window_tree_host_manager->GetRootWindowForDisplayId(
                               primary_display.id()));
   EXPECT_NE(primary_root, window_tree_host_manager->GetRootWindowForDisplayId(
                               third_display_info.id()));
   EXPECT_TRUE(primary_root->Contains(shelf_window));
 }
 
-TEST_P(WindowTreeHostManagerTest, SetPrimaryWithThreeDisplays) {
+TEST_F(WindowTreeHostManagerTest, SetPrimaryWithThreeDisplays) {
   UpdateDisplay("500x400,400x300,300x200");
   int64_t primary_id = display::Screen::GetScreen()->GetPrimaryDisplay().id();
   display::DisplayIdList non_primary_ids =
       display_manager()->GetCurrentDisplayIdList();
   auto itr =
       std::remove(non_primary_ids.begin(), non_primary_ids.end(), primary_id);
   ASSERT_TRUE(itr != non_primary_ids.end());
   non_primary_ids.erase(itr, non_primary_ids.end());
   ASSERT_EQ(2u, non_primary_ids.size());
 
@@ skipping 99 matching lines @@
               current_layout.placement_list[0].parent_display_id);
     EXPECT_EQ(display::DisplayPlacement::TOP,
               current_layout.placement_list[0].position);
     EXPECT_EQ(non_primary_ids[0], current_layout.placement_list[1].display_id);
     EXPECT_EQ(primary_id, current_layout.placement_list[1].parent_display_id);
     EXPECT_EQ(display::DisplayPlacement::RIGHT,
               current_layout.placement_list[1].position);
   }
 }
 
-TEST_P(WindowTreeHostManagerTest, SetPrimaryWithFourDisplays) {
+TEST_F(WindowTreeHostManagerTest, SetPrimaryWithFourDisplays) {
   UpdateDisplay("600x500,500x400,400x300,300x200");
   int64_t primary_id = display::Screen::GetScreen()->GetPrimaryDisplay().id();
   display::DisplayIdList non_primary_ids =
       display_manager()->GetCurrentDisplayIdList();
   auto itr =
       std::remove(non_primary_ids.begin(), non_primary_ids.end(), primary_id);
   ASSERT_TRUE(itr != non_primary_ids.end());
   non_primary_ids.erase(itr, non_primary_ids.end());
   ASSERT_EQ(3u, non_primary_ids.size());
 
@@ skipping 88 matching lines @@
     EXPECT_EQ(display::DisplayPlacement::RIGHT,
               current_layout.placement_list[1].position);
     EXPECT_EQ(non_primary_ids[2], current_layout.placement_list[2].display_id);
     EXPECT_EQ(non_primary_ids[0],
               current_layout.placement_list[2].parent_display_id);
     EXPECT_EQ(display::DisplayPlacement::RIGHT,
               current_layout.placement_list[2].position);
   }
 }
 
-TEST_P(WindowTreeHostManagerTest, OverscanInsets) {
+TEST_F(WindowTreeHostManagerTest, OverscanInsets) {
   WindowTreeHostManager* window_tree_host_manager =
       Shell::GetInstance()->window_tree_host_manager();
   TestEventHandler event_handler;
   Shell::GetInstance()->AddPreTargetHandler(&event_handler);
 
   UpdateDisplay("120x200,300x400*2");
   display::Display display1 = display::Screen::GetScreen()->GetPrimaryDisplay();
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 
   window_tree_host_manager->SetOverscanInsets(display1.id(),
@@ skipping 26 matching lines @@
 
   SwapPrimaryDisplay();
   point.SetPoint(0, 0);
   Shell::GetAllRootWindows()[1]->GetHost()->GetRootTransform().TransformPoint(
       &point);
   EXPECT_EQ("15,10", point.ToString());
 
   Shell::GetInstance()->RemovePreTargetHandler(&event_handler);
 }
 
-TEST_P(WindowTreeHostManagerTest, Rotate) {
+TEST_F(WindowTreeHostManagerTest, Rotate) {
   TestEventHandler event_handler;
   Shell::GetInstance()->AddPreTargetHandler(&event_handler);
 
   UpdateDisplay("120x200,300x400*2");
   display::Display display1 = display::Screen::GetScreen()->GetPrimaryDisplay();
   int64_t display2_id = display_manager()->GetSecondaryDisplay().id();
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
   ui::test::EventGenerator generator1(root_windows[0]);
 
   TestObserver observer;
@@ skipping 58 matching lines @@
   EXPECT_EQ(display::Display::ROTATE_270,
             GetActiveDisplayRotation(display2_id));
   EXPECT_EQ(1, observer.GetRotationChangedCountAndReset());
 
   generator1.MoveMouseToInHost(50, 40);
   EXPECT_EQ("69,159", event_handler.GetLocationAndReset());
 
   Shell::GetInstance()->RemovePreTargetHandler(&event_handler);
 }
 
-TEST_P(WindowTreeHostManagerTest, ScaleRootWindow) {
+TEST_F(WindowTreeHostManagerTest, ScaleRootWindow) {
   TestEventHandler event_handler;
   Shell::GetInstance()->AddPreTargetHandler(&event_handler);
 
   UpdateDisplay("600x400*2@1.5,500x300");
 
   display::Display display1 = display::Screen::GetScreen()->GetPrimaryDisplay();
   display::test::ScopedSetInternalDisplayId set_internal(display_manager(),
                                                          display1.id());
 
   display::Display display2 = display_manager()->GetSecondaryDisplay();
@@ skipping 14 matching lines @@
   display2 = display_manager()->GetSecondaryDisplay();
   EXPECT_EQ("0,0 375x250", display1.bounds().ToString());
   EXPECT_EQ("0,0 375x250", root_windows[0]->bounds().ToString());
   EXPECT_EQ("375,0 500x300", display2.bounds().ToString());
   EXPECT_EQ(1.25f, GetStoredUIScale(display1.id()));
   EXPECT_EQ(1.0f, GetStoredUIScale(display2.id()));
 
   Shell::GetInstance()->RemovePreTargetHandler(&event_handler);
 }
 
-TEST_P(WindowTreeHostManagerTest, TouchScale) {
+TEST_F(WindowTreeHostManagerTest, TouchScale) {
   TestEventHandler event_handler;
   Shell::GetInstance()->AddPreTargetHandler(&event_handler);
 
   UpdateDisplay("200x200*2");
   display::Display display = display::Screen::GetScreen()->GetPrimaryDisplay();
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
   aura::Window* root_window = root_windows[0];
   ui::test::EventGenerator generator(root_window);
 
   generator.PressMoveAndReleaseTouchTo(50, 50);
   // Default test touches have radius_x/y = 1.0, with device scale
   // factor = 2, the scaled radius_x/y should be 0.5.
   EXPECT_EQ(0.5, event_handler.touch_radius_x());
   EXPECT_EQ(0.5, event_handler.touch_radius_y());
 
   generator.ScrollSequence(gfx::Point(0, 0),
                            base::TimeDelta::FromMilliseconds(100), 10.0, 1.0, 5,
                            1);
 
   // ordinal_offset is invariant to the device scale factor.
   EXPECT_EQ(event_handler.scroll_x_offset(),
             event_handler.scroll_x_offset_ordinal());
   EXPECT_EQ(event_handler.scroll_y_offset(),
             event_handler.scroll_y_offset_ordinal());
 
   Shell::GetInstance()->RemovePreTargetHandler(&event_handler);
 }
 
-TEST_P(WindowTreeHostManagerTest, ConvertHostToRootCoords) {
+TEST_F(WindowTreeHostManagerTest, ConvertHostToRootCoords) {
   TestEventHandler event_handler;
   Shell::GetInstance()->AddPreTargetHandler(&event_handler);
 
   UpdateDisplay("600x400*2/r@1.5");
 
   display::Display display1 = display::Screen::GetScreen()->GetPrimaryDisplay();
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
   EXPECT_EQ("0,0 300x450", display1.bounds().ToString());
   EXPECT_EQ("0,0 300x450", root_windows[0]->bounds().ToString());
   EXPECT_EQ(1.5f, GetStoredUIScale(display1.id()));
@@ skipping 38 matching lines @@
   generator.MoveMouseToInHost(599, 399);
   EXPECT_EQ("0,449", event_handler.GetLocationAndReset());
   generator.MoveMouseToInHost(0, 399);
   EXPECT_EQ("0,0", event_handler.GetLocationAndReset());
 
   Shell::GetInstance()->RemovePreTargetHandler(&event_handler);
 }
 
 // Make sure that the compositor based mirroring can switch
 // from/to dock mode.
-TEST_P(WindowTreeHostManagerTest, DockToSingle) {
+TEST_F(WindowTreeHostManagerTest, DockToSingle) {
   const int64_t internal_id = 1;
 
   const display::ManagedDisplayInfo internal_display_info =
       CreateDisplayInfo(internal_id, 0, display::Display::ROTATE_0);
   const display::ManagedDisplayInfo external_display_info =
       CreateDisplayInfo(2, 1, display::Display::ROTATE_90);
 
   std::vector<display::ManagedDisplayInfo> display_info_list;
   // Extended
   display_info_list.push_back(internal_display_info);
@@ skipping 21 matching lines @@
   display_info_list.push_back(internal_display_info);
   display_manager()->OnNativeDisplaysChanged(display_info_list);
   EXPECT_TRUE(Shell::GetPrimaryRootWindow()
                   ->GetHost()
                   ->GetRootTransform()
                   .IsIdentityOrIntegerTranslation());
 }
 
 // Tests if switching two displays at the same time while the primary display
 // is swapped should not cause a crash. (crbug.com/426292)
-TEST_P(WindowTreeHostManagerTest, ReplaceSwappedPrimary) {
+TEST_F(WindowTreeHostManagerTest, ReplaceSwappedPrimary) {
   const display::ManagedDisplayInfo first_display_info =
       CreateDisplayInfo(10, 0, display::Display::ROTATE_0);
   const display::ManagedDisplayInfo second_display_info =
       CreateDisplayInfo(11, 1, display::Display::ROTATE_0);
 
   std::vector<display::ManagedDisplayInfo> display_info_list;
   // Extended
   display_info_list.push_back(first_display_info);
   display_info_list.push_back(second_display_info);
   display_manager()->OnNativeDisplaysChanged(display_info_list);
@@ skipping 39 matching lines @@
 };
 
 }  // names
 
 // Make sure that GetDisplayBoundsWithShelf returns the correct bounds
 // when the primary display gets replaced in one of the following scenarios:
 // 1) Two displays connected: a) b)
 // 2) both are disconnected and new one with the same size as b) is connected
 // in one configuration event.
 // See crbug.com/547280.
-TEST_P(WindowTreeHostManagerTest, ReplacePrimary) {
+TEST_F(WindowTreeHostManagerTest, ReplacePrimary) {
   display::ManagedDisplayInfo first_display_info =
       CreateDisplayInfo(10, 0, display::Display::ROTATE_0);
   first_display_info.SetBounds(gfx::Rect(0, 0, 400, 400));
   const display::ManagedDisplayInfo second_display_info =
       CreateDisplayInfo(11, 500, display::Display::ROTATE_0);
 
   std::vector<display::ManagedDisplayInfo> display_info_list;
   // Extended
   display_info_list.push_back(first_display_info);
   display_info_list.push_back(second_display_info);
   display_manager()->OnNativeDisplaysChanged(display_info_list);
   aura::Window* primary_root = Shell::GetAllRootWindows()[0];
 
   int64_t new_display_id = 20;
   RootWindowTestObserver test_observer;
   primary_root->AddObserver(&test_observer);
 
   display_info_list.clear();
   const display::ManagedDisplayInfo new_first_display_info =
       CreateDisplayInfo(new_display_id, 0, display::Display::ROTATE_0);
 
   display_info_list.push_back(new_first_display_info);
   display_manager()->OnNativeDisplaysChanged(display_info_list);
   EXPECT_EQ("0,0 500x500", test_observer.shelf_display_bounds().ToString());
   primary_root->RemoveObserver(&test_observer);
 }
 
-TEST_P(WindowTreeHostManagerTest, UpdateMouseLocationAfterDisplayChange) {
+TEST_F(WindowTreeHostManagerTest, UpdateMouseLocationAfterDisplayChange) {
   UpdateDisplay("200x200,300x300");
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 
   aura::Env* env = aura::Env::GetInstance();
 
   ui::test::EventGenerator generator(root_windows[0]);
 
   // Set the initial position.
   generator.MoveMouseToInHost(350, 150);
   EXPECT_EQ("350,150", env->last_mouse_location().ToString());
@@ skipping 19 matching lines @@
 
   // Move the mouse pointer to the bottom of 1st display.
   generator.MoveMouseToInHost(150, 290);
   EXPECT_EQ("150,290", env->last_mouse_location().ToString());
 
   // The mouse pointer is now on 2nd display.
   UpdateDisplay("300x280,200x200");
   EXPECT_EQ("450,10", env->last_mouse_location().ToString());
 }
 
-TEST_P(WindowTreeHostManagerTest,
+TEST_F(WindowTreeHostManagerTest,
        UpdateMouseLocationAfterDisplayChange_2ndOnLeft) {
   // Set the 2nd display on the left.
   display::DisplayLayoutStore* layout_store = display_manager()->layout_store();
   display::DisplayPlacement new_default(display::DisplayPlacement::LEFT, 0);
   layout_store->SetDefaultDisplayPlacement(new_default);
 
   UpdateDisplay("200x200,300x300");
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 
   EXPECT_EQ("-300,0 300x300",
@@ skipping 15 matching lines @@
   EXPECT_EQ("-100,50", env->last_mouse_location().ToString());
 
   // 2nd display was disconnected. Mouse pointer should move to
   // 1st display.
   UpdateDisplay("300x300");
   EXPECT_EQ("150,150", env->last_mouse_location().ToString());
 }
 
 // Test that the cursor swaps displays and that its scale factor and rotation
 // are updated when the primary display is swapped.
-TEST_P(WindowTreeHostManagerTest,
+TEST_F(WindowTreeHostManagerTest,
        UpdateMouseLocationAfterDisplayChange_SwapPrimary) {
   UpdateDisplay("200x200,200x200*2/r");
 
   aura::Env* env = aura::Env::GetInstance();
   Shell* shell = Shell::GetInstance();
   WindowTreeHostManager* window_tree_host_manager =
       shell->window_tree_host_manager();
   test::CursorManagerTestApi test_api(shell->cursor_manager());
 
   window_tree_host_manager->GetPrimaryRootWindow()->MoveCursorTo(
       gfx::Point(20, 50));
 
   EXPECT_EQ("20,50", env->last_mouse_location().ToString());
   EXPECT_EQ(1.0f, test_api.GetCurrentCursor().device_scale_factor());
   EXPECT_EQ(display::Display::ROTATE_0, test_api.GetCurrentCursorRotation());
 
   SwapPrimaryDisplay();
 
   EXPECT_EQ("20,50", env->last_mouse_location().ToString());
   EXPECT_EQ(2.0f, test_api.GetCurrentCursor().device_scale_factor());
   EXPECT_EQ(display::Display::ROTATE_90, test_api.GetCurrentCursorRotation());
 }
 
 // Test that the cursor moves to the other display and that its scale factor
 // and rotation are updated when the primary display is disconnected.
-TEST_P(WindowTreeHostManagerTest,
+TEST_F(WindowTreeHostManagerTest,
        UpdateMouseLocationAfterDisplayChange_PrimaryDisconnected) {
   aura::Env* env = aura::Env::GetInstance();
   Shell* shell = Shell::GetInstance();
   WindowTreeHostManager* window_tree_host_manager =
       shell->window_tree_host_manager();
   test::CursorManagerTestApi test_api(shell->cursor_manager());
 
   UpdateDisplay("300x300*2/r,200x200");
   // Swap the primary display to make it possible to remove the primary display
   // via UpdateDisplay().
@@ skipping 12 matching lines @@
             window_tree_host_manager->GetPrimaryDisplayId());
 
   // Cursor should be centered on the remaining display.
   EXPECT_EQ("75,75", env->last_mouse_location().ToString());
   EXPECT_EQ(2.0f, test_api.GetCurrentCursor().device_scale_factor());
   EXPECT_EQ(display::Display::ROTATE_90, test_api.GetCurrentCursorRotation());
 }
 
 // GetRootWindowForDisplayId() for removed display::Display during
 // OnDisplayRemoved() should not cause crash. See http://crbug.com/415222
-TEST_P(WindowTreeHostManagerTest,
+TEST_F(WindowTreeHostManagerTest,
        GetRootWindowForDisplayIdDuringDisplayDisconnection) {
   UpdateDisplay("300x300,200x200");
   aura::Window* root2 = Shell::GetInstance()
                             ->window_tree_host_manager()
                             ->GetRootWindowForDisplayId(
                                 display_manager()->GetSecondaryDisplay().id());
   views::Widget* widget = views::Widget::CreateWindowWithContextAndBounds(
       nullptr, root2, gfx::Rect(350, 0, 100, 100));
   views::View* view = new views::View();
   widget->GetContentsView()->AddChildView(view);
   view->SetBounds(0, 0, 100, 100);
   widget->Show();
 
   TestMouseWatcherListener listener;
   views::MouseWatcher watcher(
       new views::MouseWatcherViewHost(view, gfx::Insets()), &listener);
   watcher.Start();
 
   ui::test::EventGenerator event_generator(
       widget->GetNativeWindow()->GetRootWindow());
   event_generator.MoveMouseToCenterOf(widget->GetNativeWindow());
 
   UpdateDisplay("300x300");
   watcher.Stop();
 
   widget->CloseNow();
 }
 
 }  // namespace ash