Enable display rotation, magnifier in 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>
 
 #include "ash/ash_switches.h"
 #include "ash/display/cursor_window_controller.h"
 #include "ash/display/display_layout_store.h"
 #include "ash/display/display_manager.h"
 #include "ash/display/mirror_window_controller.h"
 #include "ash/display/root_window_transformers.h"
 #include "ash/host/ash_window_tree_host.h"
 #include "ash/host/ash_window_tree_host_init_params.h"
 #include "ash/host/root_window_transformer.h"
+#include "ash/magnifier/magnification_controller.h"
+#include "ash/magnifier/partial_magnification_controller.h"
 #include "ash/root_window_controller.h"
 #include "ash/root_window_settings.h"
 #include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
 #include "ash/wm/coordinate_conversion.h"
 #include "base/command_line.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 329 matching lines @@
   return GetRootWindowForDisplayId(primary_display_id);
 }
 
 aura::Window* DisplayController::GetRootWindowForDisplayId(int64 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];
+    int64 display_id) {
+  CHECK_EQ(1u, window_tree_hosts_.count(display_id))
+      << "display id = " << display_id;
+  return window_tree_hosts_[display_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();
@@ skipping 195 matching lines @@
       target_location_in_native = center;
       closest_distance_squared = distance_squared;
     }
   }
 
   gfx::Point target_location_in_root = target_location_in_native;
   dst_root_window->GetHost()->ConvertPointFromNativeScreen(
       &target_location_in_root);
 
 #if defined(USE_OZONE)
+  LOG(ERROR) << "Start OZONE";
   gfx::Point target_location_in_screen = target_location_in_root;
   ::wm::ConvertPointToScreen(dst_root_window, &target_location_in_screen);
   const gfx::Display& target_display =
       display_manager->FindDisplayContainingPoint(target_location_in_screen);
   int64 target_display_id = target_display.id();
 
   // Do not move the cursor if the cursor's location did not change. This avoids
   // moving (and showing) the cursor:
   // - At startup.
   // - When the device is rotated in maximized mode.
@@ skipping 11 matching lines @@
     // that the cursor is on changes.
     Shell::GetInstance()->cursor_manager()->SetDisplay(target_display);
 
     // Update the cursor's root location. This ends up dispatching a synthetic
     // mouse move. The synthetic mouse move updates the composited cursor's
     // location and hover effects. Synthetic mouse moves do not affect the
     // cursor's visibility.
     dst_root_window->GetHost()->dispatcher()->OnCursorMovedToRootLocation(
         target_location_in_root);
   }
+  LOG(ERROR) << "END OZONE";
 #else
   dst_root_window->MoveCursorTo(target_location_in_root);
 #endif
 }
 
 bool DisplayController::UpdateWorkAreaOfDisplayNearestWindow(
     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 defined(OS_CHROMEOS)
   if (GetDisplayManager()->default_multi_display_mode() ==
       DisplayManager::UNIFIED) {
     if (primary_display_id == gfx::Display::kInvalidDisplayID)
       primary_display_id = display.id();
     AshWindowTreeHost* ash_host =
         AddWindowTreeHostForDisplay(display, AshWindowTreeHostInitParams());
     RootWindowController::CreateForSecondaryDisplay(ash_host);
 
+    // Magnifier controllers keep pointers to the current root window.
+    // Update them here to avoid accessing them later.
+    Shell::GetInstance()->magnification_controller()->SwitchTargetRootWindow(
+        ash_host->AsWindowTreeHost()->window(), false);
+    Shell::GetInstance()
+        ->partial_magnification_controller()
+        ->SwitchTargetRootWindow(ash_host->AsWindowTreeHost()->window());
+
     if (primary_tree_host_for_replace_) {
       AshWindowTreeHost* to_delete = primary_tree_host_for_replace_;
       primary_tree_host_for_replace_ = nullptr;
       DeleteHost(to_delete);
 #ifndef NDEBUG
       auto iter = std::find_if(
           window_tree_hosts_.begin(), window_tree_hosts_.end(),
           [to_delete](const std::pair<int64, AshWindowTreeHost*>& pair) {
             return pair.second == to_delete;
           });
@@ skipping 220 matching lines @@
   Shell::GetInstance()->display_configurator_animation()
       ->StartFadeInAnimation();
 #endif
 }
 
 void DisplayController::SetMirrorModeAfterAnimation(bool mirror) {
   GetDisplayManager()->SetMirrorMode(mirror);
 }
 
 }  // namespace ash