display_controller_unittest.cc revision ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16
1// Copyright (c) 2012 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5#include "ash/display/display_controller.h" 6 7#include "ash/display/display_info.h" 8#include "ash/display/display_layout_store.h" 9#include "ash/display/display_manager.h" 10#include "ash/launcher/launcher.h" 11#include "ash/screen_ash.h" 12#include "ash/shelf/shelf_widget.h" 13#include "ash/shell.h" 14#include "ash/test/ash_test_base.h" 15#include "ash/test/cursor_manager_test_api.h" 16#include "ui/aura/env.h" 17#include "ui/aura/root_window.h" 18#include "ui/aura/test/event_generator.h" 19#include "ui/aura/window_tracker.h" 20#include "ui/base/events/event_handler.h" 21#include "ui/gfx/display.h" 22#include "ui/gfx/screen.h" 23#include "ui/views/widget/widget.h" 24 25#if defined(USE_X11) 26#include "ui/base/x/x11_util.h" 27#include <X11/Xlib.h> 28#undef RootWindow 29#endif 30 31namespace ash { 32namespace { 33 34const char kDesktopBackgroundView[] = "DesktopBackgroundView"; 35 36class TestObserver : public DisplayController::Observer, 37 public gfx::DisplayObserver { 38 public: 39 TestObserver() 40 : changing_count_(0), 41 changed_count_(0), 42 bounds_changed_count_(0), 43 changed_display_id_(0) { 44 Shell::GetInstance()->display_controller()->AddObserver(this); 45 Shell::GetScreen()->AddObserver(this); 46 } 47 48 virtual ~TestObserver() { 49 Shell::GetInstance()->display_controller()->RemoveObserver(this); 50 Shell::GetScreen()->RemoveObserver(this); 51 } 52 53 // Overridden from DisplayController::Observer 54 virtual void OnDisplayConfigurationChanging() OVERRIDE { 55 ++changing_count_; 56 } 57 virtual void OnDisplayConfigurationChanged() OVERRIDE { 58 ++changed_count_; 59 } 60 61 // Overrideen from gfx::DisplayObserver 62 virtual void OnDisplayBoundsChanged(const gfx::Display& display) OVERRIDE { 63 changed_display_id_ = display.id(); 64 bounds_changed_count_ ++; 65 } 66 virtual void OnDisplayAdded(const gfx::Display& new_display) OVERRIDE { 67 } 68 virtual void OnDisplayRemoved(const gfx::Display& old_display) OVERRIDE { 69 } 70 71 int CountAndReset() { 72 EXPECT_EQ(changing_count_, changed_count_); 73 int count = changing_count_; 74 changing_count_ = changed_count_ = 0; 75 return count; 76 } 77 78 int64 GetBoundsChangedCountAndReset() { 79 int count = bounds_changed_count_; 80 bounds_changed_count_ = 0; 81 return count; 82 } 83 84 int64 GetChangedDisplayIdAndReset() { 85 int64 id = changed_display_id_; 86 changed_display_id_ = 0; 87 return id; 88 } 89 90 private: 91 int changing_count_; 92 int changed_count_; 93 94 int bounds_changed_count_; 95 int64 changed_display_id_; 96 97 DISALLOW_COPY_AND_ASSIGN(TestObserver); 98}; 99 100gfx::Display GetPrimaryDisplay() { 101 return Shell::GetScreen()->GetDisplayNearestWindow( 102 Shell::GetAllRootWindows()[0]); 103} 104 105gfx::Display GetSecondaryDisplay() { 106 return Shell::GetScreen()->GetDisplayNearestWindow( 107 Shell::GetAllRootWindows()[1]); 108} 109 110void SetSecondaryDisplayLayoutAndOffset(DisplayLayout::Position position, 111 int offset) { 112 DisplayLayout layout(position, offset); 113 ASSERT_GT(Shell::GetScreen()->GetNumDisplays(), 1); 114 Shell::GetInstance()->display_controller()-> 115 SetLayoutForCurrentDisplays(layout); 116} 117 118void SetSecondaryDisplayLayout(DisplayLayout::Position position) { 119 SetSecondaryDisplayLayoutAndOffset(position, 0); 120} 121 122void SetDefaultDisplayLayout(DisplayLayout::Position position) { 123 Shell::GetInstance()->display_manager()->layout_store()-> 124 SetDefaultDisplayLayout(DisplayLayout(position, 0)); 125} 126 127class DisplayControllerShutdownTest : public test::AshTestBase { 128 public: 129 virtual void TearDown() OVERRIDE { 130 test::AshTestBase::TearDown(); 131 if (!SupportsMultipleDisplays()) 132 return; 133 134 // Make sure that primary display is accessible after shutdown. 135 gfx::Display primary = Shell::GetScreen()->GetPrimaryDisplay(); 136 EXPECT_EQ("0,0 444x333", primary.bounds().ToString()); 137 EXPECT_EQ(2, Shell::GetScreen()->GetNumDisplays()); 138 } 139}; 140 141class TestEventHandler : public ui::EventHandler { 142 public: 143 TestEventHandler() : target_root_(NULL), 144 touch_radius_x_(0.0), 145 touch_radius_y_(0.0), 146 scroll_x_offset_(0.0), 147 scroll_y_offset_(0.0), 148 scroll_x_offset_ordinal_(0.0), 149 scroll_y_offset_ordinal_(0.0) {} 150 virtual ~TestEventHandler() {} 151 152 virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE { 153 if (event->flags() & ui::EF_IS_SYNTHESIZED && 154 event->type() != ui::ET_MOUSE_EXITED && 155 event->type() != ui::ET_MOUSE_ENTERED) { 156 return; 157 } 158 aura::Window* target = static_cast<aura::Window*>(event->target()); 159 mouse_location_ = event->root_location(); 160 target_root_ = target->GetRootWindow(); 161 event->StopPropagation(); 162 } 163 164 virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE { 165 aura::Window* target = static_cast<aura::Window*>(event->target()); 166 // Only record when the target is the background which covers 167 // entire root window. 168 if (target->name() != kDesktopBackgroundView) 169 return; 170 touch_radius_x_ = event->radius_x(); 171 touch_radius_y_ = event->radius_y(); 172 event->StopPropagation(); 173 } 174 175 virtual void OnScrollEvent(ui::ScrollEvent* event) OVERRIDE { 176 aura::Window* target = static_cast<aura::Window*>(event->target()); 177 // Only record when the target is the background which covers 178 // entire root window. 179 if (target->name() != kDesktopBackgroundView) 180 return; 181 182 if (event->type() == ui::ET_SCROLL) { 183 scroll_x_offset_ = event->x_offset(); 184 scroll_y_offset_ = event->y_offset(); 185 scroll_x_offset_ordinal_ = event->x_offset_ordinal(); 186 scroll_y_offset_ordinal_ = event->y_offset_ordinal(); 187 } 188 event->StopPropagation(); 189 } 190 191 std::string GetLocationAndReset() { 192 std::string result = mouse_location_.ToString(); 193 mouse_location_.SetPoint(0, 0); 194 target_root_ = NULL; 195 return result; 196 } 197 198 float touch_radius_x() { return touch_radius_x_; } 199 float touch_radius_y() { return touch_radius_y_; } 200 float scroll_x_offset() { return scroll_x_offset_; } 201 float scroll_y_offset() { return scroll_y_offset_; } 202 float scroll_x_offset_ordinal() { return scroll_x_offset_ordinal_; } 203 float scroll_y_offset_ordinal() { return scroll_y_offset_ordinal_; } 204 205 private: 206 gfx::Point mouse_location_; 207 aura::RootWindow* target_root_; 208 209 float touch_radius_x_; 210 float touch_radius_y_; 211 float scroll_x_offset_; 212 float scroll_y_offset_; 213 float scroll_x_offset_ordinal_; 214 float scroll_y_offset_ordinal_; 215 216 DISALLOW_COPY_AND_ASSIGN(TestEventHandler); 217}; 218 219gfx::Display::Rotation GetStoredRotation(int64 id) { 220 return Shell::GetInstance()->display_manager()->GetDisplayInfo(id).rotation(); 221} 222 223float GetStoredUIScale(int64 id) { 224 return Shell::GetInstance()->display_manager()->GetDisplayInfo(id).ui_scale(); 225} 226 227#if defined(USE_X11) 228void GetPrimaryAndSeconary(aura::RootWindow** primary, 229 aura::RootWindow** secondary) { 230 *primary = Shell::GetPrimaryRootWindow(); 231 Shell::RootWindowList root_windows = Shell::GetAllRootWindows(); 232 *secondary = root_windows[0] == *primary ? root_windows[1] : root_windows[0]; 233} 234 235std::string GetXWindowName(aura::RootWindow* window) { 236 char* name = NULL; 237 XFetchName(ui::GetXDisplay(), window->GetAcceleratedWidget(), &name); 238 std::string ret(name); 239 XFree(name); 240 return ret; 241} 242#endif 243 244} // namespace 245 246typedef test::AshTestBase DisplayControllerTest; 247 248TEST_F(DisplayControllerShutdownTest, Shutdown) { 249 if (!SupportsMultipleDisplays()) 250 return; 251 252 UpdateDisplay("444x333, 200x200"); 253} 254 255TEST_F(DisplayControllerTest, SecondaryDisplayLayout) { 256 if (!SupportsMultipleDisplays()) 257 return; 258 259 TestObserver observer; 260 UpdateDisplay("500x500,400x400"); 261 EXPECT_EQ(1, observer.CountAndReset()); // resize and add 262 EXPECT_EQ(1, observer.GetBoundsChangedCountAndReset()); 263 gfx::Insets insets(5, 5, 5, 5); 264 int64 secondary_display_id = ScreenAsh::GetSecondaryDisplay().id(); 265 Shell::GetInstance()->display_manager()->UpdateWorkAreaOfDisplay( 266 secondary_display_id, insets); 267 268 // Default layout is RIGHT. 269 EXPECT_EQ("0,0 500x500", GetPrimaryDisplay().bounds().ToString()); 270 EXPECT_EQ("500,0 400x400", GetSecondaryDisplay().bounds().ToString()); 271 EXPECT_EQ("505,5 390x390", GetSecondaryDisplay().work_area().ToString()); 272 273 // Layout the secondary display to the bottom of the primary. 274 SetSecondaryDisplayLayout(DisplayLayout::BOTTOM); 275 EXPECT_EQ(1, observer.CountAndReset()); 276 EXPECT_EQ(1, observer.GetBoundsChangedCountAndReset()); 277 EXPECT_EQ(secondary_display_id, observer.GetChangedDisplayIdAndReset()); 278 EXPECT_EQ("0,0 500x500", GetPrimaryDisplay().bounds().ToString()); 279 EXPECT_EQ("0,500 400x400", GetSecondaryDisplay().bounds().ToString()); 280 EXPECT_EQ("5,505 390x390", GetSecondaryDisplay().work_area().ToString()); 281 282 // Layout the secondary display to the left of the primary. 283 SetSecondaryDisplayLayout(DisplayLayout::LEFT); 284 EXPECT_EQ(1, observer.CountAndReset()); 285 EXPECT_EQ(1, observer.GetBoundsChangedCountAndReset()); 286 EXPECT_EQ(secondary_display_id, observer.GetChangedDisplayIdAndReset()); 287 EXPECT_EQ("0,0 500x500", GetPrimaryDisplay().bounds().ToString()); 288 EXPECT_EQ("-400,0 400x400", GetSecondaryDisplay().bounds().ToString()); 289 EXPECT_EQ("-395,5 390x390", GetSecondaryDisplay().work_area().ToString()); 290 291 // Layout the secondary display to the top of the primary. 292 SetSecondaryDisplayLayout(DisplayLayout::TOP); 293 EXPECT_EQ(1, observer.CountAndReset()); 294 EXPECT_EQ(1, observer.GetBoundsChangedCountAndReset()); 295 EXPECT_EQ(secondary_display_id, observer.GetChangedDisplayIdAndReset()); 296 EXPECT_EQ("0,0 500x500", GetPrimaryDisplay().bounds().ToString()); 297 EXPECT_EQ("0,-400 400x400", GetSecondaryDisplay().bounds().ToString()); 298 EXPECT_EQ("5,-395 390x390", GetSecondaryDisplay().work_area().ToString()); 299 300 // Layout to the right with an offset. 301 SetSecondaryDisplayLayoutAndOffset(DisplayLayout::RIGHT, 300); 302 EXPECT_EQ(1, observer.CountAndReset()); // resize and add 303 EXPECT_EQ(1, observer.GetBoundsChangedCountAndReset()); 304 EXPECT_EQ(secondary_display_id, observer.GetChangedDisplayIdAndReset()); 305 EXPECT_EQ("0,0 500x500", GetPrimaryDisplay().bounds().ToString()); 306 EXPECT_EQ("500,300 400x400", GetSecondaryDisplay().bounds().ToString()); 307 308 // Keep the minimum 100. 309 SetSecondaryDisplayLayoutAndOffset(DisplayLayout::RIGHT, 490); 310 EXPECT_EQ(1, observer.CountAndReset()); // resize and add 311 EXPECT_EQ(1, observer.GetBoundsChangedCountAndReset()); 312 EXPECT_EQ(secondary_display_id, observer.GetChangedDisplayIdAndReset()); 313 EXPECT_EQ("0,0 500x500", GetPrimaryDisplay().bounds().ToString()); 314 EXPECT_EQ("500,400 400x400", GetSecondaryDisplay().bounds().ToString()); 315 316 SetSecondaryDisplayLayoutAndOffset(DisplayLayout::RIGHT, -400); 317 EXPECT_EQ(secondary_display_id, observer.GetChangedDisplayIdAndReset()); 318 EXPECT_EQ(1, observer.GetBoundsChangedCountAndReset()); 319 EXPECT_EQ(1, observer.CountAndReset()); // resize and add 320 EXPECT_EQ("0,0 500x500", GetPrimaryDisplay().bounds().ToString()); 321 EXPECT_EQ("500,-300 400x400", GetSecondaryDisplay().bounds().ToString()); 322 323 // Layout to the bottom with an offset. 324 SetSecondaryDisplayLayoutAndOffset(DisplayLayout::BOTTOM, -200); 325 EXPECT_EQ(secondary_display_id, observer.GetChangedDisplayIdAndReset()); 326 EXPECT_EQ(1, observer.GetBoundsChangedCountAndReset()); 327 EXPECT_EQ(1, observer.CountAndReset()); // resize and add 328 EXPECT_EQ("0,0 500x500", GetPrimaryDisplay().bounds().ToString()); 329 EXPECT_EQ("-200,500 400x400", GetSecondaryDisplay().bounds().ToString()); 330 331 // Keep the minimum 100. 332 SetSecondaryDisplayLayoutAndOffset(DisplayLayout::BOTTOM, 490); 333 EXPECT_EQ(secondary_display_id, observer.GetChangedDisplayIdAndReset()); 334 EXPECT_EQ(1, observer.GetBoundsChangedCountAndReset()); 335 EXPECT_EQ(1, observer.CountAndReset()); // resize and add 336 EXPECT_EQ("0,0 500x500", GetPrimaryDisplay().bounds().ToString()); 337 EXPECT_EQ("400,500 400x400", GetSecondaryDisplay().bounds().ToString()); 338 339 SetSecondaryDisplayLayoutAndOffset(DisplayLayout::BOTTOM, -400); 340 EXPECT_EQ(secondary_display_id, observer.GetChangedDisplayIdAndReset()); 341 EXPECT_EQ(1, observer.GetBoundsChangedCountAndReset()); 342 EXPECT_EQ(1, observer.CountAndReset()); // resize and add 343 EXPECT_EQ("0,0 500x500", GetPrimaryDisplay().bounds().ToString()); 344 EXPECT_EQ("-300,500 400x400", GetSecondaryDisplay().bounds().ToString()); 345 346 // Setting the same layout shouldn't invoke observers. 347 SetSecondaryDisplayLayoutAndOffset(DisplayLayout::BOTTOM, -400); 348 EXPECT_EQ(0, observer.GetChangedDisplayIdAndReset()); 349 EXPECT_EQ(0, observer.GetBoundsChangedCountAndReset()); 350 EXPECT_EQ(0, observer.CountAndReset()); // resize and add 351 EXPECT_EQ("0,0 500x500", GetPrimaryDisplay().bounds().ToString()); 352 EXPECT_EQ("-300,500 400x400", GetSecondaryDisplay().bounds().ToString()); 353} 354 355TEST_F(DisplayControllerTest, BoundsUpdated) { 356 if (!SupportsMultipleDisplays()) 357 return; 358 359 TestObserver observer; 360 SetDefaultDisplayLayout(DisplayLayout::BOTTOM); 361 UpdateDisplay("200x200,300x300"); // layout, resize and add. 362 EXPECT_EQ(1, observer.CountAndReset()); 363 364 internal::DisplayManager* display_manager = 365 Shell::GetInstance()->display_manager(); 366 gfx::Insets insets(5, 5, 5, 5); 367 display_manager->UpdateWorkAreaOfDisplay( 368 ScreenAsh::GetSecondaryDisplay().id(), insets); 369 370 EXPECT_EQ("0,0 200x200", GetPrimaryDisplay().bounds().ToString()); 371 EXPECT_EQ("0,200 300x300", GetSecondaryDisplay().bounds().ToString()); 372 EXPECT_EQ("5,205 290x290", GetSecondaryDisplay().work_area().ToString()); 373 374 UpdateDisplay("400x400,200x200"); 375 EXPECT_EQ(1, observer.CountAndReset()); // two resizes 376 EXPECT_EQ("0,0 400x400", GetPrimaryDisplay().bounds().ToString()); 377 EXPECT_EQ("0,400 200x200", GetSecondaryDisplay().bounds().ToString()); 378 379 UpdateDisplay("400x400,300x300"); 380 EXPECT_EQ(1, observer.CountAndReset()); 381 EXPECT_EQ("0,0 400x400", GetPrimaryDisplay().bounds().ToString()); 382 EXPECT_EQ("0,400 300x300", GetSecondaryDisplay().bounds().ToString()); 383 384 UpdateDisplay("400x400"); 385 EXPECT_EQ(1, observer.CountAndReset()); 386 EXPECT_EQ("0,0 400x400", GetPrimaryDisplay().bounds().ToString()); 387 EXPECT_EQ(1, Shell::GetScreen()->GetNumDisplays()); 388 389 UpdateDisplay("400x500*2,300x300"); 390 EXPECT_EQ(1, observer.CountAndReset()); 391 ASSERT_EQ(2, Shell::GetScreen()->GetNumDisplays()); 392 EXPECT_EQ("0,0 200x250", GetPrimaryDisplay().bounds().ToString()); 393 EXPECT_EQ("0,250 300x300", GetSecondaryDisplay().bounds().ToString()); 394 395 // No change 396 UpdateDisplay("400x500*2,300x300"); 397 EXPECT_EQ(0, observer.CountAndReset()); 398 399 // Rotation 400 int64 primary_id = GetPrimaryDisplay().id(); 401 display_manager->SetDisplayRotation(primary_id, gfx::Display::ROTATE_90); 402 EXPECT_EQ(1, observer.CountAndReset()); 403 display_manager->SetDisplayRotation(primary_id, gfx::Display::ROTATE_90); 404 EXPECT_EQ(0, observer.CountAndReset()); 405 406 // UI scale is eanbled only on internal display. 407 int64 secondary_id = GetSecondaryDisplay().id(); 408 gfx::Display::SetInternalDisplayId(secondary_id); 409 display_manager->SetDisplayUIScale(secondary_id, 1.125f); 410 EXPECT_EQ(1, observer.CountAndReset()); 411 display_manager->SetDisplayUIScale(secondary_id, 1.125f); 412 EXPECT_EQ(0, observer.CountAndReset()); 413 display_manager->SetDisplayUIScale(primary_id, 1.125f); 414 EXPECT_EQ(0, observer.CountAndReset()); 415 display_manager->SetDisplayUIScale(primary_id, 1.125f); 416 EXPECT_EQ(0, observer.CountAndReset()); 417} 418 419TEST_F(DisplayControllerTest, MirroredLayout) { 420 if (!SupportsMultipleDisplays()) 421 return; 422 423 DisplayController* display_controller = 424 Shell::GetInstance()->display_controller(); 425 UpdateDisplay("500x500,400x400"); 426 EXPECT_FALSE(display_controller->GetCurrentDisplayLayout().mirrored); 427 EXPECT_EQ(2, Shell::GetScreen()->GetNumDisplays()); 428 EXPECT_EQ( 429 2U, Shell::GetInstance()->display_manager()->num_connected_displays()); 430 431 UpdateDisplay("1+0-500x500,1+0-500x500"); 432 EXPECT_TRUE(display_controller->GetCurrentDisplayLayout().mirrored); 433 EXPECT_EQ(1, Shell::GetScreen()->GetNumDisplays()); 434 EXPECT_EQ( 435 2U, Shell::GetInstance()->display_manager()->num_connected_displays()); 436 437 UpdateDisplay("500x500,500x500"); 438 EXPECT_FALSE(display_controller->GetCurrentDisplayLayout().mirrored); 439 EXPECT_EQ(2, Shell::GetScreen()->GetNumDisplays()); 440 EXPECT_EQ( 441 2U, Shell::GetInstance()->display_manager()->num_connected_displays()); 442} 443 444TEST_F(DisplayControllerTest, InvertLayout) { 445 EXPECT_EQ("left, 0", 446 DisplayLayout(DisplayLayout::RIGHT, 0).Invert().ToString()); 447 EXPECT_EQ("left, -100", 448 DisplayLayout(DisplayLayout::RIGHT, 100).Invert().ToString()); 449 EXPECT_EQ("left, 50", 450 DisplayLayout(DisplayLayout::RIGHT, -50).Invert().ToString()); 451 452 EXPECT_EQ("right, 0", 453 DisplayLayout(DisplayLayout::LEFT, 0).Invert().ToString()); 454 EXPECT_EQ("right, -90", 455 DisplayLayout(DisplayLayout::LEFT, 90).Invert().ToString()); 456 EXPECT_EQ("right, 60", 457 DisplayLayout(DisplayLayout::LEFT, -60).Invert().ToString()); 458 459 EXPECT_EQ("bottom, 0", 460 DisplayLayout(DisplayLayout::TOP, 0).Invert().ToString()); 461 EXPECT_EQ("bottom, -80", 462 DisplayLayout(DisplayLayout::TOP, 80).Invert().ToString()); 463 EXPECT_EQ("bottom, 70", 464 DisplayLayout(DisplayLayout::TOP, -70).Invert().ToString()); 465 466 EXPECT_EQ("top, 0", 467 DisplayLayout(DisplayLayout::BOTTOM, 0).Invert().ToString()); 468 EXPECT_EQ("top, -70", 469 DisplayLayout(DisplayLayout::BOTTOM, 70).Invert().ToString()); 470 EXPECT_EQ("top, 80", 471 DisplayLayout(DisplayLayout::BOTTOM, -80).Invert().ToString()); 472} 473 474TEST_F(DisplayControllerTest, SwapPrimary) { 475 if (!SupportsMultipleDisplays()) 476 return; 477 478 DisplayController* display_controller = 479 Shell::GetInstance()->display_controller(); 480 481 UpdateDisplay("200x200,300x300"); 482 gfx::Display primary_display = Shell::GetScreen()->GetPrimaryDisplay(); 483 gfx::Display secondary_display = ScreenAsh::GetSecondaryDisplay(); 484 485 DisplayLayout display_layout(DisplayLayout::RIGHT, 50); 486 display_controller->SetLayoutForCurrentDisplays(display_layout); 487 488 EXPECT_NE(primary_display.id(), secondary_display.id()); 489 aura::RootWindow* primary_root = 490 display_controller->GetRootWindowForDisplayId(primary_display.id()); 491 aura::RootWindow* secondary_root = 492 display_controller->GetRootWindowForDisplayId(secondary_display.id()); 493 EXPECT_NE(primary_root, secondary_root); 494 aura::Window* launcher_window = 495 Launcher::ForPrimaryDisplay()->shelf_widget()->GetNativeView(); 496 EXPECT_TRUE(primary_root->Contains(launcher_window)); 497 EXPECT_FALSE(secondary_root->Contains(launcher_window)); 498 EXPECT_EQ(primary_display.id(), 499 Shell::GetScreen()->GetDisplayNearestPoint( 500 gfx::Point(-100, -100)).id()); 501 EXPECT_EQ(primary_display.id(), 502 Shell::GetScreen()->GetDisplayNearestWindow(NULL).id()); 503 504 EXPECT_EQ("0,0 200x200", primary_display.bounds().ToString()); 505 EXPECT_EQ("0,0 200x152", primary_display.work_area().ToString()); 506 EXPECT_EQ("200,0 300x300", secondary_display.bounds().ToString()); 507 EXPECT_EQ("200,0 300x252", secondary_display.work_area().ToString()); 508 EXPECT_EQ("right, 50", 509 display_controller->GetCurrentDisplayLayout().ToString()); 510 511 // Switch primary and secondary 512 display_controller->SetPrimaryDisplay(secondary_display); 513 const DisplayLayout& inverted_layout = 514 display_controller->GetCurrentDisplayLayout(); 515 EXPECT_EQ("left, -50", inverted_layout.ToString()); 516 517 EXPECT_EQ(secondary_display.id(), 518 Shell::GetScreen()->GetPrimaryDisplay().id()); 519 EXPECT_EQ(primary_display.id(), ScreenAsh::GetSecondaryDisplay().id()); 520 EXPECT_EQ(secondary_display.id(), 521 Shell::GetScreen()->GetDisplayNearestPoint( 522 gfx::Point(-100, -100)).id()); 523 EXPECT_EQ(secondary_display.id(), 524 Shell::GetScreen()->GetDisplayNearestWindow(NULL).id()); 525 526 EXPECT_EQ( 527 primary_root, 528 display_controller->GetRootWindowForDisplayId(secondary_display.id())); 529 EXPECT_EQ( 530 secondary_root, 531 display_controller->GetRootWindowForDisplayId(primary_display.id())); 532 EXPECT_TRUE(primary_root->Contains(launcher_window)); 533 EXPECT_FALSE(secondary_root->Contains(launcher_window)); 534 535 // Test if the bounds are correctly swapped. 536 gfx::Display swapped_primary = Shell::GetScreen()->GetPrimaryDisplay(); 537 gfx::Display swapped_secondary = ScreenAsh::GetSecondaryDisplay(); 538 EXPECT_EQ("0,0 300x300", swapped_primary.bounds().ToString()); 539 EXPECT_EQ("0,0 300x252", swapped_primary.work_area().ToString()); 540 EXPECT_EQ("-200,-50 200x200", swapped_secondary.bounds().ToString()); 541 542 EXPECT_EQ("-200,-50 200x152", swapped_secondary.work_area().ToString()); 543 544 aura::WindowTracker tracker; 545 tracker.Add(primary_root); 546 tracker.Add(secondary_root); 547 548 // Deleting 2nd display should move the primary to original primary display. 549 UpdateDisplay("200x200"); 550 RunAllPendingInMessageLoop(); // RootWindow is deleted in a posted task. 551 EXPECT_EQ(1, Shell::GetScreen()->GetNumDisplays()); 552 EXPECT_EQ(primary_display.id(), Shell::GetScreen()->GetPrimaryDisplay().id()); 553 EXPECT_EQ(primary_display.id(), 554 Shell::GetScreen()->GetDisplayNearestPoint( 555 gfx::Point(-100, -100)).id()); 556 EXPECT_EQ(primary_display.id(), 557 Shell::GetScreen()->GetDisplayNearestWindow(NULL).id()); 558 EXPECT_TRUE(tracker.Contains(primary_root)); 559 EXPECT_FALSE(tracker.Contains(secondary_root)); 560 EXPECT_TRUE(primary_root->Contains(launcher_window)); 561} 562 563TEST_F(DisplayControllerTest, SwapPrimaryById) { 564 if (!SupportsMultipleDisplays()) 565 return; 566 567 DisplayController* display_controller = 568 Shell::GetInstance()->display_controller(); 569 570 UpdateDisplay("200x200,300x300"); 571 gfx::Display primary_display = Shell::GetScreen()->GetPrimaryDisplay(); 572 gfx::Display secondary_display = ScreenAsh::GetSecondaryDisplay(); 573 574 DisplayLayout display_layout(DisplayLayout::RIGHT, 50); 575 display_controller->SetLayoutForCurrentDisplays(display_layout); 576 577 EXPECT_NE(primary_display.id(), secondary_display.id()); 578 aura::RootWindow* primary_root = 579 display_controller->GetRootWindowForDisplayId(primary_display.id()); 580 aura::RootWindow* secondary_root = 581 display_controller->GetRootWindowForDisplayId(secondary_display.id()); 582 aura::Window* launcher_window = 583 Launcher::ForPrimaryDisplay()->shelf_widget()->GetNativeView(); 584 EXPECT_TRUE(primary_root->Contains(launcher_window)); 585 EXPECT_FALSE(secondary_root->Contains(launcher_window)); 586 EXPECT_NE(primary_root, secondary_root); 587 EXPECT_EQ(primary_display.id(), 588 Shell::GetScreen()->GetDisplayNearestPoint( 589 gfx::Point(-100, -100)).id()); 590 EXPECT_EQ(primary_display.id(), 591 Shell::GetScreen()->GetDisplayNearestWindow(NULL).id()); 592 593 // Switch primary and secondary by display ID. 594 TestObserver observer; 595 display_controller->SetPrimaryDisplayId(secondary_display.id()); 596 EXPECT_EQ(secondary_display.id(), 597 Shell::GetScreen()->GetPrimaryDisplay().id()); 598 EXPECT_EQ(primary_display.id(), ScreenAsh::GetSecondaryDisplay().id()); 599 EXPECT_LT(0, observer.CountAndReset()); 600 601 EXPECT_EQ( 602 primary_root, 603 display_controller->GetRootWindowForDisplayId(secondary_display.id())); 604 EXPECT_EQ( 605 secondary_root, 606 display_controller->GetRootWindowForDisplayId(primary_display.id())); 607 EXPECT_TRUE(primary_root->Contains(launcher_window)); 608 EXPECT_FALSE(secondary_root->Contains(launcher_window)); 609 610 const DisplayLayout& inverted_layout = 611 display_controller->GetCurrentDisplayLayout(); 612 613 EXPECT_EQ("left, -50", inverted_layout.ToString()); 614 615 // Calling the same ID don't do anything. 616 display_controller->SetPrimaryDisplayId(secondary_display.id()); 617 EXPECT_EQ(0, observer.CountAndReset()); 618 619 aura::WindowTracker tracker; 620 tracker.Add(primary_root); 621 tracker.Add(secondary_root); 622 623 // Deleting 2nd display should move the primary to original primary display. 624 UpdateDisplay("200x200"); 625 RunAllPendingInMessageLoop(); // RootWindow is deleted in a posted task. 626 EXPECT_EQ(1, Shell::GetScreen()->GetNumDisplays()); 627 EXPECT_EQ(primary_display.id(), Shell::GetScreen()->GetPrimaryDisplay().id()); 628 EXPECT_EQ(primary_display.id(), 629 Shell::GetScreen()->GetDisplayNearestPoint( 630 gfx::Point(-100, -100)).id()); 631 EXPECT_EQ(primary_display.id(), 632 Shell::GetScreen()->GetDisplayNearestWindow(NULL).id()); 633 EXPECT_TRUE(tracker.Contains(primary_root)); 634 EXPECT_FALSE(tracker.Contains(secondary_root)); 635 EXPECT_TRUE(primary_root->Contains(launcher_window)); 636 637 internal::DisplayManager* display_manager = 638 Shell::GetInstance()->display_manager(); 639 // Adding 2nd display with the same ID. The 2nd display should become primary 640 // since secondary id is still stored as desirable_primary_id. 641 std::vector<internal::DisplayInfo> display_info_list; 642 display_info_list.push_back( 643 display_manager->GetDisplayInfo(primary_display.id())); 644 display_info_list.push_back( 645 display_manager->GetDisplayInfo(secondary_display.id())); 646 display_manager->OnNativeDisplaysChanged(display_info_list); 647 648 EXPECT_EQ(2, Shell::GetScreen()->GetNumDisplays()); 649 EXPECT_EQ(secondary_display.id(), 650 Shell::GetScreen()->GetPrimaryDisplay().id()); 651 EXPECT_EQ(primary_display.id(), ScreenAsh::GetSecondaryDisplay().id()); 652 EXPECT_EQ( 653 primary_root, 654 display_controller->GetRootWindowForDisplayId(secondary_display.id())); 655 EXPECT_NE( 656 primary_root, 657 display_controller->GetRootWindowForDisplayId(primary_display.id())); 658 EXPECT_TRUE(primary_root->Contains(launcher_window)); 659 660 // Deleting 2nd display and adding 2nd display with a different ID. The 2nd 661 // display shouldn't become primary. 662 UpdateDisplay("200x200"); 663 internal::DisplayInfo third_display_info( 664 secondary_display.id() + 1, std::string(), false); 665 third_display_info.SetBounds(secondary_display.bounds()); 666 ASSERT_NE(primary_display.id(), third_display_info.id()); 667 668 const internal::DisplayInfo& primary_display_info = 669 display_manager->GetDisplayInfo(primary_display.id()); 670 std::vector<internal::DisplayInfo> display_info_list2; 671 display_info_list2.push_back(primary_display_info); 672 display_info_list2.push_back(third_display_info); 673 display_manager->OnNativeDisplaysChanged(display_info_list2); 674 EXPECT_EQ(2, Shell::GetScreen()->GetNumDisplays()); 675 EXPECT_EQ(primary_display.id(), 676 Shell::GetScreen()->GetPrimaryDisplay().id()); 677 EXPECT_EQ(third_display_info.id(), ScreenAsh::GetSecondaryDisplay().id()); 678 EXPECT_EQ( 679 primary_root, 680 display_controller->GetRootWindowForDisplayId(primary_display.id())); 681 EXPECT_NE( 682 primary_root, 683 display_controller->GetRootWindowForDisplayId(third_display_info.id())); 684 EXPECT_TRUE(primary_root->Contains(launcher_window)); 685} 686 687TEST_F(DisplayControllerTest, CursorDeviceScaleFactorSwapPrimary) { 688 if (!SupportsMultipleDisplays()) 689 return; 690 691 DisplayController* display_controller = 692 Shell::GetInstance()->display_controller(); 693 694 UpdateDisplay("200x200,200x200*2"); 695 gfx::Display primary_display = Shell::GetScreen()->GetPrimaryDisplay(); 696 gfx::Display secondary_display = ScreenAsh::GetSecondaryDisplay(); 697 698 aura::RootWindow* primary_root = 699 display_controller->GetRootWindowForDisplayId(primary_display.id()); 700 aura::RootWindow* secondary_root = 701 display_controller->GetRootWindowForDisplayId(secondary_display.id()); 702 EXPECT_NE(primary_root, secondary_root); 703 704 test::CursorManagerTestApi test_api(Shell::GetInstance()->cursor_manager()); 705 706 EXPECT_EQ(1.0f, 707 primary_root->AsRootWindowHostDelegate()->GetDeviceScaleFactor()); 708 primary_root->MoveCursorTo(gfx::Point(50, 50)); 709 EXPECT_EQ(1.0f, test_api.GetDisplay().device_scale_factor()); 710 EXPECT_EQ(2.0f, 711 secondary_root->AsRootWindowHostDelegate()->GetDeviceScaleFactor()); 712 secondary_root->MoveCursorTo(gfx::Point(50, 50)); 713 EXPECT_EQ(2.0f, test_api.GetDisplay().device_scale_factor()); 714 715 // Switch primary and secondary 716 display_controller->SetPrimaryDisplay(secondary_display); 717 718 // Cursor's device scale factor should be updated accroding to the swap of 719 // primary and secondary. 720 EXPECT_EQ(1.0f, 721 secondary_root->AsRootWindowHostDelegate()->GetDeviceScaleFactor()); 722 secondary_root->MoveCursorTo(gfx::Point(50, 50)); 723 EXPECT_EQ(1.0f, test_api.GetDisplay().device_scale_factor()); 724 primary_root->MoveCursorTo(gfx::Point(50, 50)); 725 EXPECT_EQ(2.0f, 726 primary_root->AsRootWindowHostDelegate()->GetDeviceScaleFactor()); 727 EXPECT_EQ(2.0f, test_api.GetDisplay().device_scale_factor()); 728 729 // Deleting 2nd display. 730 UpdateDisplay("200x200"); 731 RunAllPendingInMessageLoop(); // RootWindow is deleted in a posted task. 732 733 // Cursor's device scale factor should be updated even without moving cursor. 734 EXPECT_EQ(1.0f, test_api.GetDisplay().device_scale_factor()); 735 736 primary_root->MoveCursorTo(gfx::Point(50, 50)); 737 EXPECT_EQ(1.0f, 738 primary_root->AsRootWindowHostDelegate()->GetDeviceScaleFactor()); 739 EXPECT_EQ(1.0f, test_api.GetDisplay().device_scale_factor()); 740} 741 742#if defined(OS_WIN) 743// TODO(scottmg): RootWindow doesn't get resized on Windows 744// Ash. http://crbug.com/247916. 745#define MAYBE_UpdateDisplayWithHostOrigin DISABLED_UpdateDisplayWithHostOrigin 746#else 747#define MAYBE_UpdateDisplayWithHostOrigin UpdateDisplayWithHostOrigin 748#endif 749 750TEST_F(DisplayControllerTest, MAYBE_UpdateDisplayWithHostOrigin) { 751 UpdateDisplay("100x200,300x400"); 752 ASSERT_EQ(2, Shell::GetScreen()->GetNumDisplays()); 753 Shell::RootWindowList root_windows = 754 Shell::GetInstance()->GetAllRootWindows(); 755 ASSERT_EQ(2U, root_windows.size()); 756 EXPECT_EQ("1,1", root_windows[0]->GetHostOrigin().ToString()); 757 EXPECT_EQ("100x200", root_windows[0]->GetHostSize().ToString()); 758 // UpdateDisplay set the origin if it's not set. 759 EXPECT_NE("1,1", root_windows[1]->GetHostOrigin().ToString()); 760 EXPECT_EQ("300x400", root_windows[1]->GetHostSize().ToString()); 761 762 UpdateDisplay("100x200,200+300-300x400"); 763 ASSERT_EQ(2, Shell::GetScreen()->GetNumDisplays()); 764 EXPECT_EQ("0,0", root_windows[0]->GetHostOrigin().ToString()); 765 EXPECT_EQ("100x200", root_windows[0]->GetHostSize().ToString()); 766 EXPECT_EQ("200,300", root_windows[1]->GetHostOrigin().ToString()); 767 EXPECT_EQ("300x400", root_windows[1]->GetHostSize().ToString()); 768 769 UpdateDisplay("400+500-200x300,300x400"); 770 ASSERT_EQ(2, Shell::GetScreen()->GetNumDisplays()); 771 EXPECT_EQ("400,500", root_windows[0]->GetHostOrigin().ToString()); 772 EXPECT_EQ("200x300", root_windows[0]->GetHostSize().ToString()); 773 EXPECT_EQ("0,0", root_windows[1]->GetHostOrigin().ToString()); 774 EXPECT_EQ("300x400", root_windows[1]->GetHostSize().ToString()); 775 776 UpdateDisplay("100+200-100x200,300+500-200x300"); 777 ASSERT_EQ(2, Shell::GetScreen()->GetNumDisplays()); 778 EXPECT_EQ("100,200", root_windows[0]->GetHostOrigin().ToString()); 779 EXPECT_EQ("100x200", root_windows[0]->GetHostSize().ToString()); 780 EXPECT_EQ("300,500", root_windows[1]->GetHostOrigin().ToString()); 781 EXPECT_EQ("200x300", root_windows[1]->GetHostSize().ToString()); 782} 783 784TEST_F(DisplayControllerTest, OverscanInsets) { 785 if (!SupportsMultipleDisplays()) 786 return; 787 788 DisplayController* display_controller = 789 Shell::GetInstance()->display_controller(); 790 TestEventHandler event_handler; 791 Shell::GetInstance()->AddPreTargetHandler(&event_handler); 792 793 UpdateDisplay("120x200,300x400*2"); 794 gfx::Display display1 = Shell::GetScreen()->GetPrimaryDisplay(); 795 Shell::RootWindowList root_windows = Shell::GetAllRootWindows(); 796 797 display_controller->SetOverscanInsets(display1.id(), 798 gfx::Insets(10, 15, 20, 25)); 799 EXPECT_EQ("0,0 80x170", root_windows[0]->bounds().ToString()); 800 EXPECT_EQ("150x200", root_windows[1]->bounds().size().ToString()); 801 EXPECT_EQ("80,0 150x200", 802 ScreenAsh::GetSecondaryDisplay().bounds().ToString()); 803 804 aura::test::EventGenerator generator(root_windows[0]); 805 generator.MoveMouseToInHost(20, 25); 806 EXPECT_EQ("5,15", event_handler.GetLocationAndReset()); 807 808 display_controller->SetOverscanInsets(display1.id(), gfx::Insets()); 809 EXPECT_EQ("0,0 120x200", root_windows[0]->bounds().ToString()); 810 EXPECT_EQ("120,0 150x200", 811 ScreenAsh::GetSecondaryDisplay().bounds().ToString()); 812 813 generator.MoveMouseToInHost(30, 20); 814 EXPECT_EQ("30,20", event_handler.GetLocationAndReset()); 815 816 // Make sure the root window transformer uses correct scale 817 // factor when swapping display. Test crbug.com/253690. 818 UpdateDisplay("400x300*2,600x400/o"); 819 root_windows = Shell::GetAllRootWindows(); 820 gfx::Point point; 821 Shell::GetAllRootWindows()[1]->GetRootTransform().TransformPoint(point); 822 EXPECT_EQ("15,10", point.ToString()); 823 824 display_controller->SwapPrimaryDisplay(); 825 point.SetPoint(0, 0); 826 Shell::GetAllRootWindows()[1]->GetRootTransform().TransformPoint(point); 827 EXPECT_EQ("15,10", point.ToString()); 828 829 Shell::GetInstance()->RemovePreTargetHandler(&event_handler); 830} 831 832TEST_F(DisplayControllerTest, Rotate) { 833 if (!SupportsMultipleDisplays()) 834 return; 835 836 DisplayController* display_controller = 837 Shell::GetInstance()->display_controller(); 838 internal::DisplayManager* display_manager = 839 Shell::GetInstance()->display_manager(); 840 TestEventHandler event_handler; 841 Shell::GetInstance()->AddPreTargetHandler(&event_handler); 842 843 UpdateDisplay("120x200,300x400*2"); 844 gfx::Display display1 = Shell::GetScreen()->GetPrimaryDisplay(); 845 int64 display2_id = ScreenAsh::GetSecondaryDisplay().id(); 846 Shell::RootWindowList root_windows = Shell::GetAllRootWindows(); 847 aura::test::EventGenerator generator1(root_windows[0]); 848 849 EXPECT_EQ("120x200", root_windows[0]->bounds().size().ToString()); 850 EXPECT_EQ("150x200", root_windows[1]->bounds().size().ToString()); 851 EXPECT_EQ("120,0 150x200", 852 ScreenAsh::GetSecondaryDisplay().bounds().ToString()); 853 generator1.MoveMouseToInHost(50, 40); 854 EXPECT_EQ("50,40", event_handler.GetLocationAndReset()); 855 EXPECT_EQ(gfx::Display::ROTATE_0, GetStoredRotation(display1.id())); 856 EXPECT_EQ(gfx::Display::ROTATE_0, GetStoredRotation(display2_id)); 857 858 display_manager->SetDisplayRotation(display1.id(), 859 gfx::Display::ROTATE_90); 860 EXPECT_EQ("200x120", root_windows[0]->bounds().size().ToString()); 861 EXPECT_EQ("150x200", root_windows[1]->bounds().size().ToString()); 862 EXPECT_EQ("200,0 150x200", 863 ScreenAsh::GetSecondaryDisplay().bounds().ToString()); 864 generator1.MoveMouseToInHost(50, 40); 865 EXPECT_EQ("40,69", event_handler.GetLocationAndReset()); 866 EXPECT_EQ(gfx::Display::ROTATE_90, GetStoredRotation(display1.id())); 867 EXPECT_EQ(gfx::Display::ROTATE_0, GetStoredRotation(display2_id)); 868 869 DisplayLayout display_layout(DisplayLayout::BOTTOM, 50); 870 display_controller->SetLayoutForCurrentDisplays(display_layout); 871 EXPECT_EQ("50,120 150x200", 872 ScreenAsh::GetSecondaryDisplay().bounds().ToString()); 873 874 display_manager->SetDisplayRotation(display2_id, 875 gfx::Display::ROTATE_270); 876 EXPECT_EQ("200x120", root_windows[0]->bounds().size().ToString()); 877 EXPECT_EQ("200x150", root_windows[1]->bounds().size().ToString()); 878 EXPECT_EQ("50,120 200x150", 879 ScreenAsh::GetSecondaryDisplay().bounds().ToString()); 880 EXPECT_EQ(gfx::Display::ROTATE_90, GetStoredRotation(display1.id())); 881 EXPECT_EQ(gfx::Display::ROTATE_270, GetStoredRotation(display2_id)); 882 883#if !defined(OS_WIN) 884 aura::test::EventGenerator generator2(root_windows[1]); 885 generator2.MoveMouseToInHost(50, 40); 886 EXPECT_EQ("179,25", event_handler.GetLocationAndReset()); 887 display_manager->SetDisplayRotation(display1.id(), 888 gfx::Display::ROTATE_180); 889 890 EXPECT_EQ("120x200", root_windows[0]->bounds().size().ToString()); 891 EXPECT_EQ("200x150", root_windows[1]->bounds().size().ToString()); 892 // Dislay must share at least 100, so the x's offset becomes 20. 893 EXPECT_EQ("20,200 200x150", 894 ScreenAsh::GetSecondaryDisplay().bounds().ToString()); 895 EXPECT_EQ(gfx::Display::ROTATE_180, GetStoredRotation(display1.id())); 896 EXPECT_EQ(gfx::Display::ROTATE_270, GetStoredRotation(display2_id)); 897 898 generator1.MoveMouseToInHost(50, 40); 899 EXPECT_EQ("69,159", event_handler.GetLocationAndReset()); 900#endif 901 902 Shell::GetInstance()->RemovePreTargetHandler(&event_handler); 903} 904 905TEST_F(DisplayControllerTest, ScaleRootWindow) { 906 if (!SupportsMultipleDisplays()) 907 return; 908 909 TestEventHandler event_handler; 910 Shell::GetInstance()->AddPreTargetHandler(&event_handler); 911 912 UpdateDisplay("600x400*2@1.5,500x300"); 913 914 gfx::Display display1 = Shell::GetScreen()->GetPrimaryDisplay(); 915 gfx::Display::SetInternalDisplayId(display1.id()); 916 917 gfx::Display display2 = ScreenAsh::GetSecondaryDisplay(); 918 Shell::RootWindowList root_windows = Shell::GetAllRootWindows(); 919 EXPECT_EQ("0,0 450x300", display1.bounds().ToString()); 920 EXPECT_EQ("0,0 450x300", root_windows[0]->bounds().ToString()); 921 EXPECT_EQ("450,0 500x300", display2.bounds().ToString()); 922 EXPECT_EQ(1.5f, GetStoredUIScale(display1.id())); 923 EXPECT_EQ(1.0f, GetStoredUIScale(display2.id())); 924 925 aura::test::EventGenerator generator(root_windows[0]); 926 generator.MoveMouseToInHost(599, 200); 927 EXPECT_EQ("449,150", event_handler.GetLocationAndReset()); 928 929 internal::DisplayManager* display_manager = 930 Shell::GetInstance()->display_manager(); 931 display_manager->SetDisplayUIScale(display1.id(), 1.25f); 932 display1 = Shell::GetScreen()->GetPrimaryDisplay(); 933 display2 = ScreenAsh::GetSecondaryDisplay(); 934 EXPECT_EQ("0,0 375x250", display1.bounds().ToString()); 935 EXPECT_EQ("0,0 375x250", root_windows[0]->bounds().ToString()); 936 EXPECT_EQ("375,0 500x300", display2.bounds().ToString()); 937 EXPECT_EQ(1.25f, GetStoredUIScale(display1.id())); 938 EXPECT_EQ(1.0f, GetStoredUIScale(display2.id())); 939 940 Shell::GetInstance()->RemovePreTargetHandler(&event_handler); 941} 942 943TEST_F(DisplayControllerTest, TouchScale) { 944 if (!SupportsMultipleDisplays()) 945 return; 946 947 TestEventHandler event_handler; 948 Shell::GetInstance()->AddPreTargetHandler(&event_handler); 949 950 UpdateDisplay("200x200*2"); 951 gfx::Display display = Shell::GetScreen()->GetPrimaryDisplay(); 952 Shell::RootWindowList root_windows = Shell::GetAllRootWindows(); 953 aura::RootWindow* root_window = root_windows[0]; 954 aura::test::EventGenerator generator(root_window); 955 956 generator.PressMoveAndReleaseTouchTo(50, 50); 957 // Default test touches have radius_x/y = 1.0, with device scale 958 // factor = 2, the scaled radius_x/y should be 0.5. 959 EXPECT_EQ(0.5, event_handler.touch_radius_x()); 960 EXPECT_EQ(0.5, event_handler.touch_radius_y()); 961 962 generator.ScrollSequence(gfx::Point(0,0), 963 base::TimeDelta::FromMilliseconds(100), 964 10.0, 1.0, 5, 1); 965 966 // With device scale factor = 2, ordinal_offset * 2 = offset. 967 EXPECT_EQ(event_handler.scroll_x_offset(), 968 event_handler.scroll_x_offset_ordinal() * 2); 969 EXPECT_EQ(event_handler.scroll_y_offset(), 970 event_handler.scroll_y_offset_ordinal() * 2); 971 972 Shell::GetInstance()->RemovePreTargetHandler(&event_handler); 973} 974 975TEST_F(DisplayControllerTest, ConvertHostToRootCoords) { 976 if (!SupportsMultipleDisplays()) 977 return; 978 979 TestEventHandler event_handler; 980 Shell::GetInstance()->AddPreTargetHandler(&event_handler); 981 982 UpdateDisplay("600x400*2/r@1.5"); 983 984 gfx::Display display1 = Shell::GetScreen()->GetPrimaryDisplay(); 985 Shell::RootWindowList root_windows = Shell::GetAllRootWindows(); 986 EXPECT_EQ("0,0 300x450", display1.bounds().ToString()); 987 EXPECT_EQ("0,0 300x450", root_windows[0]->bounds().ToString()); 988 EXPECT_EQ(1.5f, GetStoredUIScale(display1.id())); 989 990 aura::test::EventGenerator generator(root_windows[0]); 991 generator.MoveMouseToInHost(0, 0); 992 EXPECT_EQ("0,449", event_handler.GetLocationAndReset()); 993 generator.MoveMouseToInHost(599, 0); 994 EXPECT_EQ("0,0", event_handler.GetLocationAndReset()); 995 generator.MoveMouseToInHost(599, 399); 996 EXPECT_EQ("299,0", event_handler.GetLocationAndReset()); 997 generator.MoveMouseToInHost(0, 399); 998 EXPECT_EQ("299,449", event_handler.GetLocationAndReset()); 999 1000 UpdateDisplay("600x400*2/u@1.5"); 1001 display1 = Shell::GetScreen()->GetPrimaryDisplay(); 1002 root_windows = Shell::GetAllRootWindows(); 1003 EXPECT_EQ("0,0 450x300", display1.bounds().ToString()); 1004 EXPECT_EQ("0,0 450x300", root_windows[0]->bounds().ToString()); 1005 EXPECT_EQ(1.5f, GetStoredUIScale(display1.id())); 1006 1007 generator.MoveMouseToInHost(0, 0); 1008 EXPECT_EQ("449,299", event_handler.GetLocationAndReset()); 1009 generator.MoveMouseToInHost(599, 0); 1010 EXPECT_EQ("0,299", event_handler.GetLocationAndReset()); 1011 generator.MoveMouseToInHost(599, 399); 1012 EXPECT_EQ("0,0", event_handler.GetLocationAndReset()); 1013 generator.MoveMouseToInHost(0, 399); 1014 EXPECT_EQ("449,0", event_handler.GetLocationAndReset()); 1015 1016 UpdateDisplay("600x400*2/l@1.5"); 1017 display1 = Shell::GetScreen()->GetPrimaryDisplay(); 1018 root_windows = Shell::GetAllRootWindows(); 1019 EXPECT_EQ("0,0 300x450", display1.bounds().ToString()); 1020 EXPECT_EQ("0,0 300x450", root_windows[0]->bounds().ToString()); 1021 EXPECT_EQ(1.5f, GetStoredUIScale(display1.id())); 1022 1023 generator.MoveMouseToInHost(0, 0); 1024 EXPECT_EQ("299,0", event_handler.GetLocationAndReset()); 1025 generator.MoveMouseToInHost(599, 0); 1026 EXPECT_EQ("299,449", event_handler.GetLocationAndReset()); 1027 generator.MoveMouseToInHost(599, 399); 1028 EXPECT_EQ("0,449", event_handler.GetLocationAndReset()); 1029 generator.MoveMouseToInHost(0, 399); 1030 EXPECT_EQ("0,0", event_handler.GetLocationAndReset()); 1031 1032 Shell::GetInstance()->RemovePreTargetHandler(&event_handler); 1033} 1034 1035#if defined(USE_X11) 1036TEST_F(DisplayControllerTest, XWidowNameForRootWindow) { 1037 EXPECT_EQ("aura_root_0", GetXWindowName(Shell::GetPrimaryRootWindow())); 1038 1039 // Multiple display. 1040 UpdateDisplay("200x200,300x300"); 1041 aura::RootWindow* primary, *secondary; 1042 GetPrimaryAndSeconary(&primary, &secondary); 1043 EXPECT_EQ("aura_root_0", GetXWindowName(primary)); 1044 EXPECT_EQ("aura_root_x", GetXWindowName(secondary)); 1045 1046 // Swap primary. 1047 primary = secondary = NULL; 1048 Shell::GetInstance()->display_controller()->SwapPrimaryDisplay(); 1049 GetPrimaryAndSeconary(&primary, &secondary); 1050 EXPECT_EQ("aura_root_0", GetXWindowName(primary)); 1051 EXPECT_EQ("aura_root_x", GetXWindowName(secondary)); 1052 1053 // Switching back to single display. 1054 UpdateDisplay("300x400"); 1055 EXPECT_EQ("aura_root_0", GetXWindowName(Shell::GetPrimaryRootWindow())); 1056} 1057#endif 1058 1059} // namespace ash 1060