mus: Rename mojom::Cursor to mojom::CursorType.

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 111 matching lines @@
 
 }  // namespace
 
 // -----------------------------------------------------------------------------
 
 class WindowTreeTest : public testing::Test {
  public:
   WindowTreeTest() {}
   ~WindowTreeTest() override {}
 
-  ui::mojom::Cursor cursor_id() {
+  ui::mojom::CursorType cursor_id() {
     return window_event_targeting_helper_.cursor();
   }
   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() {
@@ skipping 325 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::Cursor::IBEAM);
+  window->parent()->SetPredefinedCursor(mojom::CursorType::IBEAM);
 
   // Because the cursor is over the window when SetCursor was called, we should
   // have immediately changed the cursor.
-  EXPECT_EQ(mojom::Cursor::IBEAM, cursor_id());
+  EXPECT_EQ(mojom::CursorType::IBEAM, cursor_id());
 }
 
 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::Cursor::IBEAM);
-  EXPECT_EQ(mojom::Cursor::POINTER, cursor_id());
+  window->parent()->SetPredefinedCursor(mojom::CursorType::IBEAM);
+  EXPECT_EQ(mojom::CursorType::POINTER, cursor_id());
 
   DispatchEventAndAckImmediately(CreateMouseMoveEvent(21, 22));
-  EXPECT_EQ(mojom::Cursor::IBEAM, cursor_id());
+  EXPECT_EQ(mojom::CursorType::IBEAM, cursor_id());
 }
 
 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::Cursor::IBEAM);
-  EXPECT_EQ(mojom::Cursor::POINTER, cursor_id());
+  window->SetPredefinedCursor(mojom::CursorType::IBEAM);
+  EXPECT_EQ(mojom::CursorType::POINTER, cursor_id());
 
   // With a touch event, we shouldn't update the cursor.
   DispatchEventAndAckImmediately(CreatePointerDownEvent(21, 22));
-  EXPECT_EQ(mojom::Cursor::POINTER, cursor_id());
+  EXPECT_EQ(mojom::CursorType::POINTER, cursor_id());
 }
 
 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::Cursor::IBEAM);
-  EXPECT_EQ(mojom::Cursor::POINTER, cursor_id());
+  window->parent()->SetPredefinedCursor(mojom::CursorType::IBEAM);
+  EXPECT_EQ(mojom::CursorType::POINTER, cursor_id());
 
   // Move the pointer to the inside of the window
   DispatchEventAndAckImmediately(CreateMouseMoveEvent(21, 22));
-  EXPECT_EQ(mojom::Cursor::IBEAM, cursor_id());
+  EXPECT_EQ(mojom::CursorType::IBEAM, cursor_id());
 
   // Start the drag.
   DispatchEventAndAckImmediately(CreateMouseDownEvent(21, 22));
-  EXPECT_EQ(mojom::Cursor::IBEAM, cursor_id());
+  EXPECT_EQ(mojom::CursorType::IBEAM, cursor_id());
 
   // Move the cursor (mouse is still down) outside the window.
   DispatchEventAndAckImmediately(CreateMouseMoveEvent(5, 5));
-  EXPECT_EQ(mojom::Cursor::IBEAM, cursor_id());
+  EXPECT_EQ(mojom::CursorType::IBEAM, cursor_id());
 
   // Release the cursor. We should now adapt the cursor of the window
   // underneath the pointer.
   DispatchEventAndAckImmediately(CreateMouseUpEvent(5, 5));
-  EXPECT_EQ(mojom::Cursor::POINTER, cursor_id());
+  EXPECT_EQ(mojom::CursorType::POINTER, cursor_id());
 }
 
 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::Cursor::IBEAM);
-  EXPECT_EQ(mojom::Cursor::POINTER, cursor_id());
+  window->parent()->SetPredefinedCursor(mojom::CursorType::IBEAM);
+  EXPECT_EQ(mojom::CursorType::POINTER, cursor_id());
 
   // 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::Cursor::IBEAM, cursor_id());
+  EXPECT_EQ(mojom::CursorType::IBEAM, cursor_id());
 
   // Contract the bounds again.
   window->SetBounds(gfx::Rect(20, 20, 20, 20));
-  EXPECT_EQ(mojom::Cursor::POINTER, cursor_id());
+  EXPECT_EQ(mojom::CursorType::POINTER, cursor_id());
 }
 
 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::Cursor::IBEAM);
-  embed_window2->SetPredefinedCursor(mojom::Cursor::CROSS);
+  embed_window1->SetPredefinedCursor(mojom::CursorType::IBEAM);
+  embed_window2->SetPredefinedCursor(mojom::CursorType::CROSS);
   DispatchEventAndAckImmediately(CreateMouseMoveEvent(5, 5));
   // Cursor should match that of top-most window, which is |embed_window2|.
-  EXPECT_EQ(mojom::Cursor::CROSS, cursor_id());
+  EXPECT_EQ(mojom::CursorType::CROSS, cursor_id());
   // Move |embed_window1| on top, cursor should now match it.
   embed_window1->parent()->StackChildAtTop(embed_window1);
-  EXPECT_EQ(mojom::Cursor::IBEAM, cursor_id());
+  EXPECT_EQ(mojom::CursorType::IBEAM, cursor_id());
 }
 
 // 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::Cursor::IBEAM);
-  embed_window2->SetPredefinedCursor(mojom::Cursor::CROSS);
-  embed_window1->parent()->SetPredefinedCursor(mojom::Cursor::COPY);
+  embed_window1->SetPredefinedCursor(mojom::CursorType::IBEAM);
+  embed_window2->SetPredefinedCursor(mojom::CursorType::CROSS);
+  embed_window1->parent()->SetPredefinedCursor(mojom::CursorType::COPY);
 
   // 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::Cursor::IBEAM, cursor_id());
+  EXPECT_EQ(mojom::CursorType::IBEAM, cursor_id());
 
   // Move mouse into |embed_window2|.
   DispatchEventAndAckImmediately(CreateMouseMoveEvent(25, 25));
-  EXPECT_EQ(mojom::Cursor::CROSS, cursor_id());
+  EXPECT_EQ(mojom::CursorType::CROSS, cursor_id());
 
   // Move mouse into area between, which should use cursor set on parent.
   DispatchEventAndAckImmediately(CreateMouseMoveEvent(15, 15));
-  EXPECT_EQ(mojom::Cursor::COPY, cursor_id());
+  EXPECT_EQ(mojom::CursorType::COPY, cursor_id());
 }
 
 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 858 matching lines @@
     client->tracker()->changes()->clear();
   }
 
   // Client should not have got any messages after shutdown.
   EXPECT_TRUE(client->tracker()->changes()->empty());
 }
 
 }  // namespace test
 }  // namespace ws
 }  // namespace ui