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