Enable display rotation, magnifier in unified desktop mode

ash/magnifier/magnification_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/magnifier/magnification_controller.h"
 
 #include "ash/accelerators/accelerator_controller.h"
 #include "ash/accessibility_delegate.h"
 #include "ash/ash_switches.h"
 #include "ash/display/root_window_transformers.h"
@@ skipping 75 matching lines @@
   void MoveWindow(int x, int y, bool animate) override;
   void MoveWindow(const gfx::Point& point, bool animate) override;
   gfx::Point GetWindowPosition() const override {
     return gfx::ToFlooredPoint(origin_);
   }
   void SetScrollDirection(ScrollDirection direction) override;
   gfx::Rect GetViewportRect() const override;
   void HandleFocusedNodeChanged(
       bool is_editable_node,
       const gfx::Rect& node_bounds_in_screen) override;
+  void SwitchTargetRootWindow(aura::Window* new_root_window,
+                              bool redraw_original_root_window) override;
 
   // For test
   gfx::Point GetPointOfInterestForTesting() override {
     return point_of_interest_;
   }
 
   bool IsOnAnimationForTesting() const override { return is_on_animation_; }
 
  private:
   // ui::ImplicitAnimationObserver overrides:
@@ skipping 24 matching lines @@
   // other words, zoom (or unzoom) centering around the cursor.
   void RedrawKeepingMousePosition(float scale, bool animate);
 
   void OnMouseMove(const gfx::Point& location);
 
   // Move the mouse cursot to the given point. Actual move will be done when
   // the animation is completed. This should be called after animation is
   // started.
   void AfterAnimationMoveCursorTo(const gfx::Point& location);
 
-  // Switch Magnified RootWindow to |new_root_window|. This does following:
-  //  - Unzoom the current root_window.
-  //  - Zoom the given new root_window |new_root_window|.
-  //  - Switch the target window from current window to |new_root_window|.
-  void SwitchTargetRootWindow(aura::Window* new_root_window,
-                              bool redraw_original_root_window);
-
   // Returns if the magnification scale is 1.0 or not (larger then 1.0).
   bool IsMagnified() const;
 
   // Returns the rect of the magnification window.
   gfx::RectF GetWindowRectDIP(float scale) const;
   // Returns the size of the root window.
   gfx::Size GetHostSizeDIP() const;
 
   // Correct the given scale value if necessary.
   void ValidateScale(float* scale);
@@ skipping 223 matching lines @@
     return;
 
   gfx::Rect node_bounds_in_root =
       ScreenUtil::ConvertRectFromScreen(root_window_, node_bounds_in_screen);
   if (GetViewportRect().Contains(node_bounds_in_root))
     return;
 
   MoveMagnifierWindowFollowRect(node_bounds_in_root);
 }
 
+void MagnificationControllerImpl::SwitchTargetRootWindow(
+    aura::Window* new_root_window,
+    bool redraw_original_root_window) {
+  DCHECK(new_root_window);
+
+  if (new_root_window == root_window_)
+    return;
+  // Update the |root_window_| now because RedrawKeepingMousePosition
+  // may call this back.
+  aura::Window* old_root_window = root_window_;
+  root_window_ = new_root_window;
+
+  move_cursor_after_animation_ = false;
+
+  // Stores the previous scale.
+  float scale = GetScale();
+
+  // Unmagnify the previous root window.
+  old_root_window->RemoveObserver(this);
+  if (redraw_original_root_window)
+    RedrawKeepingMousePosition(1.0f, true);
+
+  RedrawKeepingMousePosition(scale, true);
+  root_window_->AddObserver(this);
+}
+
 void MagnificationControllerImpl::AfterAnimationMoveCursorTo(
     const gfx::Point& location) {
   DCHECK(root_window_);
 
   aura::client::CursorClient* cursor_client =
       aura::client::GetCursorClient(root_window_);
   if (cursor_client) {
     // When cursor is invisible, do not move or show the cursor after the
     // animation.
     if (!cursor_client->IsCursorVisible())
@@ skipping 71 matching lines @@
   }
 }
 
 void MagnificationControllerImpl::OnWindowBoundsChanged(
     aura::Window* window,
     const gfx::Rect& old_bounds,
     const gfx::Rect& new_bounds) {
   // TODO(yoshiki): implement here. crbug.com/230979
 }
 
-void MagnificationControllerImpl::SwitchTargetRootWindow(
-    aura::Window* new_root_window,
-    bool redraw_original_root_window) {
-  DCHECK(new_root_window);
-
-  if (new_root_window == root_window_)
-    return;
-
-  // Stores the previous scale.
-  float scale = GetScale();
-
-  // Unmagnify the previous root window.
-  root_window_->RemoveObserver(this);
-  if (redraw_original_root_window)
-    RedrawKeepingMousePosition(1.0f, true);
-
-  root_window_ = new_root_window;
-  RedrawKeepingMousePosition(scale, true);
-  root_window_->AddObserver(this);
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // MagnificationControllerImpl: MagnificationController implementation
 
 void MagnificationControllerImpl::SetScale(float scale, bool animate) {
   if (!is_enabled_)
     return;
 
   ValidateScale(&scale);
   Shell::GetInstance()->accessibility_delegate()->
       SaveScreenMagnifierScale(scale);
@@ skipping 232 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // MagnificationController:
 
 // static
 MagnificationController* MagnificationController::CreateInstance() {
   return new MagnificationControllerImpl();
 }
 
 }  // namespace ash