mus: Implement interwindow drag and drop

services/ui/ws/event_dispatcher.cc

 // Copyright 2015 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/event_dispatcher.h"
 
 #include <algorithm>
 
 #include "base/time/time.h"
 #include "services/ui/ws/accelerator.h"
+#include "services/ui/ws/current_drag_operation.h"
+#include "services/ui/ws/current_drag_operation_source.h"
 #include "services/ui/ws/display.h"
 #include "services/ui/ws/event_dispatcher_delegate.h"
 #include "services/ui/ws/server_window.h"
 #include "services/ui/ws/server_window_delegate.h"
 #include "services/ui/ws/window_coordinate_conversions.h"
 #include "services/ui/ws/window_finder.h"
 #include "ui/events/event_utils.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/point_conversions.h"
 
@@ skipping 151 matching lines @@
       delegate_->SetNativeCapture(window);
   } else {
     delegate_->ReleaseNativeCapture();
     if (!mouse_button_down_)
       UpdateCursorProviderByLastKnownLocation();
   }
 
   return true;
 }
 
+void EventDispatcher::SetDragDropSourceWindow(
+    CurrentDragOperationSource* drag_source,
+    ServerWindow* window,
+    mojo::Map<mojo::String, mojo::Array<uint8_t>> mime_data,
+    uint32_t drag_operations) {
+  current_drag_drop_operation_.reset(new CurrentDragOperation(

[sky, 2016/09/06 21:11:27]

MakeUnique is the new hotness.

Should this implicitly change capture? What do we do in the aura side now?

[Elliot Glaysher, 2016/09/07 21:42:23]

The normal ash drag controller implicitly takes capture on the beginning of a
drag.

[sky, 2016/09/07 23:25:29]

Relying on ash to have done before calling this is error prone and racy. If we
need to ensure capture is set we should either fail if capture isn't set, or
implicitly grab capture if not already grabbed.

+      drag_source, window, std::move(mime_data), drag_operations));
+}
+
+void EventDispatcher::EndDragDrop() {
+  current_drag_drop_operation_.reset();
+}
+
 void EventDispatcher::AddSystemModalWindow(ServerWindow* window) {
   modal_window_controller_.AddSystemModalWindow(window);
 }
 
 void EventDispatcher::ReleaseCaptureBlockedByModalWindow(
     const ServerWindow* modal_window) {
   if (!capture_window_)
     return;
 
   if (modal_window_controller_.IsWindowBlockedBy(capture_window_,
@@ skipping 88 matching lines @@
 
   DCHECK(event.IsPointerEvent());
   ProcessPointerEvent(*event.AsPointerEvent());
   return;
 }
 
 void EventDispatcher::ProcessKeyEvent(const ui::KeyEvent& event,
                                       AcceleratorMatchPhase match_phase) {
   Accelerator* post_target =
       FindAccelerator(event, ui::mojom::AcceleratorPhase::POST_TARGET);
+  if (current_drag_drop_operation_ && event.type() == ui::ET_KEY_PRESSED &&
+      event.key_code() == ui::VKEY_ESCAPE) {
+    current_drag_drop_operation_->DispatchCancel();
+    return;
+  }
   ServerWindow* focused_window =
       delegate_->GetFocusedWindowForEventDispatcher();
   if (focused_window) {
     // Assume key events are for the client area.
     const bool in_nonclient_area = false;
     const ClientSpecificId client_id =
         delegate_->GetEventTargetClientId(focused_window, in_nonclient_area);
     delegate_->DispatchInputEventToWindow(focused_window, client_id, event,
                                           post_target);
     return;
@@ skipping 21 matching lines @@
       (!is_mouse_event || IsOnlyOneMouseButtonDown(event.flags()));
 
   // Update mouse down state upon events which change it.
   if (is_mouse_event) {
     if (event.type() == ui::ET_POINTER_DOWN)
       mouse_button_down_ = true;
     else if (is_pointer_going_up)
       mouse_button_down_ = false;
   }
 
+  if (current_drag_drop_operation_) {
+    const PointerTarget target = PointerTargetForEvent(event);

[sky, 2016/09/06 21:11:27]

Won't an early return potentially leave pointer_targets_ in the wrong state?

[Elliot Glaysher, 2016/09/07 21:42:23]

Maybe I'm misunderstanding this, but why is this a problem when sending a mouse
event to an explicitly captured when isn't?

[sky, 2016/09/07 23:25:29]

As long as you ensure capture is present, then I agree this early return is ok.
That said, what happens if capture changes part way through the drag? Should the
drag be canceled? If not, things are in a bad state.

+    current_drag_drop_operation_->DispatchLocatedEvent(event, target.window);
+    return;
+  }
+
   if (capture_window_) {
     mouse_cursor_source_window_ = capture_window_;
     DispatchToClient(capture_window_, capture_window_client_id_, event);
     return;
   }
 
   const int32_t pointer_id = event.pointer_id();
   if (!IsTrackingPointer(pointer_id) ||
       !pointer_targets_[pointer_id].is_pointer_down) {
     const bool any_pointers_down = AreAnyPointersDown();
@@ skipping 217 matching lines @@
 
 void EventDispatcher::OnWindowDestroyed(ServerWindow* window) {
   CancelPointerEventsToTarget(window);
 
   if (mouse_cursor_source_window_ == window)
     mouse_cursor_source_window_ = nullptr;
 }
 
 }  // namespace ws
 }  // namespace ui