mus: Implement interwindow drag and drop

services/ui/ws/event_dispatcher.h

 // Copyright 2015 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_EVENT_DISPATCHER_H_
 #define SERVICES_UI_WS_EVENT_DISPATCHER_H_
 
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <utility>
 
 #include "base/macros.h"
 #include "services/ui/common/types.h"
 #include "services/ui/public/interfaces/event_matcher.mojom.h"
+#include "services/ui/ws/current_drag_operation_delegate.h"
 #include "services/ui/ws/modal_window_controller.h"
 #include "services/ui/ws/server_window_observer.h"
 #include "ui/gfx/geometry/rect_f.h"
 
 namespace ui {
 class Event;
 class KeyEvent;
 class LocatedEvent;
 
 namespace ws {
 
 class Accelerator;
+class CurrentDragOperation;
 class EventDispatcherDelegate;
 class ServerWindow;
+class WindowTree;
 
 namespace test {
 class EventDispatcherTestApi;
 }
 
 // Handles dispatching events to the right location as well as updating focus.
-class EventDispatcher : public ServerWindowObserver {
+class EventDispatcher : public ServerWindowObserver,
+                        public CurrentDragOperationDelegate {
  public:
   enum class AcceleratorMatchPhase {
     // Both pre and post should be considered.
     ANY,
 
     // PRE_TARGETs are not considered, only the actual target and any
     // accelerators registered with POST_TARGET.
     POST_ONLY,
   };
 
@@ skipping 20 matching lines @@
   // Setting capture can fail if the window is blocked by a modal window
   // (indicated by returning |false|).
   bool SetCaptureWindow(ServerWindow* capture_window,
                         ClientSpecificId client_id);
 
   // Id of the client that capture events are sent to.
   ClientSpecificId capture_window_client_id() const {
     return capture_window_client_id_;
   }
 
+  // TODO(erg): Am I not supposed to pass window_tree here?
+  void SetDragDropSourceWindow(

[sky, 2016/08/24 00:08:57]

I recommend having this take an interface rather than WindowTree. WindowTree
either implements the interface, or creates an object that implements the
interface (probably the former).
As far as lifetime issues, WindowTree will know it's installed itself as the
drag drop source, right? It can cancel dnd from the destructor (or sooner) as
necessary.

+      uint32_t change_id,
+      WindowTree* window_tree,
+      ServerWindow* capture_window,
+      mojo::Map<mojo::String, mojo::Array<uint8_t>> mime_data,
+      uint32_t drag_operations);
+
   // Adds a system modal window. The window remains modal to system until it is
   // destroyed. There can exist multiple system modal windows, in which case the
   // one that is visible and added most recently or shown most recently would be
   // the active one.
   void AddSystemModalWindow(ServerWindow* window);
 
   // Checks if |modal_window| is a visible modal window that blocks current
   // capture window and if that's the case, releases the capture.
   void ReleaseCaptureBlockedByModalWindow(const ServerWindow* modal_window);
 
@@ skipping 22 matching lines @@
   bool AddAccelerator(uint32_t id, mojom::EventMatcherPtr event_matcher);
   void RemoveAccelerator(uint32_t id);
 
   // Processes the supplied event, informing the delegate as approriate. This
   // may result in generating any number of events. If |match_phase| is
   // ANY and there is a matching accelerator with PRE_TARGET found, than only
   // OnAccelerator() is called. The expectation is after the PRE_TARGET has been
   // handled this is again called with an AcceleratorMatchPhase of POST_ONLY.
   void ProcessEvent(const ui::Event& event, AcceleratorMatchPhase match_phase);
 
+  ServerWindow* FindDeepestVisibleWindowForEvents(gfx::Point* location);
+
  private:
   friend class test::EventDispatcherTestApi;
 
   // Keeps track of state associated with an active pointer.
   struct PointerTarget {
     PointerTarget()
         : window(nullptr),
           is_mouse_event(false),
           in_nonclient_area(false),
           is_pointer_down(false) {}
@@ skipping 65 matching lines @@
   // unobserve a window, UnobserveWindow() should be called the same number of
   // times.
   void ObserveWindow(ServerWindow* winodw);
   void UnobserveWindow(ServerWindow* winodw);
 
   // Returns an Accelerator bound to the specified code/flags, and of the
   // matching |phase|. Otherwise returns null.
   Accelerator* FindAccelerator(const ui::KeyEvent& event,
                                const ui::mojom::AcceleratorPhase phase);
 
-  ServerWindow* FindDeepestVisibleWindowForEvents(gfx::Point* location);
-
   // ServerWindowObserver:
   void OnWillChangeWindowHierarchy(ServerWindow* window,
                                    ServerWindow* new_parent,
                                    ServerWindow* old_parent) override;
   void OnWindowVisibilityChanged(ServerWindow* window) override;
   void OnWindowDestroyed(ServerWindow* window) override;
 
+  // CurrentDragOperationDelegate:
+  void OnDragOver(bool success) override;
+
   EventDispatcherDelegate* delegate_;
 
   ServerWindow* capture_window_;
   ClientSpecificId capture_window_client_id_;
 
+  std::unique_ptr<CurrentDragOperation> current_drag_drop_operation_;
+
   ModalWindowController modal_window_controller_;
 
   bool mouse_button_down_;
   ServerWindow* mouse_cursor_source_window_;
   bool mouse_cursor_in_non_client_area_;
 
   // The on screen location of the mouse pointer. This can be outside the
   // bounds of |mouse_cursor_source_window_|, which can capture the cursor.
   gfx::Point mouse_pointer_last_location_;
 
@@ skipping 15 matching lines @@
       AcceleratorMatchPhase::ANY;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(EventDispatcher);
 };
 
 }  // namespace ws
 }  // namespace ui
 
 #endif  // SERVICES_UI_WS_EVENT_DISPATCHER_H_