exo: Fix dragging edge cases

components/exo/shell_surface.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 "components/exo/shell_surface.h"
 
 #include <algorithm>
 
 #include "ash/aura/wm_window_aura.h"
 #include "ash/common/shelf/wm_shelf.h"
 #include "ash/common/shell_window_ids.h"
 #include "ash/common/wm/window_resizer.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm/window_state_delegate.h"
 #include "ash/common/wm_shell.h"
+#include "ash/wm/drag_window_resizer.h"
 #include "ash/wm/window_state_aura.h"
 #include "ash/wm/window_util.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
+#include "components/exo/display.h"
 #include "components/exo/surface.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_property.h"
 #include "ui/aura/window_targeter.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/accelerators/accelerator.h"
 #include "ui/gfx/path.h"
@@ skipping 145 matching lines @@
     widget_->RemoveObserver(this);
     widget_ = nullptr;
   }
 
  private:
   views::Widget* widget_;
 
   DISALLOW_COPY_AND_ASSIGN(CustomWindowStateDelegate);
 };
 
+class CustomWindowResizer : public ash::WindowResizer {
+ public:
+  explicit CustomWindowResizer(ash::wm::WindowState* window_state)
+      : WindowResizer(window_state), shell_(GetTarget()->GetShell()) {
+    shell_->LockCursor();
+  }
+
+  ~CustomWindowResizer() override { shell_->UnlockCursor(); }
+
+  // ash::WindowResizer:
+  void Drag(const gfx::Point& location, int event_flags) override {}
+  void CompleteDrag() override {}
+  void RevertDrag() override {}
+
+ private:
+  ash::WmShell* const shell_;
+
+  DISALLOW_COPY_AND_ASSIGN(CustomWindowResizer);
+};
+
 class ShellSurfaceWidget : public views::Widget {
  public:
   explicit ShellSurfaceWidget(ShellSurface* shell_surface)
       : shell_surface_(shell_surface) {}
 
   // Overridden from views::Widget
   void Close() override { shell_surface_->Close(); }
   void OnKeyEvent(ui::KeyEvent* event) override {
     // TODO(hidehiko): Handle ESC + SHIFT + COMMAND accelerator key
     // to escape pinned mode.
@@ skipping 126 matching lines @@
                         saved_animations_disabled_);
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShellSurface, public:
 
 DEFINE_LOCAL_WINDOW_PROPERTY_KEY(std::string*, kApplicationIdKey, nullptr)
 DEFINE_LOCAL_WINDOW_PROPERTY_KEY(Surface*, kMainSurfaceKey, nullptr)
 
-ShellSurface::ShellSurface(Surface* surface,
+ShellSurface::ShellSurface(const Display& display,
+                           Surface* surface,
                            ShellSurface* parent,
                            const gfx::Rect& initial_bounds,
                            bool activatable,
                            int container)
-    : widget_(nullptr),
+    : display_(display),
+      widget_(nullptr),
       surface_(surface),
       parent_(parent ? parent->GetWidget()->GetNativeWindow() : nullptr),
       initial_bounds_(initial_bounds),
       activatable_(activatable),
       container_(container) {
   WMHelper::GetInstance()->AddActivationObserver(this);
+  WMHelper::GetInstance()->AddShellObserver(this);
   surface_->SetSurfaceDelegate(this);
   surface_->AddSurfaceObserver(this);
   surface_->window()->Show();
   set_owned_by_client();
   if (parent_)
     parent_->AddObserver(this);
 }
 
-ShellSurface::ShellSurface(Surface* surface)
-    : ShellSurface(surface,
+ShellSurface::ShellSurface(const Display& display, Surface* surface)
+    : ShellSurface(display,
+                   surface,
                    nullptr,
                    gfx::Rect(),
                    true,
                    ash::kShellWindowId_DefaultContainer) {}
 
 ShellSurface::~ShellSurface() {
   DCHECK(!scoped_configure_);
-  if (resizer_)
-    EndDrag(false /* revert */);
+  EndDragOrMove(false /* revert */);
   if (widget_) {
     ash::wm::GetWindowState(widget_->GetNativeWindow())->RemoveObserver(this);
     widget_->GetNativeWindow()->RemoveObserver(this);
     if (widget_->IsVisible())
       widget_->Hide();
     widget_->CloseNow();
   }
   WMHelper::GetInstance()->RemoveActivationObserver(this);
+  WMHelper::GetInstance()->RemoveShellObserver(this);
   if (parent_)
     parent_->RemoveObserver(this);
   if (surface_) {
     if (scale_ != 1.0)
       surface_->window()->SetTransform(gfx::Transform());
     surface_->SetSurfaceDelegate(nullptr);
     surface_->RemoveSurfaceObserver(this);
   }
   WMHelper::GetInstance()->RemoveAccessibilityObserver(this);
 }
@@ skipping 79 matching lines @@
 
   if (!widget_)
     return;
 
   // Note: This will ask client to configure its surface even if not already
   // maximized or minimized.
   ScopedConfigure scoped_configure(this, true);
   widget_->Restore();
 }
 
+void ShellSurface::SetMoving() {
+  TRACE_EVENT0("exo", "ShellSurface::SetMoving");
+
+  if (move_resizer_)
+    return;
+
+  ash::wm::WindowState* const window_state =
+      ash::wm::GetWindowState(widget_->GetNativeWindow());
+
+  DCHECK(!window_state->drag_details());
+  window_state->CreateDragDetails(GetMouseLocation(), HTCAPTION,
+                                  aura::client::WINDOW_MOVE_SOURCE_MOUSE);
+
+  // The resizer renders phantom windows, but does not control window movement.
+  move_resizer_.reset(ash::DragWindowResizer::Create(
+      new CustomWindowResizer(window_state), window_state));
+
+  surface_->window()->SetCapture();
+}
+
+void ShellSurface::UnsetMoving(bool revert) {
+  TRACE_EVENT1("exo", "ShellSurface::UnsetMoving", "revert", revert);
+
+  if (!move_resizer_)
+    return;
+
+  if (revert)
+    move_resizer_->RevertDrag();
+  else
+    move_resizer_->CompleteDrag();
+
+  move_resizer_.reset();
+  surface_->window()->ReleaseCapture();
+}
+
 void ShellSurface::SetFullscreen(bool fullscreen) {
   TRACE_EVENT1("exo", "ShellSurface::SetFullscreen", "fullscreen", fullscreen);
 
   if (!widget_)
     CreateShellSurfaceWidget(ui::SHOW_STATE_FULLSCREEN);
 
   // Note: This will ask client to configure its surface even if fullscreen
   // state doesn't change.
   ScopedConfigure scoped_configure(this, true);
   widget_->SetFullscreen(fullscreen);
@@ skipping 194 matching lines @@
       if (activatable != CanActivate()) {
         set_can_activate(activatable);
         // Activate or deactivate window if activation state changed.
         if (activatable)
           wm::ActivateWindow(widget_->GetNativeWindow());
         else if (widget_->IsActive())
           wm::DeactivateWindow(widget_->GetNativeWindow());
       }
     }
 
-    // Update surface bounds.
-    surface_->window()->SetBounds(
-        gfx::Rect(surface_origin, surface_->window()->layer()->size()));
+    UpdateSurfaceBounds();
 
     // Update surface scale.
     if (pending_scale_ != scale_) {
       gfx::Transform transform;
       DCHECK_NE(pending_scale_, 0.0);
       transform.Scale(1.0 / pending_scale_, 1.0 / pending_scale_);
       surface_->window()->SetTransform(transform);
       scale_ = pending_scale_;
     }
 
     // Show widget if needed.
     if (pending_show_widget_) {
       DCHECK(!widget_->IsClosed());
       DCHECK(!widget_->IsVisible());
       pending_show_widget_ = false;
       widget_->Show();
     }
   }
 }
 
 bool ShellSurface::IsSurfaceSynchronized() const {
   // A shell surface is always desynchronized.
   return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // SurfaceObserver overrides:
 
 void ShellSurface::OnSurfaceDestroying(Surface* surface) {
-  if (resizer_)
-    EndDrag(false /* revert */);
+  EndDragOrMove(false /* revert */);
   if (widget_)
     SetMainSurface(widget_->GetNativeWindow(), nullptr);
   surface->RemoveSurfaceObserver(this);
   surface_ = nullptr;
 
   // Hide widget before surface is destroyed. This allows hide animations to
   // run using the current surface contents.
   if (widget_)
     widget_->Hide();
 
@@ skipping 19 matching lines @@
 bool ShellSurface::CanMinimize() const {
   // Shell surfaces in system modal container cannot be minimized.
   return container_ != ash::kShellWindowId_SystemModalContainer;
 }
 
 base::string16 ShellSurface::GetWindowTitle() const {
   return title_;
 }
 
 void ShellSurface::WindowClosing() {
-  if (resizer_)
-    EndDrag(true /* revert */);
+  EndDragOrMove(true /* revert */);
   SetEnabled(false);
   widget_ = nullptr;
   shadow_overlay_ = nullptr;
   shadow_underlay_ = nullptr;
 }
 
 views::Widget* ShellSurface::GetWidget() {
   return widget_;
 }
 
@@ skipping 33 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // ash::wm::WindowStateObserver overrides:
 
 void ShellSurface::OnPreWindowStateTypeChange(
     ash::wm::WindowState* window_state,
     ash::wm::WindowStateType old_type) {
   ash::wm::WindowStateType new_type = window_state->GetStateType();
   if (ash::wm::IsMaximizedOrFullscreenOrPinnedWindowStateType(old_type) ||
       ash::wm::IsMaximizedOrFullscreenOrPinnedWindowStateType(new_type)) {
+    EndDragOrMove(false /* revert */);
+
     // When transitioning in/out of maximized or fullscreen mode we need to
     // make sure we have a configure callback before we allow the default
     // cross-fade animations. The configure callback provides a mechanism for
     // the client to inform us that a frame has taken the state change into
     // account and without this cross-fade animations are unreliable.
     if (configure_callback_.is_null())
       scoped_animations_disabled_.reset(new ScopedAnimationsDisabled(this));
   }
 }
 
@@ skipping 31 matching lines @@
     if (new_bounds.size() == old_bounds.size())
       return;
 
     // If size changed then give the client a chance to produce new contents
     // before origin on screen is changed by adding offset to the next configure
     // request and offset |origin_| by the same distance.
     gfx::Vector2d origin_offset = new_bounds.origin() - old_bounds.origin();
     pending_origin_config_offset_ += origin_offset;
     origin_ -= origin_offset;
 
-    surface_->window()->SetBounds(
-        gfx::Rect(GetSurfaceOrigin(), surface_->window()->layer()->size()));
+    UpdateSurfaceBounds();
 
     // The shadow size may be updated to match the widget. Change it back
     // to the shadow content size.
     // TODO(oshima): When the arc window reiszing is enabled, we may want to
     // implement shadow management here instead of using shadow controller.
     UpdateShadow();
 
     Configure();
   }
 }
