mus: Implement interwindow drag and drop

ui/views/mus/native_widget_mus.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 UI_VIEWS_MUS_NATIVE_WIDGET_MUS_H_
 #define UI_VIEWS_MUS_NATIVE_WIDGET_MUS_H_
 
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <string>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "services/ui/public/cpp/input_event_handler.h"
 #include "services/ui/public/interfaces/window_tree.mojom.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_tree_host_observer.h"
 #include "ui/platform_window/platform_window_delegate.h"
 #include "ui/views/mus/mus_export.h"
 #include "ui/views/mus/window_tree_host_mus.h"
 #include "ui/views/widget/native_widget_private.h"
+#include "ui/wm/public/drag_drop_delegate.h"
 
 namespace aura {
 namespace client {
 class DefaultCaptureClient;
 class ScreenPositionClient;
 class WindowTreeClient;
 }
 class Window;
 }
 
 namespace ui {
 class Window;
 class WindowTreeClient;
 namespace mojom {
 enum class Cursor;
 enum class EventResult;
 }
 }
 
 namespace ui {
 class Event;
 }
 
 namespace wm {
 class CursorManager;
 class FocusController;
 }
 
 namespace views {
+class DropHelper;
+class DropTargetMus;
 class WidgetDelegate;
 
 // An implementation of NativeWidget that binds to a ui::Window. Because Aura
 // is used extensively within Views code, this code uses aura and binds to the
 // ui::Window via a Mus-specific aura::WindowTreeHost impl. Because the root
 // aura::Window in a hierarchy is created without a delegate by the
 // aura::WindowTreeHost, we must create a child aura::Window in this class
 // (content_) and attach it to the root.
 class VIEWS_MUS_EXPORT NativeWidgetMus
     : public internal::NativeWidgetPrivate,
       public aura::WindowDelegate,
       public aura::WindowTreeHostObserver,
+      public aura::client::DragDropDelegate,
       public NON_EXPORTED_BASE(ui::InputEventHandler) {
  public:
   NativeWidgetMus(internal::NativeWidgetDelegate* delegate,
                   ui::Window* window,
                   ui::mojom::SurfaceType surface_type);
   ~NativeWidgetMus() override;
 
   // Configures the set of properties supplied to the window manager when
   // creating a new Window for a Widget.
   static void ConfigurePropertiesForNewWindow(
@@ skipping 81 matching lines @@
   bool IsMaximized() const override;
   bool IsMinimized() const override;
   void Restore() override;
   void SetFullscreen(bool fullscreen) override;
   bool IsFullscreen() const override;
   void SetOpacity(float opacity) override;
   void FlashFrame(bool flash_frame) override;
   void RunShellDrag(View* view,
                     const ui::OSExchangeData& data,
                     const gfx::Point& location,
-                    int operation,
+                    int drag_operations,
                     ui::DragDropTypes::DragEventSource source) override;
   void SchedulePaintInRect(const gfx::Rect& rect) override;
   void SetCursor(gfx::NativeCursor cursor) override;
   bool IsMouseEventsEnabled() const override;
   void ClearNativeFocus() override;
   gfx::Rect GetWorkAreaBoundsInScreen() const override;
   Widget::MoveLoopResult RunMoveLoop(
       const gfx::Vector2d& drag_offset,
       Widget::MoveLoopSource source,
       Widget::MoveLoopEscapeBehavior escape_behavior) override;
@@ skipping 34 matching lines @@
   void OnMouseEvent(ui::MouseEvent* event) override;
   void OnScrollEvent(ui::ScrollEvent* event) override;
   void OnGestureEvent(ui::GestureEvent* event) override;
 
   // Overridden from aura::WindowTreeHostObserver:
   void OnHostResized(const aura::WindowTreeHost* host) override;
   void OnHostMoved(const aura::WindowTreeHost* host,
                    const gfx::Point& new_origin) override;
   void OnHostCloseRequested(const aura::WindowTreeHost* host) override;
 
+  // Overridden from aura::client::DragDropDelegate:
+  void OnDragEntered(const ui::DropTargetEvent& event) override;
+  int OnDragUpdated(const ui::DropTargetEvent& event) override;
+  void OnDragExited() override;
+  int OnPerformDrop(const ui::DropTargetEvent& event) override;
+
   // Overridden from ui::InputEventHandler:
   void OnWindowInputEvent(
       ui::Window* view,
       const ui::Event& event,
       std::unique_ptr<base::Callback<void(ui::mojom::EventResult)>>*
           ack_callback) override;
 
  private:
   friend class NativeWidgetMusTest;
   class MusWindowObserver;
@@ skipping 33 matching lines @@
 
   // Functions with the same name require the ui::WindowObserver to be in
   // a separate class.
   std::unique_ptr<MusWindowObserver> mus_window_observer_;
 
   // This is misnamed; The native widget interface offers something called
   // "native window properties" which are properties which it stores locally,
   // and this is used to unsafely pass void* pointers around chrome.
   std::map<std::string, void*> native_window_properties_;
 
+  // Receives drop events for |window_|.
+  std::unique_ptr<DropTargetMus> drop_target_;
+
   // Aura configuration.
   std::unique_ptr<WindowTreeHostMus> window_tree_host_;
   aura::Window* content_;
   std::unique_ptr<wm::FocusController> focus_client_;
   std::unique_ptr<MusCaptureClient> capture_client_;
   std::unique_ptr<aura::client::WindowTreeClient> window_tree_client_;
   std::unique_ptr<aura::client::ScreenPositionClient> screen_position_client_;
   std::unique_ptr<wm::CursorManager> cursor_manager_;
 
+  std::unique_ptr<DropHelper> drop_helper_;
+  int last_drop_operation_;
+
   base::WeakPtrFactory<NativeWidgetMus> close_widget_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeWidgetMus);
 };
 
 }  // namespace views
 
 #endif  // UI_VIEWS_MUS_NATIVE_WIDGET_MUS_H_