Unified Desktop: hook up ash to allow unified desktop mode

ash/display/display_controller.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ash/display/display_controller.h"
 
 #include <algorithm>
 #include <cmath>
 #include <map>
 
@@ skipping 142 matching lines @@
     host->compositor()->vsync_manager()->SetAuthoritativeVSyncInterval(
         base::TimeDelta::FromMicroseconds(
             base::Time::kMicrosecondsPerSecond / mode.refresh_rate));
   }
 
   // Just movnig the display requires the full redraw.
   // chrome-os-partner:33558.
   host->compositor()->ScheduleFullRedraw();
 }
 
-void ClearDisplayPropertiesOnHost(AshWindowTreeHost* ash_host,
-                                  const gfx::Display& display) {
+void ClearDisplayPropertiesOnHost(AshWindowTreeHost* ash_host) {
 #if defined(OS_CHROMEOS) && defined(USE_OZONE)
   aura::WindowTreeHost* host = ash_host->AsWindowTreeHost();
   ui::CursorController::GetInstance()->ClearCursorConfigForWindow(
       host->GetAcceleratedWidget());
 #endif
 }
 
 aura::Window* GetWindow(AshWindowTreeHost* ash_host) {
   CHECK(ash_host->AsWindowTreeHost());
   return ash_host->AsWindowTreeHost()->window();
 }
 
 }  // namespace
 
 // A utility class to store/restore focused/active window
 // when the display configuration has changed.
 class FocusActivationStore {
  public:
   FocusActivationStore()
-      : activation_client_(NULL),
-        capture_client_(NULL),
-        focus_client_(NULL),
-        focused_(NULL),
-        active_(NULL) {
-  }
+      : activation_client_(nullptr),
+        capture_client_(nullptr),
+        focus_client_(nullptr),
+        focused_(nullptr),
+        active_(nullptr) {}
 
   void Store(bool clear_focus) {
     if (!activation_client_) {
       aura::Window* root = Shell::GetPrimaryRootWindow();
       activation_client_ = aura::client::GetActivationClient(root);
       capture_client_ = aura::client::GetCaptureClient(root);
       focus_client_ = aura::client::GetFocusClient(root);
     }
     focused_ = focus_client_->GetFocusedWindow();
     if (focused_)
       tracker_.Add(focused_);
     active_ = activation_client_->GetActiveWindow();
     if (active_ && focused_ != active_)
       tracker_.Add(active_);
 
     // Deactivate the window to close menu / bubble windows.
     if (clear_focus)
       activation_client_->DeactivateWindow(active_);
 
     // Release capture if any.
-    capture_client_->SetCapture(NULL);
+    capture_client_->SetCapture(nullptr);
     // Clear the focused window if any. This is necessary because a
     // window may be deleted when losing focus (fullscreen flash for
     // example).  If the focused window is still alive after move, it'll
     // be re-focused below.
     if (clear_focus)
-      focus_client_->FocusWindow(NULL);
+      focus_client_->FocusWindow(nullptr);
   }
 
   void Restore() {
     // Restore focused or active window if it's still alive.
     if (focused_ && tracker_.Contains(focused_)) {
       focus_client_->FocusWindow(focused_);
     } else if (active_ && tracker_.Contains(active_)) {
       activation_client_->ActivateWindow(active_);
     }
     if (focused_)
       tracker_.Remove(focused_);
     if (active_)
       tracker_.Remove(active_);
-    focused_ = NULL;
-    active_ = NULL;
+    focused_ = nullptr;
+    active_ = nullptr;
   }
 
  private:
   aura::client::ActivationClient* activation_client_;
   aura::client::CaptureClient* capture_client_;
   aura::client::FocusClient* focus_client_;
   aura::WindowTracker tracker_;
   aura::Window* focused_;
   aura::Window* active_;
 
@@ skipping 14 matching lines @@
 }
 
 bool DisplayController::DisplayChangeLimiter::IsThrottled() const {
   return base::Time::Now() < throttle_timeout_;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DisplayController
 
 DisplayController::DisplayController()
-    : primary_tree_host_for_replace_(NULL),
+    : primary_tree_host_for_replace_(nullptr),
       focus_activation_store_(new FocusActivationStore()),
       cursor_window_controller_(new CursorWindowController()),
       mirror_window_controller_(new MirrorWindowController()),
       cursor_display_id_for_restore_(gfx::Display::kInvalidDisplayID),
       weak_ptr_factory_(this) {
 #if defined(OS_CHROMEOS)
   if (base::SysInfo::IsRunningOnChromeOS())
     limiter_.reset(new DisplayChangeLimiter);
 #endif
   // Reset primary display to make sure that tests don't use
   // stale display info from previous tests.
   primary_display_id = gfx::Display::kInvalidDisplayID;
 }
 
 DisplayController::~DisplayController() {
 }
 
 void DisplayController::Start() {
   Shell::GetScreen()->AddObserver(this);
   Shell::GetInstance()->display_manager()->set_delegate(this);
 }
 
 void DisplayController::Shutdown() {
   // Unset the display manager's delegate here because
   // DisplayManager outlives DisplayController.
-  Shell::GetInstance()->display_manager()->set_delegate(NULL);
+  Shell::GetInstance()->display_manager()->set_delegate(nullptr);
 
   cursor_window_controller_.reset();
   mirror_window_controller_.reset();
 
   Shell::GetScreen()->RemoveObserver(this);
 
   int64 primary_id = Shell::GetScreen()->GetPrimaryDisplay().id();
 
   // Delete non primary root window controllers first, then
   // delete the primary root window controller.
   aura::Window::Windows root_windows = DisplayController::GetAllRootWindows();
   std::vector<RootWindowController*> to_delete;
-  RootWindowController* primary_rwc = NULL;
+  RootWindowController* primary_rwc = nullptr;
   for (aura::Window::Windows::iterator iter = root_windows.begin();
        iter != root_windows.end();
        ++iter) {
     RootWindowController* rwc = GetRootWindowController(*iter);
     if (GetRootWindowSettings(*iter)->display_id == primary_id)
       primary_rwc = rwc;
     else
       to_delete.push_back(rwc);
   }
   CHECK(primary_rwc);
 
   STLDeleteElements(&to_delete);
   delete primary_rwc;
 }
 
 void DisplayController::CreatePrimaryHost(
     const AshWindowTreeHostInitParams& init_params) {
   const gfx::Display& primary_candidate =
       GetDisplayManager()->GetPrimaryDisplayCandidate();
   primary_display_id = primary_candidate.id();
   CHECK_NE(gfx::Display::kInvalidDisplayID, primary_display_id);
   AddWindowTreeHostForDisplay(primary_candidate, init_params);
 }
 
 void DisplayController::InitDisplays() {
   RootWindowController::CreateForPrimaryDisplay(
       window_tree_hosts_[primary_display_id]);
-
   DisplayManager* display_manager = GetDisplayManager();
   for (size_t i = 0; i < display_manager->GetNumDisplays(); ++i) {
     const gfx::Display& display = display_manager->GetDisplayAt(i);
     if (primary_display_id != display.id()) {
       AshWindowTreeHost* ash_host = AddWindowTreeHostForDisplay(
           display, AshWindowTreeHostInitParams());
       RootWindowController::CreateForSecondaryDisplay(ash_host);
     }
   }
 
@@ skipping 12 matching lines @@
 int64 DisplayController::GetPrimaryDisplayId() {
   CHECK_NE(gfx::Display::kInvalidDisplayID, primary_display_id);
   return primary_display_id;
 }
 
 aura::Window* DisplayController::GetPrimaryRootWindow() {
   return GetRootWindowForDisplayId(primary_display_id);
 }
 
 aura::Window* DisplayController::GetRootWindowForDisplayId(int64 id) {
-  CHECK_EQ(1u, window_tree_hosts_.count(id));
-  AshWindowTreeHost* host = window_tree_hosts_[id];
+  AshWindowTreeHost* host = GetAshWindowTreeHostForDisplayId(id);
   CHECK(host);
   return GetWindow(host);
 }
 
+AshWindowTreeHost* DisplayController::GetAshWindowTreeHostForDisplayId(
+    int64 id) {
+  CHECK_EQ(1u, window_tree_hosts_.count(id));
+  return window_tree_hosts_[id];
+}
+
 void DisplayController::CloseChildWindows() {
   for (WindowTreeHostMap::const_iterator it = window_tree_hosts_.begin();
        it != window_tree_hosts_.end();
        ++it) {
     aura::Window* root_window = GetWindow(it->second);
     RootWindowController* controller = GetRootWindowController(root_window);
     if (controller) {
       controller->CloseChildWindows();
     } else {
       while (!root_window->children().empty()) {
@@ skipping 157 matching lines @@
 void DisplayController::UpdateMouseLocationAfterDisplayChange() {
   // If the mouse is currently on a display in native location,
   // use the same native location. Otherwise find the display closest
   // to the current cursor location in screen coordinates.
 
   gfx::Point point_in_screen = Shell::GetScreen()->GetCursorScreenPoint();
   gfx::Point target_location_in_native;
   int64 closest_distance_squared = -1;
   DisplayManager* display_manager = GetDisplayManager();
 
-  aura::Window* dst_root_window = NULL;
+  aura::Window* dst_root_window = nullptr;
   for (size_t i = 0; i < display_manager->GetNumDisplays(); ++i) {
     const gfx::Display& display = display_manager->GetDisplayAt(i);
     const DisplayInfo display_info =
         display_manager->GetDisplayInfo(display.id());
     aura::Window* root_window = GetRootWindowForDisplayId(display.id());
     if (display_info.bounds_in_native().Contains(
             cursor_location_in_native_coords_for_restore_)) {
       dst_root_window = root_window;
       target_location_in_native = cursor_location_in_native_coords_for_restore_;
       break;
@@ skipping 62 matching lines @@
     const aura::Window* window,
     const gfx::Insets& insets) {
   const aura::Window* root_window = window->GetRootWindow();
   int64 id = GetRootWindowSettings(root_window)->display_id;
   // if id is |kInvaildDisplayID|, it's being deleted.
   DCHECK(id != gfx::Display::kInvalidDisplayID);
   return GetDisplayManager()->UpdateWorkAreaOfDisplay(id, insets);
 }
 
 void DisplayController::OnDisplayAdded(const gfx::Display& display) {
-  if (primary_tree_host_for_replace_) {
+  if (GetDisplayManager()->IsInUnifiedMode()) {
+    if (primary_display_id == gfx::Display::kInvalidDisplayID)
+      primary_display_id = display.id();
+    AshWindowTreeHost* ash_host =
+        AddWindowTreeHostForDisplay(display, AshWindowTreeHostInitParams());
+    RootWindowController::CreateForSecondaryDisplay(ash_host);
+
+    if (primary_tree_host_for_replace_) {
+      AshWindowTreeHost* to_delete = primary_tree_host_for_replace_;
+      primary_tree_host_for_replace_ = nullptr;
+      DeleteHost(to_delete);
+      // the host has already been removed from the window_tree_host_.
+    }
+  }
+  // TODO(oshima): It should be possible to consolidate logic for
+  // unified and non unified, but I'm keeping them separated to minimize
+  // the risk in M44. I'll consolidate this in M45.
+  else if (primary_tree_host_for_replace_) {
     DCHECK(window_tree_hosts_.empty());
     primary_display_id = display.id();
     window_tree_hosts_[display.id()] = primary_tree_host_for_replace_;
     GetRootWindowSettings(GetWindow(primary_tree_host_for_replace_))
         ->display_id = display.id();
-    primary_tree_host_for_replace_ = NULL;
+    primary_tree_host_for_replace_ = nullptr;
     const DisplayInfo& display_info =
         GetDisplayManager()->GetDisplayInfo(display.id());
     AshWindowTreeHost* ash_host = window_tree_hosts_[display.id()];
     ash_host->AsWindowTreeHost()->SetBounds(display_info.bounds_in_native());
     SetDisplayPropertiesOnHost(ash_host, display);
   } else {
     if (primary_display_id == gfx::Display::kInvalidDisplayID)
       primary_display_id = display.id();
     DCHECK(!window_tree_hosts_.empty());
-    AshWindowTreeHost* ash_host = AddWindowTreeHostForDisplay(
-        display, AshWindowTreeHostInitParams());
+    AshWindowTreeHost* ash_host =
+        AddWindowTreeHostForDisplay(display, AshWindowTreeHostInitParams());
     RootWindowController::CreateForSecondaryDisplay(ash_host);
   }
 }
 
+void DisplayController::DeleteHost(AshWindowTreeHost* host_to_delete) {
+  ClearDisplayPropertiesOnHost(host_to_delete);
+  RootWindowController* controller =
+      GetRootWindowController(GetWindow(host_to_delete));
+  DCHECK(controller);
+  controller->MoveWindowsTo(GetPrimaryRootWindow());
+  // Delete most of root window related objects, but don't delete
+  // root window itself yet because the stack may be using it.
+  controller->Shutdown();
+  base::MessageLoop::current()->DeleteSoon(FROM_HERE, controller);
+}
+
 void DisplayController::OnDisplayRemoved(const gfx::Display& display) {
   AshWindowTreeHost* host_to_delete = window_tree_hosts_[display.id()];
   CHECK(host_to_delete) << display.ToString();
 
   // When the primary root window's display is removed, move the primary
   // root to the other display.
   if (primary_display_id == display.id()) {
     // Temporarily store the primary root window in
     // |primary_root_window_for_replace_| when replacing the display.
     if (window_tree_hosts_.size() == 1) {
@@ skipping 19 matching lines @@
 
     // Setup primary root.
     window_tree_hosts_[primary_display_id] = primary_host;
     GetRootWindowSettings(GetWindow(primary_host))->display_id =
         primary_display_id;
 
     OnDisplayMetricsChanged(
         GetDisplayManager()->GetDisplayForId(primary_display_id),
         DISPLAY_METRIC_BOUNDS);
   }
-  ClearDisplayPropertiesOnHost(host_to_delete, display);
-  RootWindowController* controller =
-      GetRootWindowController(GetWindow(host_to_delete));
-  DCHECK(controller);
-  controller->MoveWindowsTo(GetPrimaryRootWindow());
-  // Delete most of root window related objects, but don't delete
-  // root window itself yet because the stack may be using it.
-  controller->Shutdown();
-  base::MessageLoop::current()->DeleteSoon(FROM_HERE, controller);
+
+  DeleteHost(host_to_delete);
 
   // The window tree host should be erased at last because some handlers can
   // access to the host through GetRootWindowForDisplayId() during
   // MoveWindowsTo(). See http://crbug.com/415222
   window_tree_hosts_.erase(display.id());
 }
 
 void DisplayController::OnDisplayMetricsChanged(const gfx::Display& display,
                                                 uint32_t metrics) {
   if (!(metrics & (DISPLAY_METRIC_BOUNDS | DISPLAY_METRIC_ROTATION |
@@ skipping 12 matching lines @@
       const_cast<aura::Window*>(host->window()));
 
   DisplayManager* display_manager = GetDisplayManager();
   if (display_manager->UpdateDisplayBounds(display.id(), host->GetBounds())) {
     mirror_window_controller_->UpdateWindow();
     cursor_window_controller_->UpdateContainer();
   }
 }
 
 void DisplayController::CreateOrUpdateMirroringDisplay(
-    const DisplayInfo& info) {
-  switch (GetDisplayManager()->second_display_mode()) {
+    const DisplayInfoList& info_list) {
+  switch (GetDisplayManager()->multi_display_mode()) {
     case DisplayManager::MIRRORING:
-      mirror_window_controller_->UpdateWindow(info);
+    case DisplayManager::UNIFIED:
+      mirror_window_controller_->UpdateWindow(info_list);
       cursor_window_controller_->UpdateContainer();
       break;
     case DisplayManager::EXTENDED:
       NOTREACHED();
   }
 }
 
 void DisplayController::CloseMirroringDisplay() {
   mirror_window_controller_->Close();
   // If cursor_compositing is enabled for large cursor, the cursor window is
@@ skipping 25 matching lines @@
   if (limiter_)
     limiter_->SetThrottleTimeout(kAfterDisplayChangeThrottleTimeoutMs);
 
   focus_activation_store_->Restore();
 
   DisplayManager* display_manager = GetDisplayManager();
   DisplayLayoutStore* layout_store = display_manager->layout_store();
   if (display_manager->num_connected_displays() > 1) {
     DisplayIdPair pair = display_manager->GetCurrentDisplayIdPair();
     layout_store->UpdateMirrorStatus(pair, display_manager->IsInMirrorMode());
-    DisplayLayout layout = layout_store->GetRegisteredDisplayLayout(pair);
 
     if (Shell::GetScreen()->GetNumDisplays() > 1 ) {
+      DisplayLayout layout = layout_store->GetRegisteredDisplayLayout(pair);
       int64 primary_id = layout.primary_id;
       SetPrimaryDisplayId(
           primary_id == gfx::Display::kInvalidDisplayID ?
           pair.first : primary_id);
       // Update the primary_id in case the above call is
       // ignored. Happens when a) default layout's primary id
       // doesn't exist, or b) the primary_id has already been
       // set to the same and didn't update it.
       layout_store->UpdatePrimaryDisplayId(
           pair, Shell::GetScreen()->GetPrimaryDisplay().id());
     }
   }
   FOR_EACH_OBSERVER(Observer, observers_, OnDisplayConfigurationChanged());
   UpdateMouseLocationAfterDisplayChange();
 }
 
 AshWindowTreeHost* DisplayController::AddWindowTreeHostForDisplay(
     const gfx::Display& display,
     const AshWindowTreeHostInitParams& init_params) {
   static int host_count = 0;
   const DisplayInfo& display_info =
       GetDisplayManager()->GetDisplayInfo(display.id());
   AshWindowTreeHostInitParams params_with_bounds(init_params);
   params_with_bounds.initial_bounds = display_info.bounds_in_native();
+  params_with_bounds.offscreen =
+      display.id() == DisplayManager::kUnifiedDisplayId;
   AshWindowTreeHost* ash_host = AshWindowTreeHost::Create(params_with_bounds);
   aura::WindowTreeHost* host = ash_host->AsWindowTreeHost();
 
-  host->window()->SetName(base::StringPrintf("RootWindow-%d", host_count++));
+  host->window()->SetName(base::StringPrintf(
+      "%sRootWindow-%d", params_with_bounds.offscreen ? "Offscreen" : "",
+      host_count++));
   host->window()->SetTitle(base::UTF8ToUTF16(display_info.name()));
   host->compositor()->SetBackgroundColor(SK_ColorBLACK);
   // No need to remove our observer observer because the DisplayController
   // outlives the host.
   host->AddObserver(this);
   InitRootWindowSettings(host->window())->display_id = display.id();
   host->InitHost();
 
   window_tree_hosts_[display.id()] = ash_host;
   SetDisplayPropertiesOnHost(ash_host, display);
 
 #if defined(OS_CHROMEOS)
-  static bool force_constrain_pointer_to_root =
-      base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kAshConstrainPointerToRoot);
-  if (base::SysInfo::IsRunningOnChromeOS() || force_constrain_pointer_to_root)
+  if (switches::ConstrainPointerToRoot())
     ash_host->ConfineCursorToRootWindow();
 #endif
   return ash_host;
 }
 
 void DisplayController::OnFadeOutForSwapDisplayFinished() {
 #if defined(OS_CHROMEOS)
   SetPrimaryDisplay(ScreenUtil::GetSecondaryDisplay());
   Shell::GetInstance()->display_configurator_animation()
       ->StartFadeInAnimation();
 #endif
 }
 
 void DisplayController::SetMirrorModeAfterAnimation(bool mirror) {
   GetDisplayManager()->SetMirrorMode(mirror);
 }
 
 }  // namespace ash