mus drag and drop: return the completed effect to the caller.

services/ui/public/cpp/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 "services/ui/public/cpp/window_tree_client.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 69 matching lines @@
       root = window;
     last_window = window;
   }
   return root;
 }
 
 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)> on_finished;
+  base::Callback<void(bool, uint32_t)> on_finished;
 };
 
 WindowTreeClient::WindowTreeClient(
     WindowTreeClientDelegate* delegate,
     WindowManagerDelegate* window_manager_delegate,
     mojo::InterfaceRequest<mojom::WindowTreeClient> request)
     : client_id_(0),
       next_window_id_(1),
       next_change_id_(1),
       delegate_(delegate),
@@ skipping 538 matching lines @@
   has_pointer_watcher_ = false;
 }
 
 void WindowTreeClient::PerformDragDrop(
     Window* window,
     int drag_pointer,
     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)>& callback) {
+    const base::Callback<void(bool, uint32_t)>& callback) {
   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, callback});
+  current_drag_state_.reset(new CurrentDragState{
+      current_drag_change, ui::mojom::kDropEffectNone, callback});
 
   tree_->PerformDragDrop(
       current_drag_change, window->server_id(), drag_pointer,
       mojo::Map<mojo::String, mojo::Array<uint8_t>>::From(drag_data),
       drag_operation);
 }
 
 void WindowTreeClient::PerformWindowMove(
     Window* window,
     ui::mojom::MoveLoopSource source,
@@ skipping 482 matching lines @@
   if (!window || !window->drop_target()) {
     callback.Run(mojom::kDropEffectNone);
     return;
   }
 
   uint32_t ret = window->drop_target()->OnCompleteDrop(key_state, position,
                                                        effect_bitmask);
   callback.Run(ret);
 }
 
+void WindowTreeClient::OnPerformDragDropCompleted(uint32_t change_id,
+                                                  bool success,
+                                                  uint32_t action_taken) {
+  if (current_drag_state_ && change_id == current_drag_state_->change_id) {
+    current_drag_state_->completed_action = action_taken;
+    OnChangeCompleted(change_id, success);
+  }
+}
+
 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_->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<mojom::WindowManager>(this,
                                                         std::move(internal)));
 }
@@ skipping 187 matching lines @@
     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);
   }
 }
 
 }  // namespace ui