mus drag and drop: return the completed effect to the caller.

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/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"
@@ skipping 161 matching lines @@
                                           window ? window->window() : nullptr);
   }
 
   void OnTestWindowDestroyed(DragTestWindow* test_window) {
     drag_operation_->OnWillDestroyDragTargetConnection(test_window);
     server_window_by_id_.erase(test_window->window()->id());
     connection_by_window_.erase(test_window->window());
   }
 
   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_;
   }
 
  private:
   // Overridden from testing::Test:
   void SetUp() override {
     testing::Test::SetUp();
 
     window_delegate_.reset(new TestServerWindowDelegate());
     root_window_.reset(
         new 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 DragControllerSource:
-  void OnDragCompleted(bool success) override {
+  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;
 
   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);
 
   DispatchDrag(window.get(), false, ui::EF_LEFT_MOUSE_BUTTON, gfx::Point(1, 1));
   EXPECT_EQ(QueuedType::ENTER, window->queue_response_type());
   window->Respond(true);
 
   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));
   EXPECT_TRUE(drag_completed_value().value_or(false));
 }
 
+TEST_F(DragControllerTest, FailsOnWindowSayingNo) {
+  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);
+
+  DispatchDrag(window.get(), false, ui::EF_LEFT_MOUSE_BUTTON, gfx::Point(1, 1));
+  EXPECT_EQ(QueuedType::ENTER, window->queue_response_type());
+  window->Respond(true);
+
+  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());
+
+  // Unlike SimpleDragDrop, respond with kDropEffectNone, which should make the
+  // drag fail.
+  window->Respond(false);
+
+  EXPECT_EQ(ui::mojom::kDropEffectNone,
+            drag_completed_action().value_or(ui::mojom::kDropEffectCopy));
+  EXPECT_FALSE(drag_completed_value().value_or(true));
+}
+
 TEST_F(DragControllerTest, OnlyDeliverMimeDataOnce) {
   std::unique_ptr<DragTestWindow> window1 = BuildWindow();
   std::unique_ptr<DragTestWindow> window2 = BuildWindow();
   mojo::Map<mojo::String, mojo::Array<uint8_t>> mime_data;
 
   // The client lib is responsible for sending the data to the window that's
   // the drag source to minimize IPC.
   EXPECT_EQ(0u, window1->times_received_drag_drop_start());
   StartDragOperation(std::move(mime_data), window1.get(),
                      ui::mojom::kDropEffectMove);
@@ skipping 297 matching lines @@
                           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.
 
 }  // namespace ws
 }  // namespace ui