Tab dragging as implemented as a mus API.

components/mus/public/cpp/window_tree_client.h

 // 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.
 
 #ifndef COMPONENTS_MUS_PUBLIC_CPP_WINDOW_TREE_CLIENT_H_
 #define COMPONENTS_MUS_PUBLIC_CPP_WINDOW_TREE_CLIENT_H_
 
 #include <stdint.h>
 
 #include <map>
@@ skipping 163 matching lines @@
 
   // Returns the current location of the mouse on screen. Note: this method may
   // race the asynchronous initialization; but in that case we return (0, 0).
   gfx::Point GetCursorScreenPoint();
 
   // See description in window_tree.mojom. When an existing event observer is
   // updated or cleared then any future events from the server for that observer
   // will be ignored.
   void SetEventObserver(mojom::EventMatcherPtr matcher);
 
+  // Performs a window move. This call blocks but spins up a nested message

[sky, 2016/06/29 00:04:08]

Update comment (no longer blocks).

+  // loop to handle incoming move messages.
+  void PerformWindowMove(Window* window,
+                         ::mus::mojom::MoveLoopSource source,
+                         const gfx::Point& cursor_location,
+                         const base::Callback<void(bool)>& callback);
+
+  // Cancels a in progress window move. (If no window is currently being moved,
+  // does nothing.)
+  void CancelWindowMove(Window* window);
+
   // Creates and returns a new Window (which is owned by the window server).
   // Windows are initially hidden, use SetVisible(true) to show.
   Window* NewWindow() { return NewWindow(nullptr); }
   Window* NewWindow(
       const std::map<std::string, std::vector<uint8_t>>* properties);
   Window* NewTopLevelWindow(
       const std::map<std::string, std::vector<uint8_t>>* properties);
 
   void AddObserver(WindowTreeClientObserver* observer);
   void RemoveObserver(WindowTreeClientObserver* observer);
@@ skipping 47 matching lines @@
                    Id focused_window_id,
                    bool drawn);
 
   // Called by WmNewDisplayAdded().
   void WmNewDisplayAddedImpl(const display::Display& display,
                              mojom::WindowDataPtr root_data,
                              bool parent_drawn);
 
   void OnReceivedCursorLocationMemory(mojo::ScopedSharedBufferHandle handle);
 
+  // Callback passed from WmPerformMoveLoop().
+  void OnWmMoveLoopCompleted(uint32_t change_id, bool completed);
+
   // Overridden from WindowTreeClient:
   void OnEmbed(ClientSpecificId client_id,
                mojom::WindowDataPtr root,
                mojom::WindowTreePtr tree,
                int64_t display_id,
                Id focused_window_id,
                bool drawn) override;
   void OnEmbeddedAppDisconnected(Id window_id) override;
   void OnUnembed(Id window_id) override;
   void OnLostCapture(Id window_id) override;
@@ skipping 54 matching lines @@
   void WmSetProperty(uint32_t change_id,
                      Id window_id,
                      const mojo::String& name,
                      mojo::Array<uint8_t> transit_data) override;
   void WmCreateTopLevelWindow(uint32_t change_id,
                               ClientSpecificId requesting_client_id,
                               mojo::Map<mojo::String, mojo::Array<uint8_t>>
                                   transport_properties) override;
   void WmClientJankinessChanged(ClientSpecificId client_id,
                                 bool janky) override;
+  void WmPerformMoveLoop(uint32_t change_id,
+                         Id window_id,
+                         ::mus::mojom::MoveLoopSource source,
+                         const gfx::Point& cursor_location) override;
+  void WmCancelMoveLoop(uint32_t window_id) override;
   void OnAccelerator(uint32_t id, std::unique_ptr<ui::Event> event) override;
 
   // Overridden from WindowManagerClient:
   void SetFrameDecorationValues(
       mojom::FrameDecorationValuesPtr values) override;
   void SetNonClientCursor(Window* window,
                           mus::mojom::Cursor cursor_id) override;
   void AddAccelerator(uint32_t id,
                       mojom::EventMatcherPtr event_matcher,
                       const base::Callback<void(bool)>& callback) override;
@@ skipping 55 matching lines @@
 
   std::unique_ptr<mojo::AssociatedBinding<mojom::WindowManager>>
       window_manager_internal_;
   mojom::WindowManagerClientAssociatedPtr window_manager_internal_client_;
 
   bool has_event_observer_ = false;
 
   // Monotonically increasing ID for event observers.
   uint32_t event_observer_id_ = 0u;
 
+  uint32_t current_move_loop_change_ = 0u;
+
+  // Callback executed when a move loop initiated by PerformWindowMove() is
+  // completed.
+  base::Callback<void(bool)> on_current_move_finished_;
+
   base::WeakPtrFactory<WindowTreeClient> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowTreeClient);
 };
 
 }  // namespace mus
 
 #endif  // COMPONENTS_MUS_PUBLIC_CPP_WINDOW_TREE_CLIENT_H_