Tab dragging as implemented as a mus API.

components/mus/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 "components/mus/ws/window_server.h"
 
 #include <set>
 #include <string>
 
 #include "base/logging.h"
@@ skipping 12 matching lines @@
 #include "components/mus/ws/window_manager_window_tree_factory.h"
 #include "components/mus/ws/window_server_delegate.h"
 #include "components/mus/ws/window_tree.h"
 #include "components/mus/ws/window_tree_binding.h"
 #include "services/shell/public/cpp/connection.h"
 #include "ui/gfx/geometry/size_conversions.h"
 
 namespace mus {
 namespace ws {
 
+struct WindowServer::CurrentMoveLoopState {
+  uint32_t change_id;
+  ServerWindow* window;
+  WindowTree* initiator;
+  gfx::Rect revert_bounds;
+};
+
 WindowServer::WindowServer(
     WindowServerDelegate* delegate,
     const scoped_refptr<mus::SurfacesState>& surfaces_state)
     : delegate_(delegate),
       surfaces_state_(surfaces_state),
       next_client_id_(1),
       display_manager_(new DisplayManager(this, &user_id_tracker_)),
       current_operation_(nullptr),
       in_destructor_(false),
       next_wm_change_id_(0),
@@ skipping 365 matching lines @@
 }
 
 void WindowServer::SetPaintCallback(
     const base::Callback<void(ServerWindow*)>& callback) {
   DCHECK(delegate_->IsTestConfig()) << "Paint callbacks are expensive, and "
                                     << "allowed only in tests.";
   DCHECK(window_paint_callback_.is_null() || callback.is_null());
   window_paint_callback_ = callback;
 }
 
+void WindowServer::StartMoveLoop(uint32_t change_id,
+                                 ServerWindow* window,
+                                 WindowTree* initiator,
+                                 const gfx::Rect& revert_bounds) {
+  current_move_loop_.reset(
+      new CurrentMoveLoopState{change_id, window, initiator, revert_bounds});
+}
+
+void WindowServer::EndMoveLoop() {
+  current_move_loop_.reset();
+}
+
+uint32_t WindowServer::GetCurrentMoveLoopChangeId() {
+  if (current_move_loop_)

[dcheng, 2016/07/06 09:27:53]

I'm not 100% sure about this, but it feels like these should just
DCHECK(current_move_loop_): it seems like these probably shouldn't be called if
we're not in a move loop anyway.

+    return current_move_loop_->change_id;
+  return 0;
+}
+
+ServerWindow* WindowServer::GetCurrentMoveLoopWindow() {
+  if (current_move_loop_)
+    return current_move_loop_->window;
+  return nullptr;
+}
+
+WindowTree* WindowServer::GetCurrentMoveLoopInitiator() {
+  if (current_move_loop_)
+    return current_move_loop_->initiator;
+  return nullptr;
+}
+
+gfx::Rect WindowServer::GetCurrentMoveLoopRevertBounds() {
+  if (current_move_loop_)
+    return current_move_loop_->revert_bounds;
+  return gfx::Rect();
+}
+
 bool WindowServer::GetAndClearInFlightWindowManagerChange(
     uint32_t window_manager_change_id,
     InFlightWindowManagerChange* change) {
   // There are valid reasons as to why we wouldn't know about the id. The
   // most likely is the client disconnected before the response from the window
   // manager came back.
   auto iter = in_flight_wm_change_map_.find(window_manager_change_id);
   if (iter == in_flight_wm_change_map_.end())
     return false;
 
@@ skipping 270 matching lines @@
 void WindowServer::OnUserIdAdded(const UserId& id) {
   activity_monitor_map_[id] = base::MakeUnique<UserActivityMonitor>(nullptr);
 }
 
 void WindowServer::OnUserIdRemoved(const UserId& id) {
   activity_monitor_map_.erase(id);
 }
 
 }  // namespace ws
 }  // namespace mus