mus: Let clients set the cursor of their window.

components/mus/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 <string>
 #include <vector>
 
 #include "base/message_loop/message_loop.h"
 #include "components/mus/common/types.h"
 #include "components/mus/common/util.h"
@@ skipping 106 matching lines @@
     tracker_.OnWindowSharedPropertyChanged(window, name, new_data.Pass());
   }
   void OnWindowInputEvent(uint32_t event_id,
                           uint32_t window,
                           EventPtr event) override {
     tracker_.OnWindowInputEvent(window, event.Pass());
   }
   void OnWindowFocused(uint32_t focused_window_id) override {
     tracker_.OnWindowFocused(focused_window_id);
   }
+  void OnWindowPredefinedCursorChanged(uint32 window_id,
+                                       mojom::Cursor cursor_id) override {
+    tracker_.OnWindowPredefinedCursorChanged(window_id, cursor_id);
+  }
   void OnChangeCompleted(uint32_t change_id, bool success) override {}
   void WmSetBounds(uint32_t change_id,
                    Id window_id,
                    mojo::RectPtr bounds) override {}
   void WmSetProperty(uint32_t change_id,
                      Id window_id,
                      const mojo::String& name,
                      mojo::Array<uint8_t> transit_data) override {}
 
   TestChangeTracker tracker_;
@@ skipping 76 matching lines @@
         mus::mojom::WindowTree::ACCESS_POLICY_EMBED_ROOT,
         mus::mojom::WindowTreeClientPtr()));
   }
   DISALLOW_COPY_AND_ASSIGN(TestWindowTreeHostConnection);
 };
 
 // -----------------------------------------------------------------------------
 // Empty implementation of DisplayManager.
 class TestDisplayManager : public DisplayManager {
  public:
-  TestDisplayManager() {}
+  explicit TestDisplayManager(int32_t* cursor_id_storage)
+      : cursor_id_storage_(cursor_id_storage) {}
   ~TestDisplayManager() override {}
 
   // DisplayManager:
   void Init(DisplayManagerDelegate* delegate) override {
     // It is necessary to tell the delegate about the ViewportMetrics to make
     // sure that the WindowTreeHostConnection is correctly initialized (and a
     // root-window is created).
     mojom::ViewportMetrics metrics;
     metrics.size_in_pixels = mojo::Size::From(gfx::Size(400, 300));
     metrics.device_pixel_ratio = 1.f;
     delegate->OnViewportMetricsChanged(mojom::ViewportMetrics(), metrics);
   }
   void SchedulePaint(const ServerWindow* window,
                      const gfx::Rect& bounds) override {}
   void SetViewportSize(const gfx::Size& size) override {}
   void SetTitle(const base::string16& title) override {}
+  void SetCursorById(int32_t cursor) override { *cursor_id_storage_ = cursor; }
   const mojom::ViewportMetrics& GetViewportMetrics() override {
     return display_metrices_;
   }
   void UpdateTextInputState(const ui::TextInputState& state) override {}
   void SetImeVisibility(bool visible) override {}
   bool IsFramePending() const override { return false; }
 
  private:
   mojom::ViewportMetrics display_metrices_;
 
+  int32_t* cursor_id_storage_;
+
   DISALLOW_COPY_AND_ASSIGN(TestDisplayManager);
 };
 
 // Factory that dispenses TestDisplayManagers.
 class TestDisplayManagerFactory : public DisplayManagerFactory {
  public:
-  TestDisplayManagerFactory() {}
+  explicit TestDisplayManagerFactory(int32_t* cursor_id_storage)
+      : cursor_id_storage_(cursor_id_storage) {}
   ~TestDisplayManagerFactory() {}
   DisplayManager* CreateDisplayManager(
       mojo::ApplicationImpl* app_impl,
       const scoped_refptr<GpuState>& gpu_state,
       const scoped_refptr<mus::SurfacesState>& surfaces_state) override {
-    return new TestDisplayManager();
+    return new TestDisplayManager(cursor_id_storage_);
   }
 
  private:
+  int32_t* cursor_id_storage_;
+
   DISALLOW_COPY_AND_ASSIGN(TestDisplayManagerFactory);
 };
 
 EventPtr CreatePointerDownEvent(int x, int y) {
   EventPtr event(Event::New());
   event->action = mus::mojom::EVENT_TYPE_POINTER_DOWN;
   event->pointer_data = PointerData::New();
   event->pointer_data->pointer_id = 1u;
   event->pointer_data->location = LocationData::New();
   event->pointer_data->location->x = x;
@@ skipping 19 matching lines @@
   event->action = mus::mojom::EVENT_TYPE_POINTER_MOVE;
   event->pointer_data = PointerData::New();
   event->pointer_data->pointer_id = std::numeric_limits<uint32_t>::max();
   event->pointer_data->location = LocationData::New();
   event->pointer_data->location->x = x;
   event->pointer_data->location->y = y;
   event->pointer_data->kind = mojom::POINTER_KIND_MOUSE;
   return event.Pass();
 }
 
