Magnifier: Move the cursor directly to the root window host.

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/display/display_controller.h"
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
 #include "ash/system/tray/system_tray_delegate.h"
+#include "base/synchronization/waitable_event.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_property.h"
 #include "ui/base/events/event.h"
 #include "ui/base/events/event_handler.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
+#include "ui/gfx/point3_f.h"
 #include "ui/gfx/point_conversions.h"
 #include "ui/gfx/point_f.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/screen.h"
 #include "ui/views/corewm/compound_event_filter.h"
 
 namespace {
 
 const float kMaxMagnifiedScale = 4.0f;
 const float kMaxMagnifiedScaleThreshold = 4.0f;
 const float kMinMagnifiedScaleThreshold = 1.1f;
 const float kNonMagnifiedScale = 1.0f;
 
 const float kInitialMagnifiedScale = 2.0f;
 const float kScrollScaleChangeFactor = 0.05f;
 
 // Threadshold of panning. If the cursor moves to within pixels (in DIP) of
 // |kPanningMergin| from the edge, the view-port moves.
 const int kPanningMergin = 100;
 
+void MoveCursorTo(aura::RootWindow* root_window,
+                  const gfx::Point root_location) {
+  gfx::Point3F host_location_3f(root_location);
+  root_window->layer()->transform().TransformPoint(host_location_3f);
+  root_window->MoveCursorToHostLoation(
+      gfx::ToCeiledPoint(host_location_3f.AsPointF()));
+}
+
 }  // namespace
 
 namespace ash {
 
 ////////////////////////////////////////////////////////////////////////////////
 // MagnificationControllerImpl:
 
 class MagnificationControllerImpl : virtual public MagnificationController,
                                     public ui::EventHandler,
                                     public ui::ImplicitAnimationObserver,
                                     public aura::WindowObserver {
  public:
   MagnificationControllerImpl();
   virtual ~MagnificationControllerImpl();
 
   // MagnificationController overrides:
   virtual void SetEnabled(bool enabled) OVERRIDE;
   virtual bool IsEnabled() const OVERRIDE;
   virtual void SetScale(float scale, bool animate) OVERRIDE;
   virtual float GetScale() const OVERRIDE { return scale_; }
   virtual void MoveWindow(int x, int y, bool animate) OVERRIDE;
   virtual void MoveWindow(const gfx::Point& point, bool animate) OVERRIDE;
   virtual gfx::Point GetWindowPosition() const OVERRIDE {
     return gfx::ToFlooredPoint(origin_);
   }
   virtual void EnsureRectIsVisible(const gfx::Rect& rect,
                                    bool animate) OVERRIDE;
   virtual void EnsurePointIsVisible(const gfx::Point& point,
                                     bool animate) OVERRIDE;
+  // For test
+  virtual gfx::Point GetPointOfInterestForTesting() OVERRIDE {
+    return point_of_interest_;
+  }
 
  private:
   // ui::ImplicitAnimationObserver overrides:
   virtual void OnImplicitAnimationsCompleted() OVERRIDE;
 
   // aura::WindowObserver overrides:
   virtual void OnWindowDestroying(aura::Window* root_window) OVERRIDE;
 
   // Redraws the magnification window with the given origin position and the
   // given scale. Returns true if the window is changed; otherwise, false.
@@ skipping 271 matching lines @@
   y = top + y_diff;
 
   if (start_zoom && !is_on_animation_) {
     // No animation on panning.
     bool animate = false;
     bool ret = RedrawDIP(gfx::Point(x, y), scale_, animate);
 
     if (ret) {
       // If the magnified region is moved, hides the mouse cursor and moves it.
       if (x_diff != 0 || y_diff != 0)
-        root_window_->MoveCursorTo(mouse);
+        MoveCursorTo(root_window_, mouse);
     }
   }
 }
 
 void MagnificationControllerImpl::AfterAnimationMoveCursorTo(
     const gfx::Point& location) {
   DCHECK(root_window_);
 
   aura::client::CursorClient* cursor_client =
       aura::client::GetCursorClient(root_window_);
@@ skipping 39 matching lines @@
     *scale = kMaxMagnifiedScale;
 
   DCHECK(kNonMagnifiedScale <= *scale && *scale <= kMaxMagnifiedScale);
 }
 
 void MagnificationControllerImpl::OnImplicitAnimationsCompleted() {
   if (!is_on_animation_)
     return;
 
   if (move_cursor_after_animation_) {
-    root_window_->MoveCursorTo(position_after_animation_);
+    MoveCursorTo(root_window_, position_after_animation_);
     move_cursor_after_animation_ = false;
 
     aura::client::CursorClient* cursor_client =
         aura::client::GetCursorClient(root_window_);
     if (cursor_client)
       cursor_client->EnableMouseEvents();
   }
 
   is_on_animation_ = false;
 }
@@ skipping 164 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // MagnificationController:
 
 // static
 MagnificationController* MagnificationController::CreateInstance() {
   return new MagnificationControllerImpl();
 }
 
 }  // namespace ash