Parameterize Ash unittests to pass with material design enabled

ash/display/display_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/display_manager.h"
 
+#include "ash/common/material_design/material_design_controller.h"
 #include "ash/accelerators/accelerator_commands.h"
 #include "ash/ash_switches.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/display/display_configuration_controller.h"
 #include "ash/display/display_info.h"
 #include "ash/display/display_layout_store.h"
 #include "ash/display/display_util.h"
 #include "ash/display/mirror_window_controller.h"
 #include "ash/display/window_tree_host_manager.h"
 #include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/test/display_manager_test_api.h"
+#include "ash/test/material_design_controller_test_api.h"
 #include "ash/test/mirror_window_test_api.h"
 #include "ash/wm/window_state_aura.h"
 #include "base/command_line.h"
 #include "base/format_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "grit/ash_strings.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window_observer.h"
@@ skipping 14 matching lines @@
 using base::StringPrintf;
 
 namespace {
 
 std::string ToDisplayName(int64_t id) {
   return "x-" + base::Int64ToString(id);
 }
 
 }  // namespace
 
-class DisplayManagerTest : public test::AshTestBase,
-                           public display::DisplayObserver,
-                           public aura::WindowObserver {
+class DisplayManagerTest
+    : public test::AshTestBase,
+      public display::DisplayObserver,
+      public aura::WindowObserver,
+      public testing::WithParamInterface<ash::MaterialDesignController::Mode> {

[varkha, 2016/06/16 02:55:05]

Here and in other fixtures that inherit from testing::WithParamInterface<Mode>:
Does it make sense to derive from AshMDTestBase and inherit the
material_design_state_ and offset?

[James Cook, 2016/06/16 16:08:56]

+1

[tdanderson, 2016/06/21 19:52:20]

Done.

  public:
   DisplayManagerTest()
       : removed_count_(0U),
         root_window_destroyed_(false),
-        changed_metrics_(0U) {
+        changed_metrics_(0U),
+        md_docked_window_height_offset_(0) {
   }
   ~DisplayManagerTest() override {}
 
   void SetUp() override {
     AshTestBase::SetUp();
+    material_design_state_.reset(
+        new test::MaterialDesignControllerTestAPI(GetParam()));
+    md_docked_window_height_offset_ =
+        ash::MaterialDesignController::IsMaterial() ? -1 : 0;
     display::Screen::GetScreen()->AddObserver(this);
     Shell::GetPrimaryRootWindow()->AddObserver(this);
   }
   void TearDown() override {
     Shell::GetPrimaryRootWindow()->RemoveObserver(this);
     display::Screen::GetScreen()->RemoveObserver(this);
+    material_design_state_.reset();
     AshTestBase::TearDown();
   }
 
   DisplayManager* display_manager() {
     return Shell::GetInstance()->display_manager();
   }
   const vector<display::Display>& changed() const { return changed_; }
   const vector<display::Display>& added() const { return added_; }
   uint32_t changed_metrics() const { return changed_metrics_; }
 
@@ skipping 23 matching lines @@
   }
 
   const display::Display& GetDisplayForId(int64_t id) {
     return display_manager()->GetDisplayForId(id);
   }
 
   const DisplayInfo& GetDisplayInfoForId(int64_t id) {
     return GetDisplayInfo(display_manager()->GetDisplayForId(id));
   }
 
+  int GetMdDockedWindowHeightOffset() {
+    return md_docked_window_height_offset_;
+  }
+
   // aura::DisplayObserver overrides:
   void OnDisplayMetricsChanged(const display::Display& display,
                                uint32_t changed_metrics) override {
     changed_.push_back(display);
     changed_metrics_ |= changed_metrics;
   }
   void OnDisplayAdded(const display::Display& new_display) override {
     added_.push_back(new_display);
   }
   void OnDisplayRemoved(const display::Display& old_display) override {
     ++removed_count_;
   }
 
   // aura::WindowObserver overrides:
   void OnWindowDestroying(aura::Window* window) override {
     ASSERT_EQ(Shell::GetPrimaryRootWindow(), window);
     root_window_destroyed_ = true;
   }
 
  private:
   vector<display::Display> changed_;
   vector<display::Display> added_;
   size_t removed_count_;
   bool root_window_destroyed_;
   uint32_t changed_metrics_;
+  std::unique_ptr<test::MaterialDesignControllerTestAPI>
+      material_design_state_;
+
+  // The material design shelf is taller (by 1px) so use this offset to
+  // adjust the expected height of a docked window.
+  int md_docked_window_height_offset_;
 
   DISALLOW_COPY_AND_ASSIGN(DisplayManagerTest);
 };
 
-TEST_F(DisplayManagerTest, UpdateDisplayTest) {
+// Note: First argument is optional and intentionally left blank.
+// (it's a prefix for the generated test cases)
+INSTANTIATE_TEST_CASE_P(
+    ,
+    DisplayManagerTest,
+    testing::Values(ash::MaterialDesignController::NON_MATERIAL,
+                    ash::MaterialDesignController::MATERIAL_NORMAL,
+                    ash::MaterialDesignController::MATERIAL_EXPERIMENTAL));
+
+TEST_P(DisplayManagerTest, UpdateDisplayTest) {
   if (!SupportsMultipleDisplays())
     return;
 
   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
 
   // Update primary and add seconary.
   UpdateDisplay("100+0-500x500,0+501-400x400");
   EXPECT_EQ(2U, display_manager()->GetNumDisplays());
   EXPECT_EQ("0,0 500x500",
             display_manager()->GetDisplayAt(0).bounds().ToString());
@@ skipping 81 matching lines @@
   // Changing primary will update secondary as well.
   UpdateDisplay("0+0-800x600,1000+1000-600x400");
   EXPECT_EQ("2 0 0", GetCountSummary());
   reset();
   EXPECT_EQ("0,0 800x600",
             display_manager()->GetDisplayAt(0).bounds().ToString());
   EXPECT_EQ("800,0 600x400",
             display_manager()->GetDisplayAt(1).bounds().ToString());
 }
 
-TEST_F(DisplayManagerTest, ScaleOnlyChange) {
+TEST_P(DisplayManagerTest, ScaleOnlyChange) {
   if (!SupportsMultipleDisplays())
     return;
   display_manager()->ToggleDisplayScaleFactor();
   EXPECT_TRUE(changed_metrics() &
               display::DisplayObserver::DISPLAY_METRIC_BOUNDS);
   EXPECT_TRUE(changed_metrics() &
               display::DisplayObserver::DISPLAY_METRIC_WORK_AREA);
 }
 
 // Test in emulation mode (use_fullscreen_host_window=false)
-TEST_F(DisplayManagerTest, EmulatorTest) {
+TEST_P(DisplayManagerTest, EmulatorTest) {
   if (!SupportsMultipleDisplays())
     return;
 
   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
 
   display_manager()->AddRemoveDisplay();
   // Update primary and add seconary.
   EXPECT_EQ(2U, display_manager()->GetNumDisplays());
   EXPECT_EQ("0 1 0", GetCountSummary());
   reset();
 
   display_manager()->AddRemoveDisplay();
   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
   EXPECT_EQ("0 0 1", GetCountSummary());
   reset();
 
   display_manager()->AddRemoveDisplay();
   EXPECT_EQ(2U, display_manager()->GetNumDisplays());
   EXPECT_EQ("0 1 0", GetCountSummary());
 }
 
 // Tests support for 3 displays.
-TEST_F(DisplayManagerTest, UpdateThreeDisplaysWithDefaultLayout) {
+TEST_P(DisplayManagerTest, UpdateThreeDisplaysWithDefaultLayout) {
   if (!SupportsMultipleDisplays())
     return;
 
   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
 
   // Test with three displays. Native origin will not affect ash
   // display layout.
   UpdateDisplay("0+0-640x480,1000+0-320x200,2000+0-400x300");
 
   EXPECT_EQ(3U, display_manager()->GetNumDisplays());
@@ skipping 37 matching lines @@
   UpdateDisplay("640x480,320x200,400x300");
 
   EXPECT_EQ("0,0 640x480",
             display_manager()->GetDisplayAt(0).bounds().ToString());
   EXPECT_EQ("10,480 320x200",
             display_manager()->GetDisplayAt(1).bounds().ToString());
   EXPECT_EQ("20,680 400x300",
             display_manager()->GetDisplayAt(2).bounds().ToString());
 }
 
-TEST_F(DisplayManagerTest, LayoutMorethanThreeDisplaysTest) {
+TEST_P(DisplayManagerTest, LayoutMorethanThreeDisplaysTest) {
   if (!SupportsMultipleDisplays())
     return;
 
   int64_t primary_id = display::Screen::GetScreen()->GetPrimaryDisplay().id();
   display::DisplayIdList list = ash::test::CreateDisplayIdListN(
       3, primary_id, primary_id + 1, primary_id + 2);
   {
     // Layout: [2]
     //         [1][P]
     display::DisplayLayoutBuilder builder(primary_id);
@@ skipping 94 matching lines @@
               display_manager()->GetDisplayAt(4).bounds().ToString());
     // 3rd is the left of 4th.
     EXPECT_EQ("-290,480 300x200",
               display_manager()->GetDisplayAt(3).bounds().ToString());
     // 1st is the bottom of 3rd.
     EXPECT_EQ("-280,680 320x200",
               display_manager()->GetDisplayAt(1).bounds().ToString());
   }
 }
 
-TEST_F(DisplayManagerTest, NoMirrorInThreeDisplays) {
+TEST_P(DisplayManagerTest, NoMirrorInThreeDisplays) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("640x480,320x200,400x300");
   ash::Shell::GetInstance()->display_configuration_controller()->SetMirrorMode(
       true, true);
   EXPECT_FALSE(display_manager()->IsInMirrorMode());
   EXPECT_EQ(3u, display_manager()->GetNumDisplays());
 #if defined(OS_CHROMEOS)
   EXPECT_EQ(l10n_util::GetStringUTF16(IDS_ASH_DISPLAY_MIRRORING_NOT_SUPPORTED),
             GetDisplayErrorNotificationMessageForTest());
 #endif
 }
 
-TEST_F(DisplayManagerTest, OverscanInsetsTest) {
+TEST_P(DisplayManagerTest, OverscanInsetsTest) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("0+0-500x500,0+501-400x400");
   reset();
   ASSERT_EQ(2u, display_manager()->GetNumDisplays());
   const DisplayInfo& display_info1 = GetDisplayInfoAt(0);
   const DisplayInfo& display_info2 = GetDisplayInfoAt(1);
   display_manager()->SetOverscanInsets(
       display_info2.id(), gfx::Insets(13, 12, 11, 10));
@@ skipping 112 matching lines @@
   display_manager()->SetOverscanInsets(primary_id, gfx::Insets(0, 0, 0, 0));
   EXPECT_TRUE(changed_metrics() &
               display::DisplayObserver::DISPLAY_METRIC_BOUNDS);
   EXPECT_TRUE(changed_metrics() &
               display::DisplayObserver::DISPLAY_METRIC_WORK_AREA);
   EXPECT_EQ(
       "0,0 500x500",
       display::Screen::GetScreen()->GetPrimaryDisplay().bounds().ToString());
 }
 
-TEST_F(DisplayManagerTest, ZeroOverscanInsets) {
+TEST_P(DisplayManagerTest, ZeroOverscanInsets) {
   if (!SupportsMultipleDisplays())
     return;
 
   // Make sure the display change events is emitted for overscan inset changes.
   UpdateDisplay("0+0-500x500,0+501-400x400");
   ASSERT_EQ(2u, display_manager()->GetNumDisplays());
   int64_t display2_id = display_manager()->GetDisplayAt(1).id();
 
   reset();
   display_manager()->SetOverscanInsets(display2_id, gfx::Insets(0, 0, 0, 0));
   EXPECT_EQ(0u, changed().size());
 
   reset();
   display_manager()->SetOverscanInsets(display2_id, gfx::Insets(1, 0, 0, 0));
   EXPECT_EQ(1u, changed().size());
   EXPECT_EQ(display2_id, changed()[0].id());
 
   reset();
   display_manager()->SetOverscanInsets(display2_id, gfx::Insets(0, 0, 0, 0));
   EXPECT_EQ(1u, changed().size());
   EXPECT_EQ(display2_id, changed()[0].id());
 }
 
-TEST_F(DisplayManagerTest, TestDeviceScaleOnlyChange) {
+TEST_P(DisplayManagerTest, TestDeviceScaleOnlyChange) {
   if (!SupportsHostWindowResize())
     return;
 
   UpdateDisplay("1000x600");
   aura::WindowTreeHost* host = Shell::GetPrimaryRootWindow()->GetHost();
   EXPECT_EQ(1, host->compositor()->device_scale_factor());
   EXPECT_EQ("1000x600",
             Shell::GetPrimaryRootWindow()->bounds().size().ToString());
   EXPECT_EQ("1 0 0", GetCountSummary());
 
   UpdateDisplay("1000x600*2");
   EXPECT_EQ(2, host->compositor()->device_scale_factor());
   EXPECT_EQ("2 0 0", GetCountSummary());
   EXPECT_EQ("500x300",
             Shell::GetPrimaryRootWindow()->bounds().size().ToString());
 }
 
 DisplayInfo CreateDisplayInfo(int64_t id, const gfx::Rect& bounds) {
   DisplayInfo info(id, ToDisplayName(id), false);
   info.SetBounds(bounds);
   return info;
 }
 
-TEST_F(DisplayManagerTest, TestNativeDisplaysChanged) {
+TEST_P(DisplayManagerTest, TestNativeDisplaysChanged) {
   const int64_t internal_display_id =
       test::DisplayManagerTestApi().SetFirstDisplayAsInternalDisplay();
   const int external_id = 10;
   const int mirror_id = 11;
   const int64_t invalid_id = display::Display::kInvalidDisplayID;
   const DisplayInfo internal_display_info =
       CreateDisplayInfo(internal_display_id, gfx::Rect(0, 0, 500, 500));
   const DisplayInfo external_display_info =
       CreateDisplayInfo(external_id, gfx::Rect(1, 1, 100, 100));
   const DisplayInfo mirroring_display_info =
@@ skipping 147 matching lines @@
   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
   EXPECT_EQ(
       "0,0 500x500",
       GetDisplayInfoForId(internal_display_id).bounds_in_native().ToString());
   EXPECT_EQ(1U, display_manager()->num_connected_displays());
   EXPECT_FALSE(display_manager()->IsInMirrorMode());
 }
 
 // Make sure crash does not happen if add and remove happens at the same time.
 // See: crbug.com/414394
-TEST_F(DisplayManagerTest, DisplayAddRemoveAtTheSameTime) {
+TEST_P(DisplayManagerTest, DisplayAddRemoveAtTheSameTime) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("100+0-500x500,0+501-400x400");
 
   const int64_t primary_id = WindowTreeHostManager::GetPrimaryDisplayId();
   const int64_t secondary_id = ScreenUtil::GetSecondaryDisplay().id();
 
   DisplayInfo primary_info = display_manager()->GetDisplayInfo(primary_id);
   DisplayInfo secondary_info = display_manager()->GetDisplayInfo(secondary_id);
 
   // An id which is different from primary and secondary.
   const int64_t third_id = secondary_id + 1;
 
   DisplayInfo third_info =
       CreateDisplayInfo(third_id, gfx::Rect(0, 0, 600, 600));
 
   std::vector<DisplayInfo> display_info_list;
   display_info_list.push_back(third_info);
   display_info_list.push_back(secondary_info);
   display_manager()->OnNativeDisplaysChanged(display_info_list);
 
   // Secondary seconary_id becomes the primary as it has smaller output index.
   EXPECT_EQ(secondary_id, WindowTreeHostManager::GetPrimaryDisplayId());
   EXPECT_EQ(third_id, ScreenUtil::GetSecondaryDisplay().id());
   EXPECT_EQ("600x600", GetDisplayForId(third_id).size().ToString());
 }
 
-#if defined(OS_WIN)
 // TODO(scottmg): RootWindow doesn't get resized on Windows
 // Ash. http://crbug.com/247916.
-#define MAYBE_TestNativeDisplaysChangedNoInternal \
-        DISABLED_TestNativeDisplaysChangedNoInternal
-#else
-#define MAYBE_TestNativeDisplaysChangedNoInternal \
-        TestNativeDisplaysChangedNoInternal
-#endif
-TEST_F(DisplayManagerTest, MAYBE_TestNativeDisplaysChangedNoInternal) {
+#if defined(OS_CHROMEOS)
+TEST_P(DisplayManagerTest, TestNativeDisplaysChangedNoInternal) {
   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
 
   // Don't change the display info if all displays are disconnected.
   std::vector<DisplayInfo> display_info_list;
   display_manager()->OnNativeDisplaysChanged(display_info_list);
   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
 
   // Connect another display which will become primary.
   const DisplayInfo external_display_info =
       CreateDisplayInfo(10, gfx::Rect(1, 1, 100, 100));
   display_info_list.push_back(external_display_info);
   display_manager()->OnNativeDisplaysChanged(display_info_list);
   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
   EXPECT_EQ("1,1 100x100",
             GetDisplayInfoForId(10).bounds_in_native().ToString());
   EXPECT_EQ("100x100", ash::Shell::GetPrimaryRootWindow()->GetHost()->
       GetBounds().size().ToString());
 }
+#endif  // defined(OS_CHROMEOS)
 
-TEST_F(DisplayManagerTest, NativeDisplaysChangedAfterPrimaryChange) {
+TEST_P(DisplayManagerTest, NativeDisplaysChangedAfterPrimaryChange) {
   if (!SupportsMultipleDisplays())
     return;
 
   const int64_t internal_display_id =
       test::DisplayManagerTestApi().SetFirstDisplayAsInternalDisplay();
   const DisplayInfo native_display_info =
       CreateDisplayInfo(internal_display_id, gfx::Rect(0, 0, 500, 500));
   const DisplayInfo secondary_display_info =
       CreateDisplayInfo(10, gfx::Rect(1, 1, 100, 100));
 
@@ skipping 13 matching lines @@
   EXPECT_EQ("0,0 100x100", GetDisplayForId(10).bounds().ToString());
 
   // OnNativeDisplaysChanged may change the display bounds.  Here makes sure
   // nothing changed if the exactly same displays are specified.
   display_manager()->OnNativeDisplaysChanged(display_info_list);
   EXPECT_EQ("-500,0 500x500",
             GetDisplayForId(internal_display_id).bounds().ToString());
   EXPECT_EQ("0,0 100x100", GetDisplayForId(10).bounds().ToString());
 }
 
-#if defined(OS_WIN)
 // TODO(msw): Broken on Windows. http://crbug.com/584038
-#define MAYBE_DontRememberBestResolution DISABLED_DontRememberBestResolution
-#else
-#define MAYBE_DontRememberBestResolution DontRememberBestResolution
-#endif
-TEST_F(DisplayManagerTest, MAYBE_DontRememberBestResolution) {
+#if defined(OS_CHROMEOS)
+TEST_P(DisplayManagerTest, DontRememberBestResolution) {
   int display_id = 1000;
   DisplayInfo native_display_info =
       CreateDisplayInfo(display_id, gfx::Rect(0, 0, 1000, 500));
   std::vector<DisplayMode> display_modes;
   display_modes.push_back(
       DisplayMode(gfx::Size(1000, 500), 58.0f, false, true));
   display_modes.push_back(
       DisplayMode(gfx::Size(800, 300), 59.0f, false, false));
   display_modes.push_back(
       DisplayMode(gfx::Size(400, 500), 60.0f, false, false));
@@ skipping 34 matching lines @@
   test::SetDisplayResolution(display_id, gfx::Size(1000, 500));
   EXPECT_TRUE(
       display_manager()->GetSelectedModeForDisplayId(display_id, &mode));
   EXPECT_EQ("1000x500", mode.size.ToString());
   EXPECT_EQ(58.0f, mode.refresh_rate);
   EXPECT_TRUE(mode.native);
   expected_mode.size = gfx::Size(1000, 500);
   EXPECT_TRUE(expected_mode.IsEquivalent(
       display_manager()->GetActiveModeForDisplayId(display_id)));
 }
+#endif  // defined(OS_CHROMEOS)
 
-#if defined(OS_WIN)
 // TODO(msw): Broken on Windows. http://crbug.com/584038
-#define MAYBE_ResolutionFallback DISABLED_ResolutionFallback
-#else
-#define MAYBE_ResolutionFallback ResolutionFallback
-#endif
-TEST_F(DisplayManagerTest, MAYBE_ResolutionFallback) {
+#if defined(OS_CHROMEOS)
+TEST_P(DisplayManagerTest, ResolutionFallback) {
   int display_id = 1000;
   DisplayInfo native_display_info =
       CreateDisplayInfo(display_id, gfx::Rect(0, 0, 1000, 500));
   std::vector<DisplayMode> display_modes;
   display_modes.push_back(
       DisplayMode(gfx::Size(1000, 500), 58.0f, false, true));
   display_modes.push_back(
       DisplayMode(gfx::Size(800, 300), 59.0f, false, false));
   display_modes.push_back(
       DisplayMode(gfx::Size(400, 500), 60.0f, false, false));
@@ skipping 33 matching lines @@
     display_manager()->OnNativeDisplaysChanged(new_display_info_list);
 
     DisplayMode mode;
     EXPECT_TRUE(
         display_manager()->GetSelectedModeForDisplayId(display_id, &mode));
     EXPECT_EQ("1000x500", mode.size.ToString());
     EXPECT_EQ(58.0f, mode.refresh_rate);
     EXPECT_TRUE(mode.native);
   }
 }
+#endif  // defined(OS_CHROMEOS)
 
-TEST_F(DisplayManagerTest, Rotate) {
+TEST_P(DisplayManagerTest, Rotate) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("100x200/r,300x400/l");
   EXPECT_EQ("1,1 100x200",
             GetDisplayInfoAt(0).bounds_in_native().ToString());
   EXPECT_EQ("200x100",
             GetDisplayInfoAt(0).size_in_pixel().ToString());
 
   EXPECT_EQ("1,201 300x400",
@@ skipping 71 matching lines @@
   display_manager()->SetDisplayRotation(
       internal_display_id, display::Display::ROTATE_180,
       display::Display::ROTATION_SOURCE_ACTIVE);
   const DisplayInfo post_rotation_info =
       display_manager()->display_info_[internal_display_id];
   EXPECT_NE(info.GetActiveRotation(), post_rotation_info.GetActiveRotation());
   EXPECT_EQ(display::Display::ROTATE_180,
             post_rotation_info.GetActiveRotation());
 }
 
-#if defined(OS_WIN)
 // TODO(msw): Broken on Windows. http://crbug.com/584038
-#define MAYBE_UIScale DISABLED_UIScale
-#else
-#define MAYBE_UIScale UIScale
-#endif
-TEST_F(DisplayManagerTest, MAYBE_UIScale) {
+#if defined(OS_CHROMEOS)
+TEST_P(DisplayManagerTest, UIScale) {
   test::ScopedDisable125DSFForUIScaling disable;
 
   UpdateDisplay("1280x800");
   int64_t display_id = display::Screen::GetScreen()->GetPrimaryDisplay().id();
   SetDisplayUIScale(display_id, 1.125f);
   EXPECT_EQ(1.0, GetDisplayInfoAt(0).configured_ui_scale());
   SetDisplayUIScale(display_id, 0.8f);
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).configured_ui_scale());
   SetDisplayUIScale(display_id, 0.75f);
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).configured_ui_scale());
@@ skipping 72 matching lines @@
   // 1.25 ui scaling on 1.25 DSF device should use 1.0 DSF
   // on screen.
   UpdateDisplay("1280x850*1.25");
   SetDisplayUIScale(display_id, 1.25f);
   EXPECT_EQ(1.25f, GetDisplayInfoAt(0).configured_ui_scale());
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).GetEffectiveUIScale());
   display = display::Screen::GetScreen()->GetPrimaryDisplay();
   EXPECT_EQ(1.0f, display.device_scale_factor());
   EXPECT_EQ("1280x850", display.bounds().size().ToString());
 }
+#endif  // defined(OS_CHROMEOS)
 
-TEST_F(DisplayManagerTest, UIScaleWithDisplayMode) {
+TEST_P(DisplayManagerTest, UIScaleWithDisplayMode) {
   int display_id = 1000;
 
   // Setup the display modes with UI-scale.
   DisplayInfo native_display_info =
       CreateDisplayInfo(display_id, gfx::Rect(0, 0, 1280, 800));
   const DisplayMode base_mode(gfx::Size(1280, 800), 60.0f, false, false);
   std::vector<DisplayMode> mode_list = CreateInternalDisplayModeList(base_mode);
   native_display_info.SetDisplayModes(mode_list);
 
   std::vector<DisplayInfo> display_info_list;
@@ skipping 37 matching lines @@
   EXPECT_EQ(0.625f, GetDisplayInfoAt(0).configured_ui_scale());
   EXPECT_TRUE(expected_mode.IsEquivalent(
       display_manager()->GetActiveModeForDisplayId(display_id)));
   SetDisplayUIScale(display_id, 0.5f);
   EXPECT_EQ(0.5f, GetDisplayInfoAt(0).configured_ui_scale());
   expected_mode.ui_scale = 0.5f;
   EXPECT_TRUE(expected_mode.IsEquivalent(
       display_manager()->GetActiveModeForDisplayId(display_id)));
 }
 
-#if defined(OS_WIN) && !defined(USE_ASH)
 // TODO(msw): Broken on Windows. http://crbug.com/584038
-#define MAYBE_Use125DSFForUIScaling DISABLED_Use125DSFForUIScaling
-#else
-#define MAYBE_Use125DSFForUIScaling Use125DSFForUIScaling
-#endif
-TEST_F(DisplayManagerTest, MAYBE_Use125DSFForUIScaling) {
+#if defined(OS_CHROMEOS)
+TEST_P(DisplayManagerTest, Use125DSFForUIScaling) {
   int64_t display_id = display::Screen::GetScreen()->GetPrimaryDisplay().id();
 
   test::ScopedSetInternalDisplayId set_internal(display_id);
   UpdateDisplay("1920x1080*1.25");
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).GetEffectiveDeviceScaleFactor());
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).GetEffectiveUIScale());
 
   SetDisplayUIScale(display_id, 0.8f);
   EXPECT_EQ(1.25f, GetDisplayInfoAt(0).GetEffectiveDeviceScaleFactor());
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).GetEffectiveUIScale());
   EXPECT_EQ("1536x864", GetDisplayForId(display_id).size().ToString());
 
   SetDisplayUIScale(display_id, 0.5f);
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).GetEffectiveDeviceScaleFactor());
   EXPECT_EQ(0.5f, GetDisplayInfoAt(0).GetEffectiveUIScale());
   EXPECT_EQ("960x540", GetDisplayForId(display_id).size().ToString());
 
   SetDisplayUIScale(display_id, 1.25f);
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).GetEffectiveDeviceScaleFactor());
   EXPECT_EQ(1.25f, GetDisplayInfoAt(0).GetEffectiveUIScale());
   EXPECT_EQ("2400x1350", GetDisplayForId(display_id).size().ToString());
 }
