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

ui/aura/root_window.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 "ui/aura/root_window.h"
 
 #include <vector>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
@@ skipping 271 matching lines @@
 }
 
 void RootWindow::OnMouseEventsEnableStateChanged(bool enabled) {
   // Send entered / exited so that visual state can be updated to match
   // mouse events state.
   PostMouseMoveEventAfterWindowChange();
   // TODO(mazda): Add code to disable mouse events when |enabled| == false.
 }
 
 void RootWindow::MoveCursorTo(const gfx::Point& location_in_dip) {
-  gfx::Point3F point_3f(location_in_dip);
-  GetRootTransform().TransformPoint(point_3f);
-  host_->MoveCursorTo(gfx::ToFlooredPoint(point_3f.AsPointF()));
+  gfx::Point location(location_in_dip);
+  ConvertPointToHost(&location);
+  host_->MoveCursorTo(location);
   SetLastMouseLocation(this, location_in_dip);

[oshima, 2013/04/25 14:58:13]

Sorry if I wasn't clear. Can you refactor this method and
MoveCursorToHostLocation so that it shares the same code?

[yoshiki, 2013/04/25 16:05:19]

We can't use MoveCursorToHostLoation from MoveCursorTo because we disables
synthesize_mouse_move in MoveCursorToHostLoation, but not in MoveCursorTo.
Instead, I added MoveCursorToInternal to share the common code. Do you think
it's good?

[oshima, 2013/04/25 16:09:02]

I think we should set this in both cases.
Yes, that's what I meant by refactoring. You need to move SetLastMouseLocation
out.

[yoshiki, 2013/04/25 16:23:27]

Done. Moved 'synthesize_mouse_move_ = false' to MoveCursorToInternal.
Sorry, I'm confusing. Do you mean we should move SetLastMouseLocation from
MoveCursorToInternal to somewhere?

   client::CursorClient* cursor_client = client::GetCursorClient(this);
   if (cursor_client) {
     const gfx::Display& display =
         gfx::Screen::GetScreenFor(this)->GetDisplayNearestWindow(this);
     cursor_client->SetDisplay(display);
   }
 }
 
+void RootWindow::MoveCursorToHostLoation(const gfx::Point& host_location) {
+  host_->MoveCursorTo(host_location);

[sky, 2013/04/25 14:41:35]

Shouldn't moving the cursor trigger all of the following code to execute? By
that I mean shouldn't moving the cursor result in a mouse move (or whatever) and
update everything accordingly?

[oshima, 2013/04/25 14:58:13]

Yes, but asynchronously. My understanding is that this is to make cursor move
synchronous
(useful for mouse control and testing). RootWindowHostLinux does similar thing
for window resize.

[yoshiki, 2013/04/25 16:05:19]

Right, I want to move the cursor synchronously.

[sky, 2013/04/25 16:46:59]

Why is it important that the mouse is synchronous? And you mispelled Location
here.

+  gfx::Point root_location(host_location);
+  ConvertPointFromHost(&root_location);
+  SetLastMouseLocation(this, root_location);
+  client::CursorClient* cursor_client = client::GetCursorClient(this);
+  if (cursor_client) {
+    const gfx::Display& display =
+        gfx::Screen::GetScreenFor(this)->GetDisplayNearestWindow(this);
+    cursor_client->SetDisplay(display);
+  }
+
+  synthesize_mouse_move_ = false;
+}
+
 bool RootWindow::ConfineCursorToWindow() {
   // We would like to be able to confine the cursor to that window. However,
   // currently, we do not have such functionality in X. So we just confine
   // to the root window. This is ok because this option is currently only
   // being used in fullscreen mode, so root_window bounds = window bounds.
   return host_->ConfineCursorToRootWindow();
 }
 
 void RootWindow::Draw() {
   defer_draw_scheduling_ = false;
@@ skipping 851 matching lines @@
 }
 
 gfx::Transform RootWindow::GetInverseRootTransform() const {
   float scale = ui::GetDeviceScaleFactor(layer());
   gfx::Transform transform;
   transform.Scale(1.0f / scale, 1.0f / scale);
   return transformer_->GetInverseTransform() * transform;
 }
 
 }  // namespace aura