mus: Use the new drag API to implement tab dragging in chrome.

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 "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 "components/bitmap_uploader/bitmap_uploader.h"
 #include "components/mus/public/cpp/property_type_converters.h"
 #include "components/mus/public/cpp/window.h"
 #include "components/mus/public/cpp/window_observer.h"
 #include "components/mus/public/cpp/window_property.h"
 #include "components/mus/public/cpp/window_tree_client.h"
 #include "components/mus/public/interfaces/cursor.mojom.h"
 #include "components/mus/public/interfaces/window_manager.mojom.h"
 #include "components/mus/public/interfaces/window_manager_constants.mojom.h"
 #include "components/mus/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/env.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/base/view_prop.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.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/mus/surface_context_factory.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/native_widget_aura.h"
@@ skipping 279 matching lines @@
 // TODO(jamescook): Support other scale factors.
 SkBitmap AppIconFromDelegate(WidgetDelegate* delegate) {
   if (!delegate)
     return SkBitmap();
   gfx::ImageSkia app_icon = delegate->GetWindowAppIcon();
   if (app_icon.isNull())
     return SkBitmap();
   return app_icon.GetRepresentation(1.f).sk_bitmap();
 }
 
-// Handles acknowledgement of an input event, either immediately when a nested
+// Handles acknowledgment of an input event, either immediately when a nested
 // message loop starts, or upon destruction.
 class EventAckHandler : public base::MessageLoop::NestingObserver {
  public:
   explicit EventAckHandler(
       std::unique_ptr<base::Callback<void(EventResult)>> ack_callback)
       : ack_callback_(std::move(ack_callback)) {
     DCHECK(ack_callback_);
     base::MessageLoop::current()->AddNestingObserver(this);
   }
 
@@ skipping 17 matching lines @@
     }
   }
 
  private:
   std::unique_ptr<base::Callback<void(EventResult)>> ack_callback_;
   bool handled_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(EventAckHandler);
 };
 
+void OnMoveLoopEnd(bool* out_success,
+                   base::Closure quit_closure,
+                   bool in_success) {
+  *out_success = in_success;
+  quit_closure.Run();
+}
+
 }  // namespace
 
 class NativeWidgetMus::MusWindowObserver : public mus::WindowObserver {
  public:
   explicit MusWindowObserver(NativeWidgetMus* native_widget_mus)
       : native_widget_mus_(native_widget_mus),
         show_state_(mus::mojom::ShowState::DEFAULT) {
     mus_window()->AddObserver(this);
   }
 
@@ skipping 52 matching lines @@
   void OnWindowDestroyed(mus::Window* window) override {
     DCHECK_EQ(mus_window(), window);
     platform_window_delegate()->OnClosed();
   }
   void OnWindowBoundsChanging(mus::Window* window,
                               const gfx::Rect& old_bounds,
                               const gfx::Rect& new_bounds) override {
     DCHECK_EQ(window, mus_window());
     window_tree_host()->SetBounds(new_bounds);
   }
+  void OnWindowBoundsChanged(mus::Window* window,
+                             const gfx::Rect& old_bounds,
+                             const gfx::Rect& new_bounds) override {
+    Widget* widget = NativeWidgetMus::GetWidgetForWindow(window);

[sky, 2016/06/30 00:18:31]

How come NativeWidgetMus::OnBoundsChanged doesn't cover this?

[Elliot Glaysher, 2016/06/30 19:48:25]

Because it doesn't get called in response to this. (And shouldn't.)

During MusWindowObserver::OnWindowBoundsChanging(), we tell
WindowTreeHostPlatform::SetBounds() the new bounds. That goes to
StubWindow::SetBounds(). That goes to WindowTreeHostPlatform::OnBoundsChanged(),
which dispatchs to aura::WindowTreeHostObserver.

However, pulling on this thread, this chunk is still wrong. I've replaced this
with making NWMus implement aura::WTHO. Looking at DesktopNativeWidgetAura, we
should have a OnHostMoved() method calling Widget::OnNativeWidgetMove() instead.

+    if (widget)
+      widget->OnNativeWidgetMove();
+  }
   void OnWindowFocusChanged(mus::Window* gained_focus,
                             mus::Window* lost_focus) override {
     if (gained_focus == mus_window())
       platform_window_delegate()->OnActivationChanged(true);
     else if (lost_focus == mus_window())
       platform_window_delegate()->OnActivationChanged(false);
   }
   void OnRequestClose(mus::Window* window) override {
     platform_window_delegate()->OnCloseRequest();
   }