+EventPtr CreateMouseDownEvent(int x, int y) {
+  EventPtr event = CreatePointerDownEvent(x, y);
+  event->pointer_data->kind = mojom::POINTER_KIND_MOUSE;
+  return event.Pass();
+}
+
+EventPtr CreateMouseUpEvent(int x, int y) {
+  EventPtr event = CreatePointerUpEvent(x, y);
+  event->pointer_data->kind = mojom::POINTER_KIND_MOUSE;
+  return event.Pass();
+}
+
 }  // namespace
 
 // -----------------------------------------------------------------------------
 
 class WindowTreeTest : public testing::Test {
  public:
-  WindowTreeTest() : wm_client_(nullptr) {}
+  WindowTreeTest()
+      : wm_client_(nullptr),
+        cursor_id_(0),
+        display_manager_factory_(&cursor_id_) {}
   ~WindowTreeTest() override {}
 
   // WindowTreeImpl for the window manager.
   WindowTreeImpl* wm_connection() {
     return connection_manager_->GetConnection(1);
   }
 
   TestWindowTreeClient* last_window_tree_client() {
     return delegate_.last_client();
   }
 
   TestClientConnection* last_client_connection() {
     return delegate_.last_connection();
   }
 
   ConnectionManager* connection_manager() { return connection_manager_.get(); }
 
   TestWindowTreeClient* wm_client() { return wm_client_; }
+  int32_t cursor_id() { return cursor_id_; }
 
   TestWindowTreeHostConnection* host_connection() { return host_connection_; }
 
   void DispatchEventWithoutAck(mojom::EventPtr event) {
     host_connection()->window_tree_host()->OnEvent(event.Pass());
   }
 
   void AckPreviousEvent() {
     host_connection()
         ->window_tree_host()
         ->tree_awaiting_input_ack_->OnWindowInputEventAck(0);
   }
 
   void DispatchEventAndAckImmediately(mojom::EventPtr event) {
     DispatchEventWithoutAck(event.Pass());
     AckPreviousEvent();
   }
 
+  // Embeds a child window to the root window. Shared setup between several of
+  // the unit tests.
+  void SetupEventTargeting(TestWindowTreeClient** out_client,
+                           ServerWindow** out_window);
+
  protected:
   // testing::Test:
   void SetUp() override {
     DisplayManager::set_factory_for_testing(&display_manager_factory_);
     // TODO(fsamuel): This is probably broken. We need a root.
     connection_manager_.reset(
         new ConnectionManager(&delegate_, scoped_refptr<SurfacesState>()));
     WindowTreeHostImpl* host = new WindowTreeHostImpl(
         mus::mojom::WindowTreeHostClientPtr(), connection_manager_.get(),
         nullptr, scoped_refptr<GpuState>(), scoped_refptr<mus::SurfacesState>(),
         nullptr);
     // TODO(fsamuel): This is way too magical. We need to find a better way to
     // manage lifetime.
     host_connection_ = new TestWindowTreeHostConnection(
         make_scoped_ptr(host), connection_manager_.get());
     host->Init(host_connection_);
     wm_client_ = delegate_.last_client();
   }
 
  private:
   // TestWindowTreeClient that is used for the WM connection.
   TestWindowTreeClient* wm_client_;
+  int32_t cursor_id_;
   TestDisplayManagerFactory display_manager_factory_;
   TestConnectionManagerDelegate delegate_;
   TestWindowTreeHostConnection* host_connection_;
   scoped_ptr<ConnectionManager> connection_manager_;
   base::MessageLoop message_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowTreeTest);
 };
 
