Wires up drag/drop for aura-mus

ui/aura/mus/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 "ui/aura/mus/window_tree_client.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "services/service_manager/public/cpp/connector.h"
 #include "services/ui/public/interfaces/window_manager_window_tree_factory.mojom.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/capture_client.h"
+#include "ui/aura/client/drag_drop_client.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/client/transient_window_client.h"
+#include "ui/aura/mus/drag_drop_controller_mus.h"
 #include "ui/aura/mus/in_flight_change.h"
 #include "ui/aura/mus/input_method_mus.h"
 #include "ui/aura/mus/property_converter.h"
 #include "ui/aura/mus/surface_id_handler.h"
 #include "ui/aura/mus/window_manager_delegate.h"
 #include "ui/aura/mus/window_mus.h"
 #include "ui/aura/mus/window_port_mus.h"
 #include "ui/aura/mus/window_tree_client_delegate.h"
 #include "ui/aura/mus/window_tree_client_observer.h"
 #include "ui/aura/mus/window_tree_host_mus.h"
@@ skipping 94 matching lines @@
 WindowTreeHostMus* GetWindowTreeHostMus(WindowMus* window) {
   return GetWindowTreeHostMus(window->GetWindow());
 }
 
 bool IsInternalProperty(const void* key) {
   return key == client::kModalKey;
 }
 
 }  // namespace
 
-struct WindowTreeClient::CurrentDragState {
-  // The current change id of the current drag an drop ipc.
-  uint32_t change_id;
-
-  // The effect to return when we send our finish signal.
-  uint32_t completed_action;
-
-  // Callback executed when a drag initiated by PerformDragDrop() is completed.
-  base::Callback<void(bool, uint32_t)> on_finished;
-};
-
 WindowTreeClient::WindowTreeClient(
     WindowTreeClientDelegate* delegate,
     WindowManagerDelegate* window_manager_delegate,
     mojo::InterfaceRequest<ui::mojom::WindowTreeClient> request)
     : client_id_(0),
       next_window_id_(1),
       next_change_id_(1),
       delegate_(delegate),
       window_manager_delegate_(window_manager_delegate),
       binding_(this),
@@ skipping 316 matching lines @@
       // See WindowTreeHostMus for details on ownership.
       new WindowTreeHostMus(base::MakeUnique<WindowPortMus>(this, false), this,
                             type, display_id, user_window);
       break;
     }
   }
   WindowMus* user_window_mus = WindowMus::Get(user_window);
   roots_.insert(user_window_mus);
   if (!window_data.is_null())
     SetLocalPropertiesFromServerProperties(user_window_mus, window_data);
