exo: Initial support for multiple displays in ARC

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/common/frame/custom_frame_view_ash.h"
 #include "ash/common/shelf/wm_shelf.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/common/wm_window.h"
 #include "ash/public/cpp/shell_window_ids.h"
+#include "ash/wm/drag_window_resizer.h"

[reveman, 2017/02/06 19:49:34]

please remove from this patch

[Dominik Laskowski, 2017/02/08 18:07:40]

See comment below.

 #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/surface.h"
 #include "ui/aura/client/aura_constants.h"
@@ skipping 154 matching lines @@
     widget_->RemoveObserver(this);
     widget_ = nullptr;
   }
 
  private:
   views::Widget* widget_;
 
   DISALLOW_COPY_AND_ASSIGN(CustomWindowStateDelegate);
 };
 
+class CustomWindowResizer : public ash::WindowResizer {

[reveman, 2017/02/06 19:49:34]

please remove from this patch

[Dominik Laskowski, 2017/02/08 18:07:40]

Dragging and multi-display positioning are interdependent.

+ 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 127 matching lines @@
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShellSurface, public:
 
 DEFINE_LOCAL_UI_CLASS_PROPERTY_KEY(Surface*, kMainSurfaceKey, nullptr)
 
 ShellSurface::ShellSurface(Surface* surface,
                            ShellSurface* parent,
-                           const gfx::Rect& initial_bounds,
+                           BoundsMode bounds_mode,
+                           const gfx::Point& origin,
                            bool activatable,
                            bool can_minimize,
                            int container)
     : widget_(nullptr),
       surface_(surface),
       parent_(parent ? parent->GetWidget()->GetNativeWindow() : nullptr),
-      initial_bounds_(initial_bounds),
+      bounds_mode_(bounds_mode),
+      origin_(origin),
       activatable_(activatable),
       can_minimize_(can_minimize),
       container_(container) {
   WMHelper::GetInstance()->AddActivationObserver(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,
                    nullptr,
-                   gfx::Rect(),
+                   BoundsMode::SHELL,
+                   gfx::Point(),
                    true,
                    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);
     // Remove transient children so they are not automatically destroyed.
     for (auto child : wm::GetTransientChildren(widget_->GetNativeWindow()))
       wm::RemoveTransientChild(widget_->GetNativeWindow(), child);
     if (widget_->IsVisible())
       widget_->Hide();
     widget_->CloseNow();
   }
   WMHelper::GetInstance()->RemoveActivationObserver(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);
+
+  if (!destroyed_callback_.is_null())
+    destroyed_callback_.Run();
 }
 
 void ShellSurface::AcknowledgeConfigure(uint32_t serial) {
   TRACE_EVENT1("exo", "ShellSurface::AcknowledgeConfigure", "serial", serial);
 
   // Apply all configs that are older or equal to |serial|. The result is that
   // the origin of the main surface will move and the resize direction will
   // change to reflect the acknowledgement of configure request with |serial|
   // at the next call to Commit().
   while (!pending_configs_.empty()) {
     auto config = pending_configs_.front();
     pending_configs_.pop_front();
 
     // Add the config offset to the accumulated offset that will be applied when
     // Commit() is called.
     pending_origin_offset_ += config.origin_offset;
 
     // Set the resize direction that will be applied when Commit() is called.
     pending_resize_component_ = config.resize_component;
 
     if (config.serial == serial)
       break;
   }
 
-  if (widget_)
+  if (widget_) {
     UpdateWidgetBounds();
+    UpdateShadow();
+  }
 }
 
 void ShellSurface::SetParent(ShellSurface* parent) {
   TRACE_EVENT1("exo", "ShellSurface::SetParent", "parent",
                parent ? base::UTF16ToASCII(parent->title_) : "null");
 
   if (parent_) {
     parent_->RemoveObserver(this);
     if (widget_)
       wm::RemoveTransientChild(parent_, widget_->GetNativeWindow());
@@ skipping 48 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 138 matching lines @@
 
 void ShellSurface::SetTopInset(int height) {
   TRACE_EVENT1("exo", "ShellSurface::SetTopInset", "height", height);
 
   pending_top_inset_height_ = height;
 }
 
 void ShellSurface::SetOrigin(const gfx::Point& origin) {
   TRACE_EVENT1("exo", "ShellSurface::SetOrigin", "origin", origin.ToString());
 
-  initial_bounds_ = gfx::Rect(origin, gfx::Size(1, 1));
+  const gfx::Point old_origin = origin_;
+  origin_ = origin;
+
+  if (bounds_mode_ != BoundsMode::CLIENT || origin == old_origin)
+    return;
+
+  // If the origin changed, give the client a chance to adjust window positions
+  // before switching to the new coordinate system. Retain the old origin by
+  // reverting the origin delta until the next configure is acknowledged.
+  const gfx::Vector2d delta = origin - old_origin;
+  origin_offset_ -= delta;
+  pending_origin_offset_accumulator_ += delta;
+
+  if (widget_) {
+    UpdateWidgetBounds();
+    UpdateShadow();
+  }
+
+  Configure();
 }
 
 void ShellSurface::SetActivatable(bool activatable) {
   TRACE_EVENT1("exo", "ShellSurface::SetActivatable", "activatable",
                activatable);
 
   activatable_ = activatable;
 }
 
 void ShellSurface::SetContainer(int container) {
@@ skipping 26 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // SurfaceDelegate overrides:
 
 void ShellSurface::OnSurfaceCommit() {
   surface_->CheckIfSurfaceHierarchyNeedsCommitToNewSurfaces();
   surface_->CommitSurfaceHierarchy();
 
   if (enabled() && !widget_) {
     // Defer widget creation until surface contains some contents.
-    if (surface_->content_size().IsEmpty())
+    if (surface_->content_size().IsEmpty()) {
       Configure();
-    else
-      CreateShellSurfaceWidget(ui::SHOW_STATE_NORMAL);
+      return;
+    }
+
+    CreateShellSurfaceWidget(ui::SHOW_STATE_NORMAL);
   }
 
   // Apply the accumulated pending origin offset to reflect acknowledged
   // configure requests.
-  origin_ += pending_origin_offset_;
+  origin_offset_ += pending_origin_offset_;
   pending_origin_offset_ = gfx::Vector2d();
 
   // Update resize direction to reflect acknowledged configure requests.
   resize_component_ = pending_resize_component_;
 
   if (widget_) {
     // Apply new window geometry.
     geometry_ = pending_geometry_;
 
     UpdateWidgetBounds();
@@ skipping 18 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());
       }
     }
 
-    gfx::Rect client_view_bounds =
-        widget_->non_client_view()->frame_view()->GetBoundsForClientView();
-
-    // Update surface bounds.
-    surface_->window()->SetBounds(
-        gfx::Rect(GetSurfaceOrigin() + client_view_bounds.OffsetFromOrigin(),
-                  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_) {
     // Remove transient children so they are not automatically hidden.
     for (auto child : wm::GetTransientChildren(widget_->GetNativeWindow()))
       wm::RemoveTransientChild(widget_->GetNativeWindow(), child);
     widget_->Hide();
   }
 
   // Note: In its use in the Wayland server implementation, the surface
   // destroyed callback may destroy the ShellSurface instance. This call needs
   // to be last so that the instance can be destroyed.
   if (!surface_destroyed_callback_.is_null())
     surface_destroyed_callback_.Run();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // views::WidgetDelegate overrides:
 
 bool ShellSurface::CanResize() const {
-  return initial_bounds_.IsEmpty();
+  return bounds_mode_ == BoundsMode::SHELL;
 }
 
 bool ShellSurface::CanMaximize() const {
   // Shell surfaces in system modal container cannot be maximized.
   if (container_ == ash::kShellWindowId_SystemModalContainer)
     return false;
 
   // Non-transient shell surfaces can be maximized.
   return !parent_;
 }
 
 bool ShellSurface::CanMinimize() const {
   return can_minimize_;
 }
 
 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 51 matching lines @@
     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)) {
     // 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())
+
+    // TODO(domlaskowski): For shell surfaces whose bounds are controlled by the

[reveman, 2017/02/06 19:49:34]

Please remove this as it shouldn't hurt to trigger the callback with a 0 origin
delta. You can filter it out in the remote shell code.

[Dominik Laskowski, 2017/02/08 18:07:40]

The TODO alludes to the above comment, i.e. animations should be disabled even
though we have a configure callback.

+    // client, the configure callback does not yet support window state changes.
+    if (configure_callback_.is_null() || bounds_mode_ == BoundsMode::CLIENT)
       scoped_animations_disabled_.reset(new ScopedAnimationsDisabled(this));
   }
 }
 
 void ShellSurface::OnPostWindowStateTypeChange(
     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)) {
@@ skipping 11 matching lines @@
   // Re-enable animations if they were disabled in pre state change handler.
   scoped_animations_disabled_.reset();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // aura::WindowObserver overrides:
 
 void ShellSurface::OnWindowBoundsChanged(aura::Window* window,
                                          const gfx::Rect& old_bounds,
                                          const gfx::Rect& new_bounds) {
-  if (!widget_ || !surface_ || ignore_window_bounds_changes_)
+  if (bounds_mode_ != BoundsMode::SHELL || !widget_ || !surface_ ||

[reveman, 2017/02/06 19:49:34]

why is this needed. should ignore_window_bounds_changes_ be set correctly when
this happens instead?

[Dominik Laskowski, 2017/02/08 18:07:40]

The origin offset should not be modified for size changes when bounds are
controlled by the client, because the configure protocol does not support
resizing. I've moved this check to where the shell surface is registered as a
WindowObserver, because the other handler is also inapplicable.

+      ignore_window_bounds_changes_)
     return;
 
   if (window == widget_->GetNativeWindow()) {
     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;
+    // before origin on screen is changed. Retain the old origin by reverting
+    // the origin delta until the next configure is acknowledged.
+    const gfx::Vector2d delta = new_bounds.origin() - old_bounds.origin();
+    origin_offset_ -= delta;
+    pending_origin_offset_accumulator_ += delta;
 
-    gfx::Rect client_view_bounds =
-        widget_->non_client_view()->frame_view()->GetBoundsForClientView();
-
-    // Update surface bounds.
-    surface_->window()->SetBounds(
-        gfx::Rect(GetSurfaceOrigin() + client_view_bounds.OffsetFromOrigin(),
-                  surface_->window()->layer()->size()));
+    UpdateSurfaceBounds();

[reveman, 2017/02/06 19:49:33]

is this change needed?

[Dominik Laskowski, 2017/02/08 18:07:40]

Yes, UpdateSurfaceBounds is called from several places.

 
     // 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::AccessibilityObserver overrides:
@@ skipping 91 matching lines @@
   views::Widget::InitParams params;
   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_;
+  params.bounds = gfx::Rect(origin_, gfx::Size());
   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);
   widget_->Init(params);
 
   aura::Window* window = widget_->GetNativeWindow();
   window->SetName("ExoShellSurface");
   window->SetProperty(aura::client::kAccessibilityFocusFallsbackToWidgetKey,
                       false);
   window->AddChild(surface_->window());
   window->SetEventTargeter(base::WrapUnique(new CustomWindowTargeter(widget_)));
   SetApplicationId(window, application_id_);
   SetMainSurface(window, surface_);
 
   // Start tracking changes to window bounds and window state.
   window->AddObserver(this);
   ash::wm::WindowState* window_state = ash::wm::GetWindowState(window);
   window_state->AddObserver(this);
 
-  // Absolete positioned shell surfaces may request the bounds that does not
-  // fill the entire work area / display in maximized / fullscreen state.
-  // Allow such clients to update the bounds in these states.
-  if (!initial_bounds_.IsEmpty())
-    window_state->set_allow_set_bounds_in_maximized(true);
+  // Allow the client to request bounds that do not fill the entire work area
+  // when maximized, or the entire display when fullscreen.
+  window_state->set_allow_set_bounds_in_maximized(bounds_mode_ ==
+                                                  BoundsMode::CLIENT);
 
   // Notify client of initial state if different than normal.
   if (window_state->GetStateType() != ash::wm::WINDOW_STATE_TYPE_NORMAL &&
       !state_changed_callback_.is_null()) {
     state_changed_callback_.Run(ash::wm::WINDOW_STATE_TYPE_NORMAL,
                                 window_state->GetStateType());
   }
 
-  // Disable movement if initial bounds were specified.
-  widget_->set_movement_disabled(!initial_bounds_.IsEmpty());
-  window_state->set_ignore_keyboard_bounds_change(!initial_bounds_.IsEmpty());
+  // Disable movement if bounds are controlled by the client or fixed.
+  widget_->set_movement_disabled(bounds_mode_ != BoundsMode::SHELL);

[reveman, 2017/02/06 19:49:33]

nit: consider "bool shell_controls_bounds = bounds_mode_ != BoundsMode::SHELL;"
before this line to avoid doing '!=' twice

[Dominik Laskowski, 2017/02/08 18:07:40]

Done.

+  window_state->set_ignore_keyboard_bounds_change(bounds_mode_ !=
+                                                  BoundsMode::SHELL);
 
   // AutoHide shelf in fullscreen state.
   window_state->set_hide_shelf_when_fullscreen(false);
 
   // Fade visibility animations for non-activatable windows.
   if (!activatable_) {
     wm::SetWindowVisibilityAnimationType(
         window, wm::WINDOW_VISIBILITY_ANIMATION_TYPE_FADE);
   }
 
@@ skipping 12 matching lines @@
   pending_show_widget_ = true;
 }
 
 void ShellSurface::Configure() {
   // Delay configure callback if |scoped_configure_| is set.
   if (scoped_configure_) {
     scoped_configure_->set_needs_configure();
     return;
   }
 
-  gfx::Vector2d origin_offset = pending_origin_config_offset_;
-  pending_origin_config_offset_ = gfx::Vector2d();
+  const gfx::Vector2d origin_offset = pending_origin_offset_accumulator_;
+  pending_origin_offset_accumulator_ = gfx::Vector2d();
 
   int resize_component = HTCAPTION;
   if (widget_) {
     ash::wm::WindowState* window_state =
         ash::wm::GetWindowState(widget_->GetNativeWindow());
 
     // If surface is being resized, save the resize direction.
     if (window_state->is_dragged())
       resize_component = window_state->drag_details()->window_component;
   }
 
   uint32_t serial = 0;
   if (!configure_callback_.is_null()) {
     if (widget_) {
       const views::NonClientView* non_client_view = widget_->non_client_view();
       serial = configure_callback_.Run(
           non_client_view->frame_view()->GetBoundsForClientView().size(),
           ash::wm::GetWindowState(widget_->GetNativeWindow())->GetStateType(),
-          IsResizing(), widget_->IsActive());
+          IsResizing(), widget_->IsActive(), origin_);
     } else {
-      serial = configure_callback_.Run(
-          gfx::Size(), ash::wm::WINDOW_STATE_TYPE_NORMAL, false, false);
+      serial = configure_callback_.Run(gfx::Size(),
+                                       ash::wm::WINDOW_STATE_TYPE_NORMAL, false,
+                                       false, origin_);
     }
   }
 
   if (!serial) {
     pending_origin_offset_ += origin_offset;
     pending_resize_component_ = resize_component;
     return;
   }
 
   // Apply origin offset and resize component at the first Commit() after this
   // configure request has been acknowledged.
   pending_configs_.push_back({serial, origin_offset, resize_component});
   LOG_IF(WARNING, pending_configs_.size() > 100)
       << "Number of pending configure acks for shell surface has reached: "
       << pending_configs_.size();
 }
 
 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::WmWindow::Get(widget_->GetNativeWindow()), drag_location, component,