+#endif  // defined(OS_CHROMEOS)
 
-#if defined(OS_WIN) && !defined(USE_ASH)
 // TODO(msw): Broken on Windows. http://crbug.com/584038
-#define MAYBE_FHD125DefaultsTo08UIScaling DISABLED_FHD125DefaultsTo08UIScaling
-#else
-#define MAYBE_FHD125DefaultsTo08UIScaling FHD125DefaultsTo08UIScaling
-#endif
-TEST_F(DisplayManagerTest, MAYBE_FHD125DefaultsTo08UIScaling) {
+#if defined(OS_CHROMEOS)
+TEST_P(DisplayManagerTest, FHD125DefaultsTo08UIScaling) {
   int64_t display_id = display::Screen::GetScreen()->GetPrimaryDisplay().id();
 
   display_id++;
   test::ScopedSetInternalDisplayId set_internal(display_id);
 
   // Setup the display modes with UI-scale.
   DisplayInfo native_display_info =
       CreateDisplayInfo(display_id, gfx::Rect(0, 0, 1920, 1080));
   native_display_info.set_device_scale_factor(1.25);
 
   const DisplayMode base_mode(gfx::Size(1920, 1080), 60.0f, false, false);
   std::vector<DisplayMode> mode_list = CreateInternalDisplayModeList(base_mode);
   native_display_info.SetDisplayModes(mode_list);
 
   std::vector<DisplayInfo> display_info_list;
   display_info_list.push_back(native_display_info);
 
   display_manager()->OnNativeDisplaysChanged(display_info_list);
 
   EXPECT_EQ(1.25f, GetDisplayInfoAt(0).GetEffectiveDeviceScaleFactor());
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).GetEffectiveUIScale());
 }