@@ skipping 10 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // WMHelper::ActivationObserver overrides:
 
 void ShellSurface::OnWindowActivated(
     aura::Window* gained_active,
     aura::Window* lost_active) {
   if (!widget_)
     return;
 
+  if (lost_active == widget_->GetNativeWindow())
+    UnsetMoving(false /* revert */);
+
   if (gained_active == widget_->GetNativeWindow() ||
       lost_active == widget_->GetNativeWindow()) {
     DCHECK(activatable_);
     Configure();
     UpdateShadow();
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// WMHelper::ShellObserver overrides:
+
+void ShellSurface::OnOverviewModeStarted() {
+  EndDragOrMove(false /* revert */);
+  ignore_widget_bounds_changes_ = true;
+}
+
+void ShellSurface::OnOverviewModeEnded() {
+  ignore_widget_bounds_changes_ = false;
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // WMHelper::AccessibilityObserver overrides:
 
 void ShellSurface::OnAccessibilityModeChanged() {
   UpdateShadow();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ui::EventHandler overrides:
 
 void ShellSurface::OnKeyEvent(ui::KeyEvent* event) {
@@ skipping 83 matching lines @@
   params.type = views::Widget::InitParams::TYPE_WINDOW;
   params.ownership = views::Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET;
   params.delegate = this;
   params.shadow_type = views::Widget::InitParams::SHADOW_TYPE_NONE;
   params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
   params.show_state = show_state;
   // Make shell surface a transient child if |parent_| has been set.
   params.parent =
       parent_ ? parent_ : WMHelper::GetInstance()->GetContainer(container_);
   params.bounds = initial_bounds_;
+  display_.ConvertFromVirtualToScreen(&params.bounds);
   bool activatable = activatable_;
   // ShellSurfaces in system modal container are only activatable if input
   // region is non-empty. See OnCommitSurface() for more details.
   if (container_ == ash::kShellWindowId_SystemModalContainer)
     activatable &= !surface_->GetHitTestBounds().IsEmpty();
   params.activatable = activatable ? views::Widget::InitParams::ACTIVATABLE_YES
                                    : views::Widget::InitParams::ACTIVATABLE_NO;
 
   // Note: NativeWidget owns this widget.
   widget_ = new ShellSurfaceWidget(this);
@@ skipping 93 matching lines @@
 void ShellSurface::AttemptToStartDrag(int component) {
   DCHECK(widget_);
 
   // Cannot start another drag if one is already taking place.
   if (resizer_)
     return;
 
   if (widget_->GetNativeWindow()->HasCapture())
     return;
 
-  aura::Window* root_window = widget_->GetNativeWindow()->GetRootWindow();
-  gfx::Point drag_location =
-      root_window->GetHost()->dispatcher()->GetLastMouseLocationInRoot();
-  aura::Window::ConvertPointToTarget(
-      root_window, widget_->GetNativeWindow()->parent(), &drag_location);
-
   // Set the cursor before calling CreateWindowResizer(), as that will
   // eventually call LockCursor() and prevent the cursor from changing.
-  aura::client::CursorClient* cursor_client =
-      aura::client::GetCursorClient(root_window);
+  aura::client::CursorClient* cursor_client = aura::client::GetCursorClient(
+      widget_->GetNativeWindow()->GetRootWindow());
   DCHECK(cursor_client);
 
   switch (component) {
     case HTCAPTION:
       cursor_client->SetCursor(ui::kCursorPointer);
       break;
     case HTTOP:
       cursor_client->SetCursor(ui::kCursorNorthResize);
       break;
     case HTTOPRIGHT:
@@ skipping 16 matching lines @@
       break;
     case HTTOPLEFT:
       cursor_client->SetCursor(ui::kCursorNorthWestResize);
       break;
     default:
       NOTREACHED();
       break;
   }
 
   resizer_ = ash::CreateWindowResizer(
-      ash::WmWindowAura::Get(widget_->GetNativeWindow()), drag_location,
+      ash::WmWindowAura::Get(widget_->GetNativeWindow()), GetMouseLocation(),
       component, aura::client::WINDOW_MOVE_SOURCE_MOUSE);
   if (!resizer_)
     return;
 
   // Apply pending origin offsets and resize direction before starting a new
   // resize operation. These can still be pending if the client has acknowledged
   // the configure request but not yet called Commit().
   origin_ += pending_origin_offset_;
   pending_origin_offset_ = gfx::Vector2d();
   resize_component_ = pending_resize_component_;
@@ skipping 21 matching lines @@
   widget_->GetNativeWindow()->ReleaseCapture();
   resizer_.reset();
 
   // Notify client that resizing state has changed.
   if (was_resizing)
     Configure();
 
   UpdateWidgetBounds();
 }
 
+void ShellSurface::EndDragOrMove(bool revert) {
+  if (resizer_)
+    EndDrag(revert);
+  else
+    UnsetMoving(revert);
+}
+
 bool ShellSurface::IsResizing() const {
   if (!resizer_)
     return false;
 
   return resizer_->details().bounds_change &
          ash::WindowResizer::kBoundsChange_Resizes;
 }
 
 gfx::Rect ShellSurface::GetVisibleBounds() const {
   // Use |geometry_| if set, otherwise use the visual bounds of the surface.
   return geometry_.IsEmpty() ? gfx::Rect(surface_->window()->layer()->size())
                              : geometry_;
 }
 
 gfx::Point ShellSurface::GetSurfaceOrigin() const {
   gfx::Rect window_bounds = widget_->GetNativeWindow()->bounds();
 
   // If initial bounds were specified then surface origin is always relative
   // to those bounds.
-  if (!initial_bounds_.IsEmpty())
-    return initial_bounds_.origin() - window_bounds.OffsetFromOrigin();
+  if (!initial_bounds_.IsEmpty()) {
+    gfx::Point origin = window_bounds.origin();
+    wm::ConvertPointToScreen(widget_->GetNativeWindow()->parent(), &origin);
+    display_.ConvertFromScreenToVirtual(&origin);
+    return initial_bounds_.origin() - origin.OffsetFromOrigin();
+  }
 
   gfx::Rect visible_bounds = GetVisibleBounds();
   switch (resize_component_) {
     case HTCAPTION:
       return origin_ - visible_bounds.OffsetFromOrigin();
     case HTBOTTOM:
     case HTRIGHT:
     case HTBOTTOMRIGHT:
       return gfx::Point() - visible_bounds.OffsetFromOrigin();
     case HTTOP:
@@ skipping 21 matching lines @@
   // Return early if the shell is currently managing the bounds of the widget.
   // 1) When a window is either maximized/fullscreen/pinned, and the bounds
   // isn't controlled by a client.
   ash::wm::WindowState* window_state =
       ash::wm::GetWindowState(widget_->GetNativeWindow());
   if (window_state->IsMaximizedOrFullscreenOrPinned() &&
       !window_state->allow_set_bounds_in_maximized()) {
     return;
   }
 
-  // 2) When a window is being dragged.
-  if (IsResizing())
+  // 2) When a window is being dragged, or is being moved by the shell.
+  if (IsResizing() || ignore_widget_bounds_changes_)
     return;
 
   // Return early if there is pending configure requests.
   if (!pending_configs_.empty() || scoped_configure_)
     return;
 
-  gfx::Rect visible_bounds = GetVisibleBounds();
+  gfx::Rect visible_bounds = GetVisibleBounds();  // In virtual coordinates.
   gfx::Rect new_widget_bounds = visible_bounds;
 
   // Avoid changing widget origin unless initial bounds were specified and
   // widget origin is always relative to it.
   if (initial_bounds_.IsEmpty())
     new_widget_bounds.set_origin(widget_->GetWindowBoundsInScreen().origin());
 
+  else {
+    new_widget_bounds.set_origin(initial_bounds_.origin() +
+                                 visible_bounds.OffsetFromOrigin());
+    display_.ConvertFromVirtualToScreen(&new_widget_bounds);
+  }
+
   // Update widget origin using the surface origin if the current location of
   // surface is being anchored to one side of the widget as a result of a
   // resize operation.
   if (resize_component_ != HTCAPTION) {
     gfx::Point new_widget_origin =
         GetSurfaceOrigin() + visible_bounds.OffsetFromOrigin();
     wm::ConvertPointToScreen(widget_->GetNativeWindow(), &new_widget_origin);
     new_widget_bounds.set_origin(new_widget_origin);
   }
 
   // Set |ignore_window_bounds_changes_| as this change to window bounds
   // should not result in a configure request.
   DCHECK(!ignore_window_bounds_changes_);
   ignore_window_bounds_changes_ = true;
-  if (widget_->GetWindowBoundsInScreen() != new_widget_bounds)
-    widget_->SetBounds(new_widget_bounds);
+  if (widget_->GetWindowBoundsInScreen() != new_widget_bounds) {
+    if (!move_resizer_) {
+      widget_->SetBounds(new_widget_bounds);
+      UpdateSurfaceBounds();
+    } else {
+      // Convert from screen to display coordinates.
+      gfx::Point origin = new_widget_bounds.origin();
+      wm::ConvertPointFromScreen(widget_->GetNativeWindow()->parent(), &origin);
+      new_widget_bounds.set_origin(origin);
+
+      // Move the window relative to the current display.
+      widget_->GetNativeWindow()->SetBounds(new_widget_bounds);
+      UpdateSurfaceBounds();
+
+      // Render phantom windows when beyond the current display.
+      move_resizer_->Drag(GetMouseLocation(), 0);
+    }
+  }
+
   ignore_window_bounds_changes_ = false;
+}
 
-  // A change to the widget size requires surface bounds to be re-adjusted.
+void ShellSurface::UpdateSurfaceBounds() {
   surface_->window()->SetBounds(
       gfx::Rect(GetSurfaceOrigin(), surface_->window()->layer()->size()));
 }
 
 void ShellSurface::UpdateShadow() {
   if (!widget_)
     return;
   aura::Window* window = widget_->GetNativeWindow();
   if (shadow_content_bounds_.IsEmpty()) {
     wm::SetShadowType(window, wm::SHADOW_TYPE_NONE);
     if (shadow_underlay_)
       shadow_underlay_->Hide();
   } else {
     wm::SetShadowType(window, wm::SHADOW_TYPE_RECTANGULAR);
 
-    // TODO(oshima): Adjust the coordinates from client screen to
-    // chromeos screen when multi displays are supported.
     gfx::Point origin = window->bounds().origin();
     gfx::Point shadow_origin = shadow_content_bounds_.origin();
+
+    display_.ConvertFromVirtualToScreen(&shadow_origin);
+    wm::ConvertPointFromScreen(window->parent(), &shadow_origin);
     shadow_origin -= origin.OffsetFromOrigin();
     gfx::Rect shadow_bounds(shadow_origin, shadow_content_bounds_.size());
 
     // Always create and show the underlay, even in maximized/fullscreen.
     if (!shadow_underlay_) {
       shadow_underlay_ = new aura::Window(nullptr);
       shadow_underlay_event_handler_ =
           base::MakeUnique<ShadowUnderlayEventHandler>();
       shadow_underlay_->SetTargetHandler(shadow_underlay_event_handler_.get());
       DCHECK(shadow_underlay_->owned_by_parent());
@@ skipping 53 matching lines @@
       shadow_overlay_->Init(ui::LAYER_NOT_DRAWN);
       shadow_overlay_->layer()->Add(shadow->layer());
       window->AddChild(shadow_overlay_);
       shadow_overlay_->Show();
     }
     shadow_overlay_->SetBounds(shadow_bounds);
     shadow->SetContentBounds(gfx::Rect(shadow_bounds.size()));
   }
 }
 
+gfx::Point ShellSurface::GetMouseLocation() const {
+  aura::Window* const root_window = widget_->GetNativeWindow()->GetRootWindow();
+  gfx::Point location =
+      root_window->GetHost()->dispatcher()->GetLastMouseLocationInRoot();
+  aura::Window::ConvertPointToTarget(
+      root_window, widget_->GetNativeWindow()->parent(), &location);
+  return location;
+}
+
 }  // namespace exo