Tab dragging as implemented as a mus API.

components/mus/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 "components/mus/ws/window_tree.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 394 matching lines @@
       waiting_for_top_level_window_info->client_window_id;
   roots_.insert(window);
   Display* display = GetDisplay(window);
   int64_t display_id =
       display ? display->id() : display::Display::kInvalidDisplayID;
   const bool drawn = window->parent() && window->parent()->IsDrawn();
   client()->OnTopLevelCreated(client_change_id, WindowToWindowData(window),
                               display_id, drawn);
 }
 
+void WindowTree::OnMoveLoopCompleted(uint32_t client_change_id,
+                                     bool completed) {
+  client()->OnMoveLoopCompleted(client_change_id, completed);
+}
+
 void WindowTree::AddActivationParent(const ClientWindowId& window_id) {
   ServerWindow* window = GetWindowByClientId(window_id);
   if (window) {
     Display* display = GetDisplay(window);
     if (display)
       display->AddActivationParent(window);
     else
       DVLOG(1) << "AddActivationParent window not associated with display";
   } else {
     DVLOG(1) << "AddActivationParent supplied invalid window id";
@@ skipping 863 matching lines @@
     Display* display = GetDisplay(window);
     if (display)
       display->SetImeVisibility(window, visible);
   }
 }
 
 void WindowTree::OnWindowInputEventAck(uint32_t event_id,
                                        mojom::EventResult result) {
   if (event_ack_id_ == 0 || event_id != event_ack_id_) {
     // TODO(sad): Something bad happened. Kill the client?
-    NOTIMPLEMENTED() << "Wrong event acked.";
+    NOTIMPLEMENTED() << ": Wrong event acked. event_id=" << event_id
+                     << ", event_ack_id_=" << event_ack_id_;
   }
   event_ack_id_ = 0;
 
   if (janky_)
     event_source_wms_->window_tree()->ClientJankinessChanged(this);
 
   WindowManagerState* event_source_wms = event_source_wms_;
   event_source_wms_ = nullptr;
   if (event_source_wms)
     event_source_wms->OnEventAck(this, result);
@@ skipping 89 matching lines @@
           this, std::move(internal)));
 }
 
 void WindowTree::GetCursorLocationMemory(
     const GetCursorLocationMemoryCallback& callback) {
   callback.Run(
       window_server_->display_manager()->GetUserDisplayManager(user_id_)->
       GetCursorLocationMemory());
 }
 
+void WindowTree::PerformWindowMove(uint32_t change_id,
+                                   Id window_id,
+                                   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|.
+    OnMoveLoopCompleted(change_id, false);
+    return;
+  }
+
+  WindowManagerDisplayRoot* display_root =
+      GetWindowManagerDisplayRoot(window);
+  WindowManagerState* wms = display_root->window_manager_state();

[sky, 2016/06/24 19:59:01]

Make sure you deal with a null display_root. This would happen if the window
isn't parented to a drawn root.

+
+  if (wms->in_move_loop()) {
+    // The window manager is already servicing a move loop; we can't start a
+    // second one.
+    OnMoveLoopCompleted(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.)
+  wms->SetCapture(window, wms->window_tree()->id());
+
+  const uint32_t wm_change_id =
+      window_server_->GenerateWindowManagerChangeId(this, change_id);
+  wms->StartMoveLoop(wm_change_id, window->id(), window->bounds());

[sky, 2016/06/24 19:59:01]

I tend think this code should call WMS::StartMoveLoop() and it should handle all
the internals, e.g. move SetCapture, generating changing and call to
WmPerformMoveLoop there.

[Elliot Glaysher, 2016/06/28 22:32:37]

I went through trying to move it, but it would require access both to
window_manager_internal_ and to ClientWindowIdForWindow().

+  wms->window_tree()->window_manager_internal_->WmPerformMoveLoop(
+      wm_change_id, wms->window_tree()->ClientWindowIdForWindow(window).id,
+      cursor);
+}
+
+void WindowTree::CancelWindowMove(Id window_id) {
+  ServerWindow* window = GetWindowByClientId(ClientWindowId(window_id));
+  bool success = window && access_policy_->CanInitiateMoveLoop(window);
+  if (!success)

[sky, 2016/06/24 19:59:01]

This should also fail if this client didn't initiate the current move.

+    return;
+
+  WindowManagerDisplayRoot* display_root =
+      GetWindowManagerDisplayRoot(window);
+  WindowManagerState* wms = display_root->window_manager_state();

[sky, 2016/06/24 19:59:01]

Similar comment about display_root.

+
+  wms->window_tree()->window_manager_internal_->WmCancelMoveLoop(
+      wms->window_tree()->ClientWindowIdForWindow(window).id);
+}
+
 void WindowTree::AddAccelerator(uint32_t id,
                                 mojom::EventMatcherPtr event_matcher,
                                 const AddAcceleratorCallback& callback) {
   DCHECK(window_manager_state_);
   const bool success =
       window_manager_state_->event_dispatcher()->AddAccelerator(
           id, std::move(event_matcher));
   callback.Run(success);
 }
 
@@ skipping 92 matching lines @@
   ServerWindow* window =
       GetWindowByClientId(ClientWindowId(transport_window_id));
   if (window && window->id().client_id != id_) {
     DVLOG(1) << "OnWmCreatedTopLevelWindow supplied invalid window id";
     window_server_->WindowManagerSentBogusMessage();
     window = nullptr;
   }
   window_server_->WindowManagerCreatedTopLevelWindow(this, change_id, window);
 }
 
+void WindowTree::OnWmMoveLoopCompleted(uint32_t change_id,
+                                       bool succeeded) {
+  if (window_manager_state_) {

[sky, 2016/06/24 19:59:01]

nit: early return.

+    ServerWindow* window = nullptr;
+    if (!window_manager_state_->in_move_loop() ||
+        window_manager_state_->GetCurrentMoveLoopChangeId() != change_id) {
+      window_server_->WindowManagerSentBogusMessage();
+    } else {
+      window = GetWindow(window_manager_state_->GetCurrentMoveLoopWindowId());
+    }
+
+    if (window && window->id().client_id != id_) {
+      window_server_->WindowManagerSentBogusMessage();
+      window = nullptr;
+    } else {
+      // Clear the implicit capture.
+      window_manager_state_->SetCapture(nullptr, false);

[sky, 2016/06/24 19:59:01]

Similar comment about having WMS handle all the details of canceling the drag.

+    }
+
+    if (!succeeded && window && window_manager_state_->in_move_loop()) {
+      // Our move loop didn't succeed, which means that we must restore the
+      // original bounds of the window.
+      window->SetBounds(
+          window_manager_state_->GetCurrentMoveLoopRevertBounds());
+    }
+
+    window_manager_state_->EndMoveLoop();
+    window_server_->WindowManagerCompletedMoveLoop(change_id, window,
+                                                   succeeded);
+  }
+}
+
 bool WindowTree::HasRootForAccessPolicy(const ServerWindow* window) const {
   return HasRoot(window);
 }
 
 bool WindowTree::IsWindowKnownForAccessPolicy(
     const ServerWindow* window) const {
   return IsWindowKnown(window);
 }
 
 bool WindowTree::IsWindowRootOfAnotherTreeForAccessPolicy(
     const ServerWindow* window) const {
   WindowTree* tree = window_server_->GetTreeWithRoot(window);
   return tree && tree != this;
 }
 
 }  // namespace ws
 }  // namespace mus