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();
@@ skipping 148 matching lines @@
   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 240 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_) {
-    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;
-    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 {
+  // TODO(oshima): Consolidate these logic.
+  if (GetDisplayManager()->IsInUnifiedMode()) {
     if (primary_display_id == gfx::Display::kInvalidDisplayID)
       primary_display_id = display.id();
-    DCHECK(!window_tree_hosts_.empty());
     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_ = NULL;

[Jun Mukai, 2015/04/26 23:45:07]

nullptr

[oshima, 2015/04/27 17:48:38]

Done.

+      DeleteHost(to_delete);
+      // the host has already been removed from the window_tree_host_.
+    }
+  } else {
+    if (primary_tree_host_for_replace_) {

[Jun Mukai, 2015/04/26 23:45:07]

why not else if?

[oshima, 2015/04/27 17:48:38]

Done.

+      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;

[Jun Mukai, 2015/04/26 23:45:07]

nullptr

[oshima, 2015/04/27 17:48:38]

Done.

+      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());
+      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