mus: Implement interwindow drag and drop

services/ui/public/cpp/window_tree_client.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/public/cpp/window_tree_client.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "services/shell/public/cpp/connector.h"
 #include "services/ui/common/util.h"
 #include "services/ui/public/cpp/in_flight_change.h"
 #include "services/ui/public/cpp/input_event_handler.h"
+#include "services/ui/public/cpp/window_drop_target.h"
 #include "services/ui/public/cpp/window_manager_delegate.h"
 #include "services/ui/public/cpp/window_observer.h"
 #include "services/ui/public/cpp/window_private.h"
 #include "services/ui/public/cpp/window_tracker.h"
 #include "services/ui/public/cpp/window_tree_client_delegate.h"
 #include "services/ui/public/cpp/window_tree_client_observer.h"
 #include "services/ui/public/interfaces/window_manager_window_tree_factory.mojom.h"
 #include "ui/events/event.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/geometry/size.h"
@@ skipping 46 matching lines @@
     }
     Window* window = AddWindowToClient(
         client, !parents.empty() ? parents.back() : NULL, windows[i]);
     if (!last_window)
       root = window;
     last_window = window;
   }
   return root;
 }
 
+struct WindowTreeClient::CurrentDragState {
+  // The current change id of the current drag an drop ipc.
+  uint32_t change_id;
+
+  // Callback executed when a drag initiated by PerformDragDrop() is completed.
+  base::Callback<void(bool)> on_finished;
+};
+
 WindowTreeClient::WindowTreeClient(
     WindowTreeClientDelegate* delegate,
     WindowManagerDelegate* window_manager_delegate,
     mojo::InterfaceRequest<mojom::WindowTreeClient> request)
     : client_id_(0),
       next_window_id_(1),
       next_change_id_(1),
       delegate_(delegate),
       window_manager_delegate_(window_manager_delegate),
       capture_window_(nullptr),
@@ skipping 529 matching lines @@
   has_pointer_watcher_ = true;
   tree_->StartPointerWatcher(want_moves);
 }
 
 void WindowTreeClient::StopPointerWatcher() {
   DCHECK(has_pointer_watcher_);
   tree_->StopPointerWatcher();
   has_pointer_watcher_ = false;
 }
 