+  // All WindowTreeHosts are destroyed before this, so we don't need to unset
+  // the DragDropClient.
+  client::SetDragDropClient(user_window->GetRootWindow(),
+                            drag_drop_controller_.get());
   return user_window;
 }
 
 WindowMus* WindowTreeClient::NewWindowFromWindowData(
     WindowMus* parent,
     const ui::mojom::WindowDataPtr& window_data) {
   std::unique_ptr<WindowPortMus> window_port_mus(
       CreateWindowPortMus(window_data));
   WindowPortMus* window_port_mus_ptr = window_port_mus.get();
   Window* window = new Window(nullptr, std::move(window_port_mus));
   WindowMus* window_mus = window_port_mus_ptr;
   window->Init(ui::LAYER_NOT_DRAWN);
   SetLocalPropertiesFromServerProperties(window_mus, window_data);
   window_mus->SetBoundsFromServer(window_data->bounds);
   if (parent)
     parent->AddChildFromServer(window_port_mus_ptr);
   if (window_data->visible)
     window_mus->SetVisibleFromServer(true);
   return window_port_mus_ptr;
 }
 
 void WindowTreeClient::SetWindowTree(ui::mojom::WindowTreePtr window_tree_ptr) {
   tree_ptr_ = std::move(window_tree_ptr);
   tree_ = tree_ptr_.get();
 
+  drag_drop_controller_ = base::MakeUnique<DragDropControllerMus>(this, tree_);
+
   tree_ptr_->GetCursorLocationMemory(
       base::Bind(&WindowTreeClient::OnReceivedCursorLocationMemory,
                  weak_factory_.GetWeakPtr()));
 
   tree_ptr_.set_connection_error_handler(base::Bind(
       &WindowTreeClient::OnConnectionLost, weak_factory_.GetWeakPtr()));
 
   if (window_manager_delegate_) {
     tree_ptr_->GetWindowManagerClient(GetProxy(&window_manager_internal_client_,
                                                tree_ptr_.associated_group()));
@@ skipping 369 matching lines @@
   has_pointer_watcher_ = true;
   tree_->StartPointerWatcher(want_moves);
 }
 
 void WindowTreeClient::StopPointerWatcher() {
   DCHECK(has_pointer_watcher_);
   tree_->StopPointerWatcher();
   has_pointer_watcher_ = false;
 }
 
-void WindowTreeClient::PerformDragDrop(
-    Window* window,
-    const std::map<std::string, std::vector<uint8_t>>& drag_data,
-    int drag_operation,
-    const gfx::Point& cursor_location,
-    const SkBitmap& bitmap,
-    const base::Callback<void(bool, uint32_t)>& callback) {
-  // TODO: dnd.
-  /*
-  DCHECK(!current_drag_state_);
-
-  // TODO(erg): Pass |cursor_location| and |bitmap| in PerformDragDrop() when
-  // we start showing an image representation of the drag under he cursor.
-
-  if (window->drop_target()) {
-    // To minimize the number of round trips, copy the drag drop data to our
-    // handler here, instead of forcing mus to send this same data back.
-    OnDragDropStart(
-        mojo::Map<mojo::String, mojo::Array<uint8_t>>::From(drag_data));
-  }
-
-  uint32_t current_drag_change = ScheduleInFlightChange(
-      base::MakeUnique<InFlightDragChange>(window, ChangeType::DRAG_LOOP));
-  current_drag_state_.reset(new CurrentDragState{
-      current_drag_change, ui::mojom::kDropEffectNone, callback});
-
-  tree_->PerformDragDrop(
-      current_drag_change, window->server_id(),
-      mojo::Map<mojo::String, mojo::Array<uint8_t>>::From(drag_data),
-      drag_operation);
-  */
-}
-
-void WindowTreeClient::CancelDragDrop(Window* window) {
-  // Server will clean up drag and fail the in-flight change.
-  tree_->CancelDragDrop(WindowMus::Get(window)->server_id());
-}
-
 void WindowTreeClient::PerformWindowMove(
     Window* window,
     ui::mojom::MoveLoopSource source,
     const gfx::Point& cursor_location,
     const base::Callback<void(bool)>& callback) {
   DCHECK(on_current_move_finished_.is_null());
   on_current_move_finished_ = callback;
 
   WindowMus* window_mus = WindowMus::Get(window);
   current_move_loop_change_ = ScheduleInFlightChange(
@@ skipping 405 matching lines @@
   std::unique_ptr<SurfaceInfo> surface_info(base::MakeUnique<SurfaceInfo>());
   surface_info->surface_id = surface_id;
   surface_info->surface_sequence = surface_sequence;
   surface_info->frame_size = frame_size;
   surface_info->device_scale_factor = device_scale_factor;
   window->SetSurfaceIdFromServer(std::move(surface_info));
 }
 
 void WindowTreeClient::OnDragDropStart(
     mojo::Map<mojo::String, mojo::Array<uint8_t>> mime_data) {
-  mime_drag_data_ = std::move(mime_data);
+  drag_drop_controller_->OnDragDropStart(
+      mime_data.To<std::map<std::string, std::vector<uint8_t>>>());
 }
 
 void WindowTreeClient::OnDragEnter(Id window_id,
                                    uint32_t key_state,
                                    const gfx::Point& position,
                                    uint32_t effect_bitmask,
                                    const OnDragEnterCallback& callback) {
-  // TODO: dnd.
-  /*
-  Window* window = GetWindowByServerId(window_id);
-  if (!window || !window->drop_target()) {
-    callback.Run(ui::mojom::kDropEffectNone);
-    return;
-  }
-
-  if (!base::ContainsKey(drag_entered_windows_, window_id)) {
-    window->drop_target()->OnDragDropStart(
-        mime_drag_data_.To<std::map<std::string, std::vector<uint8_t>>>());
-    drag_entered_windows_.insert(window_id);
-  }
-
-  uint32_t ret =
-      window->drop_target()->OnDragEnter(key_state, position, effect_bitmask);
-  callback.Run(ret);
-  */
+  callback.Run(drag_drop_controller_->OnDragEnter(
+      GetWindowByServerId(window_id), key_state, position, effect_bitmask));
 }
 
 void WindowTreeClient::OnDragOver(Id window_id,
                                   uint32_t key_state,
                                   const gfx::Point& position,
                                   uint32_t effect_bitmask,
                                   const OnDragOverCallback& callback) {
-  // TODO: dnd.
-  /*
-  Window* window = GetWindowByServerId(window_id);
-  if (!window || !window->drop_target()) {
-    callback.Run(ui::mojom::kDropEffectNone);
-    return;
-  }
-
-  uint32_t ret =
-      window->drop_target()->OnDragOver(key_state, position, effect_bitmask);
-  callback.Run(ret);
-  */
+  callback.Run(drag_drop_controller_->OnDragOver(
+      GetWindowByServerId(window_id), key_state, position, effect_bitmask));
 }
 
 void WindowTreeClient::OnDragLeave(Id window_id) {
-  // TODO: dnd.
-  /*
-  Window* window = GetWindowByServerId(window_id);
-  if (!window || !window->drop_target())
-    return;
-
-  window->drop_target()->OnDragLeave();
-  */
+  drag_drop_controller_->OnDragLeave(GetWindowByServerId(window_id));
 }
 
 void WindowTreeClient::OnDragDropDone() {
-  // TODO: dnd.
-  /*
-  for (Id id : drag_entered_windows_) {
-    Window* window = GetWindowByServerId(id);
-    if (!window || !window->drop_target())
-      continue;
-    window->drop_target()->OnDragDropDone();
-  }
-  drag_entered_windows_.clear();
-  */
+  drag_drop_controller_->OnDragDropDone();
 }
 
 void WindowTreeClient::OnCompleteDrop(Id window_id,
                                       uint32_t key_state,
                                       const gfx::Point& position,
                                       uint32_t effect_bitmask,
                                       const OnCompleteDropCallback& callback) {
-  // TODO: dnd.
-  /*
-  Window* window = GetWindowByServerId(window_id);
-  if (!window || !window->drop_target()) {
-    callback.Run(ui::mojom::kDropEffectNone);
-    return;
-  }
-
-  uint32_t ret = window->drop_target()->OnCompleteDrop(key_state, position,
-                                                       effect_bitmask);
-  callback.Run(ret);
-  */
+  callback.Run(drag_drop_controller_->OnCompleteDrop(
+      GetWindowByServerId(window_id), key_state, position, effect_bitmask));
 }
 
 void WindowTreeClient::OnPerformDragDropCompleted(uint32_t change_id,
                                                   bool success,
                                                   uint32_t action_taken) {
-  // TODO: dnd.
-  /*
-  if (current_drag_state_ && change_id == current_drag_state_->change_id) {
-    current_drag_state_->completed_action = action_taken;
+  if (drag_drop_controller_->DoesChangeIdMatchDragChangeId(change_id)) {
     OnChangeCompleted(change_id, success);
+    drag_drop_controller_->OnPerformDragDropCompleted(action_taken);
   }
-  */
 }
 
 void WindowTreeClient::OnChangeCompleted(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;
 
   if (!success)
     change->ChangeFailed();
 
   InFlightChange* next_change = GetOldestInFlightChangeMatching(*change);
   if (next_change) {
     if (!success)
       next_change->SetRevertValueFrom(*change);
   } else if (!success) {
     change->Revert();
   }
 
   if (change_id == current_move_loop_change_) {
     current_move_loop_change_ = 0;
     on_current_move_finished_.Run(success);
     on_current_move_finished_.Reset();
   }
-
-  if (current_drag_state_ && change_id == current_drag_state_->change_id) {
-    OnDragDropDone();
-
-    current_drag_state_->on_finished.Run(success,
-                                         current_drag_state_->completed_action);
-    current_drag_state_.reset();
-  }
 }
 
 void WindowTreeClient::GetWindowManager(
     mojo::AssociatedInterfaceRequest<WindowManager> internal) {
   window_manager_internal_.reset(
       new mojo::AssociatedBinding<ui::mojom::WindowManager>(
           this, std::move(internal)));
 }
 
 void WindowTreeClient::RequestClose(uint32_t window_id) {
@@ skipping 55 matching lines @@
     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) {
   WindowMus* window = GetWindowByServerId(window_id);
   bool result = false;
   if (window) {
-    // TODO: map properties.
     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->GetWindow(),
                                                        name, &data);
     if (result) {
       delegate_->GetPropertyConverter()->SetPropertyFromTransportValue(
@@ skipping 208 matching lines @@
   }
   // The change originated from client code and needs to be sent to the server.
   DCHECK(tree_);
   WindowMus* child_mus = WindowMus::Get(transient_child);
   const uint32_t change_id =
       ScheduleInFlightChange(base::MakeUnique<CrashInFlightChange>(
           child_mus, ChangeType::REMOVE_TRANSIENT_WINDOW_FROM_PARENT));
   tree_->RemoveTransientWindowFromParent(change_id, child_mus->server_id());
 }
 
+uint32_t WindowTreeClient::CreateChangeIdForDrag(WindowMus* window) {
+  return ScheduleInFlightChange(
+      base::MakeUnique<InFlightDragChange>(window, ChangeType::DRAG_LOOP));
+}
+
 }  // namespace aura