Cursor state should be global for all CursorManagers

ui/views/corewm/cursor_manager_unittest.cc

 // Copyright (c) 2013 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/views/corewm/cursor_manager.h"
 
 #include "ui/aura/client/cursor_client_observer.h"
 #include "ui/views/corewm/native_cursor_manager.h"
 #include "ui/views/test/views_test_base.h"
 
 namespace {
 
 class TestingCursorManager : public views::corewm::NativeCursorManager {
  public:
-  gfx::NativeCursor current_cursor() { return cursor_; }
-
   // Overridden from views::corewm::NativeCursorManager:
   virtual void SetDisplay(
       const gfx::Display& display,
       views::corewm::NativeCursorManagerDelegate* delegate) OVERRIDE {}
 
   virtual void SetCursor(
       gfx::NativeCursor cursor,
       views::corewm::NativeCursorManagerDelegate* delegate) OVERRIDE {
-    cursor_ = cursor;
     delegate->CommitCursor(cursor);
   }
 
   virtual void SetVisibility(
       bool visible,
       views::corewm::NativeCursorManagerDelegate* delegate) OVERRIDE {
     delegate->CommitVisibility(visible);
   }
 
   virtual void SetMouseEventsEnabled(
       bool enabled,
       views::corewm::NativeCursorManagerDelegate* delegate) OVERRIDE {
     delegate->CommitMouseEventsEnabled(enabled);
   }
 
   virtual void SetCursorSet(
       ui::CursorSetType cursor_set,
       views::corewm::NativeCursorManagerDelegate* delegate) OVERRIDE {
     delegate->CommitCursorSet(cursor_set);
   }
 
   virtual void SetScale(
       float scale,
       views::corewm::NativeCursorManagerDelegate* delegate) OVERRIDE {
     delegate->CommitScale(scale);
   }
-
- private:
-  gfx::NativeCursor cursor_;
 };
 
 }  // namespace
 
 class CursorManagerTest : public views::ViewsTestBase {
  protected:
   CursorManagerTest()
       : delegate_(new TestingCursorManager),
+        delegate_second_(new TestingCursorManager),
         cursor_manager_(scoped_ptr<views::corewm::NativeCursorManager>(
-            delegate_)) {
+            delegate_)),
+        cursor_manager_second_(scoped_ptr<views::corewm::NativeCursorManager>(
+            delegate_second_)) {
   }
 
-  gfx::NativeCursor current_cursor() { return delegate_->current_cursor(); }
-
   TestingCursorManager* delegate_;
+  TestingCursorManager* delegate_second_;
   views::corewm::CursorManager cursor_manager_;