+#endif  // defined(OS_CHROMEOS)
 
-#if defined(OS_WIN) && !defined(USE_ASH)
 // TODO(msw): Broken on Windows. http://crbug.com/584038
-#define MAYBE_FHD125DefaultsTo08UIScalingNoOverride \
-  DISABLED_FHD125DefaultsTo08UIScalingNoOverride
-#else
-#define MAYBE_FHD125DefaultsTo08UIScalingNoOverride \
-  FHD125DefaultsTo08UIScalingNoOverride
-#endif
+#if defined(OS_CHROMEOS)
 // Don't default to 1.25 DSF if the user already has a prefrence stored for
 // the internal display.
-TEST_F(DisplayManagerTest, MAYBE_FHD125DefaultsTo08UIScalingNoOverride) {
+TEST_P(DisplayManagerTest, FHD125DefaultsTo08UIScalingNoOverride) {
   int64_t display_id = display::Screen::GetScreen()->GetPrimaryDisplay().id();
 
   display_id++;
   test::ScopedSetInternalDisplayId set_internal(display_id);
   const gfx::Insets dummy_overscan_insets;
   display_manager()->RegisterDisplayProperty(
       display_id, display::Display::ROTATE_0, 1.0f, &dummy_overscan_insets,
       gfx::Size(), 1.0f, ui::ColorCalibrationProfile());
 
   // Setup the display modes with UI-scale.
   DisplayInfo native_display_info =
       CreateDisplayInfo(display_id, gfx::Rect(0, 0, 1920, 1080));
   native_display_info.set_device_scale_factor(1.25);
 
   const DisplayMode base_mode(gfx::Size(1920, 1080), 60.0f, false, false);
   std::vector<DisplayMode> mode_list = CreateInternalDisplayModeList(base_mode);
   native_display_info.SetDisplayModes(mode_list);
 
   std::vector<DisplayInfo> display_info_list;
   display_info_list.push_back(native_display_info);
 
   display_manager()->OnNativeDisplaysChanged(display_info_list);
 
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).GetEffectiveDeviceScaleFactor());
   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).GetEffectiveUIScale());
 }
