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/display.h"
+#include "services/ui/ws/drag_controller.h"
+#include "services/ui/ws/drag_source.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"
 
 namespace ui {
@@ skipping 94 matching lines @@
   if (!window)
     client_id = kInvalidClientId;
 
   if (window == capture_window_ && client_id == capture_window_client_id_)
     return true;
 
   // A window that is blocked by a modal window cannot gain capture.
   if (window && modal_window_controller_.IsWindowBlocked(window))
     return false;
 
+  // If we're currently performing a drag and drop, reject setting the capture
+  // window.
+  if (drag_controller_)
+    return false;
+
   if (capture_window_) {
     // Stop observing old capture window. |pointer_targets_| are cleared on
     // initial setting of a capture window.
     UnobserveWindow(capture_window_);
   } else {
-    // Cancel implicit capture to all other windows.
-    for (const auto& pair : pointer_targets_) {
-      ServerWindow* target = pair.second.window;
-      if (!target)
-        continue;
-      UnobserveWindow(target);
-      if (target == window)
-        continue;
-
-      ui::EventType event_type = pair.second.is_mouse_event
-                                     ? ui::ET_POINTER_EXITED
-                                     : ui::ET_POINTER_CANCELLED;
-      ui::EventPointerType pointer_type =
-          pair.second.is_mouse_event ? ui::EventPointerType::POINTER_TYPE_MOUSE
-                                     : ui::EventPointerType::POINTER_TYPE_TOUCH;
-      // TODO(jonross): Track previous location in PointerTarget for sending
-      // cancels.
-      ui::PointerEvent event(
-          event_type, gfx::Point(), gfx::Point(), ui::EF_NONE, pair.first,
-          0 /* changed_button_flags */, ui::PointerDetails(pointer_type),
-          ui::EventTimeForNow());
-      DispatchToPointerTarget(pair.second, event);
-    }
-    pointer_targets_.clear();
+    CancelImplicitCaptureExcept(window);
   }
 
   // Set the capture before changing native capture; otherwise, the callback
   // from native platform might try to set the capture again.
   const bool had_capture_window = capture_window_ != nullptr;
   ServerWindow* old_capture_window = capture_window_;
   capture_window_ = window;
   capture_window_client_id_ = client_id;
 
   delegate_->OnCaptureChanged(capture_window_, old_capture_window);
 
   // Begin tracking the capture window if it is not yet being observed.
   if (window) {
     ObserveWindow(window);
     // TODO(sky): this conditional is problematic for the case of capture moving
     // to a different display.
     if (!had_capture_window)
       delegate_->SetNativeCapture(window);
   } else {
     delegate_->ReleaseNativeCapture();
     if (!mouse_button_down_)
       UpdateCursorProviderByLastKnownLocation();
   }
 
   return true;
 }
 
+void EventDispatcher::SetDragDropSourceWindow(
+    DragSource* drag_source,
+    ServerWindow* window,
+    DragTargetConnection* source_connection,
+    int32_t drag_pointer,
+    mojo::Map<mojo::String, mojo::Array<uint8_t>> mime_data,
+    uint32_t drag_operations) {
+  CancelImplicitCaptureExcept(nullptr);
+  drag_controller_ = base::MakeUnique<DragController>(
+      drag_source, window, source_connection, drag_pointer,
+      std::move(mime_data), drag_operations);
+}
+
+void EventDispatcher::EndDragDrop() {
+  drag_controller_.reset();
+}
+
+void EventDispatcher::OnWillDestroyDragTargetConnection(
+    DragTargetConnection* connection) {
+  if (drag_controller_)
+    drag_controller_->OnWillDestroyDragTargetConnection(connection);
+}
+
 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 (drag_controller_ && event.type() == ui::ET_KEY_PRESSED &&
+      event.key_code() == ui::VKEY_ESCAPE) {
+    drag_controller_->Cancel();
+    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 (drag_controller_) {
+    const PointerTarget target = PointerTargetForEvent(event);
+    if (drag_controller_->DispatchPointerEvent(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 187 matching lines @@
 
 ServerWindow* EventDispatcher::FindDeepestVisibleWindowForEvents(
     gfx::Point* location) {
   ServerWindow* root = delegate_->GetRootWindowContaining(location);
   if (!root)
     return nullptr;
 
   return ui::ws::FindDeepestVisibleWindowForEvents(root, location);
 }
 
+void EventDispatcher::CancelImplicitCaptureExcept(ServerWindow* window) {
+  for (const auto& pair : pointer_targets_) {
+    ServerWindow* target = pair.second.window;
+    if (!target)
+      continue;
+    UnobserveWindow(target);
+    if (window && target == window)

[sky, 2016/09/13 18:15:32]

I don't think you need the 'window' conditional.

[Elliot Glaysher, 2016/09/14 22:19:16]

|window| can be null (called at line 173).

[sky, 2016/09/14 22:52:02]

Sure, but the !target on line 559 means you know target is not-null at this
point, so the only way target == window is true is if window is non-null,
meaning the if (window) part is unnecessary.

[Elliot Glaysher, 2016/09/15 17:12:40]

Done.

+      continue;
+
+    ui::EventType event_type = pair.second.is_mouse_event
+                                   ? ui::ET_POINTER_EXITED
+                                   : ui::ET_POINTER_CANCELLED;
+    ui::EventPointerType pointer_type =
+        pair.second.is_mouse_event ? ui::EventPointerType::POINTER_TYPE_MOUSE
+                                   : ui::EventPointerType::POINTER_TYPE_TOUCH;
+    // TODO(jonross): Track previous location in PointerTarget for sending
+    // cancels.
+    ui::PointerEvent event(event_type, gfx::Point(), gfx::Point(), ui::EF_NONE,
+                           pair.first, 0 /* changed_button_flags */,
+                           ui::PointerDetails(pointer_type),
+                           ui::EventTimeForNow());
+    DispatchToPointerTarget(pair.second, event);
+  }
+  pointer_targets_.clear();
+}
+
 void EventDispatcher::OnWillChangeWindowHierarchy(ServerWindow* window,
                                                   ServerWindow* new_parent,
                                                   ServerWindow* old_parent) {
   // TODO(sky): moving to a different root likely needs to transfer capture.
   // TODO(sky): this isn't quite right, I think the logic should be (assuming
   // moving in same root and still drawn):
   // . if there is capture and window is still in the same root, continue
   //   sending to it.
   // . if there isn't capture, then reevaluate each of the pointer targets
   //   sending exit as necessary.
@@ skipping 10 matching lines @@
 
 void EventDispatcher::OnWindowDestroyed(ServerWindow* window) {
   CancelPointerEventsToTarget(window);
 
   if (mouse_cursor_source_window_ == window)
     mouse_cursor_source_window_ = nullptr;
 }
 
 }  // namespace ws
 }  // namespace ui