exo: Synchronize multi-display window positioning

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"
@@ skipping 351 matching lines @@
     // 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 238 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());
 
+  if (origin == origin_)
+    return;
+
+  if (bounds_mode_ != BoundsMode::CLIENT) {
+    origin_ = 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.
+  gfx::Vector2d delta = origin - origin_;
+  origin_offset_ -= delta;
+  pending_origin_offset_accumulator_ += delta;
+
   origin_ = origin;
+
+  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_offset_ += pending_origin_offset_;
   pending_origin_offset_ = gfx::Vector2d();
 
   // Update resize direction to reflect acknowledged configure requests.
   resize_component_ = pending_resize_component_;
 
@@ skipping 171 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
+    // 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) {
+  // TODO(domlaskowski): For shell surfaces whose bounds are controlled by the
+  // client, the configure callback does not yet support resizing.
+  if (bounds_mode_ == BoundsMode::CLIENT)
+    return;
+
   if (!widget_ || !surface_ || 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. Retain the old origin by reverting
     // the origin delta until the next configure is acknowledged.
@@ skipping 231 matching lines @@
       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
@@ skipping 112 matching lines @@
          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 {
-  // 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.
-  if (bounds_mode_ != BoundsMode::SHELL) {
-    gfx::Point position = widget_->GetNativeWindow()->bounds().origin();
-    wm::ConvertPointToScreen(widget_->GetNativeWindow()->parent(), &position);
-    return origin_ - position.OffsetFromOrigin();
-  }
+  DCHECK(bounds_mode_ == BoundsMode::SHELL || resize_component_ == HTCAPTION);
 
   gfx::Rect visible_bounds = GetVisibleBounds();
   gfx::Rect client_bounds =
       widget_->non_client_view()->frame_view()->GetBoundsForClientView();
   switch (resize_component_) {
     case HTCAPTION:
-      return gfx::Point() + origin_offset_ - visible_bounds.OffsetFromOrigin();
+      return (bounds_mode_ == BoundsMode::CLIENT ? origin_ : gfx::Point()) +
+             origin_offset_ - visible_bounds.OffsetFromOrigin();

[reveman, 2017/02/24 16:50:00]

nit: split into multiple lines to make it easier to read. maybe just add:

if (bounds_mode_ == BoundsMode::CLIENT)
  return origin_ + origin_offset_ - visible_bounds.OffsetFromOrigin();

above existing line 1308 as an early out

[Dominik Laskowski, 2017/02/24 18:51:30]

Done.

     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();
     case HTLEFT:
     case HTBOTTOMLEFT:
@@ skipping 31 matching lines @@
     return;
 
   gfx::Rect visible_bounds = GetVisibleBounds();
   gfx::Rect new_widget_bounds =
       widget_->non_client_view()->GetWindowBoundsForClientBounds(
           visible_bounds);
 
   switch (bounds_mode_) {
     case BoundsMode::CLIENT:
     case BoundsMode::FIXED:
-      // Position is relative to the origin.
-      new_widget_bounds += origin_.OffsetFromOrigin();
+      new_widget_bounds.set_origin(origin_ -
+                                   GetSurfaceOrigin().OffsetFromOrigin());
       break;
     case BoundsMode::SHELL:
       // 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 widget_origin =
             GetSurfaceOrigin() + visible_bounds.OffsetFromOrigin();
         wm::ConvertPointToScreen(widget_->GetNativeWindow(), &widget_origin);
         new_widget_bounds.set_origin(widget_origin);
@@ skipping 28 matching lines @@
     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 =
         gfx::ScaleToEnclosedRect(shadow_content_bounds_, 1.f / scale_);
+
+    // Convert from screen to display coordinates.
+    if (!shadow_content_bounds.IsEmpty()) {
+      gfx::Point origin = shadow_content_bounds.origin() - origin_offset_;
+      wm::ConvertPointFromScreen(window->parent(), &origin);
+      shadow_content_bounds.set_origin(origin);
+    }
+
     gfx::Rect shadow_underlay_bounds = shadow_content_bounds_;
-    if (shadow_underlay_bounds.IsEmpty())
+
+    if (shadow_underlay_bounds.IsEmpty()) {
       shadow_underlay_bounds = gfx::Rect(surface_->window()->bounds().size());
+    } else if (shadow_underlay_in_surface_) {
+      // Since the shadow underlay is positioned relative to the surface, its
+      // origin corresponds to the shadow content position relative to the
+      // origin specified by the client.
+      shadow_underlay_bounds -=
+          gfx::ScaleToCeiledPoint(origin_ + origin_offset_, scale_)
+              .OffsetFromOrigin();
+    }
 
     if (!shadow_underlay_in_surface_) {
       shadow_content_bounds = shadow_content_bounds_;
       if (shadow_content_bounds.IsEmpty()) {
         shadow_content_bounds = window->bounds();
+      } else {
+        // Convert from screen to display coordinates.
+        gfx::Point origin = shadow_content_bounds.origin() - origin_offset_;
+        wm::ConvertPointFromScreen(window->parent(), &origin);
+        shadow_content_bounds.set_origin(origin);
       }
     }
 
-    // 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();
+    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 85 matching lines @@
     // 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);
   }
 }
 
 }  // namespace exo