+#endif  // defined(OS_CHROMEOS)
 
-TEST_F(DisplayManagerTest, ResolutionChangeInUnifiedMode) {
+TEST_P(DisplayManagerTest, ResolutionChangeInUnifiedMode) {
   if (!SupportsMultipleDisplays())
     return;
   // Don't check root window destruction in unified mode.
   Shell::GetPrimaryRootWindow()->RemoveObserver(this);
 
   display_manager()->SetUnifiedDesktopEnabled(true);
 
   UpdateDisplay("200x200, 400x400");
 
   int64_t unified_id = display::Screen::GetScreen()->GetPrimaryDisplay().id();
@@ skipping 24 matching lines @@
   UpdateDisplay("600x600, 200x200");
   EXPECT_EQ(
       "1200x600",
       display::Screen::GetScreen()->GetPrimaryDisplay().size().ToString());
   active_mode = display_manager()->GetActiveModeForDisplayId(unified_id);
   EXPECT_EQ(1.0f, active_mode.ui_scale);
   EXPECT_TRUE(active_mode.native);
   EXPECT_EQ("1200x600", active_mode.size.ToString());
 }
 
-#if defined(OS_WIN)
 // TODO(scottmg): RootWindow doesn't get resized on Windows
 // Ash. http://crbug.com/247916.
-#define MAYBE_UpdateMouseCursorAfterRotateZoom \
-  DISABLED_UpdateMouseCursorAfterRotateZoom
-#else
-#define MAYBE_UpdateMouseCursorAfterRotateZoom UpdateMouseCursorAfterRotateZoom
-#endif
-TEST_F(DisplayManagerTest, MAYBE_UpdateMouseCursorAfterRotateZoom) {
+#if defined(OS_CHROMEOS)
+TEST_P(DisplayManagerTest, UpdateMouseCursorAfterRotateZoom) {
   // Make sure just rotating will not change native location.
   UpdateDisplay("300x200,200x150");
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
   aura::Env* env = aura::Env::GetInstance();
 
   ui::test::EventGenerator generator1(root_windows[0]);
   ui::test::EventGenerator generator2(root_windows[1]);
 
   // Test on 1st display.
   generator1.MoveMouseToInHost(150, 50);
@@ skipping 26 matching lines @@
   generator2.MoveMouseToInHost(200, 250);
   EXPECT_EQ("700,125", env->last_mouse_location().ToString());
   UpdateDisplay("600x400,400x300*2@1.5");
   EXPECT_EQ("750,187", env->last_mouse_location().ToString());
 
   // The native location is now outside, so move to the
   // center of closest display.
   UpdateDisplay("600x400,400x200*2@1.5");
   EXPECT_EQ("750,75", env->last_mouse_location().ToString());
 }
+#endif  // defined(OS_CHROMEOS)
 
 class TestDisplayObserver : public display::DisplayObserver {
  public:
   TestDisplayObserver() : changed_(false) {}
   ~TestDisplayObserver() override {}
 
   // display::DisplayObserver overrides:
   void OnDisplayMetricsChanged(const display::Display&, uint32_t) override {}
   void OnDisplayAdded(const display::Display& new_display) override {
     // Mirror window should already be delete before restoring
@@ skipping 14 matching lines @@
     return changed;
   }
 
  private:
   test::MirrorWindowTestApi test_api;
   bool changed_;
 
   DISALLOW_COPY_AND_ASSIGN(TestDisplayObserver);
 };
 
-TEST_F(DisplayManagerTest, SoftwareMirroring) {
+TEST_P(DisplayManagerTest, SoftwareMirroring) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("300x400,400x500");
 
   test::MirrorWindowTestApi test_api;
   EXPECT_EQ(nullptr, test_api.GetHost());
 
   TestDisplayObserver display_observer;
   display::Screen::GetScreen()->AddObserver(&display_observer);
@@ skipping 45 matching lines @@
 
   // Overscan insets are ignored.
   UpdateDisplay("400x600/o,600x800/o");
   EXPECT_FALSE(display_observer.changed_and_reset());
   EXPECT_EQ("400x600",
             test_api.GetHost()->window()->bounds().size().ToString());
 
   display::Screen::GetScreen()->RemoveObserver(&display_observer);
 }
 
-TEST_F(DisplayManagerTest, RotateInSoftwareMirroring) {
+TEST_P(DisplayManagerTest, RotateInSoftwareMirroring) {
   if (!SupportsMultipleDisplays())
     return;
 
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   UpdateDisplay("600x400,500x300");
   display_manager->SetMirrorMode(true);
 
   EXPECT_EQ(1U, display_manager->GetNumDisplays());
   int64_t primary_id = display::Screen::GetScreen()->GetPrimaryDisplay().id();
   display_manager->SetDisplayRotation(primary_id, display::Display::ROTATE_180,
                                       display::Display::ROTATION_SOURCE_ACTIVE);
   display_manager->SetMirrorMode(false);
 }
 
-TEST_F(DisplayManagerTest, SingleDisplayToSoftwareMirroring) {
+TEST_P(DisplayManagerTest, SingleDisplayToSoftwareMirroring) {
   if (!SupportsMultipleDisplays())
     return;
   UpdateDisplay("600x400");
 
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   display_manager->SetMultiDisplayMode(DisplayManager::MIRRORING);
   UpdateDisplay("600x400,600x400");
 
   EXPECT_TRUE(display_manager->IsInMirrorMode());
   EXPECT_EQ(1U, display_manager->GetNumDisplays());
   WindowTreeHostManager* window_tree_host_manager =
       ash::Shell::GetInstance()->window_tree_host_manager();
   EXPECT_TRUE(
       window_tree_host_manager->mirror_window_controller()->GetWindow());
 
   UpdateDisplay("600x400");
   EXPECT_FALSE(display_manager->IsInMirrorMode());
   EXPECT_EQ(1U, display_manager->GetNumDisplays());
   EXPECT_FALSE(
       window_tree_host_manager->mirror_window_controller()->GetWindow());
 }
 
 #if defined(OS_CHROMEOS)
 // Make sure this does not cause any crashes. See http://crbug.com/412910
 // This test is limited to OS_CHROMEOS because CursorCompositingEnabled is only
 // for ChromeOS.
-TEST_F(DisplayManagerTest, SoftwareMirroringWithCompositingCursor) {
+TEST_P(DisplayManagerTest, SoftwareMirroringWithCompositingCursor) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("300x400,400x500");
 
   test::MirrorWindowTestApi test_api;
   EXPECT_EQ(nullptr, test_api.GetHost());
 
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   DisplayInfo secondary_info = display_manager->GetDisplayInfo(
@@ skipping 15 matching lines @@
   new_info_list.push_back(secondary_info);
   display_manager->OnNativeDisplaysChanged(new_info_list);
 
   root_windows = Shell::GetAllRootWindows();
   EXPECT_TRUE(root_windows[0]->Contains(test_api.GetCursorWindow()));
 
   Shell::GetInstance()->SetCursorCompositingEnabled(false);
 }
 #endif  // OS_CHROMEOS
 
-TEST_F(DisplayManagerTest, MirroredLayout) {
+TEST_P(DisplayManagerTest, MirroredLayout) {
   if (!SupportsMultipleDisplays())
     return;
 
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   UpdateDisplay("500x500,400x400");
   EXPECT_FALSE(display_manager->GetCurrentDisplayLayout().mirrored);
   EXPECT_EQ(2, display::Screen::GetScreen()->GetNumDisplays());
   EXPECT_EQ(2U, display_manager->num_connected_displays());
 
   UpdateDisplay("1+0-500x500,1+0-500x500");
   EXPECT_TRUE(display_manager->GetCurrentDisplayLayout().mirrored);
   EXPECT_EQ(1, display::Screen::GetScreen()->GetNumDisplays());
   EXPECT_EQ(2U, display_manager->num_connected_displays());
 
   UpdateDisplay("500x500,500x500");
   EXPECT_FALSE(display_manager->GetCurrentDisplayLayout().mirrored);
   EXPECT_EQ(2, display::Screen::GetScreen()->GetNumDisplays());
   EXPECT_EQ(2U, display_manager->num_connected_displays());
 }
 
-TEST_F(DisplayManagerTest, InvertLayout) {
+TEST_P(DisplayManagerTest, InvertLayout) {
   EXPECT_EQ("left, 0",
             display::DisplayPlacement(display::DisplayPlacement::RIGHT, 0)
                 .Swap()
                 .ToString());
   EXPECT_EQ("left, -100",
             display::DisplayPlacement(display::DisplayPlacement::RIGHT, 100)
                 .Swap()
                 .ToString());
   EXPECT_EQ("left, 50",
             display::DisplayPlacement(display::DisplayPlacement::RIGHT, -50)
@@ skipping 33 matching lines @@
   EXPECT_EQ("top, -70",
             display::DisplayPlacement(display::DisplayPlacement::BOTTOM, 70)
                 .Swap()
                 .ToString());
   EXPECT_EQ("top, 80",
             display::DisplayPlacement(display::DisplayPlacement::BOTTOM, -80)
                 .Swap()
                 .ToString());
 }
 
-TEST_F(DisplayManagerTest, NotifyPrimaryChange) {
+TEST_P(DisplayManagerTest, NotifyPrimaryChange) {
   if (!SupportsMultipleDisplays())
     return;
   UpdateDisplay("500x500,500x500");
   test::SwapPrimaryDisplay();
   reset();
   UpdateDisplay("500x500");
   EXPECT_FALSE(changed_metrics() &
                display::DisplayObserver::DISPLAY_METRIC_BOUNDS);
   EXPECT_FALSE(changed_metrics() &
                display::DisplayObserver::DISPLAY_METRIC_WORK_AREA);
   EXPECT_TRUE(changed_metrics() &
               display::DisplayObserver::DISPLAY_METRIC_PRIMARY);
 
   UpdateDisplay("500x500,500x500");
   test::SwapPrimaryDisplay();
   UpdateDisplay("500x400");
   EXPECT_TRUE(changed_metrics() &
               display::DisplayObserver::DISPLAY_METRIC_BOUNDS);
   EXPECT_TRUE(changed_metrics() &
               display::DisplayObserver::DISPLAY_METRIC_WORK_AREA);
   EXPECT_TRUE(changed_metrics() &
               display::DisplayObserver::DISPLAY_METRIC_PRIMARY);
 }
 
-TEST_F(DisplayManagerTest, NotifyPrimaryChangeUndock) {
+TEST_P(DisplayManagerTest, NotifyPrimaryChangeUndock) {
   if (!SupportsMultipleDisplays())
     return;
   // Assume the default display is an external display, and
   // emulates undocking by switching to another display.
   DisplayInfo another_display_info =
       CreateDisplayInfo(1, gfx::Rect(0, 0, 1280, 800));
   std::vector<DisplayInfo> info_list;
   info_list.push_back(another_display_info);
   reset();
   display_manager()->OnNativeDisplaysChanged(info_list);
   EXPECT_TRUE(changed_metrics() &
               display::DisplayObserver::DISPLAY_METRIC_BOUNDS);
   EXPECT_TRUE(changed_metrics() &
               display::DisplayObserver::DISPLAY_METRIC_WORK_AREA);
   EXPECT_TRUE(changed_metrics() &
               display::DisplayObserver::DISPLAY_METRIC_PRIMARY);
 }
 
-#if defined(OS_WIN)
 // TODO(scottmg): RootWindow doesn't get resized on Windows
 // Ash. http://crbug.com/247916.
-#define MAYBE_UpdateDisplayWithHostOrigin DISABLED_UpdateDisplayWithHostOrigin
-#else
-#define MAYBE_UpdateDisplayWithHostOrigin UpdateDisplayWithHostOrigin
-#endif
-
-TEST_F(DisplayManagerTest, MAYBE_UpdateDisplayWithHostOrigin) {
+#if defined(OS_CHROMEOS)
+TEST_P(DisplayManagerTest, UpdateDisplayWithHostOrigin) {
   UpdateDisplay("100x200,300x400");
   ASSERT_EQ(2, display::Screen::GetScreen()->GetNumDisplays());
   aura::Window::Windows root_windows =
       Shell::GetInstance()->GetAllRootWindows();
   ASSERT_EQ(2U, root_windows.size());
   aura::WindowTreeHost* host0 = root_windows[0]->GetHost();
   aura::WindowTreeHost* host1 = root_windows[1]->GetHost();
 
   EXPECT_EQ("1,1", host0->GetBounds().origin().ToString());
   EXPECT_EQ("100x200", host0->GetBounds().size().ToString());
@@ skipping 15 matching lines @@
   EXPECT_EQ("0,0", host1->GetBounds().origin().ToString());
   EXPECT_EQ("300x400", host1->GetBounds().size().ToString());
 
   UpdateDisplay("100+200-100x200,300+500-200x300");
   ASSERT_EQ(2, display::Screen::GetScreen()->GetNumDisplays());
   EXPECT_EQ("100,200", host0->GetBounds().origin().ToString());
   EXPECT_EQ("100x200", host0->GetBounds().size().ToString());
   EXPECT_EQ("300,500", host1->GetBounds().origin().ToString());
   EXPECT_EQ("200x300", host1->GetBounds().size().ToString());
 }
+#endif  // defined(OS_CHROMEOS)
 
-TEST_F(DisplayManagerTest, UnifiedDesktopBasic) {
+TEST_P(DisplayManagerTest, UnifiedDesktopBasic) {
   if (!SupportsMultipleDisplays())
     return;
 
   // Don't check root window destruction in unified mode.
   Shell::GetPrimaryRootWindow()->RemoveObserver(this);
 
   UpdateDisplay("400x500,300x200");
 
   // Enable after extended mode.
   display_manager()->SetUnifiedDesktopEnabled(true);
@@ skipping 38 matching lines @@
   // Switch back to extended desktop.
   display_manager()->SetUnifiedDesktopEnabled(false);
   EXPECT_EQ(gfx::Size(500, 300), screen->GetPrimaryDisplay().size());
   EXPECT_EQ(gfx::Size(400, 500), ScreenUtil::GetSecondaryDisplay().size());
   EXPECT_EQ(gfx::Size(500, 300),
             display_manager()
                 ->GetDisplayForId(ScreenUtil::GetSecondaryDisplay().id() + 1)
                 .size());
 }
 
-TEST_F(DisplayManagerTest, UnifiedDesktopWithHardwareMirroring) {
+TEST_P(DisplayManagerTest, UnifiedDesktopWithHardwareMirroring) {
   if (!SupportsMultipleDisplays())
     return;
   // Don't check root window destruction in unified mode.
   Shell::GetPrimaryRootWindow()->RemoveObserver(this);
 
   // Enter to hardware mirroring.
   DisplayInfo d1(1, "", false);
   d1.SetBounds(gfx::Rect(0, 0, 500, 500));
   DisplayInfo d2(2, "", false);
   d2.SetBounds(gfx::Rect(0, 0, 500, 500));
@@ skipping 19 matching lines @@
   // Exit from hardware mirroring.
   d2.SetBounds(gfx::Rect(0, 500, 500, 500));
   display_info_list.clear();
   display_info_list.push_back(d1);
   display_info_list.push_back(d2);
   display_manager()->OnNativeDisplaysChanged(display_info_list);
   EXPECT_FALSE(display_manager()->IsInMirrorMode());
   EXPECT_TRUE(display_manager()->IsInUnifiedMode());
 }
 
-TEST_F(DisplayManagerTest, UnifiedDesktopEnabledWithExtended) {
+TEST_P(DisplayManagerTest, UnifiedDesktopEnabledWithExtended) {
   if (!SupportsMultipleDisplays())
     return;
   // Don't check root window destruction in unified mode.
   Shell::GetPrimaryRootWindow()->RemoveObserver(this);
 
   UpdateDisplay("400x500,300x200");
   display::DisplayIdList list = display_manager()->GetCurrentDisplayIdList();
   display::DisplayLayoutBuilder builder(
       display_manager()->layout_store()->GetRegisteredDisplayLayout(list));
   builder.SetDefaultUnified(false);
   display_manager()->layout_store()->RegisterLayoutForDisplayIdList(
       list, builder.Build());
   display_manager()->SetUnifiedDesktopEnabled(true);
   EXPECT_FALSE(display_manager()->IsInUnifiedMode());
 }
 
-TEST_F(DisplayManagerTest, UnifiedDesktopWith2xDSF) {
+TEST_P(DisplayManagerTest, UnifiedDesktopWith2xDSF) {
   if (!SupportsMultipleDisplays())
     return;
   // Don't check root window destruction in unified mode.
   Shell::GetPrimaryRootWindow()->RemoveObserver(this);
 
   display_manager()->SetUnifiedDesktopEnabled(true);
   display::Screen* screen = display::Screen::GetScreen();
 
   // 2nd display is 2x.
   UpdateDisplay("400x500,1000x800*2");
@@ skipping 83 matching lines @@
   EXPECT_EQ("1300x800",
             Shell::GetPrimaryRootWindow()->bounds().size().ToString());
   accelerators::ZoomInternalDisplay(false);
   EXPECT_EQ("650x400", screen->GetPrimaryDisplay().size().ToString());
   EXPECT_EQ("650x400",
             Shell::GetPrimaryRootWindow()->bounds().size().ToString());
 }
 
 // Updating displays again in unified desktop mode should not crash.
 // crbug.com/491094.
-TEST_F(DisplayManagerTest, ConfigureUnifiedTwice) {
+TEST_P(DisplayManagerTest, ConfigureUnifiedTwice) {
   if (!SupportsMultipleDisplays())
     return;
   // Don't check root window destruction in unified mode.
   Shell::GetPrimaryRootWindow()->RemoveObserver(this);
 
   UpdateDisplay("300x200,400x500");
   // Mirror windows are created in a posted task.
   RunAllPendingInMessageLoop();
 
   UpdateDisplay("300x250,400x550");
   RunAllPendingInMessageLoop();
 }
 
-TEST_F(DisplayManagerTest, NoRotateUnifiedDesktop) {
+TEST_P(DisplayManagerTest, NoRotateUnifiedDesktop) {
   if (!SupportsMultipleDisplays())
     return;
   display_manager()->SetUnifiedDesktopEnabled(true);
 
   // Don't check root window destruction in unified mode.
   Shell::GetPrimaryRootWindow()->RemoveObserver(this);
 
   UpdateDisplay("400x500,300x200");
 
   display::Screen* screen = display::Screen::GetScreen();
   const display::Display& display = screen->GetPrimaryDisplay();
   EXPECT_EQ("1150x500", display.size().ToString());
   display_manager()->SetDisplayRotation(
       display.id(), display::Display::ROTATE_90,
       display::Display::ROTATION_SOURCE_ACTIVE);
   EXPECT_EQ("1150x500", screen->GetPrimaryDisplay().size().ToString());
   display_manager()->SetDisplayRotation(
       display.id(), display::Display::ROTATE_0,
       display::Display::ROTATION_SOURCE_ACTIVE);
   EXPECT_EQ("1150x500", screen->GetPrimaryDisplay().size().ToString());
 
   UpdateDisplay("400x500");
   EXPECT_EQ("400x500", screen->GetPrimaryDisplay().size().ToString());
 }
 
 // Makes sure the transition from unified to single won't crash
 // with docked windows.
-TEST_F(DisplayManagerTest, UnifiedWithDockWindows) {
+TEST_P(DisplayManagerTest, UnifiedWithDockWindows) {
   if (!SupportsMultipleDisplays())
     return;
+  const int height_offset = GetMdDockedWindowHeightOffset();
   display_manager()->SetUnifiedDesktopEnabled(true);
 
   // Don't check root window destruction in unified mode.
   Shell::GetPrimaryRootWindow()->RemoveObserver(this);
 
   UpdateDisplay("400x500,300x200");
 
   std::unique_ptr<aura::Window> docked(
       CreateTestWindowInShellWithBounds(gfx::Rect(10, 10, 50, 50)));
   docked->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_DOCKED);
   ASSERT_TRUE(wm::GetWindowState(docked.get())->IsDocked());
-  // 47 pixels reserved for launcher shelf height.
-  EXPECT_EQ("0,0 250x453", docked->bounds().ToString());
+  // 47 pixels reserved for launcher shelf height in non-material design, and
+  // 48 pixels reserved in material design.
+  EXPECT_EQ(gfx::Rect(0, 0, 250, 453 + height_offset).ToString(),
+            docked->bounds().ToString());
   UpdateDisplay("300x300");
   // Make sure the window is still docked.
   EXPECT_TRUE(wm::GetWindowState(docked.get())->IsDocked());
-  EXPECT_EQ("0,0 250x253", docked->bounds().ToString());
+  EXPECT_EQ(gfx::Rect(0, 0, 250, 253 + height_offset).ToString(),
+            docked->bounds().ToString());
 }
 
-TEST_F(DisplayManagerTest, DockMode) {
+TEST_P(DisplayManagerTest, DockMode) {
   if (!SupportsMultipleDisplays())
     return;
   const int64_t internal_id = 1;
   const int64_t external_id = 2;
 
   const DisplayInfo internal_display_info =
       CreateDisplayInfo(internal_id, gfx::Rect(0, 0, 500, 500));
   const DisplayInfo external_display_info =
       CreateDisplayInfo(external_id, gfx::Rect(1, 1, 100, 100));
   std::vector<DisplayInfo> display_info_list;
@@ skipping 21 matching lines @@
   EXPECT_FALSE(GetDisplayModeForNextUIScale(info, false, &mode));
   EXPECT_FALSE(SetDisplayUIScale(internal_id, 1.0f));
 
   DisplayInfo invalid_info;
   EXPECT_FALSE(GetDisplayModeForNextUIScale(invalid_info, true, &mode));
   EXPECT_FALSE(GetDisplayModeForNextUIScale(invalid_info, false, &mode));
   EXPECT_FALSE(SetDisplayUIScale(display::Display::kInvalidDisplayID, 1.0f));
 }
 
 // Make sure that bad layout information is ignored and does not crash.
-TEST_F(DisplayManagerTest, DontRegisterBadConfig) {
+TEST_P(DisplayManagerTest, DontRegisterBadConfig) {
   if (!SupportsMultipleDisplays())
     return;
   display::DisplayIdList list = ash::test::CreateDisplayIdList2(1, 2);
   display::DisplayLayoutBuilder builder(1);
   builder.AddDisplayPlacement(2, 1, display::DisplayPlacement::LEFT, 0);
   builder.AddDisplayPlacement(3, 1, display::DisplayPlacement::BOTTOM, 0);
 
   display_manager()->layout_store()->RegisterLayoutForDisplayIdList(
       list, builder.Build());
 }
@@ skipping 153 matching lines @@
   SetDisplayUIScale(display::Screen::GetScreen()->GetPrimaryDisplay().id(),
                     0.8f);
 
   ASSERT_DOUBLE_EQ(
       1.25f,
       display::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor());
   EXPECT_TRUE(IsTextSubpixelPositioningEnabled());
   EXPECT_EQ(gfx::FontRenderParams::HINTING_NONE, GetFontHintingParams());
 }
 
-TEST_F(DisplayManagerTest, CheckInitializationOfRotationProperty) {
+TEST_P(DisplayManagerTest, CheckInitializationOfRotationProperty) {
   int64_t id = display_manager()->GetDisplayAt(0).id();
   display_manager()->RegisterDisplayProperty(id, display::Display::ROTATE_90,
                                              1.0f, nullptr, gfx::Size(), 1.0f,
                                              ui::COLOR_PROFILE_STANDARD);
 
   const DisplayInfo& info = display_manager()->GetDisplayInfo(id);
 
   EXPECT_EQ(display::Display::ROTATE_90,
             info.GetRotation(display::Display::ROTATION_SOURCE_USER));
   EXPECT_EQ(display::Display::ROTATE_90,
             info.GetRotation(display::Display::ROTATION_SOURCE_ACTIVE));
 }
 
-TEST_F(DisplayManagerTest, RejectInvalidLayoutData) {
+TEST_P(DisplayManagerTest, RejectInvalidLayoutData) {
   DisplayLayoutStore* layout_store = display_manager()->layout_store();
   int64_t id1 = 10001;
   int64_t id2 = 10002;
   ASSERT_TRUE(CompareDisplayIds(id1, id2));
   display::DisplayLayoutBuilder good_builder(id1);
   good_builder.SetSecondaryPlacement(id2, display::DisplayPlacement::LEFT, 0);
   std::unique_ptr<display::DisplayLayout> good(good_builder.Build());
 
   display::DisplayIdList good_list = test::CreateDisplayIdList2(id1, id2);
   layout_store->RegisterLayoutForDisplayIdList(good_list, good->Copy());
 
   display::DisplayLayoutBuilder bad(id1);
   bad.SetSecondaryPlacement(id2, display::DisplayPlacement::BOTTOM, 0);
 
   display::DisplayIdList bad_list(2);
   bad_list[0] = id2;
   bad_list[1] = id1;
   layout_store->RegisterLayoutForDisplayIdList(bad_list, bad.Build());
 
   EXPECT_EQ(good->ToString(),
             layout_store->GetRegisteredDisplayLayout(good_list).ToString());
 }
 
-TEST_F(DisplayManagerTest, GuessDisplayIdFieldsInDisplayLayout) {
+TEST_P(DisplayManagerTest, GuessDisplayIdFieldsInDisplayLayout) {
   int64_t id1 = 10001;
   int64_t id2 = 10002;
 
   std::unique_ptr<display::DisplayLayout> old_layout(
       new display::DisplayLayout);
   old_layout->placement_list.emplace_back(display::DisplayPlacement::BOTTOM, 0);
   old_layout->primary_id = id1;
 
   DisplayLayoutStore* layout_store = display_manager()->layout_store();
   display::DisplayIdList list = test::CreateDisplayIdList2(id1, id2);
   layout_store->RegisterLayoutForDisplayIdList(list, std::move(old_layout));
   const display::DisplayLayout& stored =
       layout_store->GetRegisteredDisplayLayout(list);
 
   EXPECT_EQ(id1, stored.placement_list[0].parent_display_id);
   EXPECT_EQ(id2, stored.placement_list[0].display_id);
 }
 
 #endif  // OS_CHROMEOS
 
 }  // namespace ash