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