@@ skipping 346 matching lines @@
   // NOTIMPLEMENTED();
 }
 
 // These methods are wrong in mojo. They're not usually used to associate
 // data with a window; they are used exclusively in chrome/ to unsafely pass
 // raw pointers around. I can only find two places where we do the "safe"
 // thing (and even that requires casting an integer to a void*). They can't be
 // used safely in a world where we separate things with mojo. They should be
 // removed; not ported.
 void NativeWidgetMus::SetNativeWindowProperty(const char* name, void* value) {
-  // TODO(beng): push properties to mus::Window.
-  // NOTIMPLEMENTED();
+  native_window_properties_[name] = value;
 }
 
 void* NativeWidgetMus::GetNativeWindowProperty(const char* name) const {
-  // TODO(beng): pull properties to mus::Window.
-  // NOTIMPLEMENTED();
-  return nullptr;
+  auto it = native_window_properties_.find(name);
+  if (it == native_window_properties_.end())
+    return nullptr;
+  return it->second;
 }
 
 TooltipManager* NativeWidgetMus::GetTooltipManager() const {
   // NOTIMPLEMENTED();
   return nullptr;
 }
 
 void NativeWidgetMus::SetCapture() {
   if (content_)
     content_->SetCapture();
@@ skipping 334 matching lines @@
 
 gfx::Rect NativeWidgetMus::GetWorkAreaBoundsInScreen() const {
   // NOTIMPLEMENTED();
   return gfx::Rect();
 }
 
 Widget::MoveLoopResult NativeWidgetMus::RunMoveLoop(
     const gfx::Vector2d& drag_offset,
     Widget::MoveLoopSource source,
     Widget::MoveLoopEscapeBehavior escape_behavior) {
-  // NOTIMPLEMENTED();
-  return Widget::MOVE_LOOP_CANCELED;
+  ReleaseCapture();
+
+  base::MessageLoopForUI* loop = base::MessageLoopForUI::current();
+  base::MessageLoop::ScopedNestableTaskAllower allow_nested(loop);
+  base::RunLoop run_loop;
+
+  mus::mojom::MoveLoopSource mus_source =
+      source == Widget::MOVE_LOOP_SOURCE_MOUSE ?
+      mus::mojom::MoveLoopSource::MOUSE :
+      mus::mojom::MoveLoopSource::TOUCH;
+
+  bool success = false;
+  gfx::Point cursor_location =
+      display::Screen::GetScreen()->GetCursorScreenPoint();
+  window_->PerformWindowMove(
+      mus_source, cursor_location,
+      base::Bind(OnMoveLoopEnd, &success, run_loop.QuitClosure()));
+
+  run_loop.Run();
+
+  return success ? Widget::MOVE_LOOP_SUCCESSFUL : Widget::MOVE_LOOP_CANCELED;
 }
 
 void NativeWidgetMus::EndMoveLoop() {
-  // NOTIMPLEMENTED();
+  window_->CancelWindowMove();
 }
 
 void NativeWidgetMus::SetVisibilityChangedAnimationsEnabled(bool value) {
   // NOTIMPLEMENTED();
 }
 
 void NativeWidgetMus::SetVisibilityAnimationDuration(
     const base::TimeDelta& duration) {
   // NOTIMPLEMENTED();
 }
@@ skipping 215 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