mus: Implement interwindow drag and drop

services/ui/ws/window_server.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_server.h"
 
 #include <set>
 #include <string>
 
 #include "base/logging.h"
@@ skipping 20 matching lines @@
 namespace ui {
 namespace ws {
 
 struct WindowServer::CurrentMoveLoopState {
   uint32_t change_id;
   ServerWindow* window;
   WindowTree* initiator;
   gfx::Rect revert_bounds;
 };
 
+struct WindowServer::CurrentDragLoopState {
+  uint32_t change_id;
+  ServerWindow* window;
+  WindowTree* initiator;
+};
+
 WindowServer::WindowServer(WindowServerDelegate* delegate)
     : delegate_(delegate),
       surfaces_state_(new SurfacesState()),
       next_client_id_(1),
       display_manager_(new DisplayManager(this, &user_id_tracker_)),
       current_operation_(nullptr),
       in_destructor_(false),
       next_wm_change_id_(0),
       gpu_proxy_(new GpuServiceProxy(this)),
       window_manager_window_tree_factory_set_(this, &user_id_tracker_) {
@@ skipping 426 matching lines @@
     return current_move_loop_->initiator;
   return nullptr;
 }
 
 gfx::Rect WindowServer::GetCurrentMoveLoopRevertBounds() {
   if (current_move_loop_)
     return current_move_loop_->revert_bounds;
   return gfx::Rect();
 }
 
+void WindowServer::StartDragLoop(uint32_t change_id,
+                                 ServerWindow* window,
+                                 WindowTree* initiator) {
+  current_drag_loop_.reset(
+      new CurrentDragLoopState{change_id, window, initiator});
+}
+
+void WindowServer::EndDragLoop() {
+  current_drag_loop_.reset();
+}
+
+uint32_t WindowServer::GetCurrentDragLoopChangeId() {

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

Why does this information need to be held by the WindowServer? AFAICT it's only
needed by the WindowTree that initiates the drag. Shouldn't it be held there?

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

Parallelism with storing the move loop for the safety checks. If we have one
connection currently performing a drag, and a second tries to start a drag on a
different root in a different process, we should immediately return unsuccessful
the second one.

(Along with erroring on trying to start a move loop during a drag and vice
versa.)

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

Isn't this information seldomly used? If so, can you iterate over all the
WindowTrees to see if one has a drag loop going on?

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

WindowServer doesn't publicly expose the WindowTreeMap. Adding a method on
WindowServer to expose it or write a method on WindowServer that searches for it
feels worse than this.

[sky, 2016/09/15 18:10:46]

Fair enough.

+  if (current_drag_loop_)
+    return current_drag_loop_->change_id;
+  return 0u;
+}
+
+ServerWindow* WindowServer::GetCurrentDragLoopWindow() {
+  if (current_drag_loop_)
+    return current_drag_loop_->window;
+  return nullptr;
+}
+
+WindowTree* WindowServer::GetCurrentDragLoopInitiator() {
+  if (current_drag_loop_)
+    return current_drag_loop_->initiator;
+  return nullptr;
+}
+
 void WindowServer::OnDisplayReady(Display* display, bool is_first) {
   if (gpu_channel_)
     display->platform_display()->OnGpuChannelEstablished(gpu_channel_);
   if (is_first)
     delegate_->OnFirstDisplayReady();
 }
 
 void WindowServer::OnNoMoreDisplays() {
   delegate_->OnNoMoreDisplays();
 }
@@ skipping 296 matching lines @@
   clipboard_map_[id] = base::MakeUnique<clipboard::ClipboardImpl>();
 }
 
 void WindowServer::OnUserIdRemoved(const UserId& id) {
   activity_monitor_map_.erase(id);
   clipboard_map_.erase(id);
 }
 
 }  // namespace ws
 }  // namespace ui