mash: Use the new mus drag and drop API to get drag working in mash.

ui/views/mus/native_widget_mus.cc

 // 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.
 
 #include "ui/views/mus/native_widget_mus.h"
 
+#include <utility>
+#include <vector>
+
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "services/ui/public/cpp/property_type_converters.h"
 #include "services/ui/public/cpp/window.h"
 #include "services/ui/public/cpp/window_observer.h"
 #include "services/ui/public/cpp/window_property.h"
 #include "services/ui/public/cpp/window_tree_client.h"
 #include "services/ui/public/interfaces/cursor.mojom.h"
 #include "services/ui/public/interfaces/window_manager.mojom.h"
 #include "services/ui/public/interfaces/window_manager_constants.mojom.h"
 #include "services/ui/public/interfaces/window_tree.mojom.h"
 #include "ui/aura/client/default_capture_client.h"
 #include "ui/aura/client/window_tree_client.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/mus/mus_util.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_property.h"
 #include "ui/base/hit_test.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 #include "ui/events/event.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/path.h"
 #include "ui/native_theme/native_theme_aura.h"
 #include "ui/platform_window/platform_window_delegate.h"
+#include "ui/views/drag_utils.h"
+#include "ui/views/mus/drag_drop_client_mus.h"
+#include "ui/views/mus/drop_target_mus.h"
 #include "ui/views/mus/window_manager_connection.h"
 #include "ui/views/mus/window_manager_constants_converters.h"
 #include "ui/views/mus/window_manager_frame_values.h"
 #include "ui/views/mus/window_tree_host_mus.h"
+#include "ui/views/widget/drop_helper.h"
 #include "ui/views/widget/native_widget_aura.h"
 #include "ui/views/widget/widget_delegate.h"
 #include "ui/views/window/custom_frame_view.h"
 #include "ui/wm/core/base_focus_rules.h"
 #include "ui/wm/core/capture_controller.h"
 #include "ui/wm/core/cursor_manager.h"
 #include "ui/wm/core/default_screen_position_client.h"
 #include "ui/wm/core/focus_controller.h"
 #include "ui/wm/core/native_cursor_manager.h"
 