+void WindowTreeTest::SetupEventTargeting(TestWindowTreeClient** out_client,
+                                         ServerWindow** out_window) {
+  const WindowId embed_window_id(wm_connection()->id(), 1);
+  EXPECT_TRUE(
+      wm_connection()->NewWindow(embed_window_id, ServerWindow::Properties()));
+  EXPECT_TRUE(wm_connection()->SetWindowVisibility(embed_window_id, true));
+  EXPECT_TRUE(
+      wm_connection()->AddWindow(*(wm_connection()->root()), embed_window_id));
+  host_connection()->window_tree_host()->root_window()->SetBounds(
+      gfx::Rect(0, 0, 100, 100));
+  mojom::WindowTreeClientPtr client;
+  mojo::InterfaceRequest<mojom::WindowTreeClient> client_request =
+      GetProxy(&client);
+  wm_client()->Bind(client_request.Pass());
+  ConnectionSpecificId connection_id = 0;
+  wm_connection()->Embed(embed_window_id, client.Pass(),
+                         mojom::WindowTree::ACCESS_POLICY_DEFAULT,
+                         &connection_id);
+  WindowTreeImpl* connection1 =
+      connection_manager()->GetConnectionWithRoot(embed_window_id);
+  ASSERT_TRUE(connection1 != nullptr);
+  ASSERT_NE(connection1, wm_connection());
+
+  connection_manager()
+      ->GetWindow(embed_window_id)
+      ->SetBounds(gfx::Rect(0, 0, 50, 50));
+
+  const WindowId child1(connection1->id(), 1);
+  EXPECT_TRUE(connection1->NewWindow(child1, ServerWindow::Properties()));
+  EXPECT_TRUE(connection1->AddWindow(embed_window_id, child1));
+  connection1->GetHost()->AddActivationParent(
+      WindowIdToTransportId(embed_window_id));
+
+  ServerWindow* v1 = connection1->GetWindow(child1);
+  v1->SetVisible(true);
+  v1->SetBounds(gfx::Rect(20, 20, 20, 20));
+  EnableHitTest(v1);
+
+  TestWindowTreeClient* embed_connection = last_window_tree_client();
+  embed_connection->tracker()->changes()->clear();
+  wm_client()->tracker()->changes()->clear();
+
+  *out_client = embed_connection;
+  *out_window = v1;
+}
+
 // Verifies focus correctly changes on pointer events.
 TEST_F(WindowTreeTest, FocusOnPointer) {
   const WindowId embed_window_id(wm_connection()->id(), 1);
   EXPECT_TRUE(
       wm_connection()->NewWindow(embed_window_id, ServerWindow::Properties()));
   EXPECT_TRUE(wm_connection()->SetWindowVisibility(embed_window_id, true));
   EXPECT_TRUE(
       wm_connection()->AddWindow(*(wm_connection()->root()), embed_window_id));
   host_connection()->window_tree_host()->root_window()->SetBounds(
       gfx::Rect(0, 0, 100, 100));
@@ skipping 68 matching lines @@
   DispatchEventAndAckImmediately(CreatePointerDownEvent(61, 22));
   EXPECT_EQ(v1, host_connection()->window_tree_host()->GetFocusedWindow());
   ASSERT_EQ(wm_client()->tracker()->changes()->size(), 1u)
       << SingleChangeToDescription(*wm_client()->tracker()->changes());
   EXPECT_EQ("InputEvent window=0,2 event_action=4",
             ChangesToDescription1(*wm_client()->tracker()->changes())[0]);
   EXPECT_TRUE(connection1_client->tracker()->changes()->empty());
 }
 
 TEST_F(WindowTreeTest, BasicInputEventTarget) {
-  const WindowId embed_window_id(wm_connection()->id(), 1);
-  EXPECT_TRUE(
-      wm_connection()->NewWindow(embed_window_id, ServerWindow::Properties()));
-  EXPECT_TRUE(wm_connection()->SetWindowVisibility(embed_window_id, true));
-  EXPECT_TRUE(
-      wm_connection()->AddWindow(*(wm_connection()->root()), embed_window_id));
-  host_connection()->window_tree_host()->root_window()->SetBounds(
-      gfx::Rect(0, 0, 100, 100));
-  mojom::WindowTreeClientPtr client;
-  mojo::InterfaceRequest<mojom::WindowTreeClient> client_request =
-      GetProxy(&client);
-  wm_client()->Bind(client_request.Pass());
-  ConnectionSpecificId connection_id = 0;
-  wm_connection()->Embed(embed_window_id,
-                         client.Pass(),
-                         mojom::WindowTree::ACCESS_POLICY_DEFAULT,
-                         &connection_id);
-  WindowTreeImpl* connection1 =
-      connection_manager()->GetConnectionWithRoot(embed_window_id);
-  ASSERT_TRUE(connection1 != nullptr);
-  ASSERT_NE(connection1, wm_connection());
-
-  connection_manager()
-      ->GetWindow(embed_window_id)
-      ->SetBounds(gfx::Rect(0, 0, 50, 50));
-
-  const WindowId child1(connection1->id(), 1);
-  EXPECT_TRUE(connection1->NewWindow(child1, ServerWindow::Properties()));
-  EXPECT_TRUE(connection1->AddWindow(embed_window_id, child1));
-  connection1->GetHost()->AddActivationParent(
-      WindowIdToTransportId(embed_window_id));
-
-  ServerWindow* v1 = connection1->GetWindow(child1);
-  v1->SetVisible(true);
-  v1->SetBounds(gfx::Rect(20, 20, 20, 20));
-  EnableHitTest(v1);
-
-  TestWindowTreeClient* embed_connection = last_window_tree_client();
-  embed_connection->tracker()->changes()->clear();
-  wm_client()->tracker()->changes()->clear();
+  TestWindowTreeClient* embed_connection = nullptr;
+  ServerWindow* out_window = nullptr;
+  EXPECT_NO_FATAL_FAILURE(SetupEventTargeting(&embed_connection, &out_window));
 
   // Send an event to |v1|. |embed_connection| should get the event, not
   // |wm_client|, since |v1| lives inside an embedded window.
   DispatchEventAndAckImmediately(CreatePointerDownEvent(21, 22));
   ASSERT_EQ(1u, wm_client()->tracker()->changes()->size());
   EXPECT_EQ("Focused id=2,1",
             ChangesToDescription1(*wm_client()->tracker()->changes())[0]);
   ASSERT_EQ(2u, embed_connection->tracker()->changes()->size());
   EXPECT_EQ("Focused id=2,1",
             ChangesToDescription1(*embed_connection->tracker()->changes())[0]);
   EXPECT_EQ("InputEvent window=2,1 event_action=4",
             ChangesToDescription1(*embed_connection->tracker()->changes())[1]);
 }
 
