Tab dragging as implemented as a mus API.

components/mus/ws/window_manager_state.h

 // 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.
 
 #ifndef COMPONENTS_MUS_WS_WINDOW_MANAGER_STATE_H_
 #define COMPONENTS_MUS_WS_WINDOW_MANAGER_STATE_H_
 
 #include <stdint.h>
 
 #include <memory>
@@ skipping 38 matching lines @@
   bool got_frame_decoration_values() const {
     return got_frame_decoration_values_;
   }
 
   bool SetCapture(ServerWindow* window, ClientSpecificId client_id);
   ServerWindow* capture_window() { return event_dispatcher_.capture_window(); }
   const ServerWindow* capture_window() const {
     return event_dispatcher_.capture_window();
   }
 
+  //
+  void StartMoveLoop(uint32_t change_id, WindowId window_id,

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

In general only the functions from clients use a WindowId, the rest of the code
passes around ServerWindow. For example, SetCapture on line 53 takes the
ServerWindow, not the WindowId.

+                     const gfx::Rect& revert_bounds);
+  void EndMoveLoop();
+  uint32_t GetCurrentMoveLoopChangeId();
+  WindowId GetCurrentMoveLoopWindowId();
+  gfx::Rect GetCurrentMoveLoopRevertBounds();
+  bool in_move_loop() { return !!current_move_loop_.get(); }
+
   void ReleaseCaptureBlockedByModalWindow(const ServerWindow* modal_window);
   void ReleaseCaptureBlockedByAnyModalWindow();
 
   void AddSystemModalWindow(ServerWindow* window);
 
   // TODO(sky): EventDispatcher is really an implementation detail and should
   // not be exposed.
   EventDispatcher* event_dispatcher() { return &event_dispatcher_; }
 
   // Returns true if this is the WindowManager of the active user.
   bool IsActive() const;
 
   void Activate(const gfx::Point& mouse_location_on_screen);
   void Deactivate();
 
   // Processes an event from PlatformDisplay.
   void ProcessEvent(const ui::Event& event);
 
   // Called when the ack from an event dispatched to WindowTree |tree| is
   // received.
   // TODO(sky): make this private and use a callback.
   void OnEventAck(mojom::WindowTree* tree, mojom::EventResult result);
 
  private:
+  struct CurrentMoveLoopState;
   class ProcessedEventTarget;
   friend class Display;
   friend class test::WindowManagerStateTestApi;
 
   // There are two types of events that may be queued, both occur only when
   // waiting for an ack from a client.
   // . We get an event from the PlatformDisplay. This results in |event| being
   //   set, but |processed_target| is null.
   // . We get an event from the EventDispatcher. In this case both |event| and
   //   |processed_target| are valid.
@@ skipping 66 matching lines @@
 
   // Set to true the first time SetFrameDecorationValues() is called.
   bool got_frame_decoration_values_ = false;
   mojom::FrameDecorationValuesPtr frame_decoration_values_;
 
   mojom::WindowTree* tree_awaiting_input_ack_ = nullptr;
   std::unique_ptr<ui::Event> event_awaiting_input_ack_;
   base::WeakPtr<Accelerator> post_target_accelerator_;
   std::queue<std::unique_ptr<QueuedEvent>> event_queue_;
   base::OneShotTimer event_ack_timer_;
+  std::unique_ptr<CurrentMoveLoopState> current_move_loop_;
 
   EventDispatcher event_dispatcher_;
 
   // PlatformDisplay that currently has capture.
   PlatformDisplay* platform_display_with_capture_ = nullptr;
 
   base::WeakPtrFactory<WindowManagerState> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowManagerState);
 };
 
 }  // namespace ws
 }  // namespace mus
 
 #endif  // COMPONENTS_MUS_WS_WINDOW_MANAGER_STATE_H_