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));
 
   // TODO(fsamuel): Figure out lifetime of |window_|.
   aura::SetMusWindow(content_, window_);
   window->SetLocalProperty(kNativeWidgetMusKey, this);
   window_tree_host_.reset(new WindowTreeHostMus(this, window_));
 }
 
@@ skipping 161 matching lines @@
 
   focus_client_.reset(
       new 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_));
   aura::client::SetScreenPositionClient(hosted_window,
                                         screen_position_client_.get());
 
+  drop_target_.reset(new DropTargetMus(content_));

[sky, 2016/09/23 16:14:09]

MakeUnique

[Elliot Glaysher, 2016/09/23 21:40:48]

Changed entire file to use MakeUnique.

+  window_->SetCanAcceptDrops(drop_target_.get());
+  drop_helper_.reset(new DropHelper(GetWidget()->GetRootView()));

[sky, 2016/09/23 16:14:09]

MakeUnique

+  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_)));
     aura::client::SetCursorClient(hosted_window, cursor_manager_.get());
   }
 
   window_tree_client_.reset(new NativeWidgetMusWindowTreeClient(hosted_window));
@@ skipping 19 matching lines @@
       parent_mus->AddTransientWindow(window_);
   }
 
   if (params.parent_mus)
     params.parent_mus->AddChild(window_);
 
   // TODO(sky): deal with show state.
   if (!params.bounds.size().IsEmpty())
     SetBounds(params.bounds);
 
+  if (!params.parent) {

[sky, 2016/09/23 16:14:09]

I'm unclear as to why you don't create this for every NativeWidgetMus. Every
NativeWidgetMus contains a hierarchy of aura::Windows with a single root and has
a ui::Window. Don't you need to process the drag for every ui::Window?

[Elliot Glaysher, 2016/09/23 21:40:48]

I'm not sure I believe that this is true.

It appears that menus violate some of those assumptions. Without the `if
(!params.parent)' block around setting the drag drop client,MenuControllerTest.
MenuControllerReplacedDuringDrag times out. The test is set up to create
multiple NativeWidgets (a toplevel one, and one owned by MenuHost, which is a
child), and the implicit assumption made by the test is that replacing the
DragDropClient on the root window of the parent NativeWidget will change the
DragDropClient used by the child NativeWidget.

This check ensures this property. The parent NativeWidgetMus has a
DragDropClientMus, and the child NativeWidgetMus does not, and attempts to drag
something in the child NWMus bubble up to its parent.

(The test might also just be incorrect. Or NativeWidgetMus might not work
correctly with child widgets. Or something else that I'm not thinking of.)

[sky, 2016/09/26 02:12:59]

See line 541, which creates the WindowTreeHost which has an Aura::Window.
content_ is addded to it.
If you do end up sharing a DragDropClients, won't that mean the wrong ui::Window
is used as the source?

[Elliot Glaysher, 2016/09/26 20:57:29]

Disabled the test as discussed in person.

+    // On the desktop, we initialize some aura::clients on only the root
+    // window; DesktopNativeWidgetAura and NativeWidgetAura do different
+    // things. When we make a DesktopNativeWidgetMus (and that should be the
+    // root NativeWidget in programs other than the window manager), these
+    // should go there.
+    drag_drop_client_.reset(new DragDropClientMus(content_, window_));

[sky, 2016/09/23 16:14:09]

MakeUnique

+    aura::client::SetDragDropClient(hosted_window, drag_drop_client_.get());
+  }
+
   // TODO(beng): much else, see [Desktop]NativeWidgetAura.
 
   native_widget_delegate_->OnNativeWidgetCreated(false);
 }
 
 void NativeWidgetMus::OnWidgetInitDone() {
   // The client area is calculated from the NonClientView. During
   // InitNativeWidget() the NonClientView has not been created. When this
   // function is called the NonClientView has been created, so that we can
   // correctly calculate the client area and push it to the ui::Window.
@@ skipping 387 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