Skip mulitple-dispay tests on win8

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/display/display_controller.h"
 #include "ash/screen_ash.h"
 #include "ash/shell.h"
 #include "ash/test/ash_test_base.h"
@@ skipping 101 matching lines @@
  private:
   vector<gfx::Display> changed_;
   vector<gfx::Display> added_;
   size_t removed_count_;
   bool root_window_destroyed_;
 
   DISALLOW_COPY_AND_ASSIGN(DisplayManagerTest);
 };
 
 TEST_F(DisplayManagerTest, NativeDisplayTest) {
+  RETURN_IF_WIN8;
+
   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());
 
   EXPECT_EQ("1 1 0", GetCountSummary());
   EXPECT_EQ(display_manager()->GetDisplayAt(0)->id(), changed()[0].id());
@@ skipping 71 matching lines @@
   // Secondary display is on right.
   EXPECT_EQ("1000,0 600x400",
             display_manager()->GetDisplayAt(1)->bounds().ToString());
   EXPECT_EQ("1000,1000 600x400",
             GetDisplayInfoAt(1).bounds_in_pixel().ToString());
   reset();
 }
 
 // Test in emulation mode (use_fullscreen_host_window=false)
 TEST_F(DisplayManagerTest, EmulatorTest) {
+  RETURN_IF_WIN8;
+
   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());
   reset();
 }
 
 TEST_F(DisplayManagerTest, OverscanInsetsTest) {
+  RETURN_IF_WIN8;
+
   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));
 
   std::vector<gfx::Display> changed_displays = changed();
   EXPECT_EQ(1u, changed_displays.size());
@@ skipping 82 matching lines @@
             GetDisplayInfo(ScreenAsh::GetSecondaryDisplay()).
             bounds_in_pixel().ToString());
   EXPECT_EQ("0,501 400x400",
             GetDisplayInfo(Shell::GetScreen()->GetPrimaryDisplay()).
             bounds_in_pixel().ToString());
   EXPECT_EQ("0,0 188x190",
             Shell::GetScreen()->GetPrimaryDisplay().bounds().ToString());
 }
 
 TEST_F(DisplayManagerTest, ZeroOverscanInsets) {
+  RETURN_IF_WIN8;
+
   // 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 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();
@@ skipping 19 matching lines @@
   EXPECT_EQ("500x300",
             Shell::GetPrimaryRootWindow()->bounds().size().ToString());
 }
 
 DisplayInfo CreateDisplayInfo(int64 id, const gfx::Rect& bounds) {
   DisplayInfo info(id, StringPrintf("x-%d", static_cast<int>(id)), false);
   info.SetBounds(bounds);
   return info;
 }
 
