ash/display/display_controller_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_controller.h"
   6
   7 #include "ash/display/display_manager.h"
   8 #include "ash/launcher/launcher.h"
   9 #include "ash/screen_ash.h"
  10 #include "ash/shell.h"
  11 #include "ash/test/ash_test_base.h"
  12 #include "ash/test/cursor_manager_test_api.h"
  13 #include "ui/aura/env.h"
  14 #include "ui/aura/root_window.h"
  15 #include "ui/aura/window_tracker.h"
  16 #include "ui/gfx/display.h"
  17 #include "ui/gfx/screen.h"
  18 #include "ui/views/widget/widget.h"
  19
  20 namespace ash {
  21 namespace test {
  22 namespace {
  23
  24 class TestObserver : public DisplayController::Observer {
  25  public:
  26   TestObserver() : count_(0) {
  27     Shell::GetInstance()->display_controller()->AddObserver(this);
  28   }
  29
  30   virtual ~TestObserver() {
  31     Shell::GetInstance()->display_controller()->RemoveObserver(this);
  32   }
  33
  34   virtual void OnDisplayConfigurationChanging() OVERRIDE {
  35     ++count_;
  36   }
  37
  38   int CountAndReset() {
  39     int c = count_;
  40     count_ = 0;
  41     return c;
  42   }
  43
  44  private:
  45   int count_;
  46
  47   DISALLOW_COPY_AND_ASSIGN(TestObserver);
  48 };
  49
  50 gfx::Display GetPrimaryDisplay() {
  51   return Shell::GetScreen()->GetDisplayNearestWindow(
  52       Shell::GetAllRootWindows()[0]);
  53 }
  54
  55 gfx::Display GetSecondaryDisplay() {
  56   return Shell::GetScreen()->GetDisplayNearestWindow(
  57       Shell::GetAllRootWindows()[1]);
  58 }
  59
  60 void SetSecondaryDisplayLayoutAndOffset(DisplayLayout::Position position,
  61                                         int offset) {
  62   DisplayController* display_controller =
  63       Shell::GetInstance()->display_controller();
  64   DisplayLayout layout = display_controller->default_display_layout();
  65   layout.position = position;
  66   layout.offset = offset;
  67   display_controller->SetDefaultDisplayLayout(layout);
  68 }
  69
  70 void SetSecondaryDisplayLayout(DisplayLayout::Position position) {
  71   SetSecondaryDisplayLayoutAndOffset(position, 0);
  72 }
  73
  74 class DisplayControllerShutdownTest : public test::AshTestBase {
  75  public:
  76   virtual void TearDown() OVERRIDE {
  77     test::AshTestBase::TearDown();
  78     // Make sure that primary display is accessible after shutdown.
  79     gfx::Display primary = gfx::Screen::GetNativeScreen()->GetPrimaryDisplay();
  80     EXPECT_EQ("0,0 444x333", primary.bounds().ToString());
  81     EXPECT_EQ(2, gfx::Screen::GetNativeScreen()->GetNumDisplays());
  82   }
  83 };
  84
  85 }  // namespace
  86
  87 typedef test::AshTestBase DisplayControllerTest;
  88
  89 TEST_F(DisplayControllerShutdownTest, Shutdown) {
  90   UpdateDisplay("444x333, 200x200");
  91 }
  92
  93 TEST_F(DisplayControllerTest, SecondaryDisplayLayout) {
  94   TestObserver observer;
  95   UpdateDisplay("500x500,400x400");
  96   EXPECT_EQ(2, observer.CountAndReset());  // resize and add
  97   gfx::Display* secondary_display =
  98       Shell::GetInstance()->display_manager()->GetDisplayAt(1);
  99   gfx::Insets insets(5, 5, 5, 5);
 100   secondary_display->UpdateWorkAreaFromInsets(insets);
 101
 102   // Default layout is RIGHT.
 103   EXPECT_EQ("0,0 500x500", GetPrimaryDisplay().bounds().ToString());
 104   EXPECT_EQ("500,0 400x400", GetSecondaryDisplay().bounds().ToString());
 105   EXPECT_EQ("505,5 390x390", GetSecondaryDisplay().work_area().ToString());
 106
 107   // Layout the secondary display to the bottom of the primary.
 108   SetSecondaryDisplayLayout(DisplayLayout::BOTTOM);
 109   EXPECT_EQ(1, observer.CountAndReset());
 110   EXPECT_EQ("0,0 500x500", GetPrimaryDisplay().bounds().ToString());
 111   EXPECT_EQ("0,500 400x400", GetSecondaryDisplay().bounds().ToString());
 112   EXPECT_EQ("5,505 390x390", GetSecondaryDisplay().work_area().ToString());
 113
 114   // Layout the secondary display to the left of the primary.
 115   SetSecondaryDisplayLayout(DisplayLayout::LEFT);
 116   EXPECT_EQ(1, observer.CountAndReset());
 117   EXPECT_EQ("0,0 500x500", GetPrimaryDisplay().bounds().ToString());
 118   EXPECT_EQ("-400,0 400x400", GetSecondaryDisplay().bounds().ToString());
 119   EXPECT_EQ("-395,5 390x390", GetSecondaryDisplay().work_area().ToString());
 120
 121   // Layout the secondary display to the top of the primary.
 122   SetSecondaryDisplayLayout(DisplayLayout::TOP);
 123   EXPECT_EQ(1, observer.CountAndReset());
 124   EXPECT_EQ("0,0 500x500", GetPrimaryDisplay().bounds().ToString());
 125   EXPECT_EQ("0,-400 400x400", GetSecondaryDisplay().bounds().ToString());
 126   EXPECT_EQ("5,-395 390x390", GetSecondaryDisplay().work_area().ToString());
 127
 128   // Layout to the right with an offset.
 129   SetSecondaryDisplayLayoutAndOffset(DisplayLayout::RIGHT, 300);
 130   EXPECT_EQ(1, observer.CountAndReset());  // resize and add
 131   EXPECT_EQ("0,0 500x500", GetPrimaryDisplay().bounds().ToString());
 132   EXPECT_EQ("500,300 400x400", GetSecondaryDisplay().bounds().ToString());
 133
 134   // Keep the minimum 100.
 135   SetSecondaryDisplayLayoutAndOffset(DisplayLayout::RIGHT, 490);
 136   EXPECT_EQ(1, observer.CountAndReset());  // resize and add
 137   EXPECT_EQ("0,0 500x500", GetPrimaryDisplay().bounds().ToString());
 138   EXPECT_EQ("500,400 400x400", GetSecondaryDisplay().bounds().ToString());
 139
 140   SetSecondaryDisplayLayoutAndOffset(DisplayLayout::RIGHT, -400);
 141   EXPECT_EQ(1, observer.CountAndReset());  // resize and add
 142   EXPECT_EQ("0,0 500x500", GetPrimaryDisplay().bounds().ToString());
 143   EXPECT_EQ("500,-300 400x400", GetSecondaryDisplay().bounds().ToString());
 144
 145   //  Layout to the bottom with an offset.
 146   SetSecondaryDisplayLayoutAndOffset(DisplayLayout::BOTTOM, -200);
 147   EXPECT_EQ(1, observer.CountAndReset());  // resize and add
 148   EXPECT_EQ("0,0 500x500", GetPrimaryDisplay().bounds().ToString());
 149   EXPECT_EQ("-200,500 400x400", GetSecondaryDisplay().bounds().ToString());
 150
 151   // Keep the minimum 100.
 152   SetSecondaryDisplayLayoutAndOffset(DisplayLayout::BOTTOM, 490);
 153   EXPECT_EQ(1, observer.CountAndReset());  // resize and add
 154   EXPECT_EQ("0,0 500x500", GetPrimaryDisplay().bounds().ToString());
 155   EXPECT_EQ("400,500 400x400", GetSecondaryDisplay().bounds().ToString());
 156
 157   SetSecondaryDisplayLayoutAndOffset(DisplayLayout::BOTTOM, -400);
 158   EXPECT_EQ(1, observer.CountAndReset());  // resize and add
 159   EXPECT_EQ("0,0 500x500", GetPrimaryDisplay().bounds().ToString());
 160   EXPECT_EQ("-300,500 400x400", GetSecondaryDisplay().bounds().ToString());
 161
 162 }
 163
 164 TEST_F(DisplayControllerTest, BoundsUpdated) {
 165   TestObserver observer;
 166   SetSecondaryDisplayLayout(DisplayLayout::BOTTOM);
 167   UpdateDisplay("200x200,300x300");  // layout, resize and add.
 168   EXPECT_EQ(3, observer.CountAndReset());
 169
 170   gfx::Display* secondary_display =
 171       Shell::GetInstance()->display_manager()->GetDisplayAt(1);
 172   gfx::Insets insets(5, 5, 5, 5);
 173   secondary_display->UpdateWorkAreaFromInsets(insets);
 174
 175   EXPECT_EQ("0,0 200x200", GetPrimaryDisplay().bounds().ToString());
 176   EXPECT_EQ("0,200 300x300", GetSecondaryDisplay().bounds().ToString());
 177   EXPECT_EQ("5,205 290x290", GetSecondaryDisplay().work_area().ToString());
 178
 179   UpdateDisplay("400x400,200x200");
 180   EXPECT_EQ(2, observer.CountAndReset());  // two resizes
 181   EXPECT_EQ("0,0 400x400", GetPrimaryDisplay().bounds().ToString());
 182   EXPECT_EQ("0,400 200x200", GetSecondaryDisplay().bounds().ToString());
 183   EXPECT_EQ("5,405 190x190", GetSecondaryDisplay().work_area().ToString());
 184
 185   UpdateDisplay("400x400,300x300");
 186   EXPECT_EQ(1, observer.CountAndReset());
 187   EXPECT_EQ("0,0 400x400", GetPrimaryDisplay().bounds().ToString());
 188   EXPECT_EQ("0,400 300x300", GetSecondaryDisplay().bounds().ToString());
 189   EXPECT_EQ("5,405 290x290", GetSecondaryDisplay().work_area().ToString());
 190
 191   UpdateDisplay("400x400");
 192   EXPECT_EQ(1, observer.CountAndReset());
 193   EXPECT_EQ("0,0 400x400", GetPrimaryDisplay().bounds().ToString());
 194   EXPECT_EQ(1, Shell::GetScreen()->GetNumDisplays());
 195
 196   UpdateDisplay("500x500,700x700");
 197   EXPECT_EQ(2, observer.CountAndReset());
 198   ASSERT_EQ(2, Shell::GetScreen()->GetNumDisplays());
 199   EXPECT_EQ("0,0 500x500", GetPrimaryDisplay().bounds().ToString());
 200   EXPECT_EQ("0,500 700x700", GetSecondaryDisplay().bounds().ToString());
 201 }
 202
 203 TEST_F(DisplayControllerTest, InvertLayout) {
 204   EXPECT_EQ("left, 0",
 205             DisplayLayout(DisplayLayout::RIGHT, 0).Invert().ToString());
 206   EXPECT_EQ("left, -100",
 207             DisplayLayout(DisplayLayout::RIGHT, 100).Invert().ToString());
 208   EXPECT_EQ("left, 50",
 209             DisplayLayout(DisplayLayout::RIGHT, -50).Invert().ToString());
 210
 211   EXPECT_EQ("right, 0",
 212             DisplayLayout(DisplayLayout::LEFT, 0).Invert().ToString());
 213   EXPECT_EQ("right, -90",
 214             DisplayLayout(DisplayLayout::LEFT, 90).Invert().ToString());
 215   EXPECT_EQ("right, 60",
 216             DisplayLayout(DisplayLayout::LEFT, -60).Invert().ToString());
 217
 218   EXPECT_EQ("bottom, 0",
 219             DisplayLayout(DisplayLayout::TOP, 0).Invert().ToString());
 220   EXPECT_EQ("bottom, -80",
 221             DisplayLayout(DisplayLayout::TOP, 80).Invert().ToString());
 222   EXPECT_EQ("bottom, 70",
 223             DisplayLayout(DisplayLayout::TOP, -70).Invert().ToString());
 224
 225   EXPECT_EQ("top, 0",
 226             DisplayLayout(DisplayLayout::BOTTOM, 0).Invert().ToString());
 227   EXPECT_EQ("top, -70",
 228             DisplayLayout(DisplayLayout::BOTTOM, 70).Invert().ToString());
 229   EXPECT_EQ("top, 80",
 230             DisplayLayout(DisplayLayout::BOTTOM, -80).Invert().ToString());
 231 }
 232
 233 TEST_F(DisplayControllerTest, SwapPrimary) {
 234   DisplayController* display_controller =
 235       Shell::GetInstance()->display_controller();
 236
 237   UpdateDisplay("200x200,300x300");
 238   gfx::Display primary_display = Shell::GetScreen()->GetPrimaryDisplay();
 239   gfx::Display secondary_display = ScreenAsh::GetSecondaryDisplay();
 240
 241   std::string secondary_name = Shell::GetInstance()->
 242       display_manager()->GetDisplayNameFor(secondary_display);
 243   DisplayLayout secondary_layout(DisplayLayout::RIGHT, 50);
 244   display_controller->SetLayoutForDisplayName(secondary_name, secondary_layout);
 245
 246   EXPECT_NE(primary_display.id(), secondary_display.id());
 247   aura::RootWindow* primary_root =
 248       display_controller->GetRootWindowForDisplayId(primary_display.id());
 249   aura::RootWindow* secondary_root =
 250       display_controller->GetRootWindowForDisplayId(secondary_display.id());
 251   EXPECT_NE(primary_root, secondary_root);
 252   aura::Window* launcher_window =
 253       Launcher::ForPrimaryDisplay()->widget()->GetNativeView();
 254   EXPECT_TRUE(primary_root->Contains(launcher_window));
 255   EXPECT_FALSE(secondary_root->Contains(launcher_window));
 256   EXPECT_EQ(primary_display.id(),
 257             Shell::GetScreen()->GetDisplayNearestPoint(
 258                 gfx::Point(-100, -100)).id());
 259   EXPECT_EQ(primary_display.id(),
 260             Shell::GetScreen()->GetDisplayNearestWindow(NULL).id());
 261
 262   EXPECT_EQ("0,0 200x200", primary_display.bounds().ToString());
 263   EXPECT_EQ("0,0 200x152", primary_display.work_area().ToString());
 264   EXPECT_EQ("200,0 300x300", secondary_display.bounds().ToString());
 265   EXPECT_EQ("200,0 300x300", secondary_display.work_area().ToString());
 266
 267   // Switch primary and secondary
 268   display_controller->SetPrimaryDisplay(secondary_display);
 269   EXPECT_EQ(secondary_display.id(),
 270       Shell::GetScreen()->GetPrimaryDisplay().id());
 271   EXPECT_EQ(primary_display.id(), ScreenAsh::GetSecondaryDisplay().id());
 272   EXPECT_EQ(secondary_display.id(),
 273             Shell::GetScreen()->GetDisplayNearestPoint(
 274                 gfx::Point(-100, -100)).id());
 275   EXPECT_EQ(secondary_display.id(),
 276             Shell::GetScreen()->GetDisplayNearestWindow(NULL).id());
 277
 278   EXPECT_EQ(
 279       primary_root,
 280       display_controller->GetRootWindowForDisplayId(secondary_display.id()));
 281   EXPECT_EQ(
 282       secondary_root,
 283       display_controller->GetRootWindowForDisplayId(primary_display.id()));
 284   EXPECT_TRUE(primary_root->Contains(launcher_window));
 285   EXPECT_FALSE(secondary_root->Contains(launcher_window));
 286
 287   // Test if the bounds are correctly swapped.
 288   gfx::Display swapped_primary = Shell::GetScreen()->GetPrimaryDisplay();
 289   gfx::Display swapped_secondary = ScreenAsh::GetSecondaryDisplay();
 290   EXPECT_EQ("0,0 300x300", swapped_primary.bounds().ToString());
 291   EXPECT_EQ("0,0 300x252", swapped_primary.work_area().ToString());
 292   EXPECT_EQ("-200,-50 200x200", swapped_secondary.bounds().ToString());
 293   EXPECT_EQ("-200,-50 200x200", swapped_secondary.work_area().ToString());
 294
 295   const DisplayLayout& inverted_layout =
 296       display_controller->GetLayoutForDisplay(primary_display);
 297
 298   EXPECT_EQ("left, -50", inverted_layout.ToString());
 299
 300   aura::WindowTracker tracker;
 301   tracker.Add(primary_root);
 302   tracker.Add(secondary_root);
 303
 304   // Deleting 2nd display should move the primary to original primary display.
 305   UpdateDisplay("200x200");
 306   RunAllPendingInMessageLoop();  // RootWindow is deleted in a posted task.
 307   EXPECT_EQ(1, Shell::GetScreen()->GetNumDisplays());
 308   EXPECT_EQ(primary_display.id(), Shell::GetScreen()->GetPrimaryDisplay().id());
 309   EXPECT_EQ(primary_display.id(),
 310             Shell::GetScreen()->GetDisplayNearestPoint(
 311                 gfx::Point(-100, -100)).id());
 312   EXPECT_EQ(primary_display.id(),
 313             Shell::GetScreen()->GetDisplayNearestWindow(NULL).id());
 314   EXPECT_TRUE(tracker.Contains(primary_root));
 315   EXPECT_FALSE(tracker.Contains(secondary_root));
 316   EXPECT_TRUE(primary_root->Contains(launcher_window));
 317 }
 318
 319 TEST_F(DisplayControllerTest, SwapPrimaryById) {
 320   DisplayController* display_controller =
 321       Shell::GetInstance()->display_controller();
 322
 323   UpdateDisplay("200x200,300x300");
 324   gfx::Display primary_display = Shell::GetScreen()->GetPrimaryDisplay();
 325   gfx::Display secondary_display = ScreenAsh::GetSecondaryDisplay();
 326
 327   std::string secondary_name = Shell::GetInstance()->
 328       display_manager()->GetDisplayNameFor(secondary_display);
 329   DisplayLayout secondary_layout(DisplayLayout::RIGHT, 50);
 330   display_controller->SetLayoutForDisplayName(secondary_name, secondary_layout);
 331
 332   EXPECT_NE(primary_display.id(), secondary_display.id());
 333   aura::RootWindow* primary_root =
 334       display_controller->GetRootWindowForDisplayId(primary_display.id());
 335   aura::RootWindow* secondary_root =
 336       display_controller->GetRootWindowForDisplayId(secondary_display.id());
 337   aura::Window* launcher_window =
 338       Launcher::ForPrimaryDisplay()->widget()->GetNativeView();
 339   EXPECT_TRUE(primary_root->Contains(launcher_window));
 340   EXPECT_FALSE(secondary_root->Contains(launcher_window));
 341   EXPECT_NE(primary_root, secondary_root);
 342   EXPECT_EQ(primary_display.id(),
 343             Shell::GetScreen()->GetDisplayNearestPoint(
 344                 gfx::Point(-100, -100)).id());
 345   EXPECT_EQ(primary_display.id(),
 346             Shell::GetScreen()->GetDisplayNearestWindow(NULL).id());
 347
 348   // Switch primary and secondary by display ID.
 349   TestObserver observer;
 350   display_controller->SetPrimaryDisplayId(secondary_display.id());
 351   EXPECT_EQ(secondary_display.id(),
 352             Shell::GetScreen()->GetPrimaryDisplay().id());
 353   EXPECT_EQ(primary_display.id(), ScreenAsh::GetSecondaryDisplay().id());
 354   EXPECT_LT(0, observer.CountAndReset());
 355
 356   EXPECT_EQ(
 357       primary_root,
 358       display_controller->GetRootWindowForDisplayId(secondary_display.id()));
 359   EXPECT_EQ(
 360       secondary_root,
 361       display_controller->GetRootWindowForDisplayId(primary_display.id()));
 362   EXPECT_TRUE(primary_root->Contains(launcher_window));
 363   EXPECT_FALSE(secondary_root->Contains(launcher_window));
 364
 365   const DisplayLayout& inverted_layout =
 366       display_controller->GetLayoutForDisplay(primary_display);
 367
 368   EXPECT_EQ("left, -50", inverted_layout.ToString());
 369
 370   // Calling the same ID don't do anything.
 371   display_controller->SetPrimaryDisplayId(secondary_display.id());
 372   EXPECT_EQ(0, observer.CountAndReset());
 373
 374   aura::WindowTracker tracker;
 375   tracker.Add(primary_root);
 376   tracker.Add(secondary_root);
 377
 378   // Deleting 2nd display should move the primary to original primary display.
 379   UpdateDisplay("200x200");
 380   RunAllPendingInMessageLoop();  // RootWindow is deleted in a posted task.
 381   EXPECT_EQ(1, Shell::GetScreen()->GetNumDisplays());
 382   EXPECT_EQ(primary_display.id(), Shell::GetScreen()->GetPrimaryDisplay().id());
 383   EXPECT_EQ(primary_display.id(),
 384             Shell::GetScreen()->GetDisplayNearestPoint(
 385                 gfx::Point(-100, -100)).id());
 386   EXPECT_EQ(primary_display.id(),
 387             Shell::GetScreen()->GetDisplayNearestWindow(NULL).id());
 388   EXPECT_TRUE(tracker.Contains(primary_root));
 389   EXPECT_FALSE(tracker.Contains(secondary_root));
 390   EXPECT_TRUE(primary_root->Contains(launcher_window));
 391
 392   // Adding 2nd display with the same ID.  The 2nd display should become primary
 393   // since secondary id is still stored as desirable_primary_id.
 394   std::vector<gfx::Display> displays;
 395   displays.push_back(primary_display);
 396   displays.push_back(secondary_display);
 397   internal::DisplayManager* display_manager =
 398       Shell::GetInstance()->display_manager();
 399   display_manager->OnNativeDisplaysChanged(displays);
 400
 401   EXPECT_EQ(2, Shell::GetScreen()->GetNumDisplays());
 402   EXPECT_EQ(secondary_display.id(),
 403             Shell::GetScreen()->GetPrimaryDisplay().id());
 404   EXPECT_EQ(primary_display.id(), ScreenAsh::GetSecondaryDisplay().id());
 405   EXPECT_EQ(
 406       primary_root,
 407       display_controller->GetRootWindowForDisplayId(secondary_display.id()));
 408   EXPECT_NE(
 409       primary_root,
 410       display_controller->GetRootWindowForDisplayId(primary_display.id()));
 411   EXPECT_TRUE(primary_root->Contains(launcher_window));
 412
 413   // Deleting 2nd display and adding 2nd display with a different ID.  The 2nd
 414   // display shouldn't become primary.
 415   UpdateDisplay("200x200");
 416   std::vector<gfx::Display> displays2;
 417   gfx::Display third_display(
 418       secondary_display.id() + 1, secondary_display.bounds());
 419   ASSERT_NE(primary_display.id(), third_display.id());
 420   displays2.push_back(primary_display);
 421   displays2.push_back(third_display);
 422   display_manager->OnNativeDisplaysChanged(displays2);
 423   EXPECT_EQ(2, Shell::GetScreen()->GetNumDisplays());
 424   EXPECT_EQ(primary_display.id(),
 425             Shell::GetScreen()->GetPrimaryDisplay().id());
 426   EXPECT_EQ(third_display.id(), ScreenAsh::GetSecondaryDisplay().id());
 427   EXPECT_EQ(
 428       primary_root,
 429       display_controller->GetRootWindowForDisplayId(primary_display.id()));
 430   EXPECT_NE(
 431       primary_root,
 432       display_controller->GetRootWindowForDisplayId(third_display.id()));
 433   EXPECT_TRUE(primary_root->Contains(launcher_window));
 434 }
 435
 436 #if defined(OS_WIN)
 437 // Multiple displays are not supported on Windows Ash. http://crbug.com/165962
 438 #define MAYBE_CursorDeviceScaleFactorSwapPrimary \
 439         DISABLED_CursorDeviceScaleFactorSwapPrimary
 440 #else
 441 #define MAYBE_CursorDeviceScaleFactorSwapPrimary \
 442         CursorDeviceScaleFactorSwapPrimary
 443 #endif
 444
 445 TEST_F(DisplayControllerTest, MAYBE_CursorDeviceScaleFactorSwapPrimary) {
 446   DisplayController* display_controller =
 447       Shell::GetInstance()->display_controller();
 448
 449   UpdateDisplay("200x200,200x200*2");
 450   gfx::Display primary_display = Shell::GetScreen()->GetPrimaryDisplay();
 451   gfx::Display secondary_display = ScreenAsh::GetSecondaryDisplay();
 452
 453   aura::RootWindow* primary_root =
 454       display_controller->GetRootWindowForDisplayId(primary_display.id());
 455   aura::RootWindow* secondary_root =
 456       display_controller->GetRootWindowForDisplayId(secondary_display.id());
 457   EXPECT_NE(primary_root, secondary_root);
 458
 459   test::CursorManagerTestApi test_api(Shell::GetInstance()->cursor_manager());
 460
 461   EXPECT_EQ(1.0f,
 462             primary_root->AsRootWindowHostDelegate()->GetDeviceScaleFactor());
 463   primary_root->MoveCursorTo(gfx::Point(50, 50));
 464   EXPECT_EQ(1.0f, test_api.GetDeviceScaleFactor());
 465   EXPECT_EQ(2.0f,
 466             secondary_root->AsRootWindowHostDelegate()->GetDeviceScaleFactor());
 467   secondary_root->MoveCursorTo(gfx::Point(50, 50));
 468   EXPECT_EQ(2.0f, test_api.GetDeviceScaleFactor());
 469
 470   // Switch primary and secondary
 471   display_controller->SetPrimaryDisplay(secondary_display);
 472
 473   // Cursor's device scale factor should be updated accroding to the swap of
 474   // primary and secondary.
 475   EXPECT_EQ(1.0f,
 476             secondary_root->AsRootWindowHostDelegate()->GetDeviceScaleFactor());
 477   secondary_root->MoveCursorTo(gfx::Point(50, 50));
 478   EXPECT_EQ(1.0f, test_api.GetDeviceScaleFactor());
 479   primary_root->MoveCursorTo(gfx::Point(50, 50));
 480   EXPECT_EQ(2.0f,
 481             primary_root->AsRootWindowHostDelegate()->GetDeviceScaleFactor());
 482   EXPECT_EQ(2.0f, test_api.GetDeviceScaleFactor());
 483
 484   // Deleting 2nd display.
 485   UpdateDisplay("200x200");
 486   RunAllPendingInMessageLoop();  // RootWindow is deleted in a posted task.
 487
 488   // Cursor's device scale factor should be updated even without moving cursor.
 489   EXPECT_EQ(1.0f, test_api.GetDeviceScaleFactor());
 490
 491   primary_root->MoveCursorTo(gfx::Point(50, 50));
 492   EXPECT_EQ(1.0f,
 493             primary_root->AsRootWindowHostDelegate()->GetDeviceScaleFactor());
 494   EXPECT_EQ(1.0f, test_api.GetDeviceScaleFactor());
 495 }
 496
 497 #if defined(OS_WIN)
 498 // TODO(oshima): On Windows, we don't update the origin/size right away.
 499 #define MAYBE_UpdateDisplayWithHostOrigin DISABLED_UpdateDisplayWithHostOrigin
 500 #else
 501 #define MAYBE_UpdateDisplayWithHostOrigin UpdateDisplayWithHostOrigin
 502 #endif
 503
 504 TEST_F(DisplayControllerTest, MAYBE_UpdateDisplayWithHostOrigin) {
 505   UpdateDisplay("100x200,300x400");
 506   ASSERT_EQ(2, Shell::GetScreen()->GetNumDisplays());
 507   Shell::RootWindowList root_windows =
 508       Shell::GetInstance()->GetAllRootWindows();
 509   ASSERT_EQ(2U, root_windows.size());
 510   EXPECT_EQ("1,1", root_windows[0]->GetHostOrigin().ToString());
 511   EXPECT_EQ("100x200", root_windows[0]->GetHostSize().ToString());
 512   // UpdateDisplay set the origin if it's not set.
 513   EXPECT_NE("1,1", root_windows[1]->GetHostOrigin().ToString());
 514   EXPECT_EQ("300x400", root_windows[1]->GetHostSize().ToString());
 515
 516   UpdateDisplay("100x200,200+300-300x400");
 517   ASSERT_EQ(2, Shell::GetScreen()->GetNumDisplays());
 518   EXPECT_EQ("0,0", root_windows[0]->GetHostOrigin().ToString());
 519   EXPECT_EQ("100x200", root_windows[0]->GetHostSize().ToString());
 520   EXPECT_EQ("200,300", root_windows[1]->GetHostOrigin().ToString());
 521   EXPECT_EQ("300x400", root_windows[1]->GetHostSize().ToString());
 522
 523   UpdateDisplay("400+500-200x300,300x400");
 524   ASSERT_EQ(2, Shell::GetScreen()->GetNumDisplays());
 525   EXPECT_EQ("400,500", root_windows[0]->GetHostOrigin().ToString());
 526   EXPECT_EQ("200x300", root_windows[0]->GetHostSize().ToString());
 527   EXPECT_EQ("0,0", root_windows[1]->GetHostOrigin().ToString());
 528   EXPECT_EQ("300x400", root_windows[1]->GetHostSize().ToString());
 529
 530   UpdateDisplay("100+200-100x200,300+500-200x300");
 531   ASSERT_EQ(2, Shell::GetScreen()->GetNumDisplays());
 532   EXPECT_EQ("100,200", root_windows[0]->GetHostOrigin().ToString());
 533   EXPECT_EQ("100x200", root_windows[0]->GetHostSize().ToString());
 534   EXPECT_EQ("300,500", root_windows[1]->GetHostOrigin().ToString());
 535   EXPECT_EQ("200x300", root_windows[1]->GetHostSize().ToString());
 536 }
 537
 538 }  // namespace test
 539 }  // namespace ash