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