+  views::corewm::CursorManager cursor_manager_second_;
 };
 
 class TestingCursorClientObserver : public aura::client::CursorClientObserver {
  public:
   TestingCursorClientObserver()
       : cursor_visibility_(false),
         did_visibility_change_(false) {}
   void reset() { cursor_visibility_ = did_visibility_change_ = false; }
   bool is_cursor_visible() const { return cursor_visibility_; }
   bool did_visibility_change() const { return did_visibility_change_; }
 
   // Overridden from aura::client::CursorClientObserver:
   virtual void OnCursorVisibilityChanged(bool is_visible) OVERRIDE {
     cursor_visibility_ = is_visible;
     did_visibility_change_ = true;
   }
 
  private:
   bool cursor_visibility_;
   bool did_visibility_change_;
 
   DISALLOW_COPY_AND_ASSIGN(TestingCursorClientObserver);
 };
 
 TEST_F(CursorManagerTest, ShowHideCursor) {
+  cursor_manager_.ResetState();
+
   cursor_manager_.SetCursor(ui::kCursorCopy);
-  EXPECT_EQ(ui::kCursorCopy, current_cursor().native_type());
+  EXPECT_EQ(ui::kCursorCopy, cursor_manager_.GetCursor().native_type());
 
   cursor_manager_.ShowCursor();
   EXPECT_TRUE(cursor_manager_.IsCursorVisible());
   cursor_manager_.HideCursor();
   EXPECT_FALSE(cursor_manager_.IsCursorVisible());
   // The current cursor does not change even when the cursor is not shown.
-  EXPECT_EQ(ui::kCursorCopy, current_cursor().native_type());
+  EXPECT_EQ(ui::kCursorCopy, cursor_manager_.GetCursor().native_type());
 
   // Check if cursor visibility is locked.
   cursor_manager_.LockCursor();
   EXPECT_FALSE(cursor_manager_.IsCursorVisible());
   cursor_manager_.ShowCursor();
   EXPECT_FALSE(cursor_manager_.IsCursorVisible());
   cursor_manager_.UnlockCursor();
   EXPECT_TRUE(cursor_manager_.IsCursorVisible());
 
   cursor_manager_.LockCursor();
@@ skipping 22 matching lines @@
 
   cursor_manager_.HideCursor();
   cursor_manager_.LockCursor();
   cursor_manager_.UnlockCursor();
   EXPECT_FALSE(cursor_manager_.IsCursorVisible());
 }
 
 // Verifies that LockCursor/UnlockCursor work correctly with
 // EnableMouseEvents and DisableMouseEvents
 TEST_F(CursorManagerTest, EnableDisableMouseEvents) {
+  cursor_manager_.ResetState();
+
   cursor_manager_.SetCursor(ui::kCursorCopy);
-  EXPECT_EQ(ui::kCursorCopy, current_cursor().native_type());
+  EXPECT_EQ(ui::kCursorCopy, cursor_manager_.GetCursor().native_type());
 
   cursor_manager_.EnableMouseEvents();
   EXPECT_TRUE(cursor_manager_.IsMouseEventsEnabled());
   cursor_manager_.DisableMouseEvents();
   EXPECT_FALSE(cursor_manager_.IsMouseEventsEnabled());
   // The current cursor does not change even when the cursor is not shown.
-  EXPECT_EQ(ui::kCursorCopy, current_cursor().native_type());
+  EXPECT_EQ(ui::kCursorCopy, cursor_manager_.GetCursor().native_type());
 
   // Check if cursor enable state is locked.
   cursor_manager_.LockCursor();
   EXPECT_FALSE(cursor_manager_.IsMouseEventsEnabled());
   cursor_manager_.EnableMouseEvents();
   EXPECT_FALSE(cursor_manager_.IsMouseEventsEnabled());
   cursor_manager_.UnlockCursor();
   EXPECT_TRUE(cursor_manager_.IsMouseEventsEnabled());
 
   cursor_manager_.LockCursor();
@@ skipping 20 matching lines @@
   cursor_manager_.UnlockCursor();
   EXPECT_TRUE(cursor_manager_.IsMouseEventsEnabled());
 
   cursor_manager_.DisableMouseEvents();
   cursor_manager_.LockCursor();
   cursor_manager_.UnlockCursor();
   EXPECT_FALSE(cursor_manager_.IsMouseEventsEnabled());
 }
 
 TEST_F(CursorManagerTest, SetCursorSet) {
-  EXPECT_EQ(ui::CURSOR_SET_NORMAL, cursor_manager_.GetCurrentCursorSet());
+  cursor_manager_.ResetState();
+
+  EXPECT_EQ(ui::CURSOR_SET_NORMAL, cursor_manager_.GetCursorSet());
 
   cursor_manager_.SetCursorSet(ui::CURSOR_SET_NORMAL);
-  EXPECT_EQ(ui::CURSOR_SET_NORMAL, cursor_manager_.GetCurrentCursorSet());
+  EXPECT_EQ(ui::CURSOR_SET_NORMAL, cursor_manager_.GetCursorSet());
 
   cursor_manager_.SetCursorSet(ui::CURSOR_SET_LARGE);
-  EXPECT_EQ(ui::CURSOR_SET_LARGE, cursor_manager_.GetCurrentCursorSet());
+  EXPECT_EQ(ui::CURSOR_SET_LARGE, cursor_manager_.GetCursorSet());
 
   cursor_manager_.SetCursorSet(ui::CURSOR_SET_NORMAL);
-  EXPECT_EQ(ui::CURSOR_SET_NORMAL, cursor_manager_.GetCurrentCursorSet());
+  EXPECT_EQ(ui::CURSOR_SET_NORMAL, cursor_manager_.GetCursorSet());
 }
 
 TEST_F(CursorManagerTest, SetScale) {
-  EXPECT_EQ(1.f, cursor_manager_.GetCurrentScale());
+  cursor_manager_.ResetState();
+
+  EXPECT_EQ(1.f, cursor_manager_.GetScale());
   cursor_manager_.SetScale(2.f);
-  EXPECT_EQ(2.f, cursor_manager_.GetCurrentScale());
+  EXPECT_EQ(2.f, cursor_manager_.GetScale());
 
   // Cusror scale does change even while cursor is locked.
   cursor_manager_.LockCursor();
-  EXPECT_EQ(2.f, cursor_manager_.GetCurrentScale());
+  EXPECT_EQ(2.f, cursor_manager_.GetScale());
   cursor_manager_.SetScale(2.5f);
-  EXPECT_EQ(2.5f, cursor_manager_.GetCurrentScale());
+  EXPECT_EQ(2.5f, cursor_manager_.GetScale());
   cursor_manager_.UnlockCursor();
 
-  EXPECT_EQ(2.5f, cursor_manager_.GetCurrentScale());
+  EXPECT_EQ(2.5f, cursor_manager_.GetScale());
   cursor_manager_.SetScale(1.f);
-  EXPECT_EQ(1.f, cursor_manager_.GetCurrentScale());
+  EXPECT_EQ(1.f, cursor_manager_.GetScale());
 }
 
 TEST_F(CursorManagerTest, IsMouseEventsEnabled) {
+  cursor_manager_.ResetState();
+
   cursor_manager_.EnableMouseEvents();
   EXPECT_TRUE(cursor_manager_.IsMouseEventsEnabled());
   cursor_manager_.DisableMouseEvents();
   EXPECT_FALSE(cursor_manager_.IsMouseEventsEnabled());
 }
 
 // Verifies that the mouse events enable state changes correctly when
 // ShowCursor/HideCursor and EnableMouseEvents/DisableMouseEvents are used
 // together.
 TEST_F(CursorManagerTest, ShowAndEnable) {
+  cursor_manager_.ResetState();
+
   // Changing the visibility of the cursor does not affect the enable state.
   cursor_manager_.EnableMouseEvents();
   cursor_manager_.ShowCursor();
   EXPECT_TRUE(cursor_manager_.IsCursorVisible());
   EXPECT_TRUE(cursor_manager_.IsMouseEventsEnabled());
   cursor_manager_.HideCursor();
   EXPECT_FALSE(cursor_manager_.IsCursorVisible());
   EXPECT_TRUE(cursor_manager_.IsMouseEventsEnabled());
   cursor_manager_.ShowCursor();
   EXPECT_TRUE(cursor_manager_.IsCursorVisible());
@@ skipping 35 matching lines @@
   EXPECT_FALSE(cursor_manager_.IsMouseEventsEnabled());
   cursor_manager_.DisableMouseEvents();
   EXPECT_FALSE(cursor_manager_.IsCursorVisible());
   EXPECT_FALSE(cursor_manager_.IsMouseEventsEnabled());
 }
 
 // Verifies that calling DisableMouseEvents multiple times in a row makes no
 // difference compared with calling it once.
 // This is a regression test for http://crbug.com/169404.
 TEST_F(CursorManagerTest, MultipleDisableMouseEvents) {
+  cursor_manager_.ResetState();
+
   cursor_manager_.DisableMouseEvents();
   cursor_manager_.DisableMouseEvents();
   cursor_manager_.EnableMouseEvents();
   cursor_manager_.LockCursor();
   cursor_manager_.UnlockCursor();
   EXPECT_TRUE(cursor_manager_.IsCursorVisible());
 }
 
 // Verifies that calling EnableMouseEvents multiple times in a row makes no
 // difference compared with calling it once.
 TEST_F(CursorManagerTest, MultipleEnableMouseEvents) {
+  cursor_manager_.ResetState();
+
   cursor_manager_.DisableMouseEvents();
   cursor_manager_.EnableMouseEvents();
   cursor_manager_.EnableMouseEvents();
   cursor_manager_.LockCursor();
   cursor_manager_.UnlockCursor();
   EXPECT_TRUE(cursor_manager_.IsCursorVisible());
 }
 
 TEST_F(CursorManagerTest, TestCursorClientObserver) {
+  cursor_manager_.ResetState();
+
   // Add two observers. Both should have OnCursorVisibilityChanged()
   // invoked when the visibility of the cursor changes.
   TestingCursorClientObserver observer_a;
   TestingCursorClientObserver observer_b;
   cursor_manager_.AddObserver(&observer_a);
   cursor_manager_.AddObserver(&observer_b);
 
   // Initial state before any events have been sent.
   observer_a.reset();
   observer_b.reset();
@@ skipping 31 matching lines @@
   EXPECT_FALSE(observer_a.is_cursor_visible());
 
   // Show the cursor using ShowCursor().
   observer_a.reset();
   observer_b.reset();
   cursor_manager_.ShowCursor();
   EXPECT_TRUE(observer_a.did_visibility_change());
   EXPECT_FALSE(observer_b.did_visibility_change());
   EXPECT_TRUE(observer_a.is_cursor_visible());
 }
