Enable CursorManager::LockCursor to lock cursor visibility.

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 106 matching lines @@
 // RootWindow, public:
 
 RootWindow::RootWindow(const CreateParams& params)
     : Window(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(host_(CreateHost(this, params))),
       ALLOW_THIS_IN_INITIALIZER_LIST(schedule_paint_factory_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(event_factory_(this)),
       mouse_button_flags_(0),
       touch_ids_down_(0),
       last_cursor_(ui::kCursorNull),
-      // TODO(ivankr): this currently tracks the default state in
-      // RootWindowHostLinux. Other platforms do not implement ShowCursor().
-      cursor_shown_(true),
       mouse_pressed_handler_(NULL),
       mouse_moved_handler_(NULL),
       mouse_event_dispatch_target_(NULL),
       event_dispatch_target_(NULL),
       focus_manager_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           gesture_recognizer_(ui::GestureRecognizer::Create(this))),
       synthesize_mouse_move_(false),
       waiting_on_compositing_end_(false),
       draw_on_compositing_end_(false),
@@ skipping 102 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::ShowCursor(bool show) {
+void RootWindow::OnCursorVisibilityChanged(bool show) {
   // Send entered / exited so that visual state can be updated to match
   // cursor state.
-  if (show != cursor_shown_) {
-    cursor_shown_ = show;
-    host_->ShowCursor(show);
-    Env::GetInstance()->SetCursorShown(show);
-    PostMouseMoveEventAfterWindowChange();
-  }
+  Env::GetInstance()->SetCursorShown(show);
+  PostMouseMoveEventAfterWindowChange();
 }
 
 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);
 }
 
 bool RootWindow::ConfineCursorToWindow() {
@@ skipping 252 matching lines @@
 void RootWindow::OnCompositingAborted(ui::Compositor*) {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindow, ui::LayerDelegate implementation:
 
 void RootWindow::OnDeviceScaleFactorChanged(
     float device_scale_factor) {
   const bool cursor_is_in_bounds =
       GetBoundsInScreen().Contains(Env::GetInstance()->last_mouse_location());
-  if (cursor_is_in_bounds && cursor_shown_)
-    ShowCursor(false);
+  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);
+  }
   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) {
-    client::CursorClient* cursor_client = client::GetCursorClient(this);
     if (cursor_client)
       cursor_client->SetDeviceScaleFactor(device_scale_factor);
   }
-  if (cursor_is_in_bounds && cursor_shown_)
-    ShowCursor(true);
+  if (cursor_is_in_bounds && cursor_client && cursor_visible)
+    cursor_client->ShowCursor(true);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindow, overridden from aura::Window:
 
 bool RootWindow::CanFocus() const {
   return IsVisible();
 }
 
 bool RootWindow::CanReceiveEvents() const {
@@ skipping 502 matching lines @@
 void RootWindow::UnlockCompositor() {
   DCHECK(compositor_lock_);
   compositor_lock_ = NULL;
   if (draw_on_compositor_unlock_) {
     draw_on_compositor_unlock_ = false;
     ScheduleDraw();
   }
 }
 
 }  // namespace aura