mus: Implement interwindow drag and drop

services/ui/ws/window_tree.cc

 // Copyright 2014 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/window_tree.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 437 matching lines @@
     if (display)
       display->AddActivationParent(window);
     else
       DVLOG(1) << "AddActivationParent window not associated with display";
   } else {
     DVLOG(1) << "AddActivationParent supplied invalid window id";
   }
 }
 
 void WindowTree::OnChangeCompleted(uint32_t change_id, bool success) {
+  if (window_server_->in_drag_loop() &&
+      change_id == window_server_->GetCurrentDragLoopChangeId()) {
+    window_server_->EndDragLoop();
+  }
+
   client()->OnChangeCompleted(change_id, success);
 }
 
 void WindowTree::OnAccelerator(uint32_t accelerator_id,
                                const ui::Event& event,
                                bool needs_ack) {
   DCHECK(window_manager_internal_);
   if (needs_ack)
     GenerateEventAckId();
   else
     DCHECK_EQ(0u, event_ack_id_);
   // TODO(moshayedi): crbug.com/617167. Don't clone even once we map
   // mojom::Event directly to ui::Event.
   window_manager_internal_->OnAccelerator(event_ack_id_, accelerator_id,
                                           ui::Event::Clone(event));
 }
 
 void WindowTree::ClientJankinessChanged(WindowTree* tree) {
   tree->janky_ = !tree->janky_;
   // Don't inform the client if it is the source of jank (which generally only
   // happens while debugging).
   if (window_manager_internal_ && tree != this) {
     window_manager_internal_->WmClientJankinessChanged(
         tree->id(), tree->janky());
   }
 }
 
+void WindowTree::PerformOnDragEnter(
+    const ServerWindow* window,
+    mojo::Map<mojo::String, mojo::Array<uint8_t>> mime_data,
+    uint32_t key_state,
+    const gfx::Point& cursor_offset,
+    uint32_t effect_bitmask,
+    const base::Callback<void(uint32_t)>& callback) {
+  ClientWindowId client_window_id;
+  if (!IsWindowKnown(window, &client_window_id)) {
+    NOTREACHED();
+    callback.Run(0);
+    return;
+  }
+  client()->OnDragEnter(client_window_id.id, std::move(mime_data), key_state,
+                        cursor_offset, effect_bitmask, callback);
+}
+
+void WindowTree::PerformOnDragOver(
+    const ServerWindow* window,
+    uint32_t key_state,
+    const gfx::Point& cursor_offset,
+    uint32_t effect_bitmask,
+    const base::Callback<void(uint32_t)>& callback) {
+  ClientWindowId client_window_id;
+  if (!IsWindowKnown(window, &client_window_id)) {
+    NOTREACHED();
+    callback.Run(0);
+    return;
+  }
+  client()->OnDragOver(client_window_id.id, key_state, cursor_offset,
+                       effect_bitmask, callback);
+}
+
+void WindowTree::PerformOnDragLeave(const ServerWindow* window) {
+  ClientWindowId client_window_id;
+  if (!IsWindowKnown(window, &client_window_id)) {
+    NOTREACHED();
+    return;
+  }
+  client()->OnDragLeave(client_window_id.id);
+}
+
+void WindowTree::PerformOnDragDrop(
+    const ServerWindow* window,
+    uint32_t key_state,
+    const gfx::Point& cursor_offset,
+    uint32_t effect_bitmask,
+    const base::Callback<void(uint32_t)>& callback) {
+  ClientWindowId client_window_id;
+  if (!IsWindowKnown(window, &client_window_id)) {
+    NOTREACHED();
+    callback.Run(0);
+    return;
+  }
+  client()->OnDragDrop(client_window_id.id, key_state, cursor_offset,
+                       effect_bitmask, callback);
+}
+
 void WindowTree::ProcessWindowBoundsChanged(const ServerWindow* window,
                                             const gfx::Rect& old_bounds,
                                             const gfx::Rect& new_bounds,
                                             bool originated_change) {
   ClientWindowId client_window_id;
   if (originated_change || !IsWindowKnown(window, &client_window_id))
     return;
   client()->OnWindowBoundsChanged(client_window_id.id, old_bounds, new_bounds);
 }
 
@@ skipping 883 matching lines @@
     DVLOG(1) << "SetHitTestMask failed";
     return;
   }
 
   if (mask)
     window->SetHitTestMask(*mask);
   else
     window->ClearHitTestMask();
 }
 