+
+// Verifies that the cursor state is global among all CursorManager instances.
+TEST_F(CursorManagerTest, CursorManagerGlobalState) {
+  cursor_manager_.ResetState();
+  cursor_manager_second_.ResetState();
+
+  // Verify the cursor can be locked using one cursor manager and
+  // unlocked using another.
+  EXPECT_FALSE(cursor_manager_.IsCursorLocked());
+  EXPECT_FALSE(cursor_manager_second_.IsCursorLocked());
+
+  cursor_manager_.LockCursor();
+  EXPECT_TRUE(cursor_manager_.IsCursorLocked());
+  EXPECT_TRUE(cursor_manager_second_.IsCursorLocked());
+
+  cursor_manager_second_.UnlockCursor();
+  EXPECT_FALSE(cursor_manager_.IsCursorLocked());
+  EXPECT_FALSE(cursor_manager_second_.IsCursorLocked());
+
+  // Verify that mouse events can be disabled using one cursor manager
+  // and re-enabled using another.
+  EXPECT_TRUE(cursor_manager_.IsCursorVisible());
+  EXPECT_TRUE(cursor_manager_.IsMouseEventsEnabled());
+  EXPECT_TRUE(cursor_manager_second_.IsCursorVisible());
+  EXPECT_TRUE(cursor_manager_second_.IsMouseEventsEnabled());
+
+  cursor_manager_second_.DisableMouseEvents();
+  EXPECT_FALSE(cursor_manager_.IsCursorVisible());
+  EXPECT_FALSE(cursor_manager_.IsMouseEventsEnabled());
+  EXPECT_FALSE(cursor_manager_second_.IsCursorVisible());
+  EXPECT_FALSE(cursor_manager_second_.IsMouseEventsEnabled());
+
+  cursor_manager_.EnableMouseEvents();
+  EXPECT_TRUE(cursor_manager_.IsCursorVisible());
+  EXPECT_TRUE(cursor_manager_.IsMouseEventsEnabled());
+  EXPECT_TRUE(cursor_manager_second_.IsCursorVisible());
+  EXPECT_TRUE(cursor_manager_second_.IsMouseEventsEnabled());
+
+  // Verify that setting the cursor on one cursor manager will set
+  // it on another.
+  EXPECT_EQ(ui::kCursorNone, cursor_manager_.GetCursor().native_type());
+  EXPECT_EQ(ui::kCursorNone, cursor_manager_second_.GetCursor().native_type());
+
+  cursor_manager_.SetCursor(ui::kCursorPointer);
+  EXPECT_EQ(ui::kCursorPointer, cursor_manager_.GetCursor().native_type());
+  EXPECT_EQ(ui::kCursorPointer,
+      cursor_manager_second_.GetCursor().native_type());
+
+  // Verify that hiding the cursor using one cursor manager will
+  // also hide it on the other.
+  cursor_manager_second_.HideCursor();
+  EXPECT_FALSE(cursor_manager_.IsCursorVisible());
+  EXPECT_TRUE(cursor_manager_.IsMouseEventsEnabled());
+  EXPECT_FALSE(cursor_manager_second_.IsCursorVisible());
+  EXPECT_TRUE(cursor_manager_second_.IsMouseEventsEnabled());
+
+  // Verify that the visibility cannot be changed by one cursor
+  // manager if the cursor has been locked by another.
+  cursor_manager_second_.LockCursor();
+  cursor_manager_.ShowCursor();
+  EXPECT_FALSE(cursor_manager_.IsCursorVisible());
+  EXPECT_FALSE(cursor_manager_second_.IsCursorVisible());
+
+  // Verify the cursor is visible on unlock.
+  cursor_manager_.UnlockCursor();
+  EXPECT_TRUE(cursor_manager_.IsCursorVisible());
+  EXPECT_TRUE(cursor_manager_second_.IsCursorVisible());
+}