Tab dragging as implemented as a mus API.

ash/mus/frame/move_event_handler.cc

 // Copyright 2015 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 "ash/mus/frame/move_event_handler.h"
 
 #include "ash/mus/bridge/wm_window_mus.h"
+#include "base/lazy_instance.h"
 #include "components/mus/public/cpp/window.h"
 #include "components/mus/public/cpp/window_manager_delegate.h"
 #include "components/mus/public/interfaces/cursor.mojom.h"
 #include "ui/aura/window.h"
 #include "ui/base/hit_test.h"
 #include "ui/events/event.h"
 
 namespace ash {
 namespace mus {
 namespace {
 
+base::LazyInstance<std::map<WmWindow*, MoveEventHandler*>> g_live_handlers =
+    LAZY_INSTANCE_INITIALIZER;
+
 ::mus::mojom::Cursor CursorForWindowComponent(int window_component) {
   switch (window_component) {
     case HTBOTTOM:
       return ::mus::mojom::Cursor::SOUTH_RESIZE;
     case HTBOTTOMLEFT:
       return ::mus::mojom::Cursor::SOUTH_WEST_RESIZE;
     case HTBOTTOMRIGHT:
       return ::mus::mojom::Cursor::SOUTH_EAST_RESIZE;
     case HTLEFT:
       return ::mus::mojom::Cursor::WEST_RESIZE;
     case HTRIGHT:
       return ::mus::mojom::Cursor::EAST_RESIZE;
     case HTTOP:
       return ::mus::mojom::Cursor::NORTH_RESIZE;
     case HTTOPLEFT:
       return ::mus::mojom::Cursor::NORTH_WEST_RESIZE;
     case HTTOPRIGHT:
       return ::mus::mojom::Cursor::NORTH_EAST_RESIZE;
     default:
       return ::mus::mojom::Cursor::CURSOR_NULL;
   }
 }
 
+void OnMoveLoopCompleted(const base::Callback<void(bool success)>& end_closure,
+                         wm::WmToplevelWindowEventHandler::DragResult result) {
+  end_closure.Run(result ==
+                  wm::WmToplevelWindowEventHandler::DragResult::SUCCESS);
+}
+
 }  // namespace
 
 MoveEventHandler::MoveEventHandler(
     ::mus::Window* mus_window,
     ::mus::WindowManagerClient* window_manager_client,
     aura::Window* aura_window)
     : wm_window_(WmWindowMus::Get(mus_window)),
       window_manager_client_(window_manager_client),
       root_window_(aura_window->GetRootWindow()),
       toplevel_window_event_handler_(wm_window_->GetShell()) {
   root_window_->AddObserver(this);
   root_window_->AddPreTargetHandler(this);
+
+  DCHECK(g_live_handlers.Get().find(wm_window_) == g_live_handlers.Get().end());
+  g_live_handlers.Get()[wm_window_] = this;
 }
 
 MoveEventHandler::~MoveEventHandler() {
   Detach();
 }
 
+// static
+MoveEventHandler* MoveEventHandler::GetForWindow(WmWindow* wm_window) {
+  auto it = g_live_handlers.Get().find(wm_window);
+  if (it != g_live_handlers.Get().end())
+    return it->second;
+  return nullptr;
+}
+
+void MoveEventHandler::AttemptToStartDrag(
+    const gfx::Point& point_in_parent,
+    int window_component,
+    const base::Callback<void(bool success)>& end_closure) {
+  toplevel_window_event_handler_.AttemptToStartDrag(
+      wm_window_, point_in_parent, window_component,
+      aura::client::WINDOW_MOVE_SOURCE_MOUSE,
+      base::Bind(&OnMoveLoopCompleted, end_closure));
+}
+
+void MoveEventHandler::RevertDrag() {
+  toplevel_window_event_handler_.RevertDrag();
+}
+
 void MoveEventHandler::Detach() {
   if (!root_window_)
     return;
 
   root_window_->RemoveObserver(this);
   root_window_->RemovePreTargetHandler(this);
   root_window_ = nullptr;
+
+  g_live_handlers.Get().erase(wm_window_);
 }
 
 void MoveEventHandler::OnMouseEvent(ui::MouseEvent* event) {
   toplevel_window_event_handler_.OnMouseEvent(event, wm_window_);
   if (!toplevel_window_event_handler_.is_drag_in_progress() &&
       (event->type() == ui::ET_POINTER_MOVED ||
        event->type() == ui::ET_MOUSE_MOVED)) {
     const int hit_test_location =
         wm_window_->GetNonClientComponent(event->location());
     window_manager_client_->SetNonClientCursor(
         wm_window_->mus_window(), CursorForWindowComponent(hit_test_location));
   }
 }
 
 void MoveEventHandler::OnGestureEvent(ui::GestureEvent* event) {
   toplevel_window_event_handler_.OnGestureEvent(event, wm_window_);
 }
 
 void MoveEventHandler::OnCancelMode(ui::CancelModeEvent* event) {
   toplevel_window_event_handler_.RevertDrag();
 }
 
 void MoveEventHandler::OnWindowDestroying(aura::Window* window) {
   DCHECK_EQ(root_window_, window);
   Detach();
 }
 
 }  // namespace mus
 }  // namespace ash