@@ skipping 40 matching lines @@
       if (mus_window)
         mus_window->SetFocus();
     }
   }
 
   DISALLOW_COPY_AND_ASSIGN(FocusControllerMus);
 };
 
 class ContentWindowLayoutManager : public aura::LayoutManager {
  public:
-   ContentWindowLayoutManager(aura::Window* outer, aura::Window* inner)
+  ContentWindowLayoutManager(aura::Window* outer, aura::Window* inner)
       : outer_(outer), inner_(inner) {}
-   ~ContentWindowLayoutManager() override {}
+  ~ContentWindowLayoutManager() override {}
 
  private:
   // aura::LayoutManager:
   void OnWindowResized() override { inner_->SetBounds(outer_->bounds()); }
   void OnWindowAddedToLayout(aura::Window* child) override {
     OnWindowResized();
   }
   void OnWillRemoveWindowFromLayout(aura::Window* child) override {}
   void OnWindowRemovedFromLayout(aura::Window* child) override {}
   void OnChildWindowVisibilityChanged(aura::Window* child,
@@ skipping 404 matching lines @@
 NativeWidgetMus::NativeWidgetMus(internal::NativeWidgetDelegate* delegate,
                                  ui::Window* window,
                                  ui::mojom::SurfaceType surface_type)
     : window_(window),
       last_cursor_(ui::mojom::Cursor::CURSOR_NULL),
       native_widget_delegate_(delegate),
       surface_type_(surface_type),
       show_state_before_fullscreen_(ui::mojom::ShowState::DEFAULT),
       ownership_(Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET),
       content_(new aura::Window(this)),
+      last_drop_operation_(ui::DragDropTypes::DRAG_NONE),
       close_widget_factory_(this) {
   window_->set_input_event_handler(this);
-  mus_window_observer_.reset(new MusWindowObserver(this));
+  mus_window_observer_ = base::MakeUnique<MusWindowObserver>(this);
 
   // TODO(fsamuel): Figure out lifetime of |window_|.
   aura::SetMusWindow(content_, window_);
   window->SetLocalProperty(kNativeWidgetMusKey, this);
-  window_tree_host_.reset(new WindowTreeHostMus(this, window_));
+  window_tree_host_ = base::MakeUnique<WindowTreeHostMus>(this, window_);
 }
 
 NativeWidgetMus::~NativeWidgetMus() {
   if (ownership_ == Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET) {
     DCHECK(!window_);
     delete native_widget_delegate_;
   } else {
     if (window_)
       window_->set_input_event_handler(nullptr);
     CloseNow();
@@ skipping 144 matching lines @@
   window_tree_host_->InitHost();
   hosted_window->SetProperty(kMusWindow, window_);
 
   // TODO(moshayedi): crbug.com/641039. Investigate whether there are any cases
   // where we need input method but don't have the WindowManagerConnection here.
   if (WindowManagerConnection::Exists()) {
     window_tree_host_->InitInputMethod(
         WindowManagerConnection::Get()->connector());
   }
 
-  focus_client_.reset(
-      new FocusControllerMus(new FocusRulesImpl(hosted_window)));
+  focus_client_ =
+      base::MakeUnique<FocusControllerMus>(new FocusRulesImpl(hosted_window));
 
   aura::client::SetFocusClient(hosted_window, focus_client_.get());
   aura::client::SetActivationClient(hosted_window, focus_client_.get());
-  screen_position_client_.reset(new ScreenPositionClientMus(window_));
+  screen_position_client_ = base::MakeUnique<ScreenPositionClientMus>(window_);
   aura::client::SetScreenPositionClient(hosted_window,
                                         screen_position_client_.get());
 
+  drag_drop_client_ = base::MakeUnique<DragDropClientMus>(window_);
+  aura::client::SetDragDropClient(hosted_window, drag_drop_client_.get());
+  drop_target_ = base::MakeUnique<DropTargetMus>(content_);
+  window_->SetCanAcceptDrops(drop_target_.get());
+  drop_helper_ = base::MakeUnique<DropHelper>(GetWidget()->GetRootView());
+  aura::client::SetDragDropDelegate(content_, this);
+
   // TODO(erg): Remove this check when ash/mus/move_event_handler.cc's
   // direct usage of ui::Window::SetPredefinedCursor() is switched to a
   // private method on WindowManagerClient.
   if (!is_parallel_widget_in_window_manager()) {
-    cursor_manager_.reset(new wm::CursorManager(
-        base::MakeUnique<NativeCursorManagerMus>(window_)));
+    cursor_manager_ = base::MakeUnique<wm::CursorManager>(
+        base::MakeUnique<NativeCursorManagerMus>(window_));
     aura::client::SetCursorClient(hosted_window, cursor_manager_.get());
   }
 
-  window_tree_client_.reset(new NativeWidgetMusWindowTreeClient(hosted_window));
+  window_tree_client_ =
+      base::MakeUnique<NativeWidgetMusWindowTreeClient>(hosted_window);
   hosted_window->AddPreTargetHandler(focus_client_.get());
   hosted_window->SetLayoutManager(
       new ContentWindowLayoutManager(hosted_window, content_));
-  capture_client_.reset(new MusCaptureClient(hosted_window, content_, window_));
+  capture_client_ =
+      base::MakeUnique<MusCaptureClient>(hosted_window, content_, window_);
 
   content_->SetType(ui::wm::WINDOW_TYPE_NORMAL);
   content_->Init(params.layer_type);
   if (window_->visible())
     content_->Show();
   content_->SetTransparent(true);
   content_->SetFillsBoundsCompletely(false);
   content_->set_ignore_events(!params.accept_events);
   hosted_window->AddChild(content_);
 
@@ skipping 412 matching lines @@
 
 void NativeWidgetMus::SetOpacity(float opacity) {
   if (window_)
     window_->SetOpacity(opacity);
 }
 
 void NativeWidgetMus::FlashFrame(bool flash_frame) {
   // NOTIMPLEMENTED();
 }
 
-void NativeWidgetMus::RunShellDrag(
-    View* view,
-    const ui::OSExchangeData& data,
-    const gfx::Point& location,
-    int operation,
-    ui::DragDropTypes::DragEventSource source) {
-  // NOTIMPLEMENTED();
+void NativeWidgetMus::RunShellDrag(View* view,
+                                   const ui::OSExchangeData& data,
+                                   const gfx::Point& location,
+                                   int drag_operations,
+                                   ui::DragDropTypes::DragEventSource source) {
+  if (window_)
+    views::RunShellDrag(content_, data, location, drag_operations, source);
 }
 
 void NativeWidgetMus::SchedulePaintInRect(const gfx::Rect& rect) {
   if (content_)
     content_->SchedulePaintInRect(rect);
 }
 
 void NativeWidgetMus::SetCursor(gfx::NativeCursor cursor) {
   if (!window_)
     return;
@@ skipping 233 matching lines @@
 
 void NativeWidgetMus::OnHostMoved(const aura::WindowTreeHost* host,
                                   const gfx::Point& new_origin) {
   native_widget_delegate_->OnNativeWidgetMove();
 }
 
 void NativeWidgetMus::OnHostCloseRequested(const aura::WindowTreeHost* host) {
   GetWidget()->Close();
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// NativeWidgetMus, aura::WindowDragDropDelegate implementation:
+
+void NativeWidgetMus::OnDragEntered(const ui::DropTargetEvent& event) {
+  DCHECK(drop_helper_);
+  last_drop_operation_ = drop_helper_->OnDragOver(
+      event.data(), event.location(), event.source_operations());
+}
+
+int NativeWidgetMus::OnDragUpdated(const ui::DropTargetEvent& event) {
+  DCHECK(drop_helper_);
+  last_drop_operation_ = drop_helper_->OnDragOver(
+      event.data(), event.location(), event.source_operations());
+  return last_drop_operation_;
+}
+
+void NativeWidgetMus::OnDragExited() {
+  DCHECK(drop_helper_);
+  drop_helper_->OnDragExit();
+}
+
+int NativeWidgetMus::OnPerformDrop(const ui::DropTargetEvent& event) {
+  DCHECK(drop_helper_);
+  return drop_helper_->OnDrop(event.data(), event.location(),
+                              last_drop_operation_);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// NativeWidgetMus, ui::InputEventHandler implementation:
+
 void NativeWidgetMus::OnWindowInputEvent(
     ui::Window* view,
     const ui::Event& event_in,
     std::unique_ptr<base::Callback<void(EventResult)>>* ack_callback) {
   // Take ownership of the callback, indicating that we will handle it.
   EventAckHandler ack_handler(std::move(*ack_callback));
 
   std::unique_ptr<ui::Event> event = ui::Event::Clone(event_in);
   // TODO(markdittmer): This should be this->OnEvent(event.get()), but that
   // can't happen until IME is refactored out of in WindowTreeHostMus.
@@ skipping 38 matching lines @@
 
   gfx::Path mask_path;
   native_widget_delegate_->GetHitTestMask(&mask_path);
   // TODO(jamescook): Use the full path for the mask.
   gfx::Rect mask_rect =
       gfx::ToEnclosingRect(gfx::SkRectToRectF(mask_path.getBounds()));
   window_->SetHitTestMask(mask_rect);
 }
 
 }  // namespace views