Tab dragging as implemented as a mus API.

components/mus/ws/window_manager_state.cc

 // Copyright 2016 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_manager_state.h"
 
 #include "base/memory/weak_ptr.h"
 #include "components/mus/common/event_matcher_util.h"
 #include "components/mus/ws/accelerator.h"
 #include "components/mus/ws/display_manager.h"
@@ skipping 38 matching lines @@
 std::unique_ptr<ui::Event> CoalesceEvents(std::unique_ptr<ui::Event> first,
                                           std::unique_ptr<ui::Event> second) {
   DCHECK(first->type() == ui::ET_POINTER_MOVED)
       << " Non-move events cannot be merged yet.";
   // For mouse moves, the new event just replaces the old event.
   return second;
 }
 
 }  // namespace
 
+struct WindowManagerState::CurrentMoveLoopState {
+  uint32_t change_id;
+  WindowId window_id;
+  gfx::Rect revert_bounds;
+};
+
 class WindowManagerState::ProcessedEventTarget {
  public:
   ProcessedEventTarget(ServerWindow* window,
                        ClientSpecificId client_id,
                        Accelerator* accelerator)
       : client_id_(client_id) {
     tracker_.Add(window);
     if (accelerator)
       accelerator_ = accelerator->GetWeakPtr();
   }
@@ skipping 53 matching lines @@
 #if !defined(NDEBUG)
   if (window) {
     WindowManagerDisplayRoot* display_root =
         display_manager()->GetWindowManagerDisplayRoot(window);
     DCHECK(display_root && display_root->window_manager_state() == this);
   }
 #endif
   return event_dispatcher_.SetCaptureWindow(window, client_id);
 }
 
+void WindowManagerState::StartMoveLoop(uint32_t change_id,
+                                       WindowId window_id,
+                                       const gfx::Rect& revert_bounds) {
+  current_move_loop_.reset(
+      new CurrentMoveLoopState{change_id, window_id, revert_bounds});
+}
+
+void WindowManagerState::EndMoveLoop() {
+  current_move_loop_.reset();
+}
+
+uint32_t WindowManagerState::GetCurrentMoveLoopChangeId() {
+  if (current_move_loop_)
+    return current_move_loop_->change_id;
+  return 0;
+}
+
+WindowId WindowManagerState::GetCurrentMoveLoopWindowId() {
+  if (current_move_loop_)
+    return current_move_loop_->window_id;
+  return WindowId();
+}
+
+gfx::Rect WindowManagerState::GetCurrentMoveLoopRevertBounds() {
+  if (current_move_loop_)
+    return current_move_loop_->revert_bounds;
+  return gfx::Rect();
+}
+
 void WindowManagerState::ReleaseCaptureBlockedByModalWindow(
     const ServerWindow* modal_window) {
   event_dispatcher_.ReleaseCaptureBlockedByModalWindow(modal_window);
 }
 
 void WindowManagerState::ReleaseCaptureBlockedByAnyModalWindow() {
   event_dispatcher_.ReleaseCaptureBlockedByAnyModalWindow();
 }
 
 void WindowManagerState::AddSystemModalWindow(ServerWindow* window) {
@@ skipping 315 matching lines @@
   return display_root ? display_root->root() : nullptr;
 }
 
 void WindowManagerState::OnEventTargetNotFound(const ui::Event& event) {
   window_server()->SendToEventObservers(event, user_id(),
                                         nullptr /* ignore_tree */);
 }
 
 }  // namespace ws
 }  // namespace mus