mus: Implement interwindow drag and drop

services/ui/ws/window_tree.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 SERVICES_UI_WS_WINDOW_TREE_H_
 #define SERVICES_UI_WS_WINDOW_TREE_H_
 
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <queue>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/containers/hash_tables.h"
 #include "base/macros.h"
 #include "cc/ipc/surface_id.mojom.h"
 #include "mojo/public/cpp/bindings/associated_binding.h"
 #include "services/ui/public/interfaces/window_tree.mojom.h"
 #include "services/ui/ws/access_policy_delegate.h"
+#include "services/ui/ws/drag_source.h"
+#include "services/ui/ws/drag_target_connection.h"
 #include "services/ui/ws/ids.h"
 #include "services/ui/ws/user_id.h"
 #include "services/ui/ws/window_tree_binding.h"
 
 namespace gfx {
 class Insets;
 class Rect;
 }
 
 namespace ui {
 class Event;
 }
 
 namespace ui {
 namespace ws {
 
 class AccessPolicy;
 class DisplayManager;
 class Display;
+class DragTargetConnection;
 class EventMatcher;
 class ServerWindow;
 class TargetedEvent;
 class WindowManagerDisplayRoot;
 class WindowManagerState;
 class WindowServer;
 class WindowTreeTest;
 
 namespace test {
 class WindowTreeTestApi;
 }
 
 // WindowTree represents a view onto portions of the window tree. The parts of
 // the tree exposed to the client start at the root windows. A WindowTree may
 // have any number of roots (including none). A WindowTree may not have
 // visibility of all the descendants of its roots.
 //
 // WindowTree notifies its client as changes happen to windows exposed to the
 // the client.
 //
 // See ids.h for details on how WindowTree handles identity of windows.
 class WindowTree : public mojom::WindowTree,
                    public AccessPolicyDelegate,
-                   public mojom::WindowManagerClient {
+                   public mojom::WindowManagerClient,
+                   public DragSource,
+                   public DragTargetConnection {
  public:
   WindowTree(WindowServer* window_server,
              const UserId& user_id,
              ServerWindow* root,
              std::unique_ptr<AccessPolicy> access_policy);
   ~WindowTree() override;
 
   void Init(std::unique_ptr<WindowTreeBinding> binding,
             mojom::WindowTreePtr tree);
 
@@ skipping 334 matching lines @@
                                mojo::TextInputStatePtr state) override;
   void SetImeVisibility(Id transport_window_id,
                         bool visible,
                         mojo::TextInputStatePtr state) override;
   void OnWindowInputEventAck(uint32_t event_id,
                              mojom::EventResult result) override;
   void SetClientArea(
       Id transport_window_id,
       const gfx::Insets& insets,
       mojo::Array<gfx::Rect> transport_additional_client_areas) override;
+  void SetCanAcceptDrops(Id window_id, bool accepts_drops) override;
   void SetHitTestMask(Id transport_window_id,
                       const base::Optional<gfx::Rect>& mask) override;
   void GetWindowManagerClient(
       mojo::AssociatedInterfaceRequest<mojom::WindowManagerClient> internal)
       override;
   void GetCursorLocationMemory(const GetCursorLocationMemoryCallback& callback)
       override;
+  void PerformDragDrop(uint32_t change_id,
+                       uint32_t source_window_id,
+                       int32_t drag_pointer,
+                       mojo::Map<mojo::String, mojo::Array<uint8_t>> drag_data,
+                       uint32_t drag_operation) override;
   void PerformWindowMove(uint32_t change_id,
                          Id window_id,
                          ui::mojom::MoveLoopSource source,
                          const gfx::Point& cursor) override;
   void CancelWindowMove(Id window_id) override;
 
   // mojom::WindowManagerClient:
   void AddAccelerator(uint32_t id,
                       mojom::EventMatcherPtr event_matcher,
                       const AddAcceleratorCallback& callback) override;
@@ skipping 15 matching lines @@
   void OnWmCreatedTopLevelWindow(uint32_t change_id,
                                  Id transport_window_id) override;
   void OnAcceleratorAck(uint32_t event_id, mojom::EventResult result) override;
 
   // AccessPolicyDelegate:
   bool HasRootForAccessPolicy(const ServerWindow* window) const override;
   bool IsWindowKnownForAccessPolicy(const ServerWindow* window) const override;
   bool IsWindowRootOfAnotherTreeForAccessPolicy(
       const ServerWindow* window) const override;
 
+  // DragSource:
+  void OnDragCompleted(bool success) override;
+  ServerWindow* GetWindowById(const WindowId& id) override;
+  DragTargetConnection* GetDragTargetWithRoot(
+      const ServerWindow* window) override;
+
+  // DragTargetConnection:
+  void PerformOnDragStart(
+      const ServerWindow* window,
+      mojo::Map<mojo::String, mojo::Array<uint8_t>> mime_data) override;
+  void PerformOnDragEnter(
+      const ServerWindow* window,
+      uint32_t key_state,
+      const gfx::Point& cursor_offset,
+      uint32_t effect_bitmask,
+      const base::Callback<void(uint32_t)>& callback) override;
+  void PerformOnDragOver(
+      const ServerWindow* window,
+      uint32_t key_state,
+      const gfx::Point& cursor_offset,
+      uint32_t effect_bitmask,
+      const base::Callback<void(uint32_t)>& callback) override;
+  void PerformOnDragLeave(const ServerWindow* window) override;
+  void PerformOnDragDrop(
+      const ServerWindow* window,
+      uint32_t key_state,
+      const gfx::Point& cursor_offset,
+      uint32_t effect_bitmask,
+      const base::Callback<void(uint32_t)>& callback) override;
+  void PerformOnDragFinish(const ServerWindow* window) override;
+
   WindowServer* window_server_;
 
   UserId user_id_;
 
   // Id of this tree as assigned by WindowServer.
   const ClientSpecificId id_;
   std::string name_;
 
   ClientSpecificId next_window_id_;
 
@@ skipping 41 matching lines @@
       waiting_for_top_level_window_info_;
   bool embedder_intercepts_events_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(WindowTree);
 };
 
 }  // namespace ws
 }  // namespace ui
 
 #endif  // SERVICES_UI_WS_WINDOW_TREE_H_