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 418 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 38 matching lines @@
 
 gfx::Size NativeWidgetMus::GetMinimumSize() const {
   return native_widget_delegate_->GetMinimumSize();
 }
 
 gfx::Size NativeWidgetMus::GetMaximumSize() const {
   return native_widget_delegate_->GetMaximumSize();
 }
 
 void NativeWidgetMus::OnBoundsChanged(const gfx::Rect& old_bounds,
-                                      const gfx::Rect& new_bounds) {
-  // Assume that if the old bounds was completely empty a move happened. This
-  // handles the case of a maximize animation acquiring the layer (acquiring a
-  // layer results in clearing the bounds).
-  if (old_bounds.origin() != new_bounds.origin() ||
-      (old_bounds == gfx::Rect(0, 0, 0, 0) && !new_bounds.IsEmpty())) {
-    native_widget_delegate_->OnNativeWidgetMove();
-  }
-  if (old_bounds.size() != new_bounds.size()) {
-    native_widget_delegate_->OnNativeWidgetSizeChanged(new_bounds.size());
-    UpdateClientArea();
-    UpdateHitTestMask();
-  }
-}
+                                      const gfx::Rect& new_bounds) {}

[sky, 2016/07/01 16:01:16]

I know if I saw this I would wonder why there is no implementation. Please add a
comment as to why this does nothing (something like OnHostResized/OnHostMoved
handle the logic).

 
 gfx::NativeCursor NativeWidgetMus::GetCursor(const gfx::Point& point) {
   return gfx::NativeCursor();
 }
 
 int NativeWidgetMus::GetNonClientComponent(const gfx::Point& point) const {
   return native_widget_delegate_->GetNonClientComponent(point);
 }
 
 bool NativeWidgetMus::ShouldDescendIntoChildForEventHandling(
@@ skipping 81 matching lines @@
       event->SetHandled();
   } else {
     native_widget_delegate_->OnScrollEvent(event);
   }
 }
 
 void NativeWidgetMus::OnGestureEvent(ui::GestureEvent* event) {
   native_widget_delegate_->OnGestureEvent(event);
 }
 
+void NativeWidgetMus::OnHostResized(const aura::WindowTreeHost* host) {
+  gfx::Rect new_bounds = gfx::Rect(host->window()->bounds().size());
+  content_->SetBounds(new_bounds);
+  native_widget_delegate_->OnNativeWidgetSizeChanged(new_bounds.size());
+  UpdateClientArea();
+  UpdateHitTestMask();
+}
+
+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();
 }
 
 void NativeWidgetMus::OnWindowInputEvent(
     mus::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));
@@ skipping 42 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