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/accessibility_delegate.h"
 #include "ash/common/shelf/wm_shelf.h"
 #include "ash/common/shell_window_ids.h"
 #include "ash/common/system/tray/system_tray_notifier.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(); }
+

[oshima, 2016/10/12 01:56:54]

// ash::WindowResizer:

[Dominik Laskowski, 2016/10/13 03:21:17]

Done.

+  void Drag(const gfx::Point& location, int event_flags) override {}
+  void CompleteDrag() override {}
+  void RevertDrag() override {}
+
+ private:
+  ash::WmShell* const shell_;

[oshima, 2016/10/12 01:56:54]

DISALLOW_COPY_AND_ASSIGN

[Dominik Laskowski, 2016/10/13 03:21:17]

Done.

+};
+
 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 127 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);
   }
   ash::WmShell::Get()->system_tray_notifier()->RemoveAccessibilityObserver(
       this);
@@ skipping 80 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 41 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;
+}

[oshima, 2016/10/12 01:56:54]

Can you test what happens when display configuration changes? (add/remove
display and/or switching to/from mirror mode)

[Dominik Laskowski, 2016/10/13 03:21:17]

In general, this edge case is broken even for Chrome windows. Plugging a display
in overview mode results in an invalid state where only one display is in
overview mode. Unplugging a display containing windows in overview mode results
in a crash.

The code above is needed to prevent a crash when entering overview mode while
dragging. By the way, this case (i.e. entering/exiting overview mode while
dragging) is somewhat broken for Chrome windows. It's possible for a window to
become translucent after exiting overview mode. I have another small patch to
fix this.

[oshima, 2016/10/17 17:22:58]

That's a separate issue. When display configuraiton changes, it should
drop the window in the correct display.

[Dominik Laskowski, 2016/10/18 21:22:56]

Sorry, I misread that as changing the display configuration while in overview
mode.

Reverting on display reconfiguration will be handled in Android, but support for
multiple workspaces is a prerequisite, without which Android can't detect
certain display layout changes, i.e. when the size of the virtual screen stays
the same. Currently, display configuration changes seem to reset the Android
mouse position to the origin, so the dragged window follows along. Moving the
mouse after the display has reconfigured resumes the drag at the mouse's actual
position.

+
+////////////////////////////////////////////////////////////////////////////////
 // ui::EventHandler overrides:
 
 void ShellSurface::OnKeyEvent(ui::KeyEvent* event) {
   if (!resizer_) {
     views::View::OnKeyEvent(event);
     return;
   }
 
   if (event->type() == ui::ET_KEY_PRESSED &&
       event->key_code() == ui::VKEY_ESCAPE) {
@@ skipping 76 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 54 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