[views-mus] Support custom cursors.

services/ui/ws/window_tree_unittest.cc

 // Copyright 2014 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 "services/ui/ws/window_tree.h"
 
 #include <stdint.h>
 
 #include <string>
 #include <vector>
@@ skipping 13 matching lines @@
 #include "services/ui/ws/server_window.h"
 #include "services/ui/ws/test_change_tracker.h"
 #include "services/ui/ws/test_server_window_delegate.h"
 #include "services/ui/ws/test_utils.h"
 #include "services/ui/ws/window_manager_access_policy.h"
 #include "services/ui/ws/window_manager_display_root.h"
 #include "services/ui/ws/window_server.h"
 #include "services/ui/ws/window_server_delegate.h"
 #include "services/ui/ws/window_tree_binding.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "ui/base/cursor/cursor.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace ui {
 namespace ws {
 namespace test {
 namespace {
 
 const UserId kTestUserId1 = "2";
@@ skipping 78 matching lines @@
 
 }  // namespace
 
 // -----------------------------------------------------------------------------
 
 class WindowTreeTest : public testing::Test {
  public:
   WindowTreeTest() {}
   ~WindowTreeTest() override {}
 
-  ui::mojom::CursorType cursor_id() {
-    return window_event_targeting_helper_.cursor();
+  ui::CursorType cursor_type() {
+    return window_event_targeting_helper_.cursor_type();
   }
   Display* display() { return window_event_targeting_helper_.display(); }
   TestWindowTreeClient* last_window_tree_client() {
     return window_event_targeting_helper_.last_window_tree_client();
   }
   TestWindowTreeClient* wm_client() {
     return window_event_targeting_helper_.wm_client();
   }
   WindowServer* window_server() {
     return window_event_targeting_helper_.window_server();
@@ skipping 324 matching lines @@
   TestWindowTreeClient* embed_client = nullptr;
   WindowTree* tree = nullptr;
   ServerWindow* window = nullptr;
   EXPECT_NO_FATAL_FAILURE(SetupEventTargeting(&embed_client, &tree, &window));
 
   // Like in BasicInputEventTarget, we send a pointer down event to be
   // dispatched. This is only to place the mouse cursor over that window though.
   DispatchEventAndAckImmediately(CreateMouseMoveEvent(21, 22));
 
   // Set the cursor on the parent as that is where the cursor is picked up from.
-  window->parent()->SetPredefinedCursor(mojom::CursorType::kIBeam);
+  window->parent()->SetCursor(ui::CursorData(ui::CursorType::kIBeam));
 
   // Because the cursor is over the window when SetCursor was called, we should
   // have immediately changed the cursor.
-  EXPECT_EQ(mojom::CursorType::kIBeam, cursor_id());
+  EXPECT_EQ(ui::CursorType::kIBeam, cursor_type());
 }
 
 TEST_F(WindowTreeTest, CursorChangesWhenEnteringWindowWithDifferentCursor) {
   TestWindowTreeClient* embed_client = nullptr;
   WindowTree* tree = nullptr;
   ServerWindow* window = nullptr;
   EXPECT_NO_FATAL_FAILURE(SetupEventTargeting(&embed_client, &tree, &window));
 
   // Let's create a pointer event outside the window and then move the pointer
   // inside.
   DispatchEventAndAckImmediately(CreateMouseMoveEvent(5, 5));
   // Set the cursor on the parent as that is where the cursor is picked up from.
-  window->parent()->SetPredefinedCursor(mojom::CursorType::kIBeam);
-  EXPECT_EQ(mojom::CursorType::kPointer, cursor_id());
+  window->parent()->SetCursor(ui::CursorData(ui::CursorType::kIBeam));
+  EXPECT_EQ(ui::CursorType::kPointer, cursor_type());
 
   DispatchEventAndAckImmediately(CreateMouseMoveEvent(21, 22));
-  EXPECT_EQ(mojom::CursorType::kIBeam, cursor_id());
+  EXPECT_EQ(ui::CursorType::kIBeam, cursor_type());
 }
 
 TEST_F(WindowTreeTest, TouchesDontChangeCursor) {
   TestWindowTreeClient* embed_client = nullptr;
   WindowTree* tree = nullptr;
   ServerWindow* window = nullptr;
   EXPECT_NO_FATAL_FAILURE(SetupEventTargeting(&embed_client, &tree, &window));
 
   // Let's create a pointer event outside the window and then move the pointer
   // inside.
   DispatchEventAndAckImmediately(CreateMouseMoveEvent(5, 5));
-  window->SetPredefinedCursor(mojom::CursorType::kIBeam);
-  EXPECT_EQ(mojom::CursorType::kPointer, cursor_id());
+  window->SetCursor(ui::CursorData(ui::CursorType::kIBeam));
+  EXPECT_EQ(ui::CursorType::kPointer, cursor_type());
 
   // With a touch event, we shouldn't update the cursor.
   DispatchEventAndAckImmediately(CreatePointerDownEvent(21, 22));
-  EXPECT_EQ(mojom::CursorType::kPointer, cursor_id());
+  EXPECT_EQ(ui::CursorType::kPointer, cursor_type());
 }
 
 TEST_F(WindowTreeTest, DragOutsideWindow) {
   TestWindowTreeClient* embed_client = nullptr;
   WindowTree* tree = nullptr;
   ServerWindow* window = nullptr;
   EXPECT_NO_FATAL_FAILURE(SetupEventTargeting(&embed_client, &tree, &window));
 
   // Start with the cursor outside the window. Setting the cursor shouldn't
   // change the cursor.
   DispatchEventAndAckImmediately(CreateMouseMoveEvent(5, 5));
   // Set the cursor on the parent as that is where the cursor is picked up from.
-  window->parent()->SetPredefinedCursor(mojom::CursorType::kIBeam);
-  EXPECT_EQ(mojom::CursorType::kPointer, cursor_id());
+  window->parent()->SetCursor(ui::CursorData(ui::CursorType::kIBeam));
+  EXPECT_EQ(ui::CursorType::kPointer, cursor_type());
 
   // Move the pointer to the inside of the window
   DispatchEventAndAckImmediately(CreateMouseMoveEvent(21, 22));
-  EXPECT_EQ(mojom::CursorType::kIBeam, cursor_id());
+  EXPECT_EQ(ui::CursorType::kIBeam, cursor_type());
 
   // Start the drag.
   DispatchEventAndAckImmediately(CreateMouseDownEvent(21, 22));
-  EXPECT_EQ(mojom::CursorType::kIBeam, cursor_id());
+  EXPECT_EQ(ui::CursorType::kIBeam, cursor_type());
 
   // Move the cursor (mouse is still down) outside the window.
   DispatchEventAndAckImmediately(CreateMouseMoveEvent(5, 5));
-  EXPECT_EQ(mojom::CursorType::kIBeam, cursor_id());
+  EXPECT_EQ(ui::CursorType::kIBeam, cursor_type());
 
   // Release the cursor. We should now adapt the cursor of the window
   // underneath the pointer.
   DispatchEventAndAckImmediately(CreateMouseUpEvent(5, 5));
-  EXPECT_EQ(mojom::CursorType::kPointer, cursor_id());
+  EXPECT_EQ(ui::CursorType::kPointer, cursor_type());
 }
 
 TEST_F(WindowTreeTest, ChangingWindowBoundsChangesCursor) {
   TestWindowTreeClient* embed_client = nullptr;
   WindowTree* tree = nullptr;
   ServerWindow* window = nullptr;
   EXPECT_NO_FATAL_FAILURE(SetupEventTargeting(&embed_client, &tree, &window));
 
   // Put the cursor just outside the bounds of the window.
   DispatchEventAndAckImmediately(CreateMouseMoveEvent(41, 41));
   // Sets the cursor on the root as that is where the cursor is picked up from.
-  window->parent()->SetPredefinedCursor(mojom::CursorType::kIBeam);
-  EXPECT_EQ(mojom::CursorType::kPointer, cursor_id());
+  window->parent()->SetCursor(ui::CursorData(ui::CursorType::kIBeam));
+  EXPECT_EQ(ui::CursorType::kPointer, cursor_type());
 
   // Expand the bounds of the window so they now include where the cursor now
   // is.
   window->SetBounds(gfx::Rect(20, 20, 25, 25));
-  EXPECT_EQ(mojom::CursorType::kIBeam, cursor_id());
+  EXPECT_EQ(ui::CursorType::kIBeam, cursor_type());
 
   // Contract the bounds again.
   window->SetBounds(gfx::Rect(20, 20, 20, 20));
-  EXPECT_EQ(mojom::CursorType::kPointer, cursor_id());
+  EXPECT_EQ(ui::CursorType::kPointer, cursor_type());
 }
 
 TEST_F(WindowTreeTest, WindowReorderingChangesCursor) {
   // Setup two trees parented to the root with the same bounds.
   ServerWindow* embed_window1 =
       window_event_targeting_helper_.CreatePrimaryTree(
           gfx::Rect(0, 0, 200, 200), gfx::Rect(0, 0, 50, 50));
   ServerWindow* embed_window2 =
       window_event_targeting_helper_.CreatePrimaryTree(
           gfx::Rect(0, 0, 200, 200), gfx::Rect(0, 0, 50, 50));
 
   ASSERT_EQ(embed_window1->parent(), embed_window2->parent());
   embed_window1->set_event_targeting_policy(
       mojom::EventTargetingPolicy::TARGET_AND_DESCENDANTS);
   embed_window2->set_event_targeting_policy(
       mojom::EventTargetingPolicy::TARGET_AND_DESCENDANTS);
-  embed_window1->SetPredefinedCursor(mojom::CursorType::kIBeam);
-  embed_window2->SetPredefinedCursor(mojom::CursorType::kCross);
+  embed_window1->SetCursor(ui::CursorData(ui::CursorType::kIBeam));
+  embed_window2->SetCursor(ui::CursorData(ui::CursorType::kCross));
   DispatchEventAndAckImmediately(CreateMouseMoveEvent(5, 5));
   // Cursor should match that of top-most window, which is |embed_window2|.
-  EXPECT_EQ(mojom::CursorType::kCross, cursor_id());
+  EXPECT_EQ(ui::CursorType::kCross, cursor_type());
   // Move |embed_window1| on top, cursor should now match it.
   embed_window1->parent()->StackChildAtTop(embed_window1);
-  EXPECT_EQ(mojom::CursorType::kIBeam, cursor_id());
+  EXPECT_EQ(ui::CursorType::kIBeam, cursor_type());
 }
 
 // Assertions around moving cursor between trees with roots.
 TEST_F(WindowTreeTest, CursorMultipleTrees) {
   // Setup two trees parented to the root with the same bounds.
   ServerWindow* embed_window1 =
       window_event_targeting_helper_.CreatePrimaryTree(
           gfx::Rect(0, 0, 200, 200), gfx::Rect(0, 0, 10, 10));
   ServerWindow* embed_window2 =
       window_event_targeting_helper_.CreatePrimaryTree(
           gfx::Rect(0, 0, 200, 200), gfx::Rect(20, 20, 20, 20));
   embed_window1->set_event_targeting_policy(
       mojom::EventTargetingPolicy::TARGET_AND_DESCENDANTS);
   embed_window2->set_event_targeting_policy(
       mojom::EventTargetingPolicy::TARGET_AND_DESCENDANTS);
   embed_window2->parent()->set_event_targeting_policy(
       mojom::EventTargetingPolicy::TARGET_AND_DESCENDANTS);
-  embed_window1->SetPredefinedCursor(mojom::CursorType::kIBeam);
-  embed_window2->SetPredefinedCursor(mojom::CursorType::kCross);
-  embed_window1->parent()->SetPredefinedCursor(mojom::CursorType::kCopy);
+  embed_window1->SetCursor(ui::CursorData(ui::CursorType::kIBeam));
+  embed_window2->SetCursor(ui::CursorData(ui::CursorType::kCross));
+  embed_window1->parent()->SetCursor(ui::CursorData(ui::CursorType::kCopy));
 
   // Create a child of |embed_window1|.
   ServerWindow* embed_window1_child = NewWindowInTreeWithParent(
       window_server()->GetTreeWithRoot(embed_window1), embed_window1);
   ASSERT_TRUE(embed_window1_child);
   embed_window1_child->SetBounds(gfx::Rect(0, 0, 10, 10));
   embed_window1_child->SetVisible(true);
 
   // Move mouse into |embed_window1|.
   DispatchEventAndAckImmediately(CreateMouseMoveEvent(5, 5));
-  EXPECT_EQ(mojom::CursorType::kIBeam, cursor_id());
+  EXPECT_EQ(ui::CursorType::kIBeam, cursor_type());
 
   // Move mouse into |embed_window2|.
   DispatchEventAndAckImmediately(CreateMouseMoveEvent(25, 25));
-  EXPECT_EQ(mojom::CursorType::kCross, cursor_id());
+  EXPECT_EQ(ui::CursorType::kCross, cursor_type());
 
   // Move mouse into area between, which should use cursor set on parent.
   DispatchEventAndAckImmediately(CreateMouseMoveEvent(15, 15));
-  EXPECT_EQ(mojom::CursorType::kCopy, cursor_id());
+  EXPECT_EQ(ui::CursorType::kCopy, cursor_type());
 }
 
 TEST_F(WindowTreeTest, EventAck) {
   const ClientWindowId embed_window_id = BuildClientWindowId(wm_tree(), 1);
   EXPECT_TRUE(
       wm_tree()->NewWindow(embed_window_id, ServerWindow::Properties()));
   EXPECT_TRUE(wm_tree()->SetWindowVisibility(embed_window_id, true));
   ASSERT_TRUE(FirstRoot(wm_tree()));
   EXPECT_TRUE(wm_tree()->AddWindow(FirstRootId(wm_tree()), embed_window_id));
   ASSERT_EQ(1u, display()->root_window()->children().size());
@@ skipping 936 matching lines @@
   EXPECT_TRUE(window_manager_tree->DeleteWindow(display_root_id));
   EXPECT_TRUE(window_manager_tree->roots().empty());
   EXPECT_TRUE(WindowManagerStateTestApi(window_manager_state)
                   .window_manager_display_roots()
                   .empty());
 }
 
 }  // namespace test
 }  // namespace ws
 }  // namespace ui