ash/display/display_manager_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ash/display/display_manager.h"
   6
   7 #include "ash/display/display_controller.h"
   8 #include "ash/display/display_layout_store.h"
   9 #include "ash/screen_util.h"
  10 #include "ash/shell.h"
  11 #include "ash/test/ash_test_base.h"
  12 #include "ash/test/display_manager_test_api.h"
  13 #include "ash/test/mirror_window_test_api.h"
  14 #include "base/format_macros.h"
  15 #include "base/strings/string_number_conversions.h"
  16 #include "base/strings/stringprintf.h"
  17 #include "ui/aura/env.h"
  18 #include "ui/aura/test/event_generator.h"
  19 #include "ui/aura/window_observer.h"
  20 #include "ui/aura/window_tree_host.h"
  21 #include "ui/gfx/display_observer.h"
  22 #include "ui/gfx/display.h"
  23 #include "ui/gfx/screen.h"
  24 #include "ui/gfx/screen_type_delegate.h"
  25
  26 namespace ash {
  27
  28 using std::vector;
  29 using std::string;
  30
  31 using base::StringPrintf;
  32
  33 namespace {
  34
  35 std::string ToDisplayName(int64 id) {
  36   return "x-" + base::Int64ToString(id);
  37 }
  38
  39 }  // namespace
  40
  41 class DisplayManagerTest : public test::AshTestBase,
  42                            public gfx::DisplayObserver,
  43                            public aura::WindowObserver {
  44  public:
  45   DisplayManagerTest()
  46       : removed_count_(0U),
  47         root_window_destroyed_(false) {
  48   }
  49   virtual ~DisplayManagerTest() {}
  50
  51   virtual void SetUp() OVERRIDE {
  52     AshTestBase::SetUp();
  53     Shell::GetScreen()->AddObserver(this);
  54     Shell::GetPrimaryRootWindow()->AddObserver(this);
  55   }
  56   virtual void TearDown() OVERRIDE {
  57     Shell::GetPrimaryRootWindow()->RemoveObserver(this);
  58     Shell::GetScreen()->RemoveObserver(this);
  59     AshTestBase::TearDown();
  60   }
  61
  62   DisplayManager* display_manager() {
  63     return Shell::GetInstance()->display_manager();
  64   }
  65   const vector<gfx::Display>& changed() const { return changed_; }
  66   const vector<gfx::Display>& added() const { return added_; }
  67
  68   string GetCountSummary() const {
  69     return StringPrintf("%" PRIuS " %" PRIuS " %" PRIuS,
  70                         changed_.size(), added_.size(), removed_count_);
  71   }
  72
  73   void reset() {
  74     changed_.clear();
  75     added_.clear();
  76     removed_count_ = 0U;
  77     root_window_destroyed_ = false;
  78   }
  79
  80   bool root_window_destroyed() const {
  81     return root_window_destroyed_;
  82   }
  83
  84   const DisplayInfo& GetDisplayInfo(const gfx::Display& display) {
  85     return display_manager()->GetDisplayInfo(display.id());
  86   }
  87
  88   const DisplayInfo& GetDisplayInfoAt(int index) {
  89     return GetDisplayInfo(display_manager()->GetDisplayAt(index));
  90   }
  91
  92   const gfx::Display& GetDisplayForId(int64 id) {
  93     return display_manager()->GetDisplayForId(id);
  94   }
  95
  96   const DisplayInfo& GetDisplayInfoForId(int64 id) {
  97     return GetDisplayInfo(display_manager()->GetDisplayForId(id));
  98   }
  99
 100   // aura::DisplayObserver overrides:
 101   virtual void OnDisplayBoundsChanged(const gfx::Display& display) OVERRIDE {
 102     changed_.push_back(display);
 103   }
 104   virtual void OnDisplayAdded(const gfx::Display& new_display) OVERRIDE {
 105     added_.push_back(new_display);
 106   }
 107   virtual void OnDisplayRemoved(const gfx::Display& old_display) OVERRIDE {
 108     ++removed_count_;
 109   }
 110
 111   // aura::WindowObserver overrides:
 112   virtual void OnWindowDestroying(aura::Window* window) OVERRIDE {
 113     ASSERT_EQ(Shell::GetPrimaryRootWindow(), window);
 114     root_window_destroyed_ = true;
 115   }
 116
 117  private:
 118   vector<gfx::Display> changed_;
 119   vector<gfx::Display> added_;
 120   size_t removed_count_;
 121   bool root_window_destroyed_;
 122
 123   DISALLOW_COPY_AND_ASSIGN(DisplayManagerTest);
 124 };
 125
 126 TEST_F(DisplayManagerTest, UpdateDisplayTest) {
 127   if (!SupportsMultipleDisplays())
 128     return;
 129
 130   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
 131
 132   // Update primary and add seconary.
 133   UpdateDisplay("100+0-500x500,0+501-400x400");
 134   EXPECT_EQ(2U, display_manager()->GetNumDisplays());
 135   EXPECT_EQ("0,0 500x500",
 136             display_manager()->GetDisplayAt(0).bounds().ToString());
 137
 138   EXPECT_EQ("1 1 0", GetCountSummary());
 139   EXPECT_EQ(display_manager()->GetDisplayAt(0).id(), changed()[0].id());
 140   EXPECT_EQ(display_manager()->GetDisplayAt(1).id(), added()[0].id());
 141   EXPECT_EQ("0,0 500x500", changed()[0].bounds().ToString());
 142   // Secondary display is on right.
 143   EXPECT_EQ("500,0 400x400", added()[0].bounds().ToString());
 144   EXPECT_EQ("0,501 400x400",
 145             GetDisplayInfo(added()[0]).bounds_in_native().ToString());
 146   reset();
 147
 148   // Delete secondary.
 149   UpdateDisplay("100+0-500x500");
 150   EXPECT_EQ("0 0 1", GetCountSummary());
 151   reset();
 152
 153   // Change primary.
 154   UpdateDisplay("1+1-1000x600");
 155   EXPECT_EQ("1 0 0", GetCountSummary());
 156   EXPECT_EQ(display_manager()->GetDisplayAt(0).id(), changed()[0].id());
 157   EXPECT_EQ("0,0 1000x600", changed()[0].bounds().ToString());
 158   reset();
 159
 160   // Add secondary.
 161   UpdateDisplay("1+1-1000x600,1002+0-600x400");
 162   EXPECT_EQ(2U, display_manager()->GetNumDisplays());
 163   EXPECT_EQ("0 1 0", GetCountSummary());
 164   EXPECT_EQ(display_manager()->GetDisplayAt(1).id(), added()[0].id());
 165   // Secondary display is on right.
 166   EXPECT_EQ("1000,0 600x400", added()[0].bounds().ToString());
 167   EXPECT_EQ("1002,0 600x400",
 168             GetDisplayInfo(added()[0]).bounds_in_native().ToString());
 169   reset();
 170
 171   // Secondary removed, primary changed.
 172   UpdateDisplay("1+1-800x300");
 173   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
 174   EXPECT_EQ("1 0 1", GetCountSummary());
 175   EXPECT_EQ(display_manager()->GetDisplayAt(0).id(), changed()[0].id());
 176   EXPECT_EQ("0,0 800x300", changed()[0].bounds().ToString());
 177   reset();
 178
 179   // # of display can go to zero when screen is off.
 180   const vector<DisplayInfo> empty;
 181   display_manager()->OnNativeDisplaysChanged(empty);
 182   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
 183   EXPECT_EQ("0 0 0", GetCountSummary());
 184   EXPECT_FALSE(root_window_destroyed());
 185   // Display configuration stays the same
 186   EXPECT_EQ("0,0 800x300",
 187             display_manager()->GetDisplayAt(0).bounds().ToString());
 188   reset();
 189
 190   // Connect to display again
 191   UpdateDisplay("100+100-500x400");
 192   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
 193   EXPECT_EQ("1 0 0", GetCountSummary());
 194   EXPECT_FALSE(root_window_destroyed());
 195   EXPECT_EQ("0,0 500x400", changed()[0].bounds().ToString());
 196   EXPECT_EQ("100,100 500x400",
 197             GetDisplayInfo(changed()[0]).bounds_in_native().ToString());
 198   reset();
 199
 200   // Go back to zero and wake up with multiple displays.
 201   display_manager()->OnNativeDisplaysChanged(empty);
 202   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
 203   EXPECT_FALSE(root_window_destroyed());
 204   reset();
 205
 206   // Add secondary.
 207   UpdateDisplay("0+0-1000x600,1000+1000-600x400");
 208   EXPECT_EQ(2U, display_manager()->GetNumDisplays());
 209   EXPECT_EQ("0,0 1000x600",
 210             display_manager()->GetDisplayAt(0).bounds().ToString());
 211   // Secondary display is on right.
 212   EXPECT_EQ("1000,0 600x400",
 213             display_manager()->GetDisplayAt(1).bounds().ToString());
 214   EXPECT_EQ("1000,1000 600x400",
 215             GetDisplayInfoAt(1).bounds_in_native().ToString());
 216   reset();
 217
 218   // Changing primary will update secondary as well.
 219   UpdateDisplay("0+0-800x600,1000+1000-600x400");
 220   EXPECT_EQ("2 0 0", GetCountSummary());
 221   reset();
 222   EXPECT_EQ("0,0 800x600",
 223             display_manager()->GetDisplayAt(0).bounds().ToString());
 224   EXPECT_EQ("800,0 600x400",
 225             display_manager()->GetDisplayAt(1).bounds().ToString());
 226 }
 227
 228 // Test in emulation mode (use_fullscreen_host_window=false)
 229 TEST_F(DisplayManagerTest, EmulatorTest) {
 230   if (!SupportsMultipleDisplays())
 231     return;
 232
 233   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
 234
 235   display_manager()->AddRemoveDisplay();
 236   // Update primary and add seconary.
 237   EXPECT_EQ(2U, display_manager()->GetNumDisplays());
 238   EXPECT_EQ("0 1 0", GetCountSummary());
 239   reset();
 240
 241   display_manager()->AddRemoveDisplay();
 242   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
 243   EXPECT_EQ("0 0 1", GetCountSummary());
 244   reset();
 245
 246   display_manager()->AddRemoveDisplay();
 247   EXPECT_EQ(2U, display_manager()->GetNumDisplays());
 248   EXPECT_EQ("0 1 0", GetCountSummary());
 249   reset();
 250 }
 251
 252 TEST_F(DisplayManagerTest, OverscanInsetsTest) {
 253   if (!SupportsMultipleDisplays())
 254     return;
 255
 256   UpdateDisplay("0+0-500x500,0+501-400x400");
 257   reset();
 258   ASSERT_EQ(2u, display_manager()->GetNumDisplays());
 259   const DisplayInfo& display_info1 = GetDisplayInfoAt(0);
 260   const DisplayInfo& display_info2 = GetDisplayInfoAt(1);
 261   display_manager()->SetOverscanInsets(
 262       display_info2.id(), gfx::Insets(13, 12, 11, 10));
 263
 264   std::vector<gfx::Display> changed_displays = changed();
 265   EXPECT_EQ(1u, changed_displays.size());
 266   EXPECT_EQ(display_info2.id(), changed_displays[0].id());
 267   EXPECT_EQ("0,0 500x500",
 268             GetDisplayInfoAt(0).bounds_in_native().ToString());
 269   DisplayInfo updated_display_info2 = GetDisplayInfoAt(1);
 270   EXPECT_EQ("0,501 400x400",
 271             updated_display_info2.bounds_in_native().ToString());
 272   EXPECT_EQ("378x376",
 273             updated_display_info2.size_in_pixel().ToString());
 274   EXPECT_EQ("13,12,11,10",
 275             updated_display_info2.overscan_insets_in_dip().ToString());
 276   EXPECT_EQ("500,0 378x376",
 277             ScreenUtil::GetSecondaryDisplay().bounds().ToString());
 278
 279   // Make sure that SetOverscanInsets() is idempotent.
 280   display_manager()->SetOverscanInsets(display_info1.id(), gfx::Insets());
 281   display_manager()->SetOverscanInsets(
 282       display_info2.id(), gfx::Insets(13, 12, 11, 10));
 283   EXPECT_EQ("0,0 500x500",
 284             GetDisplayInfoAt(0).bounds_in_native().ToString());
 285   updated_display_info2 = GetDisplayInfoAt(1);
 286   EXPECT_EQ("0,501 400x400",
 287             updated_display_info2.bounds_in_native().ToString());
 288   EXPECT_EQ("378x376",
 289             updated_display_info2.size_in_pixel().ToString());
 290   EXPECT_EQ("13,12,11,10",
 291             updated_display_info2.overscan_insets_in_dip().ToString());
 292
 293   display_manager()->SetOverscanInsets(
 294       display_info2.id(), gfx::Insets(10, 11, 12, 13));
 295   EXPECT_EQ("0,0 500x500",
 296             GetDisplayInfoAt(0).bounds_in_native().ToString());
 297   EXPECT_EQ("376x378",
 298             GetDisplayInfoAt(1).size_in_pixel().ToString());
 299   EXPECT_EQ("10,11,12,13",
 300             GetDisplayInfoAt(1).overscan_insets_in_dip().ToString());
 301
 302   // Recreate a new 2nd display. It won't apply the overscan inset because the
 303   // new display has a different ID.
 304   UpdateDisplay("0+0-500x500");
 305   UpdateDisplay("0+0-500x500,0+501-400x400");
 306   EXPECT_EQ("0,0 500x500",
 307             GetDisplayInfoAt(0).bounds_in_native().ToString());
 308   EXPECT_EQ("0,501 400x400",
 309             GetDisplayInfoAt(1).bounds_in_native().ToString());
 310
 311   // Recreate the displays with the same ID.  It should apply the overscan
 312   // inset.
 313   UpdateDisplay("0+0-500x500");
 314   std::vector<DisplayInfo> display_info_list;
 315   display_info_list.push_back(display_info1);
 316   display_info_list.push_back(display_info2);
 317   display_manager()->OnNativeDisplaysChanged(display_info_list);
 318   EXPECT_EQ("1,1 500x500",
 319             GetDisplayInfoAt(0).bounds_in_native().ToString());
 320   updated_display_info2 = GetDisplayInfoAt(1);
 321   EXPECT_EQ("376x378",
 322             updated_display_info2.size_in_pixel().ToString());
 323   EXPECT_EQ("10,11,12,13",
 324             updated_display_info2.overscan_insets_in_dip().ToString());
 325
 326   // HiDPI but overscan display. The specified insets size should be doubled.
 327   UpdateDisplay("0+0-500x500,0+501-400x400*2");
 328   display_manager()->SetOverscanInsets(
 329       display_manager()->GetDisplayAt(1).id(), gfx::Insets(4, 5, 6, 7));
 330   EXPECT_EQ("0,0 500x500",
 331             GetDisplayInfoAt(0).bounds_in_native().ToString());
 332   updated_display_info2 = GetDisplayInfoAt(1);
 333   EXPECT_EQ("0,501 400x400",
 334             updated_display_info2.bounds_in_native().ToString());
 335   EXPECT_EQ("376x380",
 336             updated_display_info2.size_in_pixel().ToString());
 337   EXPECT_EQ("4,5,6,7",
 338             updated_display_info2.overscan_insets_in_dip().ToString());
 339   EXPECT_EQ("8,10,12,14",
 340             updated_display_info2.GetOverscanInsetsInPixel().ToString());
 341
 342   // Make sure switching primary display applies the overscan offset only once.
 343   ash::Shell::GetInstance()->display_controller()->SetPrimaryDisplay(
 344       ScreenUtil::GetSecondaryDisplay());
 345   EXPECT_EQ("-500,0 500x500",
 346             ScreenUtil::GetSecondaryDisplay().bounds().ToString());
 347   EXPECT_EQ("0,0 500x500",
 348             GetDisplayInfo(ScreenUtil::GetSecondaryDisplay()).
 349             bounds_in_native().ToString());
 350   EXPECT_EQ("0,501 400x400",
 351             GetDisplayInfo(Shell::GetScreen()->GetPrimaryDisplay()).
 352             bounds_in_native().ToString());
 353   EXPECT_EQ("0,0 188x190",
 354             Shell::GetScreen()->GetPrimaryDisplay().bounds().ToString());
 355 }
 356
 357 TEST_F(DisplayManagerTest, ZeroOverscanInsets) {
 358   if (!SupportsMultipleDisplays())
 359     return;
 360
 361   // Make sure the display change events is emitted for overscan inset changes.
 362   UpdateDisplay("0+0-500x500,0+501-400x400");
 363   ASSERT_EQ(2u, display_manager()->GetNumDisplays());
 364   int64 display2_id = display_manager()->GetDisplayAt(1).id();
 365
 366   reset();
 367   display_manager()->SetOverscanInsets(display2_id, gfx::Insets(0, 0, 0, 0));
 368   EXPECT_EQ(0u, changed().size());
 369
 370   reset();
 371   display_manager()->SetOverscanInsets(display2_id, gfx::Insets(1, 0, 0, 0));
 372   EXPECT_EQ(1u, changed().size());
 373   EXPECT_EQ(display2_id, changed()[0].id());
 374
 375   reset();
 376   display_manager()->SetOverscanInsets(display2_id, gfx::Insets(0, 0, 0, 0));
 377   EXPECT_EQ(1u, changed().size());
 378   EXPECT_EQ(display2_id, changed()[0].id());
 379 }
 380
 381 TEST_F(DisplayManagerTest, TestDeviceScaleOnlyChange) {
 382   if (!SupportsHostWindowResize())
 383     return;
 384
 385   UpdateDisplay("1000x600");
 386   aura::WindowTreeHost* host = Shell::GetPrimaryRootWindow()->GetHost();
 387   EXPECT_EQ(1, host->compositor()->device_scale_factor());
 388   EXPECT_EQ("1000x600",
 389             Shell::GetPrimaryRootWindow()->bounds().size().ToString());
 390   UpdateDisplay("1000x600*2");
 391   EXPECT_EQ(2, host->compositor()->device_scale_factor());
 392   EXPECT_EQ("500x300",
 393             Shell::GetPrimaryRootWindow()->bounds().size().ToString());
 394 }
 395
 396 DisplayInfo CreateDisplayInfo(int64 id, const gfx::Rect& bounds) {
 397   DisplayInfo info(id, ToDisplayName(id), false);
 398   info.SetBounds(bounds);
 399   return info;
 400 }
 401
 402 TEST_F(DisplayManagerTest, TestNativeDisplaysChanged) {
 403   const int64 internal_display_id =
 404       test::DisplayManagerTestApi(display_manager()).
 405       SetFirstDisplayAsInternalDisplay();
 406   const int external_id = 10;
 407   const int mirror_id = 11;
 408   const int64 invalid_id = gfx::Display::kInvalidDisplayID;
 409   const DisplayInfo internal_display_info =
 410       CreateDisplayInfo(internal_display_id, gfx::Rect(0, 0, 500, 500));
 411   const DisplayInfo external_display_info =
 412       CreateDisplayInfo(external_id, gfx::Rect(1, 1, 100, 100));
 413   const DisplayInfo mirrored_display_info =
 414       CreateDisplayInfo(mirror_id, gfx::Rect(0, 0, 500, 500));
 415
 416   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
 417   EXPECT_EQ(1U, display_manager()->num_connected_displays());
 418   std::string default_bounds =
 419       display_manager()->GetDisplayAt(0).bounds().ToString();
 420
 421   std::vector<DisplayInfo> display_info_list;
 422   // Primary disconnected.
 423   display_manager()->OnNativeDisplaysChanged(display_info_list);
 424   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
 425   EXPECT_EQ(default_bounds,
 426             display_manager()->GetDisplayAt(0).bounds().ToString());
 427   EXPECT_EQ(1U, display_manager()->num_connected_displays());
 428   EXPECT_FALSE(display_manager()->IsMirrored());
 429
 430   if (!SupportsMultipleDisplays())
 431     return;
 432
 433   // External connected while primary was disconnected.
 434   display_info_list.push_back(external_display_info);
 435   display_manager()->OnNativeDisplaysChanged(display_info_list);
 436   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
 437
 438   EXPECT_EQ(invalid_id, GetDisplayForId(internal_display_id).id());
 439   EXPECT_EQ("1,1 100x100",
 440             GetDisplayInfoForId(external_id).bounds_in_native().ToString());
 441   EXPECT_EQ(1U, display_manager()->num_connected_displays());
 442   EXPECT_FALSE(display_manager()->IsMirrored());
 443   EXPECT_EQ(external_id, Shell::GetScreen()->GetPrimaryDisplay().id());
 444
 445   EXPECT_EQ(internal_display_id, gfx::Display::InternalDisplayId());
 446
 447   // Primary connected, with different bounds.
 448   display_info_list.clear();
 449   display_info_list.push_back(internal_display_info);
 450   display_info_list.push_back(external_display_info);
 451   display_manager()->OnNativeDisplaysChanged(display_info_list);
 452   EXPECT_EQ(2U, display_manager()->GetNumDisplays());
 453   EXPECT_EQ(internal_display_id, Shell::GetScreen()->GetPrimaryDisplay().id());
 454
 455   // This combinatino is new, so internal display becomes primary.
 456   EXPECT_EQ("0,0 500x500",
 457             GetDisplayForId(internal_display_id).bounds().ToString());
 458   EXPECT_EQ("1,1 100x100",
 459             GetDisplayInfoForId(10).bounds_in_native().ToString());
 460   EXPECT_EQ(2U, display_manager()->num_connected_displays());
 461   EXPECT_FALSE(display_manager()->IsMirrored());
 462   EXPECT_EQ(ToDisplayName(internal_display_id),
 463             display_manager()->GetDisplayNameForId(internal_display_id));
 464
 465   // Emulate suspend.
 466   display_info_list.clear();
 467   display_manager()->OnNativeDisplaysChanged(display_info_list);
 468   EXPECT_EQ(2U, display_manager()->GetNumDisplays());
 469   EXPECT_EQ("0,0 500x500",
 470             GetDisplayForId(internal_display_id).bounds().ToString());
 471   EXPECT_EQ("1,1 100x100",
 472             GetDisplayInfoForId(10).bounds_in_native().ToString());
 473   EXPECT_EQ(2U, display_manager()->num_connected_displays());
 474   EXPECT_FALSE(display_manager()->IsMirrored());
 475   EXPECT_EQ(ToDisplayName(internal_display_id),
 476             display_manager()->GetDisplayNameForId(internal_display_id));
 477
 478   // External display has disconnected then resumed.
 479   display_info_list.push_back(internal_display_info);
 480   display_manager()->OnNativeDisplaysChanged(display_info_list);
 481   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
 482   EXPECT_EQ("0,0 500x500",
 483             GetDisplayForId(internal_display_id).bounds().ToString());
 484   EXPECT_EQ(1U, display_manager()->num_connected_displays());
 485   EXPECT_FALSE(display_manager()->IsMirrored());
 486
 487   // External display was changed during suspend.
 488   display_info_list.push_back(external_display_info);
 489   display_manager()->OnNativeDisplaysChanged(display_info_list);
 490   EXPECT_EQ(2U, display_manager()->GetNumDisplays());
 491   EXPECT_EQ(2U, display_manager()->num_connected_displays());
 492   EXPECT_FALSE(display_manager()->IsMirrored());
 493
 494   // suspend...
 495   display_info_list.clear();
 496   display_manager()->OnNativeDisplaysChanged(display_info_list);
 497   EXPECT_EQ(2U, display_manager()->GetNumDisplays());
 498   EXPECT_EQ(2U, display_manager()->num_connected_displays());
 499   EXPECT_FALSE(display_manager()->IsMirrored());
 500
 501   // and resume with different external display.
 502   display_info_list.push_back(internal_display_info);
 503   display_info_list.push_back(CreateDisplayInfo(12, gfx::Rect(1, 1, 100, 100)));
 504   display_manager()->OnNativeDisplaysChanged(display_info_list);
 505   EXPECT_EQ(2U, display_manager()->GetNumDisplays());
 506   EXPECT_EQ(2U, display_manager()->num_connected_displays());
 507   EXPECT_FALSE(display_manager()->IsMirrored());
 508   EXPECT_FALSE(display_manager()->IsMirrored());
 509
 510   // mirrored...
 511   display_info_list.clear();
 512   display_info_list.push_back(internal_display_info);
 513   display_info_list.push_back(mirrored_display_info);
 514   display_manager()->OnNativeDisplaysChanged(display_info_list);
 515   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
 516   EXPECT_EQ("0,0 500x500",
 517             GetDisplayForId(internal_display_id).bounds().ToString());
 518   EXPECT_EQ(2U, display_manager()->num_connected_displays());
 519   EXPECT_EQ(11U, display_manager()->mirrored_display_id());
 520   EXPECT_TRUE(display_manager()->IsMirrored());
 521
 522   // Test display name.
 523   EXPECT_EQ(ToDisplayName(internal_display_id),
 524             display_manager()->GetDisplayNameForId(internal_display_id));
 525   EXPECT_EQ("x-10", display_manager()->GetDisplayNameForId(10));
 526   EXPECT_EQ("x-11", display_manager()->GetDisplayNameForId(11));
 527   EXPECT_EQ("x-12", display_manager()->GetDisplayNameForId(12));
 528   // Default name for the id that doesn't exist.
 529   EXPECT_EQ("Display 100", display_manager()->GetDisplayNameForId(100));
 530
 531   // and exit mirroring.
 532   display_info_list.clear();
 533   display_info_list.push_back(internal_display_info);
 534   display_info_list.push_back(external_display_info);
 535   display_manager()->OnNativeDisplaysChanged(display_info_list);
 536   EXPECT_EQ(2U, display_manager()->GetNumDisplays());
 537   EXPECT_EQ(2U, display_manager()->num_connected_displays());
 538   EXPECT_FALSE(display_manager()->IsMirrored());
 539   EXPECT_EQ("0,0 500x500",
 540             GetDisplayForId(internal_display_id).bounds().ToString());
 541   EXPECT_EQ("500,0 100x100",
 542             GetDisplayForId(10).bounds().ToString());
 543
 544   // Turn off internal
 545   display_info_list.clear();
 546   display_info_list.push_back(external_display_info);
 547   display_manager()->OnNativeDisplaysChanged(display_info_list);
 548   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
 549   EXPECT_EQ(invalid_id, GetDisplayForId(internal_display_id).id());
 550   EXPECT_EQ("1,1 100x100",
 551             GetDisplayInfoForId(external_id).bounds_in_native().ToString());
 552   EXPECT_EQ(1U, display_manager()->num_connected_displays());
 553   EXPECT_FALSE(display_manager()->IsMirrored());
 554
 555   // Switched to another display
 556   display_info_list.clear();
 557   display_info_list.push_back(internal_display_info);
 558   display_manager()->OnNativeDisplaysChanged(display_info_list);
 559   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
 560   EXPECT_EQ(
 561       "0,0 500x500",
 562       GetDisplayInfoForId(internal_display_id).bounds_in_native().ToString());
 563   EXPECT_EQ(1U, display_manager()->num_connected_displays());
 564   EXPECT_FALSE(display_manager()->IsMirrored());
 565 }
 566
 567 #if defined(OS_WIN)
 568 // TODO(scottmg): RootWindow doesn't get resized on Windows
 569 // Ash. http://crbug.com/247916.
 570 #define MAYBE_TestNativeDisplaysChangedNoInternal \
 571         DISABLED_TestNativeDisplaysChangedNoInternal
 572 #else
 573 #define MAYBE_TestNativeDisplaysChangedNoInternal \
 574         TestNativeDisplaysChangedNoInternal
 575 #endif
 576
 577 TEST_F(DisplayManagerTest, MAYBE_TestNativeDisplaysChangedNoInternal) {
 578   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
 579
 580   // Don't change the display info if all displays are disconnected.
 581   std::vector<DisplayInfo> display_info_list;
 582   display_manager()->OnNativeDisplaysChanged(display_info_list);
 583   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
 584
 585   // Connect another display which will become primary.
 586   const DisplayInfo external_display_info =
 587       CreateDisplayInfo(10, gfx::Rect(1, 1, 100, 100));
 588   display_info_list.push_back(external_display_info);
 589   display_manager()->OnNativeDisplaysChanged(display_info_list);
 590   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
 591   EXPECT_EQ("1,1 100x100",
 592             GetDisplayInfoForId(10).bounds_in_native().ToString());
 593   EXPECT_EQ("100x100", ash::Shell::GetPrimaryRootWindow()->GetHost()->
 594       GetBounds().size().ToString());
 595 }
 596
 597 #if defined(OS_WIN)
 598 // Tests that rely on the actual host size/location does not work on windows.
 599 #define MAYBE_EnsurePointerInDisplays DISABLED_EnsurePointerInDisplays
 600 #define MAYBE_EnsurePointerInDisplays_2ndOnLeft DISABLED_EnsurePointerInDisplays_2ndOnLeft
 601 #else
 602 #define MAYBE_EnsurePointerInDisplays EnsurePointerInDisplays
 603 #define MAYBE_EnsurePointerInDisplays_2ndOnLeft EnsurePointerInDisplays_2ndOnLeft
 604 #endif
 605
 606 TEST_F(DisplayManagerTest, MAYBE_EnsurePointerInDisplays) {
 607   UpdateDisplay("200x200,300x300");
 608   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 609
 610   aura::Env* env = aura::Env::GetInstance();
 611
 612   aura::test::EventGenerator generator(root_windows[0]);
 613
 614   // Set the initial position.
 615   generator.MoveMouseToInHost(350, 150);
 616   EXPECT_EQ("350,150", env->last_mouse_location().ToString());
 617
 618   // A mouse pointer will stay in the 2nd display.
 619   UpdateDisplay("300x300,200x200");
 620   EXPECT_EQ("450,50", env->last_mouse_location().ToString());
 621
 622   // A mouse pointer will be outside of displays and move to the
 623   // center of 2nd display.
 624   UpdateDisplay("300x300,100x100");
 625   EXPECT_EQ("350,50", env->last_mouse_location().ToString());
 626
 627   // 2nd display was disconnected, and the cursor is
 628   // now in the 1st display.
 629   UpdateDisplay("400x400");
 630   EXPECT_EQ("50,350", env->last_mouse_location().ToString());
 631
 632   // 1st display's resolution has changed, and the mouse pointer is
 633   // now outside. Move the mouse pointer to the center of 1st display.
 634   UpdateDisplay("300x300");
 635   EXPECT_EQ("150,150", env->last_mouse_location().ToString());
 636
 637   // Move the mouse pointer to the bottom of 1st display.
 638   generator.MoveMouseToInHost(150, 290);
 639   EXPECT_EQ("150,290", env->last_mouse_location().ToString());
 640
 641   // The mouse pointer is now on 2nd display.
 642   UpdateDisplay("300x280,200x200");
 643   EXPECT_EQ("450,10", env->last_mouse_location().ToString());
 644 }
 645
 646 TEST_F(DisplayManagerTest, MAYBE_EnsurePointerInDisplays_2ndOnLeft) {
 647   // Set the 2nd display on the left.
 648   DisplayLayoutStore* layout_store =
 649       Shell::GetInstance()->display_manager()->layout_store();
 650   DisplayLayout layout = layout_store->default_display_layout();
 651   layout.position = DisplayLayout::LEFT;
 652   layout_store->SetDefaultDisplayLayout(layout);
 653
 654   UpdateDisplay("200x200,300x300");
 655   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 656
 657   EXPECT_EQ("-300,0 300x300",
 658             ScreenUtil::GetSecondaryDisplay().bounds().ToString());
 659
 660   aura::Env* env = aura::Env::GetInstance();
 661
 662   // Set the initial position.
 663   root_windows[0]->MoveCursorTo(gfx::Point(-150, 250));
 664   EXPECT_EQ("-150,250", env->last_mouse_location().ToString());
 665
 666   // A mouse pointer will stay in 2nd display.
 667   UpdateDisplay("300x300,200x300");
 668   EXPECT_EQ("-50,150", env->last_mouse_location().ToString());
 669
 670   // A mouse pointer will be outside of displays and move to the
 671   // center of 2nd display.
 672   UpdateDisplay("300x300,200x100");
 673   EXPECT_EQ("-100,50", env->last_mouse_location().ToString());
 674
 675   // 2nd display was disconnected. Mouse pointer should move to
 676   // 1st display.
 677   UpdateDisplay("300x300");
 678   EXPECT_EQ("150,150", env->last_mouse_location().ToString());
 679 }
 680
 681 TEST_F(DisplayManagerTest, NativeDisplaysChangedAfterPrimaryChange) {
 682   if (!SupportsMultipleDisplays())
 683     return;
 684
 685   const int64 internal_display_id =
 686       test::DisplayManagerTestApi(display_manager()).
 687       SetFirstDisplayAsInternalDisplay();
 688   const DisplayInfo native_display_info =
 689       CreateDisplayInfo(internal_display_id, gfx::Rect(0, 0, 500, 500));
 690   const DisplayInfo secondary_display_info =
 691       CreateDisplayInfo(10, gfx::Rect(1, 1, 100, 100));
 692
 693   std::vector<DisplayInfo> display_info_list;
 694   display_info_list.push_back(native_display_info);
 695   display_info_list.push_back(secondary_display_info);
 696   display_manager()->OnNativeDisplaysChanged(display_info_list);
 697   EXPECT_EQ(2U, display_manager()->GetNumDisplays());
 698   EXPECT_EQ("0,0 500x500",
 699             GetDisplayForId(internal_display_id).bounds().ToString());
 700   EXPECT_EQ("500,0 100x100", GetDisplayForId(10).bounds().ToString());
 701
 702   ash::Shell::GetInstance()->display_controller()->SetPrimaryDisplay(
 703       GetDisplayForId(secondary_display_info.id()));
 704   EXPECT_EQ("-500,0 500x500",
 705             GetDisplayForId(internal_display_id).bounds().ToString());
 706   EXPECT_EQ("0,0 100x100", GetDisplayForId(10).bounds().ToString());
 707
 708   // OnNativeDisplaysChanged may change the display bounds.  Here makes sure
 709   // nothing changed if the exactly same displays are specified.
 710   display_manager()->OnNativeDisplaysChanged(display_info_list);
 711   EXPECT_EQ("-500,0 500x500",
 712             GetDisplayForId(internal_display_id).bounds().ToString());
 713   EXPECT_EQ("0,0 100x100", GetDisplayForId(10).bounds().ToString());
 714 }
 715
 716 TEST_F(DisplayManagerTest, DontRememberBestResolution) {
 717   int display_id = 1000;
 718   DisplayInfo native_display_info =
 719       CreateDisplayInfo(display_id, gfx::Rect(0, 0, 1000, 500));
 720   std::vector<DisplayMode> display_modes;
 721   display_modes.push_back(
 722       DisplayMode(gfx::Size(1000, 500), 58.0f, false, true));
 723   display_modes.push_back(
 724       DisplayMode(gfx::Size(800, 300), 59.0f, false, false));
 725   display_modes.push_back(
 726       DisplayMode(gfx::Size(400, 500), 60.0f, false, false));
 727
 728   native_display_info.set_display_modes(display_modes);
 729
 730   std::vector<DisplayInfo> display_info_list;
 731   display_info_list.push_back(native_display_info);
 732   display_manager()->OnNativeDisplaysChanged(display_info_list);
 733
 734   DisplayMode mode;
 735   EXPECT_FALSE(
 736       display_manager()->GetSelectedModeForDisplayId(display_id, &mode));
 737
 738   // Unsupported resolution.
 739   display_manager()->SetDisplayResolution(display_id, gfx::Size(800, 4000));
 740   EXPECT_FALSE(
 741       display_manager()->GetSelectedModeForDisplayId(display_id, &mode));
 742
 743   // Supported resolution.
 744   display_manager()->SetDisplayResolution(display_id, gfx::Size(800, 300));
 745   EXPECT_TRUE(
 746       display_manager()->GetSelectedModeForDisplayId(display_id, &mode));
 747   EXPECT_EQ("800x300", mode.size.ToString());
 748   EXPECT_EQ(59.0f, mode.refresh_rate);
 749   EXPECT_FALSE(mode.native);
 750
 751   // Best resolution.
 752   display_manager()->SetDisplayResolution(display_id, gfx::Size(1000, 500));
 753   EXPECT_TRUE(
 754       display_manager()->GetSelectedModeForDisplayId(display_id, &mode));
 755   EXPECT_EQ("1000x500", mode.size.ToString());
 756   EXPECT_EQ(58.0f, mode.refresh_rate);
 757   EXPECT_TRUE(mode.native);
 758 }
 759
 760 TEST_F(DisplayManagerTest, ResolutionFallback) {
 761   int display_id = 1000;
 762   DisplayInfo native_display_info =
 763       CreateDisplayInfo(display_id, gfx::Rect(0, 0, 1000, 500));
 764   std::vector<DisplayMode> display_modes;
 765   display_modes.push_back(
 766       DisplayMode(gfx::Size(1000, 500), 58.0f, false, true));
 767   display_modes.push_back(
 768       DisplayMode(gfx::Size(800, 300), 59.0f, false, false));
 769   display_modes.push_back(
 770       DisplayMode(gfx::Size(400, 500), 60.0f, false, false));
 771
 772   std::vector<DisplayMode> copy = display_modes;
 773   native_display_info.set_display_modes(copy);
 774
 775   std::vector<DisplayInfo> display_info_list;
 776   display_info_list.push_back(native_display_info);
 777   display_manager()->OnNativeDisplaysChanged(display_info_list);
 778   {
 779     display_manager()->SetDisplayResolution(display_id, gfx::Size(800, 300));
 780     DisplayInfo new_native_display_info =
 781         CreateDisplayInfo(display_id, gfx::Rect(0, 0, 400, 500));
 782     copy = display_modes;
 783     new_native_display_info.set_display_modes(copy);
 784     std::vector<DisplayInfo> new_display_info_list;
 785     new_display_info_list.push_back(new_native_display_info);
 786     display_manager()->OnNativeDisplaysChanged(new_display_info_list);
 787
 788     DisplayMode mode;
 789     EXPECT_TRUE(
 790         display_manager()->GetSelectedModeForDisplayId(display_id, &mode));
 791     EXPECT_EQ("400x500", mode.size.ToString());
 792     EXPECT_EQ(60.0f, mode.refresh_rate);
 793     EXPECT_FALSE(mode.native);
 794   }
 795   {
 796     // Best resolution should find itself on the resolutions list.
 797     display_manager()->SetDisplayResolution(display_id, gfx::Size(800, 300));
 798     DisplayInfo new_native_display_info =
 799         CreateDisplayInfo(display_id, gfx::Rect(0, 0, 1000, 500));
 800     std::vector<DisplayMode> copy = display_modes;
 801     new_native_display_info.set_display_modes(copy);
 802     std::vector<DisplayInfo> new_display_info_list;
 803     new_display_info_list.push_back(new_native_display_info);
 804     display_manager()->OnNativeDisplaysChanged(new_display_info_list);
 805
 806     DisplayMode mode;
 807     EXPECT_TRUE(
 808         display_manager()->GetSelectedModeForDisplayId(display_id, &mode));
 809     EXPECT_EQ("1000x500", mode.size.ToString());
 810     EXPECT_EQ(58.0f, mode.refresh_rate);
 811     EXPECT_TRUE(mode.native);
 812   }
 813 }
 814
 815 TEST_F(DisplayManagerTest, Rotate) {
 816   if (!SupportsMultipleDisplays())
 817     return;
 818
 819   UpdateDisplay("100x200/r,300x400/l");
 820   EXPECT_EQ("1,1 100x200",
 821             GetDisplayInfoAt(0).bounds_in_native().ToString());
 822   EXPECT_EQ("200x100",
 823             GetDisplayInfoAt(0).size_in_pixel().ToString());
 824
 825   EXPECT_EQ("1,201 300x400",
 826             GetDisplayInfoAt(1).bounds_in_native().ToString());
 827   EXPECT_EQ("400x300",
 828             GetDisplayInfoAt(1).size_in_pixel().ToString());
 829   reset();
 830   UpdateDisplay("100x200/b,300x400");
 831   EXPECT_EQ("2 0 0", GetCountSummary());
 832   reset();
 833
 834   EXPECT_EQ("1,1 100x200",
 835             GetDisplayInfoAt(0).bounds_in_native().ToString());
 836   EXPECT_EQ("100x200",
 837             GetDisplayInfoAt(0).size_in_pixel().ToString());
 838
 839   EXPECT_EQ("1,201 300x400",
 840             GetDisplayInfoAt(1).bounds_in_native().ToString());
 841   EXPECT_EQ("300x400",
 842             GetDisplayInfoAt(1).size_in_pixel().ToString());
 843
 844   // Just Rotating display will change the bounds on both display.
 845   UpdateDisplay("100x200/l,300x400");
 846   EXPECT_EQ("2 0 0", GetCountSummary());
 847   reset();
 848
 849   // Updating tothe same configuration should report no changes.
 850   UpdateDisplay("100x200/l,300x400");
 851   EXPECT_EQ("0 0 0", GetCountSummary());
 852   reset();
 853
 854   UpdateDisplay("100x200/l,300x400");
 855   EXPECT_EQ("0 0 0", GetCountSummary());
 856   reset();
 857
 858   UpdateDisplay("200x200");
 859   EXPECT_EQ("1 0 1", GetCountSummary());
 860   reset();
 861
 862   UpdateDisplay("200x200/l");
 863   EXPECT_EQ("1 0 0", GetCountSummary());
 864 }
 865
 866 TEST_F(DisplayManagerTest, UIScale) {
 867   UpdateDisplay("1280x800");
 868   int64 display_id = Shell::GetScreen()->GetPrimaryDisplay().id();
 869   display_manager()->SetDisplayUIScale(display_id, 1.125f);
 870   EXPECT_EQ(1.0, GetDisplayInfoAt(0).configured_ui_scale());
 871   display_manager()->SetDisplayUIScale(display_id, 0.8f);
 872   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).configured_ui_scale());
 873   display_manager()->SetDisplayUIScale(display_id, 0.75f);
 874   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).configured_ui_scale());
 875   display_manager()->SetDisplayUIScale(display_id, 0.625f);
 876   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).configured_ui_scale());
 877
 878   gfx::Display::SetInternalDisplayId(display_id);
 879
 880   display_manager()->SetDisplayUIScale(display_id, 1.5f);
 881   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).configured_ui_scale());
 882   display_manager()->SetDisplayUIScale(display_id, 1.25f);
 883   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).configured_ui_scale());
 884   display_manager()->SetDisplayUIScale(display_id, 1.125f);
 885   EXPECT_EQ(1.125f, GetDisplayInfoAt(0).configured_ui_scale());
 886   display_manager()->SetDisplayUIScale(display_id, 0.8f);
 887   EXPECT_EQ(0.8f, GetDisplayInfoAt(0).configured_ui_scale());
 888   display_manager()->SetDisplayUIScale(display_id, 0.75f);
 889   EXPECT_EQ(0.8f, GetDisplayInfoAt(0).configured_ui_scale());
 890   display_manager()->SetDisplayUIScale(display_id, 0.625f);
 891   EXPECT_EQ(0.625f, GetDisplayInfoAt(0).configured_ui_scale());
 892   display_manager()->SetDisplayUIScale(display_id, 0.6f);
 893   EXPECT_EQ(0.625f, GetDisplayInfoAt(0).configured_ui_scale());
 894   display_manager()->SetDisplayUIScale(display_id, 0.5f);
 895   EXPECT_EQ(0.5f, GetDisplayInfoAt(0).configured_ui_scale());
 896
 897   UpdateDisplay("1366x768");
 898   display_manager()->SetDisplayUIScale(display_id, 1.5f);
 899   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).configured_ui_scale());
 900   display_manager()->SetDisplayUIScale(display_id, 1.25f);
 901   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).configured_ui_scale());
 902   display_manager()->SetDisplayUIScale(display_id, 1.125f);
 903   EXPECT_EQ(1.125f, GetDisplayInfoAt(0).configured_ui_scale());
 904   display_manager()->SetDisplayUIScale(display_id, 0.8f);
 905   EXPECT_EQ(1.125f, GetDisplayInfoAt(0).configured_ui_scale());
 906   display_manager()->SetDisplayUIScale(display_id, 0.75f);
 907   EXPECT_EQ(0.75f, GetDisplayInfoAt(0).configured_ui_scale());
 908   display_manager()->SetDisplayUIScale(display_id, 0.6f);
 909   EXPECT_EQ(0.6f, GetDisplayInfoAt(0).configured_ui_scale());
 910   display_manager()->SetDisplayUIScale(display_id, 0.625f);
 911   EXPECT_EQ(0.6f, GetDisplayInfoAt(0).configured_ui_scale());
 912   display_manager()->SetDisplayUIScale(display_id, 0.5f);
 913   EXPECT_EQ(0.5f, GetDisplayInfoAt(0).configured_ui_scale());
 914
 915   UpdateDisplay("1280x850*2");
 916   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).configured_ui_scale());
 917   display_manager()->SetDisplayUIScale(display_id, 1.5f);
 918   EXPECT_EQ(1.5f, GetDisplayInfoAt(0).configured_ui_scale());
 919   display_manager()->SetDisplayUIScale(display_id, 1.25f);
 920   EXPECT_EQ(1.25f, GetDisplayInfoAt(0).configured_ui_scale());
 921   display_manager()->SetDisplayUIScale(display_id, 1.125f);
 922   EXPECT_EQ(1.125f, GetDisplayInfoAt(0).configured_ui_scale());
 923   display_manager()->SetDisplayUIScale(display_id, 1.0f);
 924   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).configured_ui_scale());
 925   gfx::Display display = Shell::GetScreen()->GetPrimaryDisplay();
 926   EXPECT_EQ(2.0f, display.device_scale_factor());
 927   EXPECT_EQ("640x425", display.bounds().size().ToString());
 928
 929   display_manager()->SetDisplayUIScale(display_id, 0.8f);
 930   EXPECT_EQ(0.8f, GetDisplayInfoAt(0).configured_ui_scale());
 931   display_manager()->SetDisplayUIScale(display_id, 0.75f);
 932   EXPECT_EQ(0.8f, GetDisplayInfoAt(0).configured_ui_scale());
 933   display_manager()->SetDisplayUIScale(display_id, 0.625f);
 934   EXPECT_EQ(0.625f, GetDisplayInfoAt(0).configured_ui_scale());
 935   display_manager()->SetDisplayUIScale(display_id, 0.6f);
 936   EXPECT_EQ(0.625f, GetDisplayInfoAt(0).configured_ui_scale());
 937   display_manager()->SetDisplayUIScale(display_id, 0.5f);
 938   EXPECT_EQ(0.5f, GetDisplayInfoAt(0).configured_ui_scale());
 939
 940   display_manager()->SetDisplayUIScale(display_id, 2.0f);
 941   EXPECT_EQ(2.0f, GetDisplayInfoAt(0).configured_ui_scale());
 942   EXPECT_EQ(1.0f, GetDisplayInfoAt(0).GetEffectiveUIScale());
 943   display = Shell::GetScreen()->GetPrimaryDisplay();
 944   EXPECT_EQ(1.0f, display.device_scale_factor());
 945   EXPECT_EQ("1280x850", display.bounds().size().ToString());
 946 }
 947
 948
 949 #if defined(OS_WIN)
 950 // TODO(scottmg): RootWindow doesn't get resized on Windows
 951 // Ash. http://crbug.com/247916.
 952 #define MAYBE_UpdateMouseCursorAfterRotateZoom DISABLED_UpdateMouseCursorAfterRotateZoom
 953 #else
 954 #define MAYBE_UpdateMouseCursorAfterRotateZoom UpdateMouseCursorAfterRotateZoom
 955 #endif
 956
 957 TEST_F(DisplayManagerTest, MAYBE_UpdateMouseCursorAfterRotateZoom) {
 958   // Make sure just rotating will not change native location.
 959   UpdateDisplay("300x200,200x150");
 960   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 961   aura::Env* env = aura::Env::GetInstance();
 962
 963   aura::test::EventGenerator generator1(root_windows[0]);
 964   aura::test::EventGenerator generator2(root_windows[1]);
 965
 966   // Test on 1st display.
 967   generator1.MoveMouseToInHost(150, 50);
 968   EXPECT_EQ("150,50", env->last_mouse_location().ToString());
 969   UpdateDisplay("300x200/r,200x150");
 970   EXPECT_EQ("50,149", env->last_mouse_location().ToString());
 971
 972   // Test on 2nd display.
 973   generator2.MoveMouseToInHost(50, 100);
 974   EXPECT_EQ("250,100", env->last_mouse_location().ToString());
 975   UpdateDisplay("300x200/r,200x150/l");
 976   EXPECT_EQ("249,50", env->last_mouse_location().ToString());
 977
 978   // The native location is now outside, so move to the center
 979   // of closest display.
 980   UpdateDisplay("300x200/r,100x50/l");
 981   EXPECT_EQ("225,50", env->last_mouse_location().ToString());
 982
 983   // Make sure just zooming will not change native location.
 984   UpdateDisplay("600x400*2,400x300");
 985
 986   // Test on 1st display.
 987   generator1.MoveMouseToInHost(200, 300);
 988   EXPECT_EQ("100,150", env->last_mouse_location().ToString());
 989   UpdateDisplay("600x400*2@1.5,400x300");
 990   EXPECT_EQ("150,225", env->last_mouse_location().ToString());
 991
 992   // Test on 2nd display.
 993   UpdateDisplay("600x400,400x300*2");
 994   generator2.MoveMouseToInHost(200, 250);
 995   EXPECT_EQ("700,125", env->last_mouse_location().ToString());
 996   UpdateDisplay("600x400,400x300*2@1.5");
 997   EXPECT_EQ("750,187", env->last_mouse_location().ToString());
 998
 999   // The native location is now outside, so move to the
1000   // center of closest display.
1001   UpdateDisplay("600x400,400x200*2@1.5");
1002   EXPECT_EQ("750,75", env->last_mouse_location().ToString());
1003 }
1004
1005 class TestDisplayObserver : public gfx::DisplayObserver {
1006  public:
1007   TestDisplayObserver() : changed_(false) {}
1008   virtual ~TestDisplayObserver() {}
1009
1010   // gfx::DisplayObserver overrides:
1011   virtual void OnDisplayBoundsChanged(const gfx::Display& display) OVERRIDE {
1012   }
1013   virtual void OnDisplayAdded(const gfx::Display& new_display) OVERRIDE {
1014     // Mirror window should already be delete before restoring
1015     // the external display.
1016     EXPECT_FALSE(test_api.GetHost());
1017     changed_ = true;
1018   }
1019   virtual void OnDisplayRemoved(const gfx::Display& old_display) OVERRIDE {
1020     // Mirror window should not be created until the external display
1021     // is removed.
1022     EXPECT_FALSE(test_api.GetHost());
1023     changed_ = true;
1024   }
1025
1026   bool changed_and_reset() {
1027     bool changed = changed_;
1028     changed_ = false;
1029     return changed;
1030   }
1031
1032  private:
1033   test::MirrorWindowTestApi test_api;
1034   bool changed_;
1035
1036   DISALLOW_COPY_AND_ASSIGN(TestDisplayObserver);
1037 };
1038
1039 TEST_F(DisplayManagerTest, SoftwareMirroring) {
1040   if (!SupportsMultipleDisplays())
1041     return;
1042
1043   UpdateDisplay("300x400,400x500");
1044
1045   test::MirrorWindowTestApi test_api;
1046   EXPECT_EQ(NULL, test_api.GetHost());
1047
1048   TestDisplayObserver display_observer;
1049   Shell::GetScreen()->AddObserver(&display_observer);
1050
1051   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
1052   display_manager->SetSecondDisplayMode(DisplayManager::MIRRORING);
1053   display_manager->UpdateDisplays();
1054   EXPECT_TRUE(display_observer.changed_and_reset());
1055   EXPECT_EQ(1U, display_manager->GetNumDisplays());
1056   EXPECT_EQ("0,0 300x400",
1057             Shell::GetScreen()->GetPrimaryDisplay().bounds().ToString());
1058   EXPECT_EQ("400x500", test_api.GetHost()->GetBounds().size().ToString());
1059   EXPECT_EQ("300x400",
1060             test_api.GetHost()->window()->bounds().size().ToString());
1061   EXPECT_TRUE(display_manager->IsMirrored());
1062
1063   display_manager->SetMirrorMode(false);
1064   EXPECT_TRUE(display_observer.changed_and_reset());
1065   EXPECT_EQ(NULL, test_api.GetHost());
1066   EXPECT_EQ(2U, display_manager->GetNumDisplays());
1067   EXPECT_FALSE(display_manager->IsMirrored());
1068
1069   // Make sure the mirror window has the pixel size of the
1070   // source display.
1071   display_manager->SetMirrorMode(true);
1072   EXPECT_TRUE(display_observer.changed_and_reset());
1073
1074   UpdateDisplay("300x400@0.5,400x500");
1075   EXPECT_FALSE(display_observer.changed_and_reset());
1076   EXPECT_EQ("300x400",
1077             test_api.GetHost()->window()->bounds().size().ToString());
1078
1079   UpdateDisplay("310x410*2,400x500");
1080   EXPECT_FALSE(display_observer.changed_and_reset());
1081   EXPECT_EQ("310x410",
1082             test_api.GetHost()->window()->bounds().size().ToString());
1083
1084   UpdateDisplay("320x420/r,400x500");
1085   EXPECT_FALSE(display_observer.changed_and_reset());
1086   EXPECT_EQ("320x420",
1087             test_api.GetHost()->window()->bounds().size().ToString());
1088
1089   UpdateDisplay("330x440/r,400x500");
1090   EXPECT_FALSE(display_observer.changed_and_reset());
1091   EXPECT_EQ("330x440",
1092             test_api.GetHost()->window()->bounds().size().ToString());
1093
1094   // Overscan insets are ignored.
1095   UpdateDisplay("400x600/o,600x800/o");
1096   EXPECT_FALSE(display_observer.changed_and_reset());
1097   EXPECT_EQ("400x600",
1098             test_api.GetHost()->window()->bounds().size().ToString());
1099
1100   Shell::GetScreen()->RemoveObserver(&display_observer);
1101 }
1102
1103 TEST_F(DisplayManagerTest, MirroredLayout) {
1104   if (!SupportsMultipleDisplays())
1105     return;
1106
1107   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
1108   UpdateDisplay("500x500,400x400");
1109   EXPECT_FALSE(display_manager->GetCurrentDisplayLayout().mirrored);
1110   EXPECT_EQ(2, Shell::GetScreen()->GetNumDisplays());
1111   EXPECT_EQ(2U, display_manager->num_connected_displays());
1112
1113   UpdateDisplay("1+0-500x500,1+0-500x500");
1114   EXPECT_TRUE(display_manager->GetCurrentDisplayLayout().mirrored);
1115   EXPECT_EQ(1, Shell::GetScreen()->GetNumDisplays());
1116   EXPECT_EQ(2U, display_manager->num_connected_displays());
1117
1118   UpdateDisplay("500x500,500x500");
1119   EXPECT_FALSE(display_manager->GetCurrentDisplayLayout().mirrored);
1120   EXPECT_EQ(2, Shell::GetScreen()->GetNumDisplays());
1121   EXPECT_EQ(2U, display_manager->num_connected_displays());
1122 }
1123
1124 TEST_F(DisplayManagerTest, InvertLayout) {
1125   EXPECT_EQ("left, 0",
1126             DisplayLayout(DisplayLayout::RIGHT, 0).Invert().ToString());
1127   EXPECT_EQ("left, -100",
1128             DisplayLayout(DisplayLayout::RIGHT, 100).Invert().ToString());
1129   EXPECT_EQ("left, 50",
1130             DisplayLayout(DisplayLayout::RIGHT, -50).Invert().ToString());
1131
1132   EXPECT_EQ("right, 0",
1133             DisplayLayout(DisplayLayout::LEFT, 0).Invert().ToString());
1134   EXPECT_EQ("right, -90",
1135             DisplayLayout(DisplayLayout::LEFT, 90).Invert().ToString());
1136   EXPECT_EQ("right, 60",
1137             DisplayLayout(DisplayLayout::LEFT, -60).Invert().ToString());
1138
1139   EXPECT_EQ("bottom, 0",
1140             DisplayLayout(DisplayLayout::TOP, 0).Invert().ToString());
1141   EXPECT_EQ("bottom, -80",
1142             DisplayLayout(DisplayLayout::TOP, 80).Invert().ToString());
1143   EXPECT_EQ("bottom, 70",
1144             DisplayLayout(DisplayLayout::TOP, -70).Invert().ToString());
1145
1146   EXPECT_EQ("top, 0",
1147             DisplayLayout(DisplayLayout::BOTTOM, 0).Invert().ToString());
1148   EXPECT_EQ("top, -70",
1149             DisplayLayout(DisplayLayout::BOTTOM, 70).Invert().ToString());
1150   EXPECT_EQ("top, 80",
1151             DisplayLayout(DisplayLayout::BOTTOM, -80).Invert().ToString());
1152 }
1153
1154 #if defined(OS_WIN)
1155 // TODO(scottmg): RootWindow doesn't get resized on Windows
1156 // Ash. http://crbug.com/247916.
1157 #define MAYBE_UpdateDisplayWithHostOrigin DISABLED_UpdateDisplayWithHostOrigin
1158 #else
1159 #define MAYBE_UpdateDisplayWithHostOrigin UpdateDisplayWithHostOrigin
1160 #endif
1161
1162 TEST_F(DisplayManagerTest, MAYBE_UpdateDisplayWithHostOrigin) {
1163   UpdateDisplay("100x200,300x400");
1164   ASSERT_EQ(2, Shell::GetScreen()->GetNumDisplays());
1165   aura::Window::Windows root_windows =
1166       Shell::GetInstance()->GetAllRootWindows();
1167   ASSERT_EQ(2U, root_windows.size());
1168   aura::WindowTreeHost* host0 = root_windows[0]->GetHost();
1169   aura::WindowTreeHost* host1 = root_windows[1]->GetHost();
1170
1171   EXPECT_EQ("1,1", host0->GetBounds().origin().ToString());
1172   EXPECT_EQ("100x200", host0->GetBounds().size().ToString());
1173   // UpdateDisplay set the origin if it's not set.
1174   EXPECT_NE("1,1", host1->GetBounds().origin().ToString());
1175   EXPECT_EQ("300x400", host1->GetBounds().size().ToString());
1176
1177   UpdateDisplay("100x200,200+300-300x400");
1178   ASSERT_EQ(2, Shell::GetScreen()->GetNumDisplays());
1179   EXPECT_EQ("0,0", host0->GetBounds().origin().ToString());
1180   EXPECT_EQ("100x200", host0->GetBounds().size().ToString());
1181   EXPECT_EQ("200,300", host1->GetBounds().origin().ToString());
1182   EXPECT_EQ("300x400", host1->GetBounds().size().ToString());
1183
1184   UpdateDisplay("400+500-200x300,300x400");
1185   ASSERT_EQ(2, Shell::GetScreen()->GetNumDisplays());
1186   EXPECT_EQ("400,500", host0->GetBounds().origin().ToString());
1187   EXPECT_EQ("200x300", host0->GetBounds().size().ToString());
1188   EXPECT_EQ("0,0", host1->GetBounds().origin().ToString());
1189   EXPECT_EQ("300x400", host1->GetBounds().size().ToString());
1190
1191   UpdateDisplay("100+200-100x200,300+500-200x300");
1192   ASSERT_EQ(2, Shell::GetScreen()->GetNumDisplays());
1193   EXPECT_EQ("100,200", host0->GetBounds().origin().ToString());
1194   EXPECT_EQ("100x200", host0->GetBounds().size().ToString());
1195   EXPECT_EQ("300,500", host1->GetBounds().origin().ToString());
1196   EXPECT_EQ("200x300", host1->GetBounds().size().ToString());
1197 }
1198
1199
1200 class ScreenShutdownTest : public test::AshTestBase {
1201  public:
1202   ScreenShutdownTest() {
1203   }
1204   virtual ~ScreenShutdownTest() {}
1205
1206   virtual void TearDown() OVERRIDE {
1207     gfx::Screen* orig_screen =
1208         gfx::Screen::GetScreenByType(gfx::SCREEN_TYPE_ALTERNATE);
1209     AshTestBase::TearDown();
1210     if (!SupportsMultipleDisplays())
1211       return;
1212     gfx::Screen* screen =
1213         gfx::Screen::GetScreenByType(gfx::SCREEN_TYPE_ALTERNATE);
1214     EXPECT_NE(orig_screen, screen);
1215     EXPECT_EQ(2, screen->GetNumDisplays());
1216     EXPECT_EQ("500x300", screen->GetPrimaryDisplay().size().ToString());
1217     std::vector<gfx::Display> all = screen->GetAllDisplays();
1218     EXPECT_EQ("500x300", all[0].size().ToString());
1219     EXPECT_EQ("800x400", all[1].size().ToString());
1220   }
1221
1222  private:
1223   DISALLOW_COPY_AND_ASSIGN(ScreenShutdownTest);
1224 };
1225
1226 TEST_F(ScreenShutdownTest, ScreenAfterShutdown) {
1227   if (!SupportsMultipleDisplays())
1228     return;
1229   UpdateDisplay("500x300,800x400");
1230 }
1231
1232 }  // namespace ash