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

services/ui/ws/drag_controller.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 "base/logging.h"
+#include "services/ui/public/interfaces/cursor.mojom.h"
+#include "services/ui/ws/drag_cursor_updater.h"
 #include "services/ui/ws/drag_source.h"
 #include "services/ui/ws/drag_target_connection.h"
 #include "services/ui/ws/event_dispatcher.h"
 #include "services/ui/ws/server_window.h"
 
 namespace ui {
 namespace ws {
 
 struct DragController::Operation {
   OperationType type;
   uint32_t event_flags;
   gfx::Point screen_position;
 };
 
 struct DragController::WindowState {
   // Set to true once we've observed the ServerWindow* that is the key to this
   // instance in |window_state_|.
-  bool observed;
+  bool observed = false;
 
-  // If we're waiting for a response, this is the type of message. TYPE_NONE
-  // means there's no outstanding
-  OperationType waiting_on_reply;
+  // If we're waiting for a response, this is the type of message. NONE means
+  // there's no outstanding
+  OperationType waiting_on_reply = OperationType::NONE;
 
-  // The operation that we'll send off if |waiting_on_reply| isn't TYPE_NONE.
-  Operation queued_operation;
+  // The operation that we'll send off if |waiting_on_reply| isn't NONE.
+  Operation queued_operation = {OperationType::NONE, 0, gfx::Point()};
+
+  // The current set of operations that this window accepts. This gets updated
+  // on each return message.
+  uint32_t window_operations = 0u;

[sky, 2016/09/28 15:38:13]

Please be consistent in the naming. You have OnDragStatusCompleted which takes
uint32_t bitmask, UpdateCursor taking an effect_bitmask, and this which takes
window_operations. AFAICT these are all the same thing. Maybe a typedef (using)
for DropOperations would help clarify what this.

[Elliot Glaysher, 2016/09/28 18:15:31]

Created a DropEffect and DropEffectBitmask type in the header, changed every
uint32_t which dealt with either to the correct type, and standardized on
bitmask in all functions and here.

 };
 
 DragController::DragController(
+    DragCursorUpdater* cursor_updater,
     DragSource* source,
     ServerWindow* source_window,
     DragTargetConnection* source_connection,
     int32_t drag_pointer,
     mojo::Map<mojo::String, mojo::Array<uint8_t>> mime_data,
     uint32_t drag_operations)
     : source_(source),
+      cursor_updater_(cursor_updater),
       drag_operations_(drag_operations),
       drag_pointer_id_(drag_pointer),
+      current_cursor_(static_cast<int32_t>(ui::mojom::Cursor::NO_DROP)),
       source_window_(source_window),
       source_connection_(source_connection),
       mime_data_(std::move(mime_data)),
       weak_factory_(this) {
+  SetCurrentTargetWindow(nullptr);
   EnsureWindowObserved(source_window_);
 }
 
 DragController::~DragController() {
   for (auto& pair : window_state_) {
     if (pair.second.observed)
       pair.first->RemoveObserver(this);
   }
 }
 
@@ skipping 83 matching lines @@
   auto it = window_state_.find(window);
   if (it == window_state_.end())
     return 0u;
   if (it->second.waiting_on_reply == OperationType::NONE)
     return 0u;
   if (it->second.queued_operation.type == OperationType::NONE)
     return 1u;
   return 2u;
 }
 
+void DragController::UpdateCursor(ServerWindow* window,
+                                  uint32_t effect_bitmask) {
+  WindowState& state = window_state_[window];
+  state.window_operations = effect_bitmask;
+
+  if (current_target_window_ == window) {
+    current_cursor_ = CursorForWindowOperations(effect_bitmask);
+    cursor_updater_->OnDragCursorUpdated();
+  }
+}
+
+int32_t DragController::CursorForWindowOperations(uint32_t window_operations) {
+  uint32_t combined = window_operations & drag_operations_;
+  return combined == ui::mojom::kDropEffectNone
+             ? static_cast<int32_t>(ui::mojom::Cursor::NO_DROP)
+             : static_cast<int32_t>(ui::mojom::Cursor::COPY);

[sky, 2016/09/28 15:38:13]

No link?

[Elliot Glaysher, 2016/09/28 18:15:31]

No link. I went through all the cursors and the only NO_DROP and COPY are drag
cursors.

(For chromeos, this is theoretically a place where we could do better and add
cursors for link and move as operations. However, right now those don't exist.)

+}
+
 void DragController::SetCurrentTargetWindow(ServerWindow* current_target) {
   current_target_window_ = current_target;
+
+  if (current_target_window_) {
+    // Immediately set the cursor to the last known set of operations (which
+    // could be none).
+    WindowState& state = window_state_[current_target_window_];
+    current_cursor_ = CursorForWindowOperations(state.window_operations);
+  } else {
+    // Can't drop in empty areas.
+    current_cursor_ = static_cast<int32_t>(ui::mojom::Cursor::NO_DROP);
+  }
+
+  cursor_updater_->OnDragCursorUpdated();
 }
 
 void DragController::EnsureWindowObserved(ServerWindow* window) {
   if (!window)
     return;
 
   WindowState& state = window_state_[window];
   if (!state.observed) {
     state.observed = true;
     window->AddObserver(this);
@@ skipping 79 matching lines @@
 void DragController::OnDragStatusCompleted(const WindowId& id,
                                            uint32_t bitmask) {
   ServerWindow* window = source_->GetWindowById(id);
   if (!window) {
     // The window has been deleted and its queue is empty.
     return;
   }
 
   // We must remove the completed item.
   OnRespondToOperation(window);
-
-  // TODO(erg): |bitmask| is the allowed drag actions at the mouse location. We
-  // should use this data to change the cursor.
+  UpdateCursor(window, bitmask);
 }
 
 void DragController::OnDragDropCompleted(const WindowId& id, uint32_t action) {
   ServerWindow* window = source_->GetWindowById(id);
   if (!window) {
     // The window has been deleted after we sent the drop message. It's really
     // hard to recover from this so just signal to the source that our drag
     // failed.
     MessageDragCompleted(false, ui::mojom::kDropEffectNone);
     return;
   }
 
   OnRespondToOperation(window);
   MessageDragCompleted(action != 0u, action);
 }
 
 void DragController::OnWindowDestroying(ServerWindow* window) {
   auto it = window_state_.find(window);
   if (it != window_state_.end()) {
     window->RemoveObserver(this);
     window_state_.erase(it);
   }
 
   if (current_target_window_ == window)
-    current_target_window_ = nullptr;
+    SetCurrentTargetWindow(nullptr);
 
   if (source_window_ == window) {
     source_window_ = nullptr;
     // Our source window is being deleted, fail the drag.
     MessageDragCompleted(false, ui::mojom::kDropEffectNone);
   }
 }
 
 }  // namespace ws
 }  // namespace ui