Tab dragging as implemented as a mus API.

components/mus/public/cpp/lib/window_tree_client.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/public/cpp/window_tree_client.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
+#include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
 #include "components/mus/common/util.h"
 #include "components/mus/public/cpp/input_event_handler.h"
 #include "components/mus/public/cpp/lib/in_flight_change.h"
 #include "components/mus/public/cpp/lib/window_private.h"
 #include "components/mus/public/cpp/window_manager_delegate.h"
 #include "components/mus/public/cpp/window_observer.h"
 #include "components/mus/public/cpp/window_tracker.h"
 #include "components/mus/public/cpp/window_tree_client_delegate.h"
 #include "components/mus/public/cpp/window_tree_client_observer.h"
 #include "components/mus/public/interfaces/window_manager_window_tree_factory.mojom.h"
@@ skipping 200 matching lines @@
 }
 
 bool WindowTreeClient::OwnsWindow(Window* window) const {
   // Windows created via CreateTopLevelWindow() are not owned by us, but have
   // our client id.
   return HiWord(server_id(window)) == client_id_ &&
          roots_.count(window) == 0;
 }
 
 void WindowTreeClient::SetBounds(Window* window,
-                                     const gfx::Rect& old_bounds,
-                                     const gfx::Rect& bounds) {
+                                 const gfx::Rect& old_bounds,
+                                 const gfx::Rect& bounds) {
   DCHECK(tree_);
   const uint32_t change_id = ScheduleInFlightChange(
       base::WrapUnique(new InFlightBoundsChange(window, old_bounds)));
   tree_->SetWindowBounds(change_id, server_id(window), bounds);
 }
 
 void WindowTreeClient::SetCapture(Window* window) {
   // In order for us to get here we had to have exposed a window, which implies
   // we got a client.
   DCHECK(tree_);
@@ skipping 370 matching lines @@
   if (matcher.is_null()) {
     has_event_observer_ = false;
     tree_->SetEventObserver(nullptr, 0u);
   } else {
     has_event_observer_ = true;
     event_observer_id_++;
     tree_->SetEventObserver(std::move(matcher), event_observer_id_);
   }
 }
 
+bool WindowTreeClient::PerformWindowMove(Window* window,
+                                         const gfx::Point& cursor_location) {
+  base::MessageLoopForUI* loop = base::MessageLoopForUI::current();
+  base::MessageLoop::ScopedNestableTaskAllower allow_nested(loop);

[sky, 2016/06/22 23:47:56]

mus::Window shouldn't run a nested message loop. Clients that want a nested
message loop (NativeWidgetMus) can run one if they want to.

Also, this code should only allow one move loop at a time.

+  base::RunLoop run_loop;
+
+  const uint32_t change_id = ScheduleInFlightChange(
+      base::WrapUnique(new InFlightMoveLoopChange(window, window->bounds())));
+
+  current_move_succeeded_ = false;
+  on_current_move_finished_ = run_loop.QuitClosure();
+
+  // Tell the window manager to take over moving us.
+  tree_->PerformWindowMove(change_id, window->server_id(), cursor_location);
+
+  // PerformWindowMove is deliberately not a sync call. We want to process
+  // other messages while we're otherwise blocking on RunMoveLoop(); everything
+  // in views makes this assumption.
+  //
+  // TODO(erg): Once mus is the only target for views, go through the chrome
+  // code base and try making this properly asynchronous instead of building up
+  // a nested RunLoop, as we always have in this situation.
+  run_loop.Run();
+
+  return current_move_succeeded_;
+}
+
+void WindowTreeClient::CancelWindowMove(Window* window) {
+  tree_->CancelWindowMove(window->server_id());
+}
+
 Window* WindowTreeClient::NewWindow(
     const Window::SharedProperties* properties) {
   return NewWindowImpl(NewWindowType::CHILD, properties);
 }
 
 Window* WindowTreeClient::NewTopLevelWindow(
     const Window::SharedProperties* properties) {
   Window* window = NewWindowImpl(NewWindowType::TOP_LEVEL, properties);
   // Assume newly created top level windows are drawn by default, otherwise
   // requests to focus will fail. We will get the real value in
@@ skipping 377 matching lines @@
 
   InFlightChange* next_change = GetOldestInFlightChangeMatching(*change);
   if (next_change) {
     if (!success)
       next_change->SetRevertValueFrom(*change);
   } else if (!success) {
     change->Revert();
   }
 }
 