+void WindowTreeClient::PerformDragDrop(
+    Window* window,
+    int drag_pointer,
+    const std::map<std::string, std::vector<uint8_t>>& drag_data,
+    int drag_operation,
+    const gfx::Point& cursor_location,
+    const SkBitmap& bitmap,
+    const base::Callback<void(bool)>& callback) {
+  DCHECK(!current_drag_state_);
+
+  // TODO(erg): Pass |cursor_location| and |bitmap| in PerformDragDrop() when
+  // we start showing an image representation of the drag under he cursor.
+
+  if (window->drop_target()) {
+    // To minimize the number of round trips, copy the drag drop data to our
+    // handler here, instead of forcing mus to send this same data back.
+    OnDragDropStart(
+        mojo::Map<mojo::String, mojo::Array<uint8_t>>::From(drag_data));
+  }
+
+  uint32_t current_drag_change = ScheduleInFlightChange(
+      base::MakeUnique<InFlightDragChange>(window, ChangeType::DRAG_LOOP));
+  current_drag_state_.reset(
+      new CurrentDragState{current_drag_change, callback});
+
+  tree_->PerformDragDrop(
+      current_drag_change, window->server_id(), drag_pointer,
+      mojo::Map<mojo::String, mojo::Array<uint8_t>>::From(drag_data),
+      drag_operation);
+}
+
 void WindowTreeClient::PerformWindowMove(
     Window* window,
     ui::mojom::MoveLoopSource source,
     const gfx::Point& cursor_location,
     const base::Callback<void(bool)>& callback) {
   DCHECK(on_current_move_finished_.is_null());
   on_current_move_finished_ = callback;
 
   current_move_loop_change_ = ScheduleInFlightChange(
-      base::MakeUnique<InFlightMoveLoopChange>(window));
+      base::MakeUnique<InFlightDragChange>(window, ChangeType::MOVE_LOOP));
   // Tell the window manager to take over moving us.
   tree_->PerformWindowMove(current_move_loop_change_, window->server_id(),
                            source, cursor_location);
 }
 
 void WindowTreeClient::CancelWindowMove(Window* window) {
   tree_->CancelWindowMove(window->server_id());
 }
 
 Window* WindowTreeClient::NewWindow(
@@ skipping 37 matching lines @@
 // WindowTreeClient, WindowTreeClient implementation:
 
 void WindowTreeClient::AddObserver(WindowTreeClientObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void WindowTreeClient::RemoveObserver(WindowTreeClientObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
+void WindowTreeClient::SetCanAcceptDrops(Id window_id, bool can_accept_drops) {
+  DCHECK(tree_);
+  tree_->SetCanAcceptDrops(window_id, can_accept_drops);
+}
+
 void WindowTreeClient::SetCanAcceptEvents(Id window_id,
                                           bool can_accept_events) {
   DCHECK(tree_);
   tree_->SetCanAcceptEvents(window_id, can_accept_events);
 }
 
 void WindowTreeClient::OnEmbed(ClientSpecificId client_id,
                                mojom::WindowDataPtr root_data,
                                mojom::WindowTreePtr tree,
                                int64_t display_id,
@@ skipping 326 matching lines @@
   if (!window)
     return;
 
   InFlightPredefinedCursorChange new_change(window, cursor);
   if (ApplyServerChangeToExistingInFlightChange(new_change))
     return;
 
   WindowPrivate(window).LocalSetPredefinedCursor(cursor);
 }
 
+void WindowTreeClient::OnDragDropStart(
+    mojo::Map<mojo::String, mojo::Array<uint8_t>> mime_data) {
+  mime_drag_data_ = std::move(mime_data);
+}
+
+void WindowTreeClient::OnDragEnter(Id window_id,
+                                   uint32_t key_state,
+                                   const gfx::Point& position,
+                                   uint32_t effect_bitmask,
+                                   const OnDragEnterCallback& callback) {
+  Window* window = GetWindowByServerId(window_id);
+  if (!window || !window->drop_target()) {
+    callback.Run(mojom::kDropEffectNone);
+    return;
+  }
+
+  if (!base::ContainsKey(drag_entered_windows_, window_id)) {
+    window->drop_target()->OnDragDropStart(
+        mime_drag_data_.To<std::map<std::string, std::vector<uint8_t>>>());
+    drag_entered_windows_.insert(window_id);
+  }
+
+  uint32_t ret =
+      window->drop_target()->OnDragEnter(key_state, position, effect_bitmask);
+  callback.Run(ret);
+}
+
+void WindowTreeClient::OnDragOver(Id window_id,
+                                  uint32_t key_state,
+                                  const gfx::Point& position,
+                                  uint32_t effect_bitmask,
+                                  const OnDragOverCallback& callback) {
+  Window* window = GetWindowByServerId(window_id);
+  if (!window || !window->drop_target()) {
+    callback.Run(mojom::kDropEffectNone);
+    return;
+  }
+
+  uint32_t ret =
+      window->drop_target()->OnDragOver(key_state, position, effect_bitmask);
+  callback.Run(ret);
+}
+
+void WindowTreeClient::OnDragLeave(Id window_id) {
+  Window* window = GetWindowByServerId(window_id);
+  if (!window || !window->drop_target())
+    return;
+
+  window->drop_target()->OnDragLeave();
+}
+
+void WindowTreeClient::OnDragDropDone() {
+  for (Id id : drag_entered_windows_) {
+    Window* window = GetWindowByServerId(id);
+    if (!window || !window->drop_target())
+      continue;
+    window->drop_target()->OnDragDropDone();
+  }
+  drag_entered_windows_.clear();
+}
+
+void WindowTreeClient::OnCompleteDrop(Id window_id,
+                                      uint32_t key_state,
+                                      const gfx::Point& position,
+                                      uint32_t effect_bitmask,
+                                      const OnCompleteDropCallback& callback) {
+  Window* window = GetWindowByServerId(window_id);
+  if (!window || !window->drop_target()) {
+    callback.Run(mojom::kDropEffectNone);
+    return;
+  }
+
+  uint32_t ret = window->drop_target()->OnCompleteDrop(key_state, position,
+                                                       effect_bitmask);
+  callback.Run(ret);
+}
+
 void WindowTreeClient::OnChangeCompleted(uint32_t change_id, bool success) {
   std::unique_ptr<InFlightChange> change(std::move(in_flight_map_[change_id]));
   in_flight_map_.erase(change_id);
   if (!change)
     return;
 
   if (!success)
     change->ChangeFailed();
 
   InFlightChange* next_change = GetOldestInFlightChangeMatching(*change);
   if (next_change) {
     if (!success)
       next_change->SetRevertValueFrom(*change);
   } else if (!success) {
     change->Revert();
   }
 
   if (change_id == current_move_loop_change_) {
     current_move_loop_change_ = 0;
     on_current_move_finished_.Run(success);
     on_current_move_finished_.Reset();
   }
+
+  if (current_drag_state_ && change_id == current_drag_state_->change_id) {
+    OnDragDropDone();
+
+    current_drag_state_->on_finished.Run(success);
+    current_drag_state_.reset();
+  }
 }
 
 void WindowTreeClient::GetWindowManager(
     mojo::AssociatedInterfaceRequest<WindowManager> internal) {
   window_manager_internal_.reset(
       new mojo::AssociatedBinding<mojom::WindowManager>(this,
                                                         std::move(internal)));
 }
 
 void WindowTreeClient::RequestClose(uint32_t window_id) {
@@ skipping 174 matching lines @@
     Window* window,
     const gfx::Vector2d& offset,
     const gfx::Insets& hit_area) {
   if (window_manager_internal_client_) {
     window_manager_internal_client_->SetUnderlaySurfaceOffsetAndExtendedHitArea(
         server_id(window), offset.x(), offset.y(), hit_area);
   }
 }
 
 }  // namespace ui