+TEST_F(WindowTreeTest, CursorChangesWhenMouseOverWindowAndWindowSetsCursor) {
+  TestWindowTreeClient* embed_connection = nullptr;
+  ServerWindow* out_window = nullptr;
+  EXPECT_NO_FATAL_FAILURE(SetupEventTargeting(&embed_connection, &out_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));
+
+  out_window->SetPredefinedCursor(mojom::Cursor::CURSOR_IBEAM);
+
+  // Because the cursor is over the window when SetCursor was called, we should
+  // have immediately changed the cursor.
+  EXPECT_EQ(mojom::Cursor::CURSOR_IBEAM, cursor_id());
+}
+
+TEST_F(WindowTreeTest, CursorChangesWhenEnteringWindowWithDifferentCursor) {
+  TestWindowTreeClient* embed_connection = nullptr;
+  ServerWindow* out_window = nullptr;
+  EXPECT_NO_FATAL_FAILURE(SetupEventTargeting(&embed_connection, &out_window));
+
+  // Let's create a pointer event outside the window and then move the pointer
+  // inside.
+  DispatchEventAndAckImmediately(CreateMouseMoveEvent(5, 5));
+  out_window->SetPredefinedCursor(mojom::Cursor::CURSOR_IBEAM);
+  EXPECT_EQ(mojom::Cursor::CURSOR_NULL, cursor_id());
+
+  DispatchEventAndAckImmediately(CreateMouseMoveEvent(21, 22));
+  EXPECT_EQ(mojom::Cursor::CURSOR_IBEAM, cursor_id());
+}
+
+TEST_F(WindowTreeTest, TouchesDontChangeCursor) {
+  TestWindowTreeClient* embed_connection = nullptr;
+  ServerWindow* out_window = nullptr;
+  EXPECT_NO_FATAL_FAILURE(SetupEventTargeting(&embed_connection, &out_window));
+
+  // Let's create a pointer event outside the window and then move the pointer
+  // inside.
+  DispatchEventAndAckImmediately(CreateMouseMoveEvent(5, 5));
+  out_window->SetPredefinedCursor(mojom::Cursor::CURSOR_IBEAM);
+  EXPECT_EQ(mojom::Cursor::CURSOR_NULL, cursor_id());
+
+  // With a touch event, we shouldn't update the cursor.
+  DispatchEventAndAckImmediately(CreatePointerDownEvent(21, 22));
+  EXPECT_EQ(mojom::Cursor::CURSOR_NULL, cursor_id());
+}
+
+TEST_F(WindowTreeTest, DragOutsideWindow) {
+  TestWindowTreeClient* embed_connection = nullptr;
+  ServerWindow* out_window = nullptr;
+  EXPECT_NO_FATAL_FAILURE(SetupEventTargeting(&embed_connection, &out_window));
+
+  // Start with the cursor outside the window. Setting the cursor shouldn't
+  // change the cursor.
+  DispatchEventAndAckImmediately(CreateMouseMoveEvent(5, 5));
+  out_window->SetPredefinedCursor(mojom::Cursor::CURSOR_IBEAM);
+  EXPECT_EQ(mojom::Cursor::CURSOR_NULL, cursor_id());
+
+  // Move the pointer to the inside of the window
+  DispatchEventAndAckImmediately(CreateMouseMoveEvent(21, 22));
+  EXPECT_EQ(mojom::Cursor::CURSOR_IBEAM, cursor_id());
+
+  // Start the drag.
+  DispatchEventAndAckImmediately(CreateMouseDownEvent(21, 22));
+  EXPECT_EQ(mojom::Cursor::CURSOR_IBEAM, cursor_id());
+
+  // Move the cursor (mouse is still down) outside the window.
+  DispatchEventAndAckImmediately(CreateMouseMoveEvent(5, 5));
+  EXPECT_EQ(mojom::Cursor::CURSOR_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::CURSOR_NULL, cursor_id());
+}
+
 TEST_F(WindowTreeTest, EventAck) {
   const WindowId embed_window_id(wm_connection()->id(), 1);
   EXPECT_TRUE(
       wm_connection()->NewWindow(embed_window_id, ServerWindow::Properties()));
   EXPECT_TRUE(wm_connection()->SetWindowVisibility(embed_window_id, true));
   EXPECT_TRUE(
       wm_connection()->AddWindow(*(wm_connection()->root()), embed_window_id));
   host_connection()->window_tree_host()->root_window()->SetBounds(
       gfx::Rect(0, 0, 100, 100));
 
@@ skipping 11 matching lines @@
   // Ack the first event. That should trigger the dispatch of the second event.
   AckPreviousEvent();
   ASSERT_EQ(1u, wm_client()->tracker()->changes()->size());
   EXPECT_EQ("InputEvent window=0,2 event_action=5",
             ChangesToDescription1(*wm_client()->tracker()->changes())[0]);
 }
 
 }  // namespace ws
 
 }  // namespace mus