Wires up drag/drop for aura-mus

ui/aura/mus/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 UI_AURA_MUS_WINDOW_TREE_CLIENT_H_
 #define UI_AURA_MUS_WINDOW_TREE_CLIENT_H_
 
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/atomicops.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "mojo/public/cpp/bindings/associated_binding.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "services/ui/public/interfaces/window_tree.mojom.h"
 #include "ui/aura/aura_export.h"
 #include "ui/aura/client/capture_client_observer.h"
 #include "ui/aura/client/focus_change_observer.h"
 #include "ui/aura/client/transient_window_client_observer.h"
+#include "ui/aura/mus/drag_drop_controller_host.h"
 #include "ui/aura/mus/mus_types.h"
 #include "ui/aura/mus/window_manager_delegate.h"
 #include "ui/aura/mus/window_tree_host_mus_delegate.h"
 
 namespace display {
 class Display;
 }
 
 namespace gfx {
 class Insets;
 }
 
 namespace service_manager {
 class Connector;
 }
 
 namespace aura {
+class DragDropControllerMus;
 class InFlightBoundsChange;
 class InFlightCaptureChange;
 class InFlightChange;
 class InFlightFocusChange;
 class InFlightPropertyChange;
 class InFlightVisibleChange;
 class WindowMus;
 class WindowPortMus;
 struct WindowPortInitData;
 struct WindowPortPropertyData;
@@ skipping 12 matching lines @@
 //
 // WindowTreeClient is owned by the creator. Generally when the delegate gets
 // one of OnEmbedRootDestroyed() or OnLostConnection() it should delete the
 // WindowTreeClient.
 //
 // When WindowTreeClient is deleted all windows are deleted (and observers
 // notified).
 class AURA_EXPORT WindowTreeClient
     : NON_EXPORTED_BASE(public ui::mojom::WindowTreeClient),
       NON_EXPORTED_BASE(public ui::mojom::WindowManager),
+      public DragDropControllerHost,
       public WindowManagerClient,
       public WindowTreeHostMusDelegate,
       public client::CaptureClientObserver,
       public client::FocusChangeObserver,
       public client::TransientWindowClientObserver {
  public:
   explicit WindowTreeClient(
       WindowTreeClientDelegate* delegate,
       WindowManagerDelegate* window_manager_delegate = nullptr,
       ui::mojom::WindowTreeClientRequest request = nullptr);
@@ skipping 59 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 pointer watcher is
   // updated or cleared then any future events from the server for that watcher
   // will be ignored.
   void StartPointerWatcher(bool want_moves);
   void StopPointerWatcher();
 
-  void 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);
-
-  // Cancels a in progress drag drop. (If no drag is in progress, does
-  // nothing.)
-  void CancelDragDrop(Window* window);
-
   // Performs a window move. |callback| will be asynchronously called with the
   // whether the move loop completed successfully.
   void PerformWindowMove(Window* window,
                          ui::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);
 
   void AddObserver(WindowTreeClientObserver* observer);
   void RemoveObserver(WindowTreeClientObserver* observer);
 
  private:
   friend class InFlightBoundsChange;
   friend class InFlightCaptureChange;
   friend class InFlightFocusChange;
   friend class InFlightPropertyChange;
   friend class InFlightVisibleChange;
   friend class WindowPortMus;
   friend class WindowTreeClientPrivate;
 
-  struct CurrentDragState;
-
   using IdToWindowMap = std::map<Id, WindowMus*>;
 
   // TODO(sky): this assumes change_ids never wrap, which is a bad assumption.
   using InFlightMap = std::map<uint32_t, std::unique_ptr<InFlightChange>>;
 
   void RegisterWindowMus(WindowMus* window);
 
   WindowMus* GetWindowByServerId(Id id);
 
   // Returns true if the specified window was created by this client.
@@ skipping 243 matching lines @@
 
   // Overriden from WindowTreeHostMusDelegate:
   void SetRootWindowBounds(Window* window, gfx::Rect* bounds) override;
 
   // Override from client::TransientWindowClientObserver:
   void OnTransientChildWindowAdded(Window* parent,
                                    Window* transient_child) override;
   void OnTransientChildWindowRemoved(Window* parent,
                                      Window* transient_child) override;
 
+  // Overriden from DragDropControllerHost:
+  uint32_t CreateChangeIdForDrag(WindowMus* window) override;
+
   // The one int in |cursor_location_mapping_|. When we read from this
   // location, we must always read from it atomically.
   base::subtle::Atomic32* cursor_location_memory() {
     return reinterpret_cast<base::subtle::Atomic32*>(
         cursor_location_mapping_.get());
   }
 
   // This is set once and only once when we get OnEmbed(). It gives the unique
   // id for this client.
   ClientSpecificId client_id_;
@@ skipping 49 matching lines @@
   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_;
 
   // The current change id for the window manager.
   uint32_t current_wm_move_loop_change_ = 0u;
   Id current_wm_move_loop_window_id_ = 0u;
 
-  // State related to being the initiator of a drag started with
-  // PerformDragDrop().
-  std::unique_ptr<CurrentDragState> current_drag_state_;
-
-  // The mus server sends the mime drag data once per connection; we cache this
-  // and are responsible for sending it to all of our windows.
-  mojo::Map<mojo::String, mojo::Array<uint8_t>> mime_drag_data_;
-
-  // A set of window ids for windows that we received an OnDragEnter() message
-  // for. We maintain this set so we know who to send OnDragFinish() messages
-  // at the end of the drag.
-  std::set<Id> drag_entered_windows_;
+  std::unique_ptr<DragDropControllerMus> drag_drop_controller_;
 
   base::WeakPtrFactory<WindowTreeClient> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowTreeClient);
 };
 
 }  // namespace aura
 
 #endif  // UI_AURA_MUS_WINDOW_TREE_CLIENT_H_