aura-mus: wire up drag and drop.

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 <utility>
 
 #include "base/logging.h"
 #include "services/ui/public/interfaces/cursor.mojom.h"
@@ skipping 57 matching lines @@
   }
 }
 
 void DragController::Cancel() {
   MessageDragCompleted(false, ui::mojom::kDropEffectNone);
   // |this| may be deleted now.
 }
 
 bool DragController::DispatchPointerEvent(const ui::PointerEvent& event,
                                           ServerWindow* current_target) {
+  DVLOG(2) << "DragController dispatching pointer event at "
+           << event.location().ToString();
   uint32_t event_flags =
       event.flags() &
       (ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN);
   gfx::Point screen_position = event.location();
 
   if (waiting_for_final_drop_response_) {
     // If we're waiting on a target window to respond to the final drag drop
     // call, don't process any more pointer events.
+    DVLOG(1) << "Ignoring event because we're waiting for final drop response";
     return false;
   }
 
-  if (event.pointer_details().id != drag_pointer_id_)
+  if (event.pointer_details().id != drag_pointer_id_) {
+    DVLOG(1) << "Ignoring event from different pointer "
+             << event.pointer_details().id;
     return false;
+  }
 
   // If |current_target| doesn't accept drags, walk its hierarchy up until we
   // find one that does (or set to nullptr at the top of the tree).
   while (current_target && !current_target->can_accept_drops())
     current_target = current_target->parent();
 
   if (current_target) {
     // If we're non-null, we're about to use |current_target| in some
     // way. Ensure that we receive notifications that this window has gone
     // away.
@@ skipping 11 matching lines @@
     }
 
     if (current_target) {
       // TODO(erg): If we have a queued LEAVE operation, does this turn into a
       // noop?
       QueueOperation(current_target, OperationType::ENTER, event_flags,
                      screen_position);
     }
 
     SetCurrentTargetWindow(current_target);
+  } else if (event.type() != ET_POINTER_UP) {
+    DVLOG(1) << "Performing no action for pointer event at "
+             << screen_position.ToString()
+             << "! current_target=" << current_target;
   }
 
   if (event.type() == ET_POINTER_UP) {
     if (current_target) {
       QueueOperation(current_target, OperationType::DROP, event_flags,
                      screen_position);
       waiting_for_final_drop_response_ = true;
     } else {
       // The pointer was released over no window or a window that doesn't
       // accept drags.
       MessageDragCompleted(false, ui::mojom::kDropEffectNone);
     }
   }
 
   return true;
 }
 
 void DragController::OnWillDestroyDragTargetConnection(
     DragTargetConnection* connection) {
   called_on_drag_mime_types_.erase(connection);
 }
 
 void DragController::MessageDragCompleted(bool success,
                                           DropEffect action_taken) {
+  DVLOG(1) << "Drag Completed: success=" << success
+           << ", action_taken=" << action_taken;
   for (DragTargetConnection* connection : called_on_drag_mime_types_)
     connection->PerformOnDragDropDone();
   called_on_drag_mime_types_.clear();
 
   source_->OnDragCompleted(success, action_taken);
   // |this| may be deleted now.
 }
 
 size_t DragController::GetSizeOfQueueForWindow(ServerWindow* window) {
   auto it = window_state_.find(window);
@@ skipping 49 matching lines @@
   if (!state.observed) {
     state.observed = true;
     window->AddObserver(this);
   }
 }
 
 void DragController::QueueOperation(ServerWindow* window,
                                     OperationType type,
                                     uint32_t event_flags,
                                     const gfx::Point& screen_position) {
+  DVLOG(2) << "Queueing operation " << ToString(type) << " to " << window;
+
   // If this window doesn't have the mime data, send it.
   DragTargetConnection* connection = source_->GetDragTargetForWindow(window);
   if (connection != source_connection_ &&
       !base::ContainsKey(called_on_drag_mime_types_, connection)) {
     connection->PerformOnDragDropStart(mime_data_);
     called_on_drag_mime_types_.insert(connection);
   }
 
   WindowState& state = window_state_[window];
   // Set the queued operation to the incoming.
@@ skipping 97 matching lines @@
   if (current_target_window_ == window)
     SetCurrentTargetWindow(nullptr);
 
   if (source_window_ == window) {
     source_window_ = nullptr;
     // Our source window is being deleted, fail the drag.
     MessageDragCompleted(false, ui::mojom::kDropEffectNone);
   }
 }
 
+// static
+std::string DragController::ToString(OperationType type) {
+  switch (type) {
+    case OperationType::NONE:
+      return "NONE";
+    case OperationType::ENTER:
+      return "ENTER";
+    case OperationType::OVER:
+      return "OVER";
+    case OperationType::LEAVE:
+      return "LEAVE";
+    case OperationType::DROP:
+      return "DROP";
+  }
+  NOTREACHED();
+  return std::string();
+}
+
 }  // namespace ws
 }  // namespace ui