-#if defined(OS_WIN)
-// Crashes flakily on Win8 Aura: http://crbug.com/246109.
-#define MAYBE_TestNativeDisplaysChanged DISABLED_TestNativeDisplaysChanged
-#else
-#define MAYBE_TestNativeDisplaysChanged TestNativeDisplaysChanged
-#endif
-TEST_F(DisplayManagerTest, MAYBE_TestNativeDisplaysChanged) {
+TEST_F(DisplayManagerTest, TestNativeDisplaysChanged) {
   const int internal_display_id =
       test::DisplayManagerTestApi(display_manager()).
       SetFirstDisplayAsInternalDisplay();
   const int external_id = 10;
   const int mirror_id = 11;
   const int64 invalid_id = gfx::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 mirrored_display_info =
       CreateDisplayInfo(mirror_id, gfx::Rect(0, 0, 500, 500));
 
   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
   EXPECT_EQ(1U, display_manager()->num_connected_displays());
   std::string default_bounds =
       display_manager()->GetDisplayAt(0)->bounds().ToString();
 
   std::vector<DisplayInfo> display_info_list;
   // Primary disconnected.
   display_manager()->OnNativeDisplaysChanged(display_info_list);
   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
   EXPECT_EQ(default_bounds,
             display_manager()->GetDisplayAt(0)->bounds().ToString());
   EXPECT_EQ(1U, display_manager()->num_connected_displays());
   EXPECT_FALSE(display_manager()->mirrored_display().is_valid());
 
+  RETURN_IF_WIN8;
+
   // External connected while primary was disconnected.
   display_info_list.push_back(external_display_info);
   display_manager()->OnNativeDisplaysChanged(display_info_list);
   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
 
   EXPECT_EQ(invalid_id, FindDisplayForId(internal_display_id).id());
   EXPECT_EQ("1,1 100x100",
             FindDisplayInfoForId(external_id).bounds_in_pixel().ToString());
   EXPECT_EQ(1U, display_manager()->num_connected_displays());
   EXPECT_FALSE(display_manager()->mirrored_display().is_valid());
@@ skipping 111 matching lines @@
   display_manager()->OnNativeDisplaysChanged(display_info_list);
   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
   EXPECT_EQ(
       "0,0 500x500",
       FindDisplayInfoForId(internal_display_id).bounds_in_pixel().ToString());
   EXPECT_EQ(1U, display_manager()->num_connected_displays());
   EXPECT_FALSE(display_manager()->mirrored_display().is_valid());
 }
 
 #if defined(OS_WIN)
-// This test currently fails on Win8/Metro as it picks up the actual
-// display size. http://crbug.com/154081
+// 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) {
   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",
             FindDisplayInfoForId(10).bounds_in_pixel().ToString());
   EXPECT_EQ("100x100",
             ash::Shell::GetPrimaryRootWindow()->GetHostSize().ToString());
 }
 
 TEST_F(DisplayManagerTest, EnsurePointerInDisplays) {
+  RETURN_IF_WIN8;
+
   UpdateDisplay("200x200,300x300");
   Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
 
   aura::Env* env = aura::Env::GetInstance();
 
   aura::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 outside and closest display is 1st one.
   UpdateDisplay("300x280,200x200");
   EXPECT_EQ("150,140", env->last_mouse_location().ToString());
 }
 
-#if defined(OS_WIN)
-// Flaky failures on Win8 due to window activation messages. crbug.com/239539
-#define MAYBE_EnsurePointerInDisplays_2ndOnLeft \
-  DISABLED_EnsurePointerInDisplays_2ndOnLeft
-#else
-#define MAYBE_EnsurePointerInDisplays_2ndOnLeft \
-  EnsurePointerInDisplays_2ndOnLeft
-#endif
-TEST_F(DisplayManagerTest, MAYBE_EnsurePointerInDisplays_2ndOnLeft) {
+TEST_F(DisplayManagerTest, EnsurePointerInDisplays_2ndOnLeft) {
+  RETURN_IF_WIN8;
+
   // Set the 2nd display on the left.
   DisplayController* display_controller =
       Shell::GetInstance()->display_controller();
   DisplayLayout layout = display_controller->default_display_layout();
   layout.position = DisplayLayout::LEFT;
   display_controller->SetDefaultDisplayLayout(layout);
 
   UpdateDisplay("200x200,300x300");
   Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
 
@@ skipping 15 matching lines @@
   UpdateDisplay("300x300,200x100");
   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_F(DisplayManagerTest, NativeDisplaysChangedAfterPrimaryChange) {
+  RETURN_IF_WIN8;
+
   const int64 internal_display_id =
       test::DisplayManagerTestApi(display_manager()).
       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));
 
   std::vector<DisplayInfo> display_info_list;
   display_info_list.push_back(native_display_info);
@@ skipping 12 matching lines @@
 
   // 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",
             FindDisplayForId(internal_display_id).bounds().ToString());
   EXPECT_EQ("0,0 100x100", FindDisplayForId(10).bounds().ToString());
 }
 
 TEST_F(DisplayManagerTest, AutomaticOverscanInsets) {
+  RETURN_IF_WIN8;
+
   UpdateDisplay("200x200,400x400");
 
   std::vector<DisplayInfo> display_info_list;
   display_info_list.push_back(GetDisplayInfoAt(0));
   display_info_list.push_back(GetDisplayInfoAt(1));
   display_info_list[1].set_has_overscan_for_test(true);
   int64 id = display_info_list[1].id();
   // SetDefaultOverscanInsets(&display_info_list[1]);
   display_manager()->OnNativeDisplaysChanged(display_info_list);
   // It has overscan insets, although SetOverscanInsets() isn't called.
@@ skipping 13 matching lines @@
   EXPECT_EQ("400x400",
             GetDisplayInfoAt(1).size_in_pixel().ToString());
 
   // Clearing the custom overscan should set the bounds to
   // original.
   display_manager()->ClearCustomOverscanInsets(id);
   EXPECT_EQ("380x380",
             GetDisplayInfoAt(1).size_in_pixel().ToString());
 }
 
