Make the cursor have separate mode for disabled mouse events and invisible.

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 50 matching lines @@
 float GetDeviceScaleFactorFromDisplay(Window* window) {
   return gfx::Screen::GetScreenFor(window)->
       GetDisplayNearestWindow(window).device_scale_factor();
 }
 
 Window* ConsumerToWindow(ui::GestureConsumer* consumer) {
   return consumer && !consumer->ignores_events() ?
       static_cast<Window*>(consumer) : NULL;
 }
 
-void SetLastMouseLocation(const Window* root_window,
-                          const gfx::Point& location) {
-  Env::GetInstance()->SetLastMouseLocation(*root_window, location);
+void SetLastMouseLocation(const RootWindow* root_window,
+                          const gfx::Point& location_in_root) {
+  client::ScreenPositionClient* client =
+      client::GetScreenPositionClient(root_window);
+  if (client) {
+    gfx::Point location_in_screen = location_in_root;
+    client->ConvertPointToScreen(root_window, &location_in_screen);
+    Env::GetInstance()->set_last_mouse_location(location_in_screen);
+  } else {
+    Env::GetInstance()->set_last_mouse_location(location_in_root);
+  }
 }
 
 RootWindowHost* CreateHost(RootWindow* root_window,
                            const RootWindow::CreateParams& params) {
   RootWindowHost* host = params.host ?
       params.host : RootWindowHost::Create(params.initial_bounds);
   host->SetDelegate(root_window);
   return host;
 }
 
@@ skipping 114 matching lines @@
   return host_->GetBounds().origin();
 }
 
 void RootWindow::SetCursor(gfx::NativeCursor cursor) {
   last_cursor_ = cursor;
   // A lot of code seems to depend on NULL cursors actually showing an arrow,
   // so just pass everything along to the host.
   host_->SetCursor(cursor);
 }
 
-void RootWindow::OnCursorVisibilityChanged(bool show) {
+void RootWindow::OnCursorEnableStateChanged(bool enabled) {
   // Send entered / exited so that visual state can be updated to match
   // cursor state.
-  Env::GetInstance()->SetCursorShown(show);
   PostMouseMoveEventAfterWindowChange();
-  host_->OnCursorVisibilityChanged(show);
+  host_->OnCursorEnableStateChanged(enabled);
 }
 
 void RootWindow::MoveCursorTo(const gfx::Point& location_in_dip) {
   gfx::Point location = location_in_dip;
   layer()->transform().TransformPoint(location);
   host_->MoveCursorTo(ui::ConvertPointToPixel(layer(), location));
   SetLastMouseLocation(this, location_in_dip);
   client::CursorClient* cursor_client = client::GetCursorClient(this);
   if (cursor_client)
     cursor_client->SetDeviceScaleFactor(GetDeviceScaleFactor());
@@ skipping 267 matching lines @@
 
 void RootWindow::OnDeviceScaleFactorChanged(
     float device_scale_factor) {
   const bool cursor_is_in_bounds =
       GetBoundsInScreen().Contains(Env::GetInstance()->last_mouse_location());
   bool cursor_visible = false;
   client::CursorClient* cursor_client = client::GetCursorClient(this);
   if (cursor_is_in_bounds && cursor_client) {
     cursor_visible = cursor_client->IsCursorVisible();
     if (cursor_visible)
-      cursor_client->ShowCursor(false);
+      cursor_client->EnableCursor(false);
   }
   host_->OnDeviceScaleFactorChanged(device_scale_factor);
   Window::OnDeviceScaleFactorChanged(device_scale_factor);
   // Update the device scale factor of the cursor client only when the last
   // mouse location is on this root window.
   if (cursor_is_in_bounds) {
     if (cursor_client)
       cursor_client->SetDeviceScaleFactor(device_scale_factor);
   }
   if (cursor_is_in_bounds && cursor_client && cursor_visible)
-    cursor_client->ShowCursor(true);
+    cursor_client->EnableCursor(true);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindow, overridden from aura::Window:
 
 bool RootWindow::CanFocus() const {
   return IsVisible();
 }
 
 bool RootWindow::CanReceiveEvents() const {
@@ skipping 38 matching lines @@
 }
 
 void RootWindow::SetNativeCapture() {
   host_->SetCapture();
 }
 
 void RootWindow::ReleaseNativeCapture() {
   host_->ReleaseCapture();
 }
 
-gfx::Point RootWindow::QueryMouseLocationForTest() const {
-  gfx::Point point;
-  host_->QueryMouseLocation(&point);
-  return point;
+bool RootWindow::QueryMouseLocationForTest(gfx::Point* point) const {
+  return host_->QueryMouseLocation(point);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindow, private:
 
 void RootWindow::TransformEventForDeviceScaleFactor(ui::LocatedEvent* event) {
   float scale = ui::GetDeviceScaleFactor(layer());
   gfx::Transform transform;
   transform.Scale(scale, scale);
   transform *= layer()->transform();
@@ skipping 403 matching lines @@
   ui::MouseEvent event(ui::ET_MOUSE_MOVED,
                        orig_mouse_location,
                        orig_mouse_location,
                        ui::EF_IS_SYNTHESIZED);
   event.set_system_location(Env::GetInstance()->last_mouse_location());
   OnHostMouseEvent(&event);
 #endif
 }
 
 }  // namespace aura