-      aura::client::WINDOW_MOVE_SOURCE_MOUSE);
+      ash::WmWindow::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_;
+  origin_offset_ += pending_origin_offset_;
   pending_origin_offset_ = gfx::Vector2d();
   resize_component_ = pending_resize_component_;
 
   WMHelper::GetInstance()->AddPreTargetHandler(this);
   widget_->GetNativeWindow()->SetCapture();
 
   // Notify client that resizing state has changed.
   if (IsResizing())
     Configure();
 }
@@ skipping 13 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 {
   ash::wm::WindowState* window_state =
       ash::wm::GetWindowState(widget_->GetNativeWindow());
   if (!window_state->is_dragged())
     return false;
 
   return window_state->drag_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 {
-  // If initial bounds were specified then surface origin is always relative
-  // to those bounds.
-  if (!initial_bounds_.IsEmpty()) {
-    gfx::Point origin = widget_->GetNativeWindow()->bounds().origin();
-    wm::ConvertPointToScreen(widget_->GetNativeWindow()->parent(), &origin);
-    return initial_bounds_.origin() - origin.OffsetFromOrigin();
+  // For client-positioned shell surfaces, the surface origin corresponds to the
+  // widget position relative to the origin specified by the client. Since the
+  // surface is positioned relative to the widget, negate this vector to align
+  // the surface with the widget. Note that the widget position must have been
+  // adjusted by the |origin_offset_| prior to this call.
+  if (bounds_mode_ != BoundsMode::SHELL) {
+    gfx::Point position = widget_->GetNativeWindow()->bounds().origin();
+    wm::ConvertPointToScreen(widget_->GetNativeWindow()->parent(), &position);
+    return origin_ - position.OffsetFromOrigin();
   }
 
   gfx::Rect visible_bounds = GetVisibleBounds();
   gfx::Rect client_bounds =
       widget_->non_client_view()->frame_view()->GetBoundsForClientView();
   switch (resize_component_) {
     case HTCAPTION:
-      return origin_ - visible_bounds.OffsetFromOrigin();
+      return gfx::Point() + origin_offset_ - visible_bounds.OffsetFromOrigin();
     case HTBOTTOM:
     case HTRIGHT:
     case HTBOTTOMRIGHT:
       return gfx::Point() - visible_bounds.OffsetFromOrigin();
     case HTTOP:
     case HTTOPRIGHT:
       return gfx::Point(0, client_bounds.height() - visible_bounds.height()) -
              visible_bounds.OffsetFromOrigin();
       break;
     case HTLEFT:
     case HTBOTTOMLEFT:
       return gfx::Point(client_bounds.width() - visible_bounds.width(), 0) -
              visible_bounds.OffsetFromOrigin();
     case HTTOPLEFT:
       return gfx::Point(client_bounds.width() - visible_bounds.width(),
                         client_bounds.height() - visible_bounds.height()) -
              visible_bounds.OffsetFromOrigin();
     default:
       NOTREACHED();
       return gfx::Point();
   }
 }
 
 void ShellSurface::UpdateWidgetBounds() {
   DCHECK(widget_);
 
-  // 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())
+  // Return early if the shell is currently managing the bounds of the widget,
+  // and the window is maximized/fullscreen/pinned or being dragged.
+  if (bounds_mode_ == BoundsMode::SHELL &&

[reveman, 2017/02/06 19:49:33]

please split this into multiple lines as before. the bounds mode check as a
separate statement with a "3) ..." comment

[Dominik Laskowski, 2017/02/08 18:07:40]

Done, but it's "&&" so there's no third case.

+      (ash::wm::GetWindowState(widget_->GetNativeWindow())
+           ->IsMaximizedOrFullscreenOrPinned() ||
+       IsResizing()))
     return;
 
   // Return early if there is pending configure requests.
   if (!pending_configs_.empty() || scoped_configure_)
     return;
 
   gfx::Rect visible_bounds = GetVisibleBounds();
   gfx::Rect new_widget_bounds =
       widget_->non_client_view()->GetWindowBoundsForClientBounds(
           visible_bounds);
 
-  // Avoid changing widget origin unless initial bounds were specified and
-  // widget origin is always relative to it.
-  if (initial_bounds_.IsEmpty()) {
+  if (bounds_mode_ == BoundsMode::CLIENT) {

[reveman, 2017/02/06 19:49:33]

nit: use a switch statement

[Dominik Laskowski, 2017/02/08 18:07:40]

Done. I've also merged the case below so it's clear that it only applies when
bounds are controlled by the shell.

+    // Position is relative to the latest origin acknowledged by the client.
+    new_widget_bounds -= origin_offset_;
+  } else if (bounds_mode_ == BoundsMode::FIXED) {
+    // Position is relative to the origin.
+    new_widget_bounds += origin_.OffsetFromOrigin();
+  } else {
+    // Preserve widget position.
     new_widget_bounds.set_origin(widget_->GetWindowBoundsInScreen().origin());
-  } else {
-    new_widget_bounds.set_origin(initial_bounds_.origin() +
-                                 visible_bounds.OffsetFromOrigin());
   }
 
   // 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;
+}
 
-  gfx::Rect client_view_bounds =
+void ShellSurface::UpdateSurfaceBounds() {
+  const gfx::Rect client_view_bounds =
       widget_->non_client_view()->frame_view()->GetBoundsForClientView();
 
-  // A change to the widget size requires surface bounds to be re-adjusted.
   surface_->window()->SetBounds(
       gfx::Rect(GetSurfaceOrigin() + client_view_bounds.OffsetFromOrigin(),
                 surface_->window()->layer()->size()));
 }
 
 void ShellSurface::UpdateShadow() {
   if (!widget_)
     return;
   aura::Window* window = widget_->GetNativeWindow();
   if (!shadow_enabled_) {
     wm::SetShadowElevation(window, wm::ShadowElevation::NONE);
     if (shadow_underlay_)
       shadow_underlay_->Hide();
   } else {
     wm::SetShadowElevation(window, wm::ShadowElevation::MEDIUM);
 
     gfx::Rect shadow_content_bounds = shadow_content_bounds_;
     if (shadow_content_bounds.IsEmpty())
       shadow_content_bounds = window->bounds();
 
-    // 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();
-    shadow_origin -= origin.OffsetFromOrigin();
+    gfx::Point shadow_origin = shadow_content_bounds.origin() - origin_offset_;
+    wm::ConvertPointFromScreen(window->parent(), &shadow_origin);
+    shadow_origin -= window->bounds().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());
       // Ensure the background area inside the shadow is solid black.
@@ skipping 69 matching lines @@
     // Surfaces that can't be activated are usually menus and tooltips. Use a
     // small style shadow for them.
     if (!activatable_)
       shadow->SetElevation(wm::ShadowElevation::SMALL);
     // We don't have rounded corners unless frame is enabled.
     if (!frame_enabled_)
       shadow->SetRoundedCornerRadius(0);
   }
 }
 
+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