1 // Copyright 2014 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 "ui/display/chromeos/display_configurator.h" 6 7 #include "base/bind.h" 8 #include "base/command_line.h" 9 #include "base/logging.h" 10 #include "base/strings/string_number_conversions.h" 11 #include "base/strings/stringprintf.h" 12 #include "base/sys_info.h" 13 #include "base/time/time.h" 14 #include "ui/display/display_switches.h" 15 #include "ui/display/types/chromeos/display_mode.h" 16 #include "ui/display/types/chromeos/display_snapshot.h" 17 #include "ui/display/types/chromeos/native_display_delegate.h" 18 19 namespace ui { 20 21 namespace { 22 23 typedef std::vector<const DisplayMode*> DisplayModeList; 24 25 // The delay to perform configuration after RRNotify. See the comment 26 // in |Dispatch()|. 27 const int kConfigureDelayMs = 500; 28 29 // Returns a string describing |state|. 30 std::string DisplayPowerStateToString(chromeos::DisplayPowerState state) { 31 switch (state) { 32 case chromeos::DISPLAY_POWER_ALL_ON: 33 return "ALL_ON"; 34 case chromeos::DISPLAY_POWER_ALL_OFF: 35 return "ALL_OFF"; 36 case chromeos::DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON: 37 return "INTERNAL_OFF_EXTERNAL_ON"; 38 case chromeos::DISPLAY_POWER_INTERNAL_ON_EXTERNAL_OFF: 39 return "INTERNAL_ON_EXTERNAL_OFF"; 40 default: 41 return "unknown (" + base::IntToString(state) + ")"; 42 } 43 } 44 45 // Returns a string describing |state|. 46 std::string DisplayStateToString(MultipleDisplayState state) { 47 switch (state) { 48 case MULTIPLE_DISPLAY_STATE_INVALID: 49 return "INVALID"; 50 case MULTIPLE_DISPLAY_STATE_HEADLESS: 51 return "HEADLESS"; 52 case MULTIPLE_DISPLAY_STATE_SINGLE: 53 return "SINGLE"; 54 case MULTIPLE_DISPLAY_STATE_DUAL_MIRROR: 55 return "DUAL_MIRROR"; 56 case MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED: 57 return "DUAL_EXTENDED"; 58 } 59 NOTREACHED() << "Unknown state " << state; 60 return "INVALID"; 61 } 62 63 // Returns the number of displays in |displays| that should be turned on, per 64 // |state|. If |display_power| is non-NULL, it is updated to contain the 65 // on/off state of each corresponding entry in |displays|. 66 int GetDisplayPower( 67 const std::vector<DisplayConfigurator::DisplayState>& display_states, 68 chromeos::DisplayPowerState state, 69 std::vector<bool>* display_power) { 70 int num_on_displays = 0; 71 if (display_power) 72 display_power->resize(display_states.size()); 73 74 for (size_t i = 0; i < display_states.size(); ++i) { 75 bool internal = 76 display_states[i].display->type() == DISPLAY_CONNECTION_TYPE_INTERNAL; 77 bool on = 78 state == chromeos::DISPLAY_POWER_ALL_ON || 79 (state == chromeos::DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON && 80 !internal) || 81 (state == chromeos::DISPLAY_POWER_INTERNAL_ON_EXTERNAL_OFF && internal); 82 if (display_power) 83 (*display_power)[i] = on; 84 if (on) 85 num_on_displays++; 86 } 87 return num_on_displays; 88 } 89 90 } // namespace 91 92 DisplayConfigurator::DisplayState::DisplayState() 93 : display(NULL), 94 touch_device_id(0), 95 selected_mode(NULL), 96 mirror_mode(NULL) {} 97 98 bool DisplayConfigurator::TestApi::TriggerConfigureTimeout() { 99 if (configurator_->configure_timer_.get() && 100 configurator_->configure_timer_->IsRunning()) { 101 configurator_->configure_timer_.reset(); 102 configurator_->ConfigureDisplays(); 103 return true; 104 } else { 105 return false; 106 } 107 } 108 109 // static 110 const DisplayMode* DisplayConfigurator::FindDisplayModeMatchingSize( 111 const DisplaySnapshot& display, 112 const gfx::Size& size) { 113 const DisplayMode* best_mode = NULL; 114 for (DisplayModeList::const_iterator it = display.modes().begin(); 115 it != display.modes().end(); 116 ++it) { 117 const DisplayMode* mode = *it; 118 119 if (mode->size() != size) 120 continue; 121 122 if (!best_mode) { 123 best_mode = mode; 124 continue; 125 } 126 127 if (mode->is_interlaced()) { 128 if (!best_mode->is_interlaced()) 129 continue; 130 } else { 131 // Reset the best rate if the non interlaced is 132 // found the first time. 133 if (best_mode->is_interlaced()) { 134 best_mode = mode; 135 continue; 136 } 137 } 138 if (mode->refresh_rate() < best_mode->refresh_rate()) 139 continue; 140 141 best_mode = mode; 142 } 143 144 return best_mode; 145 } 146 147 DisplayConfigurator::DisplayConfigurator() 148 : state_controller_(NULL), 149 mirroring_controller_(NULL), 150 is_panel_fitting_enabled_(false), 151 configure_display_(base::SysInfo::IsRunningOnChromeOS()), 152 display_state_(MULTIPLE_DISPLAY_STATE_INVALID), 153 power_state_(chromeos::DISPLAY_POWER_ALL_ON), 154 next_display_protection_client_id_(1) {} 155 156 DisplayConfigurator::~DisplayConfigurator() { 157 if (native_display_delegate_) 158 native_display_delegate_->RemoveObserver(this); 159 } 160 161 void DisplayConfigurator::SetDelegatesForTesting( 162 scoped_ptr<NativeDisplayDelegate> display_delegate, 163 scoped_ptr<TouchscreenDelegate> touchscreen_delegate) { 164 DCHECK(!native_display_delegate_); 165 DCHECK(!touchscreen_delegate_); 166 167 InitializeDelegates(display_delegate.Pass(), touchscreen_delegate.Pass()); 168 configure_display_ = true; 169 } 170 171 void DisplayConfigurator::SetInitialDisplayPower( 172 chromeos::DisplayPowerState power_state) { 173 DCHECK_EQ(display_state_, MULTIPLE_DISPLAY_STATE_INVALID); 174 power_state_ = power_state; 175 } 176 177 void DisplayConfigurator::Init(bool is_panel_fitting_enabled) { 178 is_panel_fitting_enabled_ = is_panel_fitting_enabled; 179 if (!configure_display_) 180 return; 181 182 PlatformInitialize(); 183 } 184 185 void DisplayConfigurator::InitializeDelegates( 186 scoped_ptr<NativeDisplayDelegate> display_delegate, 187 scoped_ptr<TouchscreenDelegate> touchscreen_delegate) { 188 if (!native_display_delegate_ && !touchscreen_delegate_) { 189 native_display_delegate_ = display_delegate.Pass(); 190 touchscreen_delegate_ = touchscreen_delegate.Pass(); 191 192 native_display_delegate_->AddObserver(this); 193 } 194 } 195 196 void DisplayConfigurator::ForceInitialConfigure( 197 uint32_t background_color_argb) { 198 if (!configure_display_) 199 return; 200 201 native_display_delegate_->GrabServer(); 202 native_display_delegate_->Initialize(); 203 204 UpdateCachedDisplays(); 205 if (cached_displays_.size() > 1 && background_color_argb) 206 native_display_delegate_->SetBackgroundColor(background_color_argb); 207 const MultipleDisplayState new_state = ChooseDisplayState(power_state_); 208 const bool success = 209 EnterStateOrFallBackToSoftwareMirroring(new_state, power_state_); 210 211 // Force the DPMS on chrome startup as the driver doesn't always detect 212 // that all displays are on when signing out. 213 native_display_delegate_->ForceDPMSOn(); 214 native_display_delegate_->UngrabServer(); 215 NotifyObservers(success, new_state); 216 } 217 218 bool DisplayConfigurator::IsMirroring() const { 219 return display_state_ == MULTIPLE_DISPLAY_STATE_DUAL_MIRROR || 220 (mirroring_controller_ && 221 mirroring_controller_->SoftwareMirroringEnabled()); 222 } 223 224 bool DisplayConfigurator::ApplyProtections(const ContentProtections& requests) { 225 for (DisplayStateList::const_iterator it = cached_displays_.begin(); 226 it != cached_displays_.end(); 227 ++it) { 228 uint32_t all_desired = 0; 229 230 // In mirror mode, protection request of all displays need to be fulfilled. 231 // In non-mirror mode, only request of client's display needs to be 232 // fulfilled. 233 ContentProtections::const_iterator request_it; 234 if (IsMirroring()) { 235 for (request_it = requests.begin(); 236 request_it != requests.end(); 237 ++request_it) 238 all_desired |= request_it->second; 239 } else { 240 request_it = requests.find(it->display->display_id()); 241 if (request_it != requests.end()) 242 all_desired = request_it->second; 243 } 244 245 switch (it->display->type()) { 246 case DISPLAY_CONNECTION_TYPE_UNKNOWN: 247 return false; 248 // DisplayPort, DVI, and HDMI all support HDCP. 249 case DISPLAY_CONNECTION_TYPE_DISPLAYPORT: 250 case DISPLAY_CONNECTION_TYPE_DVI: 251 case DISPLAY_CONNECTION_TYPE_HDMI: { 252 HDCPState new_desired_state = 253 (all_desired & CONTENT_PROTECTION_METHOD_HDCP) ? 254 HDCP_STATE_DESIRED : HDCP_STATE_UNDESIRED; 255 if (!native_display_delegate_->SetHDCPState(*it->display, 256 new_desired_state)) 257 return false; 258 break; 259 } 260 case DISPLAY_CONNECTION_TYPE_INTERNAL: 261 case DISPLAY_CONNECTION_TYPE_VGA: 262 case DISPLAY_CONNECTION_TYPE_NETWORK: 263 // No protections for these types. Do nothing. 264 break; 265 case DISPLAY_CONNECTION_TYPE_NONE: 266 NOTREACHED(); 267 break; 268 } 269 } 270 271 return true; 272 } 273 274 DisplayConfigurator::ContentProtectionClientId 275 DisplayConfigurator::RegisterContentProtectionClient() { 276 if (!configure_display_) 277 return kInvalidClientId; 278 279 return next_display_protection_client_id_++; 280 } 281 282 void DisplayConfigurator::UnregisterContentProtectionClient( 283 ContentProtectionClientId client_id) { 284 client_protection_requests_.erase(client_id); 285 286 ContentProtections protections; 287 for (ProtectionRequests::const_iterator it = 288 client_protection_requests_.begin(); 289 it != client_protection_requests_.end(); 290 ++it) { 291 for (ContentProtections::const_iterator it2 = it->second.begin(); 292 it2 != it->second.end(); 293 ++it2) { 294 protections[it2->first] |= it2->second; 295 } 296 } 297 298 ApplyProtections(protections); 299 } 300 301 bool DisplayConfigurator::QueryContentProtectionStatus( 302 ContentProtectionClientId client_id, 303 int64_t display_id, 304 uint32_t* link_mask, 305 uint32_t* protection_mask) { 306 if (!configure_display_) 307 return false; 308 309 uint32_t enabled = 0; 310 uint32_t unfulfilled = 0; 311 *link_mask = 0; 312 for (DisplayStateList::const_iterator it = cached_displays_.begin(); 313 it != cached_displays_.end(); 314 ++it) { 315 // Query display if it is in mirror mode or client on the same display. 316 if (!IsMirroring() && it->display->display_id() != display_id) 317 continue; 318 319 *link_mask |= it->display->type(); 320 switch (it->display->type()) { 321 case DISPLAY_CONNECTION_TYPE_UNKNOWN: 322 return false; 323 // DisplayPort, DVI, and HDMI all support HDCP. 324 case DISPLAY_CONNECTION_TYPE_DISPLAYPORT: 325 case DISPLAY_CONNECTION_TYPE_DVI: 326 case DISPLAY_CONNECTION_TYPE_HDMI: { 327 HDCPState state; 328 if (!native_display_delegate_->GetHDCPState(*it->display, &state)) 329 return false; 330 if (state == HDCP_STATE_ENABLED) 331 enabled |= CONTENT_PROTECTION_METHOD_HDCP; 332 else 333 unfulfilled |= CONTENT_PROTECTION_METHOD_HDCP; 334 break; 335 } 336 case DISPLAY_CONNECTION_TYPE_INTERNAL: 337 case DISPLAY_CONNECTION_TYPE_VGA: 338 case DISPLAY_CONNECTION_TYPE_NETWORK: 339 // No protections for these types. Do nothing. 340 break; 341 case DISPLAY_CONNECTION_TYPE_NONE: 342 NOTREACHED(); 343 break; 344 } 345 } 346 347 // Don't reveal protections requested by other clients. 348 ProtectionRequests::iterator it = client_protection_requests_.find(client_id); 349 if (it != client_protection_requests_.end()) { 350 uint32_t requested_mask = 0; 351 if (it->second.find(display_id) != it->second.end()) 352 requested_mask = it->second[display_id]; 353 *protection_mask = enabled & ~unfulfilled & requested_mask; 354 } else { 355 *protection_mask = 0; 356 } 357 return true; 358 } 359 360 bool DisplayConfigurator::EnableContentProtection( 361 ContentProtectionClientId client_id, 362 int64_t display_id, 363 uint32_t desired_method_mask) { 364 if (!configure_display_) 365 return false; 366 367 ContentProtections protections; 368 for (ProtectionRequests::const_iterator it = 369 client_protection_requests_.begin(); 370 it != client_protection_requests_.end(); 371 ++it) { 372 for (ContentProtections::const_iterator it2 = it->second.begin(); 373 it2 != it->second.end(); 374 ++it2) { 375 if (it->first == client_id && it2->first == display_id) 376 continue; 377 protections[it2->first] |= it2->second; 378 } 379 } 380 protections[display_id] |= desired_method_mask; 381 382 if (!ApplyProtections(protections)) 383 return false; 384 385 if (desired_method_mask == CONTENT_PROTECTION_METHOD_NONE) { 386 if (client_protection_requests_.find(client_id) != 387 client_protection_requests_.end()) { 388 client_protection_requests_[client_id].erase(display_id); 389 if (client_protection_requests_[client_id].size() == 0) 390 client_protection_requests_.erase(client_id); 391 } 392 } else { 393 client_protection_requests_[client_id][display_id] = desired_method_mask; 394 } 395 396 return true; 397 } 398 399 std::vector<ui::ColorCalibrationProfile> 400 DisplayConfigurator::GetAvailableColorCalibrationProfiles(int64_t display_id) { 401 if (!base::CommandLine::ForCurrentProcess()->HasSwitch( 402 switches::kDisableDisplayColorCalibration)) { 403 for (size_t i = 0; i < cached_displays_.size(); ++i) { 404 if (cached_displays_[i].display && 405 cached_displays_[i].display->display_id() == display_id) { 406 return native_display_delegate_->GetAvailableColorCalibrationProfiles( 407 *cached_displays_[i].display); 408 } 409 } 410 } 411 412 return std::vector<ui::ColorCalibrationProfile>(); 413 } 414 415 bool DisplayConfigurator::SetColorCalibrationProfile( 416 int64_t display_id, 417 ui::ColorCalibrationProfile new_profile) { 418 for (size_t i = 0; i < cached_displays_.size(); ++i) { 419 if (cached_displays_[i].display && 420 cached_displays_[i].display->display_id() == display_id) { 421 return native_display_delegate_->SetColorCalibrationProfile( 422 *cached_displays_[i].display, new_profile); 423 } 424 } 425 426 return false; 427 } 428 429 void DisplayConfigurator::PrepareForExit() { 430 configure_display_ = false; 431 } 432 433 bool DisplayConfigurator::SetDisplayPower( 434 chromeos::DisplayPowerState power_state, 435 int flags) { 436 if (!configure_display_) 437 return false; 438 439 VLOG(1) << "SetDisplayPower: power_state=" 440 << DisplayPowerStateToString(power_state) << " flags=" << flags 441 << ", configure timer=" 442 << ((configure_timer_.get() && configure_timer_->IsRunning()) ? 443 "Running" : "Stopped"); 444 if (power_state == power_state_ && !(flags & kSetDisplayPowerForceProbe)) 445 return true; 446 447 native_display_delegate_->GrabServer(); 448 UpdateCachedDisplays(); 449 450 const MultipleDisplayState new_state = ChooseDisplayState(power_state); 451 bool attempted_change = false; 452 bool success = false; 453 454 bool only_if_single_internal_display = 455 flags & kSetDisplayPowerOnlyIfSingleInternalDisplay; 456 bool single_internal_display = 457 cached_displays_.size() == 1 && 458 cached_displays_[0].display->type() == DISPLAY_CONNECTION_TYPE_INTERNAL; 459 if (single_internal_display || !only_if_single_internal_display) { 460 success = EnterStateOrFallBackToSoftwareMirroring(new_state, power_state); 461 attempted_change = true; 462 463 // Force the DPMS on since the driver doesn't always detect that it 464 // should turn on. This is needed when coming back from idle suspend. 465 if (success && power_state != chromeos::DISPLAY_POWER_ALL_OFF) 466 native_display_delegate_->ForceDPMSOn(); 467 } 468 469 native_display_delegate_->UngrabServer(); 470 if (attempted_change) 471 NotifyObservers(success, new_state); 472 return true; 473 } 474 475 bool DisplayConfigurator::SetDisplayMode(MultipleDisplayState new_state) { 476 if (!configure_display_) 477 return false; 478 479 VLOG(1) << "SetDisplayMode: state=" << DisplayStateToString(new_state); 480 if (display_state_ == new_state) { 481 // Cancel software mirroring if the state is moving from 482 // MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED to 483 // MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED. 484 if (mirroring_controller_ && 485 new_state == MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED) 486 mirroring_controller_->SetSoftwareMirroring(false); 487 NotifyObservers(true, new_state); 488 return true; 489 } 490 491 native_display_delegate_->GrabServer(); 492 UpdateCachedDisplays(); 493 const bool success = 494 EnterStateOrFallBackToSoftwareMirroring(new_state, power_state_); 495 native_display_delegate_->UngrabServer(); 496 497 NotifyObservers(success, new_state); 498 return success; 499 } 500 501 void DisplayConfigurator::OnConfigurationChanged() { 502 // Configure displays with |kConfigureDelayMs| delay, 503 // so that time-consuming ConfigureDisplays() won't be called multiple times. 504 if (configure_timer_.get()) { 505 configure_timer_->Reset(); 506 } else { 507 configure_timer_.reset(new base::OneShotTimer<DisplayConfigurator>()); 508 configure_timer_->Start( 509 FROM_HERE, 510 base::TimeDelta::FromMilliseconds(kConfigureDelayMs), 511 this, 512 &DisplayConfigurator::ConfigureDisplays); 513 } 514 } 515 516 void DisplayConfigurator::AddObserver(Observer* observer) { 517 observers_.AddObserver(observer); 518 } 519 520 void DisplayConfigurator::RemoveObserver(Observer* observer) { 521 observers_.RemoveObserver(observer); 522 } 523 524 void DisplayConfigurator::SuspendDisplays() { 525 // If the display is off due to user inactivity and there's only a single 526 // internal display connected, switch to the all-on state before 527 // suspending. This shouldn't be very noticeable to the user since the 528 // backlight is off at this point, and doing this lets us resume directly 529 // into the "on" state, which greatly reduces resume times. 530 if (power_state_ == chromeos::DISPLAY_POWER_ALL_OFF) { 531 SetDisplayPower(chromeos::DISPLAY_POWER_ALL_ON, 532 kSetDisplayPowerOnlyIfSingleInternalDisplay); 533 534 // We need to make sure that the monitor configuration we just did actually 535 // completes before we return, because otherwise the X message could be 536 // racing with the HandleSuspendReadiness message. 537 native_display_delegate_->SyncWithServer(); 538 } 539 } 540 541 void DisplayConfigurator::ResumeDisplays() { 542 // Force probing to ensure that we pick up any changes that were made 543 // while the system was suspended. 544 SetDisplayPower(power_state_, kSetDisplayPowerForceProbe); 545 } 546 547 void DisplayConfigurator::UpdateCachedDisplays() { 548 std::vector<DisplaySnapshot*> snapshots = 549 native_display_delegate_->GetDisplays(); 550 551 cached_displays_.clear(); 552 for (size_t i = 0; i < snapshots.size(); ++i) { 553 DisplayState display_state; 554 display_state.display = snapshots[i]; 555 cached_displays_.push_back(display_state); 556 } 557 558 touchscreen_delegate_->AssociateTouchscreens(&cached_displays_); 559 560 // Set |selected_mode| fields. 561 for (size_t i = 0; i < cached_displays_.size(); ++i) { 562 DisplayState* display_state = &cached_displays_[i]; 563 if (display_state->display->has_proper_display_id()) { 564 gfx::Size size; 565 if (state_controller_ && 566 state_controller_->GetResolutionForDisplayId( 567 display_state->display->display_id(), &size)) { 568 display_state->selected_mode = 569 FindDisplayModeMatchingSize(*display_state->display, size); 570 } 571 } 572 // Fall back to native mode. 573 if (!display_state->selected_mode) 574 display_state->selected_mode = display_state->display->native_mode(); 575 } 576 577 // Set |mirror_mode| fields. 578 if (cached_displays_.size() == 2) { 579 bool one_is_internal = 580 cached_displays_[0].display->type() == DISPLAY_CONNECTION_TYPE_INTERNAL; 581 bool two_is_internal = 582 cached_displays_[1].display->type() == DISPLAY_CONNECTION_TYPE_INTERNAL; 583 int internal_displays = 584 (one_is_internal ? 1 : 0) + (two_is_internal ? 1 : 0); 585 DCHECK_LT(internal_displays, 2); 586 LOG_IF(WARNING, internal_displays == 2) 587 << "Two internal displays detected."; 588 589 bool can_mirror = false; 590 for (int attempt = 0; !can_mirror && attempt < 2; ++attempt) { 591 // Try preserving external display's aspect ratio on the first attempt. 592 // If that fails, fall back to the highest matching resolution. 593 bool preserve_aspect = attempt == 0; 594 595 if (internal_displays == 1) { 596 if (one_is_internal) { 597 can_mirror = FindMirrorMode(&cached_displays_[0], 598 &cached_displays_[1], 599 is_panel_fitting_enabled_, 600 preserve_aspect); 601 } else { 602 DCHECK(two_is_internal); 603 can_mirror = FindMirrorMode(&cached_displays_[1], 604 &cached_displays_[0], 605 is_panel_fitting_enabled_, 606 preserve_aspect); 607 } 608 } else { // if (internal_displays == 0) 609 // No panel fitting for external displays, so fall back to exact match. 610 can_mirror = FindMirrorMode( 611 &cached_displays_[0], &cached_displays_[1], false, preserve_aspect); 612 if (!can_mirror && preserve_aspect) { 613 // FindMirrorMode() will try to preserve aspect ratio of what it 614 // thinks is external display, so if it didn't succeed with one, maybe 615 // it will succeed with the other. This way we will have the correct 616 // aspect ratio on at least one of them. 617 can_mirror = FindMirrorMode(&cached_displays_[1], 618 &cached_displays_[0], 619 false, 620 preserve_aspect); 621 } 622 } 623 } 624 } 625 } 626 627 bool DisplayConfigurator::FindMirrorMode(DisplayState* internal_display, 628 DisplayState* external_display, 629 bool try_panel_fitting, 630 bool preserve_aspect) { 631 const DisplayMode* internal_native_info = 632 internal_display->display->native_mode(); 633 const DisplayMode* external_native_info = 634 external_display->display->native_mode(); 635 if (!internal_native_info || !external_native_info) 636 return false; 637 638 // Check if some external display resolution can be mirrored on internal. 639 // Prefer the modes in the order they're present in DisplaySnapshot, assuming 640 // this is the order in which they look better on the monitor. 641 for (DisplayModeList::const_iterator external_it = 642 external_display->display->modes().begin(); 643 external_it != external_display->display->modes().end(); 644 ++external_it) { 645 const DisplayMode& external_info = **external_it; 646 bool is_native_aspect_ratio = 647 external_native_info->size().width() * external_info.size().height() == 648 external_native_info->size().height() * external_info.size().width(); 649 if (preserve_aspect && !is_native_aspect_ratio) 650 continue; // Allow only aspect ratio preserving modes for mirroring. 651 652 // Try finding an exact match. 653 for (DisplayModeList::const_iterator internal_it = 654 internal_display->display->modes().begin(); 655 internal_it != internal_display->display->modes().end(); 656 ++internal_it) { 657 const DisplayMode& internal_info = **internal_it; 658 if (internal_info.size().width() == external_info.size().width() && 659 internal_info.size().height() == external_info.size().height() && 660 internal_info.is_interlaced() == external_info.is_interlaced()) { 661 internal_display->mirror_mode = *internal_it; 662 external_display->mirror_mode = *external_it; 663 return true; // Mirror mode found. 664 } 665 } 666 667 // Try to create a matching internal display mode by panel fitting. 668 if (try_panel_fitting) { 669 // We can downscale by 1.125, and upscale indefinitely. Downscaling looks 670 // ugly, so, can fit == can upscale. Also, internal panels don't support 671 // fitting interlaced modes. 672 bool can_fit = internal_native_info->size().width() >= 673 external_info.size().width() && 674 internal_native_info->size().height() >= 675 external_info.size().height() && 676 !external_info.is_interlaced(); 677 if (can_fit) { 678 native_display_delegate_->AddMode(*internal_display->display, 679 *external_it); 680 internal_display->display->add_mode(*external_it); 681 internal_display->mirror_mode = *external_it; 682 external_display->mirror_mode = *external_it; 683 return true; // Mirror mode created. 684 } 685 } 686 } 687 688 return false; 689 } 690 691 void DisplayConfigurator::ConfigureDisplays() { 692 configure_timer_.reset(); 693 694 if (!configure_display_) 695 return; 696 697 native_display_delegate_->GrabServer(); 698 UpdateCachedDisplays(); 699 const MultipleDisplayState new_state = ChooseDisplayState(power_state_); 700 const bool success = 701 EnterStateOrFallBackToSoftwareMirroring(new_state, power_state_); 702 native_display_delegate_->UngrabServer(); 703 704 NotifyObservers(success, new_state); 705 } 706 707 void DisplayConfigurator::NotifyObservers( 708 bool success, 709 MultipleDisplayState attempted_state) { 710 if (success) { 711 FOR_EACH_OBSERVER( 712 Observer, observers_, OnDisplayModeChanged(cached_displays_)); 713 } else { 714 FOR_EACH_OBSERVER( 715 Observer, observers_, OnDisplayModeChangeFailed(attempted_state)); 716 } 717 } 718 719 bool DisplayConfigurator::EnterStateOrFallBackToSoftwareMirroring( 720 MultipleDisplayState display_state, 721 chromeos::DisplayPowerState power_state) { 722 bool success = EnterState(display_state, power_state); 723 if (mirroring_controller_) { 724 bool enable_software_mirroring = false; 725 if (!success && display_state == MULTIPLE_DISPLAY_STATE_DUAL_MIRROR) { 726 if (display_state_ != MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED || 727 power_state_ != power_state) 728 EnterState(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED, power_state); 729 enable_software_mirroring = success = 730 display_state_ == MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED; 731 } 732 mirroring_controller_->SetSoftwareMirroring(enable_software_mirroring); 733 } 734 return success; 735 } 736 737 bool DisplayConfigurator::EnterState(MultipleDisplayState display_state, 738 chromeos::DisplayPowerState power_state) { 739 std::vector<bool> display_power; 740 int num_on_displays = 741 GetDisplayPower(cached_displays_, power_state, &display_power); 742 VLOG(1) << "EnterState: display=" << DisplayStateToString(display_state) 743 << " power=" << DisplayPowerStateToString(power_state); 744 745 // Framebuffer dimensions. 746 gfx::Size size; 747 748 std::vector<gfx::Point> new_origins(cached_displays_.size(), gfx::Point()); 749 std::vector<const DisplayMode*> new_mode; 750 for (size_t i = 0; i < cached_displays_.size(); ++i) 751 new_mode.push_back(cached_displays_[i].display->current_mode()); 752 753 switch (display_state) { 754 case MULTIPLE_DISPLAY_STATE_INVALID: 755 NOTREACHED() << "Ignoring request to enter invalid state with " 756 << cached_displays_.size() << " connected display(s)"; 757 return false; 758 case MULTIPLE_DISPLAY_STATE_HEADLESS: 759 if (cached_displays_.size() != 0) { 760 LOG(WARNING) << "Ignoring request to enter headless mode with " 761 << cached_displays_.size() << " connected display(s)"; 762 return false; 763 } 764 break; 765 case MULTIPLE_DISPLAY_STATE_SINGLE: { 766 // If there are multiple displays connected, only one should be turned on. 767 if (cached_displays_.size() != 1 && num_on_displays != 1) { 768 LOG(WARNING) << "Ignoring request to enter single mode with " 769 << cached_displays_.size() << " connected displays and " 770 << num_on_displays << " turned on"; 771 return false; 772 } 773 774 for (size_t i = 0; i < cached_displays_.size(); ++i) { 775 DisplayState* state = &cached_displays_[i]; 776 new_mode[i] = display_power[i] ? state->selected_mode : NULL; 777 778 if (display_power[i] || cached_displays_.size() == 1) { 779 const DisplayMode* mode_info = state->selected_mode; 780 if (!mode_info) 781 return false; 782 if (mode_info->size() == gfx::Size(1024, 768)) { 783 VLOG(1) << "Potentially misdetecting display(1024x768):" 784 << " displays size=" << cached_displays_.size() 785 << ", num_on_displays=" << num_on_displays 786 << ", current size:" << size.width() << "x" << size.height() 787 << ", i=" << i << ", display=" << state->display->ToString() 788 << ", display_mode=" << mode_info->ToString(); 789 } 790 size = mode_info->size(); 791 } 792 } 793 break; 794 } 795 case MULTIPLE_DISPLAY_STATE_DUAL_MIRROR: { 796 if (cached_displays_.size() != 2 || 797 (num_on_displays != 0 && num_on_displays != 2)) { 798 LOG(WARNING) << "Ignoring request to enter mirrored mode with " 799 << cached_displays_.size() << " connected display(s) and " 800 << num_on_displays << " turned on"; 801 return false; 802 } 803 804 const DisplayMode* mode_info = cached_displays_[0].mirror_mode; 805 if (!mode_info) 806 return false; 807 size = mode_info->size(); 808 809 for (size_t i = 0; i < cached_displays_.size(); ++i) { 810 DisplayState* state = &cached_displays_[i]; 811 new_mode[i] = display_power[i] ? state->mirror_mode : NULL; 812 if (state->touch_device_id) { 813 if (state->mirror_mode != state->display->native_mode() && 814 state->display->is_aspect_preserving_scaling()) { 815 mirrored_display_area_ratio_map_[state->touch_device_id] = 816 GetMirroredDisplayAreaRatio(*state); 817 } 818 } 819 } 820 break; 821 } 822 case MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED: { 823 if (cached_displays_.size() != 2 || 824 (num_on_displays != 0 && num_on_displays != 2)) { 825 LOG(WARNING) << "Ignoring request to enter extended mode with " 826 << cached_displays_.size() << " connected display(s) and " 827 << num_on_displays << " turned on"; 828 return false; 829 } 830 831 for (size_t i = 0; i < cached_displays_.size(); ++i) { 832 DisplayState* state = &cached_displays_[i]; 833 new_origins[i].set_y(size.height() ? size.height() + kVerticalGap : 0); 834 new_mode[i] = display_power[i] ? state->selected_mode : NULL; 835 836 // Retain the full screen size even if all displays are off so the 837 // same desktop configuration can be restored when the displays are 838 // turned back on. 839 const DisplayMode* mode_info = cached_displays_[i].selected_mode; 840 if (!mode_info) 841 return false; 842 843 size.set_width(std::max<int>(size.width(), mode_info->size().width())); 844 size.set_height(size.height() + (size.height() ? kVerticalGap : 0) + 845 mode_info->size().height()); 846 } 847 break; 848 } 849 } 850 851 // Finally, apply the desired changes. 852 bool all_succeeded = true; 853 if (!cached_displays_.empty()) { 854 native_display_delegate_->CreateFrameBuffer(size); 855 for (size_t i = 0; i < cached_displays_.size(); ++i) { 856 const DisplayState& state = cached_displays_[i]; 857 bool configure_succeeded = false; 858 859 while (true) { 860 if (native_display_delegate_->Configure( 861 *state.display, new_mode[i], new_origins[i])) { 862 state.display->set_current_mode(new_mode[i]); 863 state.display->set_origin(new_origins[i]); 864 865 configure_succeeded = true; 866 break; 867 } 868 869 const DisplayMode* mode_info = new_mode[i]; 870 if (!mode_info) 871 break; 872 873 // Find the mode with the next-best resolution and see if that can 874 // be set. 875 int best_mode_pixels = 0; 876 877 int current_mode_pixels = mode_info->size().GetArea(); 878 for (DisplayModeList::const_iterator it = 879 state.display->modes().begin(); 880 it != state.display->modes().end(); 881 it++) { 882 int pixel_count = (*it)->size().GetArea(); 883 if ((pixel_count < current_mode_pixels) && 884 (pixel_count > best_mode_pixels)) { 885 new_mode[i] = *it; 886 best_mode_pixels = pixel_count; 887 } 888 } 889 890 if (best_mode_pixels == 0) 891 break; 892 } 893 894 if (!configure_succeeded) 895 all_succeeded = false; 896 897 // If we are trying to set mirror mode and one of the modesets fails, 898 // then the two monitors will be mis-matched. In this case, return 899 // false to let the observers be aware. 900 if (display_state == MULTIPLE_DISPLAY_STATE_DUAL_MIRROR && 901 display_power[i] && 902 state.display->current_mode() != state.mirror_mode) 903 all_succeeded = false; 904 } 905 } 906 907 if (all_succeeded) { 908 display_state_ = display_state; 909 power_state_ = power_state; 910 framebuffer_size_ = size; 911 } 912 return all_succeeded; 913 } 914 915 MultipleDisplayState DisplayConfigurator::ChooseDisplayState( 916 chromeos::DisplayPowerState power_state) const { 917 int num_on_displays = GetDisplayPower(cached_displays_, power_state, NULL); 918 switch (cached_displays_.size()) { 919 case 0: 920 return MULTIPLE_DISPLAY_STATE_HEADLESS; 921 case 1: 922 return MULTIPLE_DISPLAY_STATE_SINGLE; 923 case 2: { 924 if (num_on_displays == 1) { 925 // If only one display is currently turned on, return the "single" 926 // state so that its native mode will be used. 927 return MULTIPLE_DISPLAY_STATE_SINGLE; 928 } else { 929 if (!state_controller_) 930 return MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED; 931 // With either both displays on or both displays off, use one of the 932 // dual modes. 933 std::vector<int64_t> display_ids; 934 for (size_t i = 0; i < cached_displays_.size(); ++i) { 935 // If display id isn't available, switch to extended mode. 936 if (!cached_displays_[i].display->has_proper_display_id()) 937 return MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED; 938 display_ids.push_back(cached_displays_[i].display->display_id()); 939 } 940 return state_controller_->GetStateForDisplayIds(display_ids); 941 } 942 } 943 default: 944 NOTREACHED(); 945 } 946 return MULTIPLE_DISPLAY_STATE_INVALID; 947 } 948 949 float DisplayConfigurator::GetMirroredDisplayAreaRatio( 950 const DisplayState& display_state) { 951 float area_ratio = 1.0f; 952 const DisplayMode* native_mode_info = display_state.display->native_mode(); 953 const DisplayMode* mirror_mode_info = display_state.mirror_mode; 954 955 if (!native_mode_info || !mirror_mode_info || 956 native_mode_info->size().height() == 0 || 957 mirror_mode_info->size().height() == 0 || 958 native_mode_info->size().width() == 0 || 959 mirror_mode_info->size().width() == 0) 960 return area_ratio; 961 962 float width_ratio = static_cast<float>(mirror_mode_info->size().width()) / 963 static_cast<float>(native_mode_info->size().width()); 964 float height_ratio = static_cast<float>(mirror_mode_info->size().height()) / 965 static_cast<float>(native_mode_info->size().height()); 966 967 area_ratio = width_ratio * height_ratio; 968 return area_ratio; 969 } 970 971 } // namespace ui 972
