mus: Keep track of the drag cursor during DnD operations.

services/ui/ws/drag_controller_unittest.cc

 // Copyright 2016 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/drag_controller.h"
 
+#include "services/ui/public/interfaces/cursor.mojom.h"
 #include "services/ui/ws/drag_source.h"
 #include "services/ui/ws/drag_target_connection.h"
 #include "services/ui/ws/ids.h"
 #include "services/ui/ws/server_window.h"
 #include "services/ui/ws/test_server_window_delegate.h"
 #include "services/ui/ws/test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/base_event_utils.h"
 
 namespace ui {
@@ skipping 104 matching lines @@
  private:
   DragControllerTest* parent_;
   TestServerWindowDelegate window_delegate_;
   ServerWindow window_;
   mojo::Map<mojo::String, mojo::Array<uint8_t>> mime_data_;
   uint32_t times_received_drag_drop_start_ = 0;
 
   std::queue<DragEvent> queued_callbacks_;
 };
 
-class DragControllerTest : public testing::Test, public DragSource {
+class DragControllerTest : public testing::Test,
+                           public DragCursorUpdater,
+                           public DragSource {
  public:
   std::unique_ptr<DragTestWindow> BuildWindow() {
     WindowId id(1, ++window_id_);
     std::unique_ptr<DragTestWindow> p =
         base::MakeUnique<DragTestWindow>(this, id);
     server_window_by_id_[id] = p->window();
     connection_by_window_[p->window()] = p.get();
     return p;
   }
 
   void StartDragOperation(
       mojo::Map<mojo::String, mojo::Array<uint8_t>> mime_data,
       DragTestWindow* window,
       uint32_t drag_operations) {
     window->PerformOnDragDropStart(mime_data.Clone());
     drag_operation_ = base::MakeUnique<DragController>(
-        this, window->window(), window, PointerEvent::kMousePointerId,
+        this, this, window->window(), window, PointerEvent::kMousePointerId,
         std::move(mime_data), drag_operations);
+
+    // It would be nice if we could just let the observer method fire, but it
+    // fires during the constructor when we haven't assigned the unique_ptr
+    // yet.
+    cursor_ = ui::mojom::Cursor(drag_operation_->current_cursor());
   }
 
   void DispatchDrag(DragTestWindow* window,
                     bool mouse_released,
                     uint32_t flags,
                     const gfx::Point& position) {
     ui::PointerEvent event(
         ui::MouseEvent(mouse_released ? ET_MOUSE_RELEASED : ET_MOUSE_PRESSED,
                        position, position, ui::EventTimeForNow(), flags, 0));
     drag_operation_->DispatchPointerEvent(event,
@@ skipping 20 matching lines @@
 
   DragController* drag_operation() const { return drag_operation_.get(); }
 
   const base::Optional<uint32_t>& drag_completed_action() {
     return drag_completed_action_;
   }
   const base::Optional<bool>& drag_completed_value() {
     return drag_completed_value_;
   }
 
+  ui::mojom::Cursor cursor() { return cursor_; }
+
  private:
   // Overridden from testing::Test:
   void SetUp() override {
     testing::Test::SetUp();
 
     window_delegate_ = base::MakeUnique<TestServerWindowDelegate>();
     root_window_ =
         base::MakeUnique<ServerWindow>(window_delegate_.get(), WindowId(1, 2));
     window_delegate_->set_root_window(root_window_.get());
     root_window_->SetVisible(true);
   }
 
   void TearDown() override {
     drag_operation_.reset();
     root_window_.reset();
     window_delegate_.reset();
 
     DCHECK(server_window_by_id_.empty());
     DCHECK(connection_by_window_.empty());
 
     testing::Test::TearDown();
   }
 
+  // Overridden from DragCursorUpdater:
+  void OnDragCursorUpdated() override {
+    if (drag_operation_)
+      cursor_ = ui::mojom::Cursor(drag_operation_->current_cursor());
+  }
+
   // Overridden from DragControllerSource:
   void OnDragCompleted(bool success, uint32_t action_taken) override {
     drag_completed_action_ = action_taken;
     drag_completed_value_ = success;
   }
 
   ServerWindow* GetWindowById(const WindowId& id) override {
     auto it = server_window_by_id_.find(id);
     if (it == server_window_by_id_.end())
       return nullptr;
     return it->second;
   }
 
   DragTargetConnection* GetDragTargetForWindow(
       const ServerWindow* window) override {
     auto it = connection_by_window_.find(const_cast<ServerWindow*>(window));
     if (it == connection_by_window_.end())
       return nullptr;
     return it->second;
   }
 
   int window_id_ = 3;
 
+  ui::mojom::Cursor cursor_;
+
   std::map<WindowId, ServerWindow*> server_window_by_id_;
   std::map<ServerWindow*, DragTargetConnection*> connection_by_window_;
 
   std::unique_ptr<TestServerWindowDelegate> window_delegate_;
   std::unique_ptr<ServerWindow> root_window_;
 
   std::unique_ptr<DragController> drag_operation_;
 
   base::Optional<uint32_t> drag_completed_action_;
   base::Optional<bool> drag_completed_value_;
 };
 
 DragTestWindow::~DragTestWindow() {
   parent_->OnTestWindowDestroyed(this);
 }
 
 TEST_F(DragControllerTest, SimpleDragDrop) {
   std::unique_ptr<DragTestWindow> window = BuildWindow();
   mojo::Map<mojo::String, mojo::Array<uint8_t>> mime_data;
   StartDragOperation(std::move(mime_data), window.get(),
                      ui::mojom::kDropEffectMove);
 
+  EXPECT_EQ(ui::mojom::Cursor::NO_DROP, cursor());
+
   DispatchDrag(window.get(), false, ui::EF_LEFT_MOUSE_BUTTON, gfx::Point(1, 1));
   EXPECT_EQ(QueuedType::ENTER, window->queue_response_type());
   window->Respond(true);
 
+  // (Even though we're doing a move, the cursor name is COPY.)
+  EXPECT_EQ(ui::mojom::Cursor::COPY, cursor());
+
   DispatchDrag(window.get(), false, ui::EF_LEFT_MOUSE_BUTTON, gfx::Point(2, 2));
   EXPECT_EQ(QueuedType::OVER, window->queue_response_type());
   window->Respond(true);
 
   DispatchDrag(window.get(), true, 0, gfx::Point(2, 2));
   EXPECT_EQ(QueuedType::DROP, window->queue_response_type());
   window->Respond(true);
 
   EXPECT_EQ(ui::mojom::kDropEffectMove,
             drag_completed_action().value_or(ui::mojom::kDropEffectNone));
@@ skipping 243 matching lines @@
   window2.reset();
 
   // DragController doesn't know anything about the server window now.
   EXPECT_EQ(0u, api.GetSizeOfQueueForWindow(server_window));
   EXPECT_EQ(nullptr, api.GetCurrentTarget());
 
   // But a target window closing out from under us doesn't fail the drag.
   EXPECT_FALSE(drag_completed_value().has_value());
 }
 
+TEST_F(DragControllerTest, TargetWindowClosedResetsCursor) {
+  std::unique_ptr<DragTestWindow> window1 = BuildWindow();
+  std::unique_ptr<DragTestWindow> window2 = BuildWindow();
+  mojo::Map<mojo::String, mojo::Array<uint8_t>> mime_data;
+  StartDragOperation(std::move(mime_data), window1.get(),
+                     ui::mojom::kDropEffectMove);
+  EXPECT_EQ(ui::mojom::Cursor::NO_DROP, cursor());
+
+  // Send some events to |window|.
+  DispatchDrag(window2.get(), false, ui::EF_LEFT_MOUSE_BUTTON,
+               gfx::Point(1, 1));
+  EXPECT_EQ(QueuedType::ENTER, window2->queue_response_type());
+  window2->Respond(true);
+  DispatchDrag(window2.get(), false, ui::EF_LEFT_MOUSE_BUTTON,
+               gfx::Point(1, 1));
+  window2->Respond(true);
+  EXPECT_EQ(ui::mojom::Cursor::COPY, cursor());
+
+  // Force the destruction of |window.window|.
+  window2.reset();
+
+  // The cursor no loner indicates that it can drop on |window2|.
+  EXPECT_EQ(ui::mojom::Cursor::NO_DROP, cursor());
+}
+
 TEST_F(DragControllerTest, SourceWindowClosedWhileDrag) {
   std::unique_ptr<DragTestWindow> window1 = BuildWindow();
   std::unique_ptr<DragTestWindow> window2 = BuildWindow();
   mojo::Map<mojo::String, mojo::Array<uint8_t>> mime_data;
   StartDragOperation(std::move(mime_data), window1.get(),
                      ui::mojom::kDropEffectMove);
 
   test::DragControllerTestApi api(drag_operation());
 
-  // Send some events to |window|.
+  // Send some events to |windoww|.
   DispatchDrag(window2.get(), false, ui::EF_LEFT_MOUSE_BUTTON,
                gfx::Point(1, 1));
   EXPECT_EQ(QueuedType::ENTER, window2->queue_response_type());
   DispatchDrag(window2.get(), false, ui::EF_LEFT_MOUSE_BUTTON,
                gfx::Point(1, 1));
 
   ServerWindow* server_window = window2->window();
 
-  // Ensure that DragController is waiting for a response from |window|.
+  // Ensure that DragController is waiting for a response from |window2|.
   EXPECT_EQ(2u, api.GetSizeOfQueueForWindow(server_window));
   EXPECT_EQ(server_window, api.GetCurrentTarget());
 
   // Force the destruction of the source window.
   window1.reset();
 
   // The source window going away fails the drag.
   EXPECT_FALSE(drag_completed_value().value_or(true));
 }
 
@@ skipping 48 matching lines @@
   // This starts the operation with PointerEvent::kMousePointerId.
   StartDragOperation(std::move(mime_data), window.get(),
                      ui::mojom::kDropEffectMove);
 
   // Ignore events from pointer 5.
   DispatchDragWithPointer(window.get(), 5, false, ui::EF_LEFT_MOUSE_BUTTON,
                           gfx::Point(1, 1));
   ASSERT_EQ(0u, window->queue_size());
 }
 
-// TODO(erg): Add a test to ensure windows that the cursor isn't over
-// responding to messages don't change the cursor when we have cursor handling
-// code.
+TEST_F(DragControllerTest, RejectingWindowHasProperCursor) {
+  std::unique_ptr<DragTestWindow> window = BuildWindow();
+  mojo::Map<mojo::String, mojo::Array<uint8_t>> mime_data;
+  StartDragOperation(std::move(mime_data), window.get(),
+                     ui::mojom::kDropEffectMove);
+
+  EXPECT_EQ(ui::mojom::Cursor::NO_DROP, cursor());
+
+  DispatchDrag(window.get(), false, ui::EF_LEFT_MOUSE_BUTTON, gfx::Point(1, 1));
+  EXPECT_EQ(QueuedType::ENTER, window->queue_response_type());
+  window->Respond(true);
+
+  EXPECT_EQ(ui::mojom::Cursor::COPY, cursor());
+
+  DispatchDrag(window.get(), false, ui::EF_LEFT_MOUSE_BUTTON, gfx::Point(2, 2));
+  EXPECT_EQ(QueuedType::OVER, window->queue_response_type());
+
+  // At this point, we respond with no available drag actions at this pixel.
+  window->Respond(false);
+  EXPECT_EQ(ui::mojom::Cursor::NO_DROP, cursor());
+}
+
+TEST_F(DragControllerTest, ResopnseFromOtherWindowDoesntChangeCursor) {
+  std::unique_ptr<DragTestWindow> window1 = BuildWindow();
+  std::unique_ptr<DragTestWindow> window2 = BuildWindow();
+  mojo::Map<mojo::String, mojo::Array<uint8_t>> mime_data;
+  StartDragOperation(std::move(mime_data), window1.get(),
+                     ui::mojom::kDropEffectMove);
+
+  // Send some events to |window2|.
+  DispatchDrag(window2.get(), false, ui::EF_LEFT_MOUSE_BUTTON,
+               gfx::Point(1, 1));
+  EXPECT_EQ(QueuedType::ENTER, window2->queue_response_type());
+  DispatchDrag(window2.get(), false, ui::EF_LEFT_MOUSE_BUTTON,
+               gfx::Point(1, 1));
+
+  EXPECT_EQ(ui::mojom::Cursor::NO_DROP, cursor());
+
+  // Now enter |window1|, and respond.
+  DispatchDrag(window1.get(), false, ui::EF_LEFT_MOUSE_BUTTON,
+               gfx::Point(5, 5));
+  EXPECT_EQ(QueuedType::ENTER, window1->queue_response_type());
+  window1->Respond(true);
+
+  EXPECT_EQ(ui::mojom::Cursor::COPY, cursor());
+
+  // Window 2 responding negatively to its queued messages shouldn't change the
+  // cursor.
+  window2->Respond(false);
+
+  EXPECT_EQ(ui::mojom::Cursor::COPY, cursor());
+}
 
 }  // namespace ws
 }  // namespace ui