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