-#if defined(OS_WIN)
-// Flaky on Win8 Aura: http://crbug.com/244466
-#define MAYBE_Rotate DISABLED_Rotate
-#else
-#define MAYBE_Rotate Rotate
-#endif
-TEST_F(DisplayManagerTest, MAYBE_Rotate) {
+TEST_F(DisplayManagerTest, Rotate) {
+  RETURN_IF_WIN8;
+
   UpdateDisplay("100x200/r,300x400/l");
   EXPECT_EQ("1,1 100x200",
             GetDisplayInfoAt(0).bounds_in_pixel().ToString());
   EXPECT_EQ("200x100",
             GetDisplayInfoAt(0).size_in_pixel().ToString());
 
   EXPECT_EQ("1,201 300x400",
             GetDisplayInfoAt(1).bounds_in_pixel().ToString());
   EXPECT_EQ("400x300",
             GetDisplayInfoAt(1).size_in_pixel().ToString());
@@ skipping 84 matching lines @@
   display_manager()->SetDisplayUIScale(display_id, 0.625f);
   EXPECT_EQ(0.625f, GetDisplayInfoAt(0).ui_scale());
   display_manager()->SetDisplayUIScale(display_id, 0.6f);
   EXPECT_EQ(0.625f, GetDisplayInfoAt(0).ui_scale());
   display_manager()->SetDisplayUIScale(display_id, 0.5f);
   EXPECT_EQ(0.5f, GetDisplayInfoAt(0).ui_scale());
 }
 
 
 #if defined(OS_WIN)
-// TODO(oshima): On Windows, we don't update the origin/size right away.
+// 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) {
   // Make sure just rotating will not change native location.
   UpdateDisplay("300x200,200x150");
   Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
   aura::Env* env = aura::Env::GetInstance();
@@ skipping 23 matching lines @@
   EXPECT_EQ("150,225", env->last_mouse_location().ToString());
 
   // Test on 2nd display.
   UpdateDisplay("600x400,400x300*2");
   generator2.MoveMouseToInHost(200, 100);
   EXPECT_EQ("700,50", env->last_mouse_location().ToString());
   UpdateDisplay("600x400,400x300*2@1.5");
   EXPECT_EQ("750,75", env->last_mouse_location().ToString());
 }
 
-#if defined(OS_WIN)
-// This does not work on metro.
-#define MAYBE_SoftwareMirroring DISABLED_SoftwareMirroring
-#else
-#define MAYBE_SoftwareMirroring SoftwareMirroring
-#endif
-
 class TestDisplayObserver : public gfx::DisplayObserver {
  public:
   TestDisplayObserver() : changed_(false) {}
   virtual ~TestDisplayObserver() {}
 
   // gfx::DisplayObserver overrides:
   virtual void OnDisplayBoundsChanged(const gfx::Display& display) OVERRIDE {
   }
   virtual void OnDisplayAdded(const gfx::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, MAYBE_SoftwareMirroring) {
+TEST_F(DisplayManagerTest, SoftwareMirroring) {
+  RETURN_IF_WIN8;
+
   UpdateDisplay("300x400,400x500");
 
   test::MirrorWindowTestApi test_api;
   EXPECT_EQ(NULL, test_api.GetRootWindow());
 
   TestDisplayObserver display_observer;
   Shell::GetScreen()->AddObserver(&display_observer);
 
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   display_manager->SetSoftwareMirroring(true);
@@ skipping 41 matching lines @@
   UpdateDisplay("400x600/o,600x800/o");
   EXPECT_FALSE(display_observer.changed_and_reset());
   EXPECT_EQ("400x600", test_api.GetRootWindow()->bounds().size().ToString());
   EXPECT_EQ("600x800", GetMirroredDisplay().size().ToString());
 
   Shell::GetScreen()->RemoveObserver(&display_observer);
 }
 
 }  // namespace internal
 }  // namespace ash