+void WindowTreeClient::OnMoveLoopCompleted(uint32_t change_id, bool success) {
+  std::unique_ptr<InFlightChange> change(std::move(in_flight_map_[change_id]));
+  in_flight_map_.erase(change_id);
+  if (!change)
+    return;
+
+  current_move_succeeded_ = success;
+  on_current_move_finished_.Run();
+}
+
 void WindowTreeClient::GetWindowManager(
     mojo::AssociatedInterfaceRequest<WindowManager> internal) {
   window_manager_internal_.reset(
       new mojo::AssociatedBinding<mojom::WindowManager>(this,
                                                         std::move(internal)));
 }
 
 void WindowTreeClient::RequestClose(uint32_t window_id) {
   Window* window = GetWindowByServerId(window_id);
   if (!window || !IsRoot(window))
@@ skipping 28 matching lines @@
       // the client applies the bounds we set below.
       result = bounds == transit_bounds;
       window->SetBounds(bounds);
     }
   }
   if (window_manager_internal_client_)
     window_manager_internal_client_->WmResponse(change_id, result);
 }
 
 void WindowTreeClient::WmSetProperty(uint32_t change_id,
-                                         Id window_id,
-                                         const mojo::String& name,
-                                         mojo::Array<uint8_t> transit_data) {
+                                     Id window_id,
+                                     const mojo::String& name,
+                                     mojo::Array<uint8_t> transit_data) {
   Window* window = GetWindowByServerId(window_id);
   bool result = false;
   if (window) {
     DCHECK(window_manager_delegate_);
     std::unique_ptr<std::vector<uint8_t>> data;
     if (!transit_data.is_null()) {
       data.reset(
           new std::vector<uint8_t>(transit_data.To<std::vector<uint8_t>>()));
     }
     result = window_manager_delegate_->OnWmSetProperty(window, name, &data);
@@ skipping 16 matching lines @@
   Window* window =
       window_manager_delegate_->OnWmCreateTopLevelWindow(&properties);
   embedded_windows_[requesting_client_id].insert(window);
   if (window_manager_internal_client_) {
     window_manager_internal_client_->OnWmCreatedTopLevelWindow(
         change_id, server_id(window));
   }
 }
 
 void WindowTreeClient::WmClientJankinessChanged(ClientSpecificId client_id,
-                                                    bool janky) {
+                                                bool janky) {
   if (window_manager_delegate_) {
     auto it = embedded_windows_.find(client_id);
     CHECK(it != embedded_windows_.end());
     window_manager_delegate_->OnWmClientJankinessChanged(
         embedded_windows_[client_id], janky);
   }
 }
 
+void WindowTreeClient::WmPerformMoveLoop(uint32_t change_id,
+                                         Id window_id,
+                                         const gfx::Point& cursor_location) {
+  if (window_manager_delegate_)
+    window_manager_delegate_->OnWmPerformMoveLoop(change_id, window_id,
+                                                  cursor_location);
+}
+
+void WindowTreeClient::WmCancelMoveLoop(uint32_t window_id) {
+  if (window_manager_delegate_)
+    window_manager_delegate_->OnWmCancelMoveLoop(window_id);
+}
+
 void WindowTreeClient::OnAccelerator(uint32_t id,
                                      std::unique_ptr<ui::Event> event) {
   DCHECK(event);
   window_manager_delegate_->OnAccelerator(id, *event.get());
 }
 
 void WindowTreeClient::SetFrameDecorationValues(
     mojom::FrameDecorationValuesPtr values) {
   if (window_manager_internal_client_) {
     window_manager_internal_client_->WmSetFrameDecorationValues(
         std::move(values));
   }
 }
 
 void WindowTreeClient::SetNonClientCursor(Window* window,
-                                              mus::mojom::Cursor cursor_id) {
+                                          mus::mojom::Cursor cursor_id) {
   window_manager_internal_client_->WmSetNonClientCursor(server_id(window),
                                                         cursor_id);
 }
 
 void WindowTreeClient::AddAccelerator(
     uint32_t id,
     mojom::EventMatcherPtr event_matcher,
     const base::Callback<void(bool)>& callback) {
   if (window_manager_internal_client_) {
     window_manager_internal_client_->AddAccelerator(
@@ skipping 25 matching lines @@
 void WindowTreeClient::SetUnderlaySurfaceOffsetAndExtendedHitArea(
     Window* window,
     const gfx::Vector2d& offset,
     const gfx::Insets& hit_area) {
   if (window_manager_internal_client_) {
     window_manager_internal_client_->SetUnderlaySurfaceOffsetAndExtendedHitArea(
         server_id(window), offset.x(), offset.y(), hit_area);
   }
 }
 
+void WindowTreeClient::OnWmMoveLoopCompleted(uint32_t change_id,
+                                             uint32_t window_id,
+                                             bool completed) {
+  if (window_manager_internal_client_) {
+    window_manager_internal_client_->OnWmMoveLoopCompleted(change_id, window_id,
+                                                           completed);
+  }
+}
+
 }  // namespace mus