ash/display/display_controller.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ash/display/display_controller.h"
   6
   7 #include <algorithm>
   8 #include <cmath>
   9 #include <map>
  10
  11 #include "ash/ash_switches.h"
  12 #include "ash/display/display_layout_store.h"
  13 #include "ash/display/display_manager.h"
  14 #include "ash/display/mirror_window_controller.h"
  15 #include "ash/display/root_window_transformers.h"
  16 #include "ash/display/virtual_keyboard_window_controller.h"
  17 #include "ash/host/root_window_host_factory.h"
  18 #include "ash/root_window_controller.h"
  19 #include "ash/root_window_settings.h"
  20 #include "ash/screen_ash.h"
  21 #include "ash/shell.h"
  22 #include "ash/wm/coordinate_conversion.h"
  23 #include "base/command_line.h"
  24 #include "base/strings/stringprintf.h"
  25 #include "third_party/skia/include/utils/SkMatrix44.h"
  26 #include "ui/aura/client/activation_client.h"
  27 #include "ui/aura/client/capture_client.h"
  28 #include "ui/aura/client/cursor_client.h"
  29 #include "ui/aura/client/focus_client.h"
  30 #include "ui/aura/client/screen_position_client.h"
  31 #include "ui/aura/root_window.h"
  32 #include "ui/aura/root_window_transformer.h"
  33 #include "ui/aura/window.h"
  34 #include "ui/aura/window_property.h"
  35 #include "ui/aura/window_tracker.h"
  36 #include "ui/compositor/compositor.h"
  37 #include "ui/compositor/dip_util.h"
  38 #include "ui/gfx/display.h"
  39 #include "ui/gfx/screen.h"
  40
  41 #if defined(OS_CHROMEOS)
  42 #include "base/sys_info.h"
  43 #include "base/time/time.h"
  44 #if defined(USE_X11)
  45 #include "ash/display/output_configurator_animation.h"
  46 #include "chromeos/display/output_configurator.h"
  47 #include "ui/base/x/x11_util.h"
  48 #include "ui/gfx/x/x11_types.h"
  49
  50 // Including this at the bottom to avoid other
  51 // potential conflict with chrome headers.
  52 #include <X11/extensions/Xrandr.h>
  53 #undef RootWindow
  54 #endif  // defined(USE_X11)
  55 #endif  // defined(OS_CHROMEOS)
  56
  57 namespace ash {
  58 namespace {
  59
  60 // Primary display stored in global object as it can be
  61 // accessed after Shell is deleted. A separate display instance is created
  62 // during the shutdown instead of always keeping two display instances
  63 // (one here and another one in display_manager) in sync, which is error prone.
  64 int64 primary_display_id = gfx::Display::kInvalidDisplayID;
  65 gfx::Display* primary_display_for_shutdown = NULL;
  66 // Keeps the number of displays during the shutdown after
  67 // ash::Shell:: is deleted.
  68 int num_displays_for_shutdown = -1;
  69
  70 // Specifies how long the display change should have been disabled
  71 // after each display change operations.
  72 // |kCycleDisplayThrottleTimeoutMs| is set to be longer to avoid
  73 // changing the settings while the system is still configurating
  74 // displays. It will be overriden by |kAfterDisplayChangeThrottleTimeoutMs|
  75 // when the display change happens, so the actual timeout is much shorter.
  76 const int64 kAfterDisplayChangeThrottleTimeoutMs = 500;
  77 const int64 kCycleDisplayThrottleTimeoutMs = 4000;
  78 const int64 kSwapDisplayThrottleTimeoutMs = 500;
  79
  80 internal::DisplayManager* GetDisplayManager() {
  81   return Shell::GetInstance()->display_manager();
  82 }
  83
  84 void SetDisplayPropertiesOnHostWindow(aura::RootWindow* root,
  85                                       const gfx::Display& display) {
  86   internal::DisplayInfo info =
  87       GetDisplayManager()->GetDisplayInfo(display.id());
  88 #if defined(OS_CHROMEOS) && defined(USE_X11)
  89   // Native window property (Atom in X11) that specifies the display's
  90   // rotation, scale factor and if it's internal display.  They are
  91   // read and used by touchpad/mouse driver directly on X (contact
  92   // adlr@ for more details on touchpad/mouse driver side). The value
  93   // of the rotation is one of 0 (normal), 1 (90 degrees clockwise), 2
  94   // (180 degree) or 3 (270 degrees clockwise).  The value of the
  95   // scale factor is in percent (100, 140, 200 etc).
  96   const char kRotationProp[] = "_CHROME_DISPLAY_ROTATION";
  97   const char kScaleFactorProp[] = "_CHROME_DISPLAY_SCALE_FACTOR";
  98   const char kInternalProp[] = "_CHROME_DISPLAY_INTERNAL";
  99   const char kCARDINAL[] = "CARDINAL";
 100   int xrandr_rotation = RR_Rotate_0;
 101   switch (info.rotation()) {
 102     case gfx::Display::ROTATE_0:
 103       xrandr_rotation = RR_Rotate_0;
 104       break;
 105     case gfx::Display::ROTATE_90:
 106       xrandr_rotation = RR_Rotate_90;
 107       break;
 108     case gfx::Display::ROTATE_180:
 109       xrandr_rotation = RR_Rotate_180;
 110       break;
 111     case gfx::Display::ROTATE_270:
 112       xrandr_rotation = RR_Rotate_270;
 113       break;
 114   }
 115
 116   int internal = display.IsInternal() ? 1 : 0;
 117   gfx::AcceleratedWidget xwindow = root->host()->GetAcceleratedWidget();
 118   ui::SetIntProperty(xwindow, kInternalProp, kCARDINAL, internal);
 119   ui::SetIntProperty(xwindow, kRotationProp, kCARDINAL, xrandr_rotation);
 120   ui::SetIntProperty(xwindow,
 121                      kScaleFactorProp,
 122                      kCARDINAL,
 123                      100 * display.device_scale_factor());
 124 #endif
 125   scoped_ptr<aura::RootWindowTransformer> transformer(
 126       internal::CreateRootWindowTransformerForDisplay(root->window(), display));
 127   root->SetRootWindowTransformer(transformer.Pass());
 128 }
 129
 130 }  // namespace
 131
 132 namespace internal {
 133
 134 // A utility class to store/restore focused/active window
 135 // when the display configuration has changed.
 136 class FocusActivationStore {
 137  public:
 138   FocusActivationStore()
 139       : activation_client_(NULL),
 140         capture_client_(NULL),
 141         focus_client_(NULL),
 142         focused_(NULL),
 143         active_(NULL) {
 144   }
 145
 146   void Store(bool clear_focus) {
 147     if (!activation_client_) {
 148       aura::Window* root = Shell::GetPrimaryRootWindow();
 149       activation_client_ = aura::client::GetActivationClient(root);
 150       capture_client_ = aura::client::GetCaptureClient(root);
 151       focus_client_ = aura::client::GetFocusClient(root);
 152     }
 153     focused_ = focus_client_->GetFocusedWindow();
 154     if (focused_)
 155       tracker_.Add(focused_);
 156     active_ = activation_client_->GetActiveWindow();
 157     if (active_ && focused_ != active_)
 158       tracker_.Add(active_);
 159
 160     // Deactivate the window to close menu / bubble windows.
 161     if (clear_focus)
 162       activation_client_->DeactivateWindow(active_);
 163
 164     // Release capture if any.
 165     capture_client_->SetCapture(NULL);
 166     // Clear the focused window if any. This is necessary because a
 167     // window may be deleted when losing focus (fullscreen flash for
 168     // example).  If the focused window is still alive after move, it'll
 169     // be re-focused below.
 170     if (clear_focus)
 171       focus_client_->FocusWindow(NULL);
 172   }
 173
 174   void Restore() {
 175     // Restore focused or active window if it's still alive.
 176     if (focused_ && tracker_.Contains(focused_)) {
 177       focus_client_->FocusWindow(focused_);
 178     } else if (active_ && tracker_.Contains(active_)) {
 179       activation_client_->ActivateWindow(active_);
 180     }
 181     if (focused_)
 182       tracker_.Remove(focused_);
 183     if (active_)
 184       tracker_.Remove(active_);
 185     focused_ = NULL;
 186     active_ = NULL;
 187   }
 188
 189  private:
 190   aura::client::ActivationClient* activation_client_;
 191   aura::client::CaptureClient* capture_client_;
 192   aura::client::FocusClient* focus_client_;
 193   aura::WindowTracker tracker_;
 194   aura::Window* focused_;
 195   aura::Window* active_;
 196
 197   DISALLOW_COPY_AND_ASSIGN(FocusActivationStore);
 198 };
 199
 200 }  // namespace internal
 201
 202 ////////////////////////////////////////////////////////////////////////////////
 203 // DisplayChangeLimiter
 204
 205 DisplayController::DisplayChangeLimiter::DisplayChangeLimiter()
 206     : throttle_timeout_(base::Time::Now()) {
 207 }
 208
 209 void DisplayController::DisplayChangeLimiter::SetThrottleTimeout(
 210     int64 throttle_ms) {
 211   throttle_timeout_ =
 212       base::Time::Now() + base::TimeDelta::FromMilliseconds(throttle_ms);
 213 }
 214
 215 bool DisplayController::DisplayChangeLimiter::IsThrottled() const {
 216   return base::Time::Now() < throttle_timeout_;
 217 }
 218
 219 ////////////////////////////////////////////////////////////////////////////////
 220 // DisplayController
 221
 222 DisplayController::DisplayController()
 223     : primary_root_window_for_replace_(NULL),
 224       focus_activation_store_(new internal::FocusActivationStore()),
 225       mirror_window_controller_(new internal::MirrorWindowController),
 226       virtual_keyboard_window_controller_(
 227           new internal::VirtualKeyboardWindowController) {
 228 #if defined(OS_CHROMEOS)
 229   CommandLine* command_line = CommandLine::ForCurrentProcess();
 230   if (!command_line->HasSwitch(switches::kAshDisableDisplayChangeLimiter) &&
 231       base::SysInfo::IsRunningOnChromeOS())
 232     limiter_.reset(new DisplayChangeLimiter);
 233 #endif
 234   // Reset primary display to make sure that tests don't use
 235   // stale display info from previous tests.
 236   primary_display_id = gfx::Display::kInvalidDisplayID;
 237   delete primary_display_for_shutdown;
 238   primary_display_for_shutdown = NULL;
 239   num_displays_for_shutdown = -1;
 240 }
 241
 242 DisplayController::~DisplayController() {
 243   DCHECK(primary_display_for_shutdown);
 244 }
 245
 246 void DisplayController::Start() {
 247   Shell::GetScreen()->AddObserver(this);
 248   Shell::GetInstance()->display_manager()->set_delegate(this);
 249 }
 250
 251 void DisplayController::Shutdown() {
 252   // Unset the display manager's delegate here because
 253   // DisplayManager outlives DisplayController.
 254   Shell::GetInstance()->display_manager()->set_delegate(NULL);
 255
 256   mirror_window_controller_.reset();
 257   virtual_keyboard_window_controller_.reset();
 258
 259   DCHECK(!primary_display_for_shutdown);
 260   primary_display_for_shutdown = new gfx::Display(
 261       GetDisplayManager()->GetDisplayForId(primary_display_id));
 262   num_displays_for_shutdown = GetDisplayManager()->GetNumDisplays();
 263
 264   Shell::GetScreen()->RemoveObserver(this);
 265   // Delete all root window controllers, which deletes root window
 266   // from the last so that the primary root window gets deleted last.
 267   for (std::map<int64, aura::Window*>::const_reverse_iterator it =
 268            root_windows_.rbegin(); it != root_windows_.rend(); ++it) {
 269     internal::RootWindowController* controller =
 270         internal::GetRootWindowController(it->second);
 271     DCHECK(controller);
 272     delete controller;
 273   }
 274 }
 275
 276 // static
 277 const gfx::Display& DisplayController::GetPrimaryDisplay() {
 278   DCHECK_NE(primary_display_id, gfx::Display::kInvalidDisplayID);
 279   if (primary_display_for_shutdown)
 280     return *primary_display_for_shutdown;
 281   return GetDisplayManager()->GetDisplayForId(primary_display_id);
 282 }
 283
 284 // static
 285 int DisplayController::GetNumDisplays() {
 286   if (num_displays_for_shutdown >= 0)
 287     return num_displays_for_shutdown;
 288   return GetDisplayManager()->GetNumDisplays();
 289 }
 290
 291 void DisplayController::InitPrimaryDisplay() {
 292   const gfx::Display& primary_candidate =
 293       GetDisplayManager()->GetPrimaryDisplayCandidate();
 294   primary_display_id = primary_candidate.id();
 295   AddRootWindowForDisplay(primary_candidate);
 296 }
 297
 298 void DisplayController::InitSecondaryDisplays() {
 299   internal::DisplayManager* display_manager = GetDisplayManager();
 300   for (size_t i = 0; i < display_manager->GetNumDisplays(); ++i) {
 301     const gfx::Display& display = display_manager->GetDisplayAt(i);
 302     if (primary_display_id != display.id()) {
 303       aura::RootWindow* root = AddRootWindowForDisplay(display);
 304       internal::RootWindowController::CreateForSecondaryDisplay(root);
 305     }
 306   }
 307   UpdateHostWindowNames();
 308 }
 309
 310 void DisplayController::AddObserver(Observer* observer) {
 311   observers_.AddObserver(observer);
 312 }
 313
 314 void DisplayController::RemoveObserver(Observer* observer) {
 315   observers_.RemoveObserver(observer);
 316 }
 317
 318 aura::Window* DisplayController::GetPrimaryRootWindow() {
 319   DCHECK(!root_windows_.empty());
 320   return root_windows_[primary_display_id];
 321 }
 322
 323 aura::Window* DisplayController::GetRootWindowForDisplayId(int64 id) {
 324   return root_windows_[id];
 325 }
 326
 327 void DisplayController::CloseChildWindows() {
 328   for (std::map<int64, aura::Window*>::const_iterator it =
 329            root_windows_.begin(); it != root_windows_.end(); ++it) {
 330     aura::Window* root_window = it->second;
 331     internal::RootWindowController* controller =
 332         internal::GetRootWindowController(root_window);
 333     if (controller) {
 334       controller->CloseChildWindows();
 335     } else {
 336       while (!root_window->children().empty()) {
 337         aura::Window* child = root_window->children()[0];
 338         delete child;
 339       }
 340     }
 341   }
 342 }
 343
 344 aura::Window::Windows DisplayController::GetAllRootWindows() {
 345   aura::Window::Windows windows;
 346   for (std::map<int64, aura::Window*>::const_iterator it =
 347            root_windows_.begin(); it != root_windows_.end(); ++it) {
 348     DCHECK(it->second);
 349     if (internal::GetRootWindowController(it->second))
 350       windows.push_back(it->second);
 351   }
 352   return windows;
 353 }
 354
 355 gfx::Insets DisplayController::GetOverscanInsets(int64 display_id) const {
 356   return GetDisplayManager()->GetOverscanInsets(display_id);
 357 }
 358
 359 void DisplayController::SetOverscanInsets(int64 display_id,
 360                                           const gfx::Insets& insets_in_dip) {
 361   GetDisplayManager()->SetOverscanInsets(display_id, insets_in_dip);
 362 }
 363
 364 std::vector<internal::RootWindowController*>
 365 DisplayController::GetAllRootWindowControllers() {
 366   std::vector<internal::RootWindowController*> controllers;
 367   for (std::map<int64, aura::Window*>::const_iterator it =
 368            root_windows_.begin(); it != root_windows_.end(); ++it) {
 369     internal::RootWindowController* controller =
 370         internal::GetRootWindowController(it->second);
 371     if (controller)
 372       controllers.push_back(controller);
 373   }
 374   return controllers;
 375 }
 376
 377 void DisplayController::ToggleMirrorMode() {
 378   internal::DisplayManager* display_manager = GetDisplayManager();
 379   if (display_manager->num_connected_displays() <= 1)
 380     return;
 381
 382   if (limiter_) {
 383     if  (limiter_->IsThrottled())
 384       return;
 385     limiter_->SetThrottleTimeout(kCycleDisplayThrottleTimeoutMs);
 386   }
 387 #if defined(OS_CHROMEOS) && defined(USE_X11)
 388   Shell* shell = Shell::GetInstance();
 389   internal::OutputConfiguratorAnimation* animation =
 390       shell->output_configurator_animation();
 391   animation->StartFadeOutAnimation(base::Bind(
 392       base::IgnoreResult(&internal::DisplayManager::SetMirrorMode),
 393       base::Unretained(display_manager),
 394       !display_manager->IsMirrored()));
 395 #endif
 396 }
 397
 398 void DisplayController::SwapPrimaryDisplay() {
 399   if (limiter_) {
 400     if  (limiter_->IsThrottled())
 401       return;
 402     limiter_->SetThrottleTimeout(kSwapDisplayThrottleTimeoutMs);
 403   }
 404
 405   if (Shell::GetScreen()->GetNumDisplays() > 1) {
 406 #if defined(OS_CHROMEOS) && defined(USE_X11)
 407     internal::OutputConfiguratorAnimation* animation =
 408         Shell::GetInstance()->output_configurator_animation();
 409     if (animation) {
 410       animation->StartFadeOutAnimation(base::Bind(
 411           &DisplayController::OnFadeOutForSwapDisplayFinished,
 412           base::Unretained(this)));
 413     } else {
 414       SetPrimaryDisplay(ScreenAsh::GetSecondaryDisplay());
 415     }
 416 #else
 417     SetPrimaryDisplay(ScreenAsh::GetSecondaryDisplay());
 418 #endif
 419   }
 420 }
 421
 422 void DisplayController::SetPrimaryDisplayId(int64 id) {
 423   DCHECK_NE(gfx::Display::kInvalidDisplayID, id);
 424   if (id == gfx::Display::kInvalidDisplayID || primary_display_id == id)
 425     return;
 426
 427   const gfx::Display& display = GetDisplayManager()->GetDisplayForId(id);
 428   if (display.is_valid())
 429     SetPrimaryDisplay(display);
 430 }
 431
 432 void DisplayController::SetPrimaryDisplay(
 433     const gfx::Display& new_primary_display) {
 434   internal::DisplayManager* display_manager = GetDisplayManager();
 435   DCHECK(new_primary_display.is_valid());
 436   DCHECK(display_manager->IsActiveDisplay(new_primary_display));
 437
 438   if (!new_primary_display.is_valid() ||
 439       !display_manager->IsActiveDisplay(new_primary_display)) {
 440     LOG(ERROR) << "Invalid or non-existent display is requested:"
 441                << new_primary_display.ToString();
 442     return;
 443   }
 444
 445   if (primary_display_id == new_primary_display.id() ||
 446       root_windows_.size() < 2) {
 447     return;
 448   }
 449
 450   aura::Window* non_primary_root = root_windows_[new_primary_display.id()];
 451   LOG_IF(ERROR, !non_primary_root)
 452       << "Unknown display is requested in SetPrimaryDisplay: id="
 453       << new_primary_display.id();
 454   if (!non_primary_root)
 455     return;
 456
 457   gfx::Display old_primary_display = GetPrimaryDisplay();
 458
 459   // Swap root windows between current and new primary display.
 460   aura::Window* primary_root = root_windows_[primary_display_id];
 461   DCHECK(primary_root);
 462   DCHECK_NE(primary_root, non_primary_root);
 463
 464   root_windows_[new_primary_display.id()] = primary_root;
 465   internal::GetRootWindowSettings(primary_root)->display_id =
 466       new_primary_display.id();
 467
 468   root_windows_[old_primary_display.id()] = non_primary_root;
 469   internal::GetRootWindowSettings(non_primary_root)->display_id =
 470       old_primary_display.id();
 471
 472   primary_display_id = new_primary_display.id();
 473   GetDisplayManager()->layout_store()->UpdatePrimaryDisplayId(
 474       display_manager->GetCurrentDisplayIdPair(), primary_display_id);
 475
 476   UpdateWorkAreaOfDisplayNearestWindow(
 477       primary_root, old_primary_display.GetWorkAreaInsets());
 478   UpdateWorkAreaOfDisplayNearestWindow(
 479       non_primary_root, new_primary_display.GetWorkAreaInsets());
 480
 481   // Update the dispay manager with new display info.
 482   std::vector<internal::DisplayInfo> display_info_list;
 483   display_info_list.push_back(display_manager->GetDisplayInfo(
 484       primary_display_id));
 485   display_info_list.push_back(display_manager->GetDisplayInfo(
 486       ScreenAsh::GetSecondaryDisplay().id()));
 487   GetDisplayManager()->set_force_bounds_changed(true);
 488   GetDisplayManager()->UpdateDisplays(display_info_list);
 489   GetDisplayManager()->set_force_bounds_changed(false);
 490 }
 491
 492 void DisplayController::EnsurePointerInDisplays() {
 493   // If the mouse is currently on a display in native location,
 494   // use the same native location. Otherwise find the display closest
 495   // to the current cursor location in screen coordinates.
 496
 497   gfx::Point point_in_screen = Shell::GetScreen()->GetCursorScreenPoint();
 498   gfx::Point target_location_in_native;
 499   int64 closest_distance_squared = -1;
 500   internal::DisplayManager* display_manager = GetDisplayManager();
 501
 502   aura::Window* dst_root_window = NULL;
 503   for (size_t i = 0; i < display_manager->GetNumDisplays(); ++i) {
 504     const gfx::Display& display = display_manager->GetDisplayAt(i);
 505     const internal::DisplayInfo display_info =
 506         display_manager->GetDisplayInfo(display.id());
 507     aura::Window* root_window = GetRootWindowForDisplayId(display.id());
 508     if (display_info.bounds_in_native().Contains(
 509             cursor_location_in_native_coords_for_restore_)) {
 510       dst_root_window = root_window;
 511       target_location_in_native = cursor_location_in_native_coords_for_restore_;
 512       break;
 513     }
 514     gfx::Point center = display.bounds().CenterPoint();
 515     // Use the distance squared from the center of the dislay. This is not
 516     // exactly "closest" display, but good enough to pick one
 517     // appropriate (and there are at most two displays).
 518     // We don't care about actual distance, only relative to other displays, so
 519     // using the LengthSquared() is cheaper than Length().
 520
 521     int64 distance_squared = (center - point_in_screen).LengthSquared();
 522     if (closest_distance_squared < 0 ||
 523         closest_distance_squared > distance_squared) {
 524       aura::Window* root_window = GetRootWindowForDisplayId(display.id());
 525       aura::client::ScreenPositionClient* client =
 526           aura::client::GetScreenPositionClient(root_window);
 527       client->ConvertPointFromScreen(root_window, &center);
 528       root_window->GetDispatcher()->host()->ConvertPointToNativeScreen(&center);
 529       dst_root_window = root_window;
 530       target_location_in_native = center;
 531       closest_distance_squared = distance_squared;
 532     }
 533   }
 534   dst_root_window->GetDispatcher()->host()->ConvertPointFromNativeScreen(
 535       &target_location_in_native);
 536   dst_root_window->MoveCursorTo(target_location_in_native);
 537 }
 538
 539 bool DisplayController::UpdateWorkAreaOfDisplayNearestWindow(
 540     const aura::Window* window,
 541     const gfx::Insets& insets) {
 542   const aura::Window* root_window = window->GetRootWindow();
 543   int64 id = internal::GetRootWindowSettings(root_window)->display_id;
 544   // if id is |kInvaildDisplayID|, it's being deleted.
 545   DCHECK(id != gfx::Display::kInvalidDisplayID);
 546   return GetDisplayManager()->UpdateWorkAreaOfDisplay(id, insets);
 547 }
 548
 549 const gfx::Display& DisplayController::GetDisplayNearestWindow(
 550     const aura::Window* window) const {
 551   if (!window)
 552     return GetPrimaryDisplay();
 553   const aura::Window* root_window = window->GetRootWindow();
 554   if (!root_window)
 555     return GetPrimaryDisplay();
 556   int64 id = internal::GetRootWindowSettings(root_window)->display_id;
 557   // if id is |kInvaildDisplayID|, it's being deleted.
 558   DCHECK(id != gfx::Display::kInvalidDisplayID);
 559
 560   internal::DisplayManager* display_manager = GetDisplayManager();
 561   // RootWindow needs Display to determine its device scale factor
 562   // for non desktop display.
 563   if (display_manager->non_desktop_display().id() == id)
 564     return display_manager->non_desktop_display();
 565   return display_manager->GetDisplayForId(id);
 566 }
 567
 568 const gfx::Display& DisplayController::GetDisplayNearestPoint(
 569     const gfx::Point& point) const {
 570   // Fallback to the primary display if there is no root display containing
 571   // the |point|.
 572   const gfx::Display& display =
 573       GetDisplayManager()->FindDisplayContainingPoint(point);
 574   return display.is_valid() ? display : GetPrimaryDisplay();
 575 }
 576
 577 const gfx::Display& DisplayController::GetDisplayMatching(
 578     const gfx::Rect& rect) const {
 579   if (rect.IsEmpty())
 580     return GetDisplayNearestPoint(rect.origin());
 581
 582   int max_area = 0;
 583   const gfx::Display* matching = NULL;
 584   for (size_t i = 0; i < GetDisplayManager()->GetNumDisplays(); ++i) {
 585     const gfx::Display& display = GetDisplayManager()->GetDisplayAt(i);
 586     gfx::Rect intersect = gfx::IntersectRects(display.bounds(), rect);
 587     int area = intersect.width() * intersect.height();
 588     if (area > max_area) {
 589       max_area = area;
 590       matching = &display;
 591     }
 592   }
 593   // Fallback to the primary display if there is no matching display.
 594   return matching ? *matching : GetPrimaryDisplay();
 595 }
 596
 597 void DisplayController::OnDisplayBoundsChanged(const gfx::Display& display) {
 598   const internal::DisplayInfo& display_info =
 599       GetDisplayManager()->GetDisplayInfo(display.id());
 600   DCHECK(!display_info.bounds_in_native().IsEmpty());
 601   aura::WindowEventDispatcher* dispatcher =
 602       root_windows_[display.id()]->GetDispatcher();
 603   dispatcher->SetHostBounds(display_info.bounds_in_native());
 604   SetDisplayPropertiesOnHostWindow(dispatcher, display);
 605 }
 606
 607 void DisplayController::OnDisplayAdded(const gfx::Display& display) {
 608   if (primary_root_window_for_replace_) {
 609     DCHECK(root_windows_.empty());
 610     primary_display_id = display.id();
 611     root_windows_[display.id()] = primary_root_window_for_replace_;
 612     internal::GetRootWindowSettings(primary_root_window_for_replace_)->
 613         display_id = display.id();
 614     primary_root_window_for_replace_ = NULL;
 615     const internal::DisplayInfo& display_info =
 616         GetDisplayManager()->GetDisplayInfo(display.id());
 617     aura::WindowEventDispatcher* dispatcher =
 618         root_windows_[display.id()]->GetDispatcher();
 619     dispatcher->SetHostBounds(display_info.bounds_in_native());
 620     SetDisplayPropertiesOnHostWindow(dispatcher, display);
 621   } else {
 622     if (primary_display_id == gfx::Display::kInvalidDisplayID)
 623       primary_display_id = display.id();
 624     DCHECK(!root_windows_.empty());
 625     aura::RootWindow* root = AddRootWindowForDisplay(display);
 626     internal::RootWindowController::CreateForSecondaryDisplay(root);
 627   }
 628 }
 629
 630 void DisplayController::OnDisplayRemoved(const gfx::Display& display) {
 631   aura::Window* root_to_delete = root_windows_[display.id()];
 632   DCHECK(root_to_delete) << display.ToString();
 633
 634   // Display for root window will be deleted when the Primary RootWindow
 635   // is deleted by the Shell.
 636   root_windows_.erase(display.id());
 637
 638   // When the primary root window's display is removed, move the primary
 639   // root to the other display.
 640   if (primary_display_id == display.id()) {
 641     // Temporarily store the primary root window in
 642     // |primary_root_window_for_replace_| when replacing the display.
 643     if (root_windows_.size() == 0) {
 644       primary_display_id = gfx::Display::kInvalidDisplayID;
 645       primary_root_window_for_replace_ = root_to_delete;
 646       return;
 647     }
 648     DCHECK_EQ(1U, root_windows_.size());
 649     primary_display_id = ScreenAsh::GetSecondaryDisplay().id();
 650     aura::Window* primary_root = root_to_delete;
 651
 652     // Delete the other root instead.
 653     root_to_delete = root_windows_[primary_display_id];
 654     internal::GetRootWindowSettings(root_to_delete)->display_id = display.id();
 655
 656     // Setup primary root.
 657     root_windows_[primary_display_id] = primary_root;
 658     internal::GetRootWindowSettings(primary_root)->display_id =
 659         primary_display_id;
 660
 661     OnDisplayBoundsChanged(
 662         GetDisplayManager()->GetDisplayForId(primary_display_id));
 663   }
 664   internal::RootWindowController* controller =
 665       internal::GetRootWindowController(root_to_delete);
 666   DCHECK(controller);
 667   controller->MoveWindowsTo(GetPrimaryRootWindow());
 668   // Delete most of root window related objects, but don't delete
 669   // root window itself yet because the stack may be using it.
 670   controller->Shutdown();
 671   base::MessageLoop::current()->DeleteSoon(FROM_HERE, controller);
 672 }
 673
 674 void DisplayController::OnRootWindowHostResized(const aura::RootWindow* root) {
 675   internal::DisplayManager* display_manager = GetDisplayManager();
 676   gfx::Display display = GetDisplayNearestWindow(root->window());
 677   if (display_manager->UpdateDisplayBounds(
 678           display.id(),
 679           root->host()->GetBounds())) {
 680     mirror_window_controller_->UpdateWindow();
 681   }
 682 }
 683
 684 void DisplayController::CreateOrUpdateNonDesktopDisplay(
 685     const internal::DisplayInfo& info) {
 686   switch (GetDisplayManager()->second_display_mode()) {
 687     case internal::DisplayManager::MIRRORING:
 688       mirror_window_controller_->UpdateWindow(info);
 689       virtual_keyboard_window_controller_->Close();
 690       break;
 691     case internal::DisplayManager::VIRTUAL_KEYBOARD:
 692       mirror_window_controller_->Close();
 693       virtual_keyboard_window_controller_->UpdateWindow(info);
 694       break;
 695     case internal::DisplayManager::EXTENDED:
 696       NOTREACHED();
 697   }
 698 }
 699
 700 void DisplayController::CloseNonDesktopDisplay() {
 701   mirror_window_controller_->Close();
 702   virtual_keyboard_window_controller_->Close();
 703 }
 704
 705 void DisplayController::PreDisplayConfigurationChange(bool clear_focus) {
 706   FOR_EACH_OBSERVER(Observer, observers_, OnDisplayConfigurationChanging());
 707   focus_activation_store_->Store(clear_focus);
 708
 709   gfx::Point point_in_screen = Shell::GetScreen()->GetCursorScreenPoint();
 710   gfx::Display display =
 711       Shell::GetScreen()->GetDisplayNearestPoint(point_in_screen);
 712   aura::Window* root_window = GetRootWindowForDisplayId(display.id());
 713
 714   aura::client::ScreenPositionClient* client =
 715       aura::client::GetScreenPositionClient(root_window);
 716   client->ConvertPointFromScreen(root_window, &point_in_screen);
 717   root_window->GetDispatcher()->host()->ConvertPointToNativeScreen(
 718       &point_in_screen);
 719   cursor_location_in_native_coords_for_restore_ = point_in_screen;
 720 }
 721
 722 void DisplayController::PostDisplayConfigurationChange() {
 723   if (limiter_)
 724     limiter_->SetThrottleTimeout(kAfterDisplayChangeThrottleTimeoutMs);
 725
 726   focus_activation_store_->Restore();
 727
 728   internal::DisplayManager* display_manager = GetDisplayManager();
 729   internal::DisplayLayoutStore* layout_store = display_manager->layout_store();
 730   if (display_manager->num_connected_displays() > 1) {
 731     DisplayIdPair pair = display_manager->GetCurrentDisplayIdPair();
 732     layout_store->UpdateMirrorStatus(pair, display_manager->IsMirrored());
 733     DisplayLayout layout = layout_store->GetRegisteredDisplayLayout(pair);
 734
 735     if (Shell::GetScreen()->GetNumDisplays() > 1 ) {
 736       int64 primary_id = layout.primary_id;
 737       SetPrimaryDisplayId(
 738           primary_id == gfx::Display::kInvalidDisplayID ?
 739           pair.first : primary_id);
 740       // Update the primary_id in case the above call is
 741       // ignored. Happens when a) default layout's primary id
 742       // doesn't exist, or b) the primary_id has already been
 743       // set to the same and didn't update it.
 744       layout_store->UpdatePrimaryDisplayId(pair, GetPrimaryDisplay().id());
 745     }
 746   }
 747   FOR_EACH_OBSERVER(Observer, observers_, OnDisplayConfigurationChanged());
 748   UpdateHostWindowNames();
 749   EnsurePointerInDisplays();
 750 }
 751
 752 aura::RootWindow* DisplayController::AddRootWindowForDisplay(
 753     const gfx::Display& display) {
 754   static int root_window_count = 0;
 755   const internal::DisplayInfo& display_info =
 756       GetDisplayManager()->GetDisplayInfo(display.id());
 757   const gfx::Rect& bounds_in_native = display_info.bounds_in_native();
 758   aura::RootWindow::CreateParams params(bounds_in_native);
 759   params.host = Shell::GetInstance()->root_window_host_factory()->
 760       CreateRootWindowHost(bounds_in_native);
 761   aura::RootWindow* root_window = new aura::RootWindow(params);
 762   root_window->window()->SetName(
 763       base::StringPrintf("RootWindow-%d", root_window_count++));
 764   root_window->compositor()->SetBackgroundColor(SK_ColorBLACK);
 765   // No need to remove RootWindowObserver because
 766   // the DisplayController object outlives RootWindow objects.
 767   root_window->AddRootWindowObserver(this);
 768   internal::InitRootWindowSettings(root_window->window())->display_id =
 769       display.id();
 770   root_window->Init();
 771
 772   root_windows_[display.id()] = root_window->window();
 773   SetDisplayPropertiesOnHostWindow(root_window, display);
 774
 775 #if defined(OS_CHROMEOS)
 776   static bool force_constrain_pointer_to_root =
 777       CommandLine::ForCurrentProcess()->HasSwitch(
 778           switches::kAshConstrainPointerToRoot);
 779   if (base::SysInfo::IsRunningOnChromeOS() || force_constrain_pointer_to_root)
 780     root_window->host()->ConfineCursorToRootWindow();
 781 #endif
 782   return root_window;
 783 }
 784
 785 void DisplayController::OnFadeOutForSwapDisplayFinished() {
 786 #if defined(OS_CHROMEOS) && defined(USE_X11)
 787   SetPrimaryDisplay(ScreenAsh::GetSecondaryDisplay());
 788   Shell::GetInstance()->output_configurator_animation()->StartFadeInAnimation();
 789 #endif
 790 }
 791
 792 void DisplayController::UpdateHostWindowNames() {
 793 #if defined(USE_X11)
 794   // crbug.com/120229 - set the window title for the primary dislpay
 795   // to "aura_root_0" so gtalk can find the primary root window to broadcast.
 796   // TODO(jhorwich) Remove this once Chrome supports window-based broadcasting.
 797   aura::Window* primary = Shell::GetPrimaryRootWindow();
 798   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 799   for (size_t i = 0; i < root_windows.size(); ++i) {
 800     std::string name =
 801         root_windows[i] == primary ? "aura_root_0" : "aura_root_x";
 802     gfx::AcceleratedWidget xwindow =
 803         root_windows[i]->GetDispatcher()->host()->GetAcceleratedWidget();
 804     XStoreName(gfx::GetXDisplay(), xwindow, name.c_str());
 805   }
 806 #endif
 807 }
 808
 809 }  // namespace ash