mus: Implement interwindow drag and drop

services/ui/public/interfaces/window_tree.mojom

 // 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.
 
 module ui.mojom;
 
 import "cc/ipc/surface_id.mojom";
 import "services/ui/public/interfaces/cursor.mojom";
 import "services/ui/public/interfaces/event_matcher.mojom";
 import "services/ui/public/interfaces/mus_constants.mojom";
@@ skipping 95 matching lines @@
   // TODO(sky): convert additional_client_areas to a path.
   SetClientArea(uint32 window_id,
                 gfx.mojom.Insets insets,
                 array<gfx.mojom.Rect>? additional_client_areas);
 
   // Mouse events outside a hit test mask do not hit the window. The |mask| is
   // in window local coordinates. Pass null to clear the mask.
   // TODO(jamescook): Convert |mask| to a path. http://crbug.com/613210
   SetHitTestMask(uint32 window_id, gfx.mojom.Rect? mask);
 
+  // Called by clients that want to accept drag and drops. Windows default to
+  // this being disabled; a window must actively opt-in to receiving OnDrag*()
+  // calls.
+  SetCanAcceptDrops(uint32 window_id, bool accepts_drops);
+
   // Sets the visibility of the specified window to |visible|. Connections are
   // allowed to change the visibility of any window they have created, as well
   // as any of their roots.
   SetWindowVisibility(uint32 change_id, uint32 window_id, bool visible);
 
   // Sets an individual named property. Setting an individual property to null
   // deletes the property.
   SetWindowProperty(uint32 change_id,
                     uint32 window_id,
                     string name,
@@ skipping 137 matching lines @@
   // Tells the window manager to start moving the window. OnChangeCompleted is
   // called on whether the move was canceled. Because there's a delay between
   // when a client sends this message and when the window manager starts acting
   // on it, pass the cursor location at the start of the move.
   PerformWindowMove(uint32 change_id, uint32 window_id, MoveLoopSource source,
                     gfx.mojom.Point cursor);
 
   // Tells the window manager to cancel any in progress window move started with
   // StartWindowMove() and to revert the window bounds to how they were.
   CancelWindowMove(uint32 window_id);
+
+  // Called by the client to start a drag operation. |source_window_id| is the
+  // source window, |drag_data| is the entire set of mime to raw data
+  // mapping. We send this during the start of the drag because most views
+  // clients will try to read all this data on first entry.
+  PerformDragDrop(uint32 change_id,
+                  uint32 source_window_id,
+                  int32 drag_pointer,
+                  map<string, array<uint8>> drag_data,
+                  uint32 drag_operation);
 };
 
 // Changes to windows are not sent to the connection that originated the
 // change. For example, if connection 1 changes the bounds of a window by
 // calling SetWindowBounds(), connection 1 does not receive
 // OnWindowBoundsChanged().
 interface WindowTreeClient {
   // Invoked when the client application has been embedded at |root|.
   // See Embed() on WindowTree for more details. |tree| will be a handle back to
   // the window manager service, unless the connection is to the root connection
@@ skipping 110 matching lines @@
 
   // Called in two distinct cases: when a window known to the connection gains
   // focus, or when focus moves from a window known to the connection to a
   // window not known to the connection. In the later case |focused_window_id|
   // is 0. As with other functions this is only called if the client did not
   // initiate the change.
   OnWindowFocused(uint32 focused_window_id);
 
   OnWindowPredefinedCursorChanged(uint32 window_id, Cursor cursor_id);
 
+  // Called when the mouse cursor enters a window that has opted into accepting
+  // drags for the first time, providing a list of available mime types. We
+  // want to send this set of data only one time, so this isn't part of
+  // OnDragEnter(), which occurs every time the mouse enters a window.
+  OnDragStart(uint32 window,

[sky, 2016/09/08 23:37:20]

Based on the name I thought this was a callback from initiating a drag. But that
isn't the case. This function is about providing the mime types. Maybe
OnDragMimeTypes(...)?

Is there a reason the window is needed here? It seems like it would be better to
call this function once per connection, rather than per once per window in a
connection.

Also, did you consider grouping these functions in an associated interface?
Placing them in a separate interface means you have better lifetime (you
wouldn't need OnDragFinish() for one). I'm thinking of something like
GetDropTarget(mime_types, associated DropTarget& drop_target).

[Elliot Glaysher, 2016/09/13 00:14:19]

I renamed this and also changed it to transfer once per connection instead of
once per window.
 
I experimented with this, but this turns a bunch of explicit
OnDragMimeTypes/OnDragFinish() calls into some implicit calls around the
lifetime of a wrapper around DropTarget. (Ownership becomes an issue to worry
about since WindowTree would have to offer the same DropTarget for multiple
windows; DragController asks DragSource for the DropTargetConnection (or
DropTarget in this world) per window, and WindowTree can pass a different
WindowTree back.) 

+              map<string, array<uint8>> drag_data);
+
+  // Called when the mouse cursor enters a window that has opted into
+  // accepting drags through SetAcceptsDrags(), providing a list
+  // of available mime types.  Returns a bitmask of the supported
+  // operations.
+  OnDragEnter(uint32 window,
+              uint32 key_state,
+              gfx.mojom.Point position,
+              uint32 effect_bitmask) => (uint32 supported_op_bitmask);
+
+  // Called when the pointer moves over the window after the initial
+  // DragEnter. Returns a bitmask of the supported operations at this
+  // location.
+  OnDragOver(uint32 window,
+             uint32 key_state,
+             gfx.mojom.Point position,
+             uint32 effect_bitmask) => (uint32 supported_op_bitmask);
+
+  // Called when the pointer leaves a window or if the drop is
+  // canceled.
+  OnDragLeave(uint32 window);
+
+  // Called when the drop occurs on a window. Returns the action
+  // taken.
+  OnDragDrop(uint32 window,

[sky, 2016/09/08 23:37:20]

The 'Drag' in the name here is mildly confusing. How about OnDrop or
OnPerformDrop to better indicate this should process the actual drop.

[Elliot Glaysher, 2016/09/13 00:14:19]

Renamed to OnCompleteDrop (I'm already using the word perform in another
context).

+             uint32 key_state,
+             gfx.mojom.Point position,
+             uint32 effect_bitmask) => (uint32 effect_taken);
+
+  // Called after OnDragDrop completes for every |window| which received an
+  // OnDragStart() message. This signals that a client can forget the
+  // |drag_data| passed in via the first message.
+  OnDragFinish(uint32 window);
+
   // A change initiated from the client has completed. See description of
   // change ids for details.
   OnChangeCompleted(uint32 change_id, bool success);
 
   // The WindowManager is requesting the specified window to close. If the
   // client allows the change it should delete the window.
   RequestClose(uint32 window_id);
 
   // See description of WindowManager for details.
   GetWindowManager(associated WindowManager& internal);
 };
 
 // Mus provides this interface as a way for clients to connect and obtain a
 // WindowTree handle with a supplied WindowTreeClient handle. The
 // WindowTreeClient has no roots, use NewTopLevelWindow() to create one.
 interface WindowTreeFactory {
   CreateWindowTree(WindowTree& tree_request, WindowTreeClient client);
 };