+void WindowTree::SetCanAcceptDrags(Id window_id, bool accepts_drags) {
+  ServerWindow* window = GetWindowByClientId(ClientWindowId(window_id));
+  if (!window || !access_policy_->CanSetAcceptDrags(window)) {
+    DVLOG(1) << "SetAcceptsDrags failed";
+    return;
+  }
+
+  window->SetCanAcceptDrags(accepts_drags);
+}
+
 void WindowTree::Embed(Id transport_window_id,
                        mojom::WindowTreeClientPtr client,
                        uint32_t flags,
                        const EmbedCallback& callback) {
   callback.Run(
       Embed(ClientWindowId(transport_window_id), std::move(client), flags));
 }
 
 void WindowTree::SetFocus(uint32_t change_id, Id transport_window_id) {
   client()->OnChangeCompleted(change_id,
@@ skipping 45 matching lines @@
           this, std::move(internal)));
 }
 
 void WindowTree::GetCursorLocationMemory(
     const GetCursorLocationMemoryCallback& callback) {
   callback.Run(
       window_server_->display_manager()->GetUserDisplayManager(user_id_)->
       GetCursorLocationMemory());
 }
 
+void WindowTree::PerformDragDrop(
+    uint32_t change_id,
+    uint32_t source_window_id,
+    mojo::Map<mojo::String, mojo::Array<uint8_t>> drag_data,
+    uint32_t drag_operation,
+    const gfx::Point& cursor_offset,
+    const SkBitmap& drag_representation) {
+  ServerWindow* window = GetWindowByClientId(ClientWindowId(source_window_id));
+  bool success = window && access_policy_->CanInitiateMoveLoop(window);
+  if (!success || !ShouldRouteToWindowManager(window)) {
+    // We need to fail this move loop change, otherwise the client will just be
+    // waiting for |change_id|.
+    OnChangeCompleted(change_id, false);
+    return;
+  }
+
+  WindowManagerDisplayRoot* display_root = GetWindowManagerDisplayRoot(window);
+  if (!display_root) {
+    // The window isn't parented. There's nothing to do.
+    OnChangeCompleted(change_id, false);
+    return;
+  }
+
+  if (window_server_->in_move_loop() || window_server_->in_drag_loop()) {
+    // Either the window manager is servicing a window drag or we're servicing
+    // a drag and drop operation. We can't start a second drag.
+    OnChangeCompleted(change_id, false);
+    return;
+  }
+
+  // TODO(erg): Dealing with |drag_representation| is hard, so we're going to
+  // deal with that later.
+
+  // Here, we need to dramatically change how the mouse pointer works. Once
+  // we've started a drag drop operation, cursor events don't go to windows as
+  // normal.
+  WindowManagerState* wms = display_root->window_manager_state();
+  window_server_->StartDragLoop(change_id);
+  wms->SetDragDropSourceWindow(change_id, std::move(drag_data), drag_operation,
+                               this, window);
+}
+
 void WindowTree::PerformWindowMove(uint32_t change_id,
                                    Id window_id,
                                    ui::mojom::MoveLoopSource source,
                                    const gfx::Point& cursor) {
   ServerWindow* window = GetWindowByClientId(ClientWindowId(window_id));
   bool success = window && access_policy_->CanInitiateMoveLoop(window);
   if (!success || !ShouldRouteToWindowManager(window)) {
     // We need to fail this move loop change, otherwise the client will just be
     // waiting for |change_id|.
     OnChangeCompleted(change_id, false);
     return;
   }
 
   WindowManagerDisplayRoot* display_root = GetWindowManagerDisplayRoot(window);
   if (!display_root) {
     // The window isn't parented. There's nothing to do.
     OnChangeCompleted(change_id, false);
     return;
   }
 
-  if (window_server_->in_move_loop()) {
-    // A window manager is already servicing a move loop; we can't start a
-    // second one.
+  if (window_server_->in_move_loop() || window_server_->in_drag_loop()) {
+    // Either the window manager is servicing a window drag or we're servicing
+    // a drag and drop operation. We can't start a second drag.
     OnChangeCompleted(change_id, false);
     return;
   }
 
   // When we perform a window move loop, we give the window manager non client
   // capture. Because of how the capture public interface currently works,
   // SetCapture() will check whether the mouse cursor is currently in the
   // non-client area and if so, will redirect messages to the window
   // manager. (And normal window movement relies on this behaviour.)
   WindowManagerState* wms = display_root->window_manager_state();
@@ skipping 188 matching lines @@
 }
 
 bool WindowTree::IsWindowRootOfAnotherTreeForAccessPolicy(
     const ServerWindow* window) const {
   WindowTree* tree = window_server_->GetTreeWithRoot(window);
   return tree && tree != this;
 }
 
 }  // namespace ws
 }  // namespace ui