Fix jittering cursor in screen magnifier 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 <memory>
 #include <utility>
 
 #include "ash/accelerators/accelerator_controller.h"
@@ skipping 149 matching lines @@
   // 1) If the screen is scrolling (i.e. animating) and should scroll further,
   // it does nothing.
   // 2) If the screen is scrolling (i.e. animating) and the direction is NONE,
   // it stops the scrolling animation.
   // 3) If the direction is set to value other than NONE, it starts the
   // scrolling/ animation towards that direction.
   void StartOrStopScrollIfNecessary();
 
   // Redraw with the given zoom scale keeping the mouse cursor location. In
   // other words, zoom (or unzoom) centering around the cursor.
-  void RedrawKeepingMousePosition(float scale, bool animate);
+  // Ignore mouse position change after redrawing if |ignore_mouse_change| is
+  // true.
+  void RedrawKeepingMousePosition(float scale,
+                                  bool animate,
+                                  bool ignore_mouse_change);
 
   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);
 
   // Returns if the magnification scale is 1.0 or not (larger then 1.0).
   bool IsMagnified() const;
@@ skipping 104 matching lines @@
 MagnificationControllerImpl::~MagnificationControllerImpl() {
   ui::InputMethod* input_method = GetInputMethod(root_window_);
   if (input_method)
     input_method->RemoveObserver(this);
 
   root_window_->RemoveObserver(this);
 
   Shell::Get()->RemovePreTargetHandler(this);
 }
 
-void MagnificationControllerImpl::RedrawKeepingMousePosition(float scale,
-                                                             bool animate) {
+void MagnificationControllerImpl::RedrawKeepingMousePosition(
+    float scale,
+    bool animate,
+    bool ignore_mouse_change) {
   gfx::Point mouse_in_root = point_of_interest_;
-
   // mouse_in_root is invalid value when the cursor is hidden.
   if (!root_window_->bounds().Contains(mouse_in_root))
     mouse_in_root = root_window_->bounds().CenterPoint();
 
   const gfx::PointF origin = gfx::PointF(
       mouse_in_root.x() - (scale_ / scale) * (mouse_in_root.x() - origin_.x()),
       mouse_in_root.y() - (scale_ / scale) * (mouse_in_root.y() - origin_.y()));
   bool changed =
       RedrawDIP(origin, scale, animate ? kDefaultAnimationDurationInMs : 0,
                 kDefaultAnimationTweenType);
-  if (changed)
+  if (!ignore_mouse_change && changed)
     AfterAnimationMoveCursorTo(mouse_in_root);
 }
 
 bool MagnificationControllerImpl::Redraw(const gfx::PointF& position,
                                          float scale,
                                          bool animate) {
   const gfx::PointF position_in_dip =
       ui::ConvertPointToDIP(root_window_->layer(), position);
   return RedrawDIP(position_in_dip, scale,
                    animate ? kDefaultAnimationDurationInMs : 0,
@@ skipping 132 matching lines @@
   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);
+  // Do not move mouse back to its original position (point at border of the
+  // root window) after redrawing as doing so will trigger root window switch
+  // again.
   if (redraw_original_root_window)
-    RedrawKeepingMousePosition(1.0f, true);
+    RedrawKeepingMousePosition(1.0f, true, true);
   root_window_ = new_root_window;
-  RedrawKeepingMousePosition(scale, true);
+  RedrawKeepingMousePosition(scale, true, 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) {
@@ skipping 83 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // MagnificationControllerImpl: MagnificationController implementation
 
 void MagnificationControllerImpl::SetScale(float scale, bool animate) {
   if (!is_enabled_)
     return;
 
   ValidateScale(&scale);
   Shell::Get()->accessibility_delegate()->SaveScreenMagnifierScale(scale);
-  RedrawKeepingMousePosition(scale, animate);
+  RedrawKeepingMousePosition(scale, animate, false);
 }
 
 void MagnificationControllerImpl::MoveWindow(int x, int y, bool animate) {
   if (!is_enabled_)
     return;
 
   Redraw(gfx::PointF(x, y), scale_, animate);
 }
 
 void MagnificationControllerImpl::MoveWindow(const gfx::Point& point,
@@ skipping 21 matching lines @@
         shell->accessibility_delegate()->GetSavedScreenMagnifierScale();
     if (scale <= 0.0f)
       scale = kInitialMagnifiedScale;
     ValidateScale(&scale);
 
     // Do nothing, if already enabled with same scale.
     if (is_enabled_ && scale == scale_)
       return;
 
     is_enabled_ = enabled;
-    RedrawKeepingMousePosition(scale, true);
+    RedrawKeepingMousePosition(scale, true, false);
     shell->accessibility_delegate()->SaveScreenMagnifierScale(scale);
   } else {
     // Do nothing, if already disabled.
     if (!is_enabled_)
       return;
 
     if (input_method)
       input_method->RemoveObserver(this);
 
-    RedrawKeepingMousePosition(kNonMagnifiedScale, true);
+    RedrawKeepingMousePosition(kNonMagnifiedScale, true, false);
     is_enabled_ = enabled;
   }
 }
 
 bool MagnificationControllerImpl::IsEnabled() const {
   return is_enabled_;
 }
 
 void MagnificationControllerImpl::SetKeepFocusCentered(
     bool keep_focus_centered) {
@@ skipping 253 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // MagnificationController:
 
 // static
 MagnificationController* MagnificationController::CreateInstance() {
   return new MagnificationControllerImpl();
 }
 
 }  // namespace ash