exo: Compute SurfaceTreeHost bounds recursively

The RenderPass::output_rect and host window bounds for SurfaceTreeHost
were set to the content size of the root surface. Hence, surfaces were
clipped to the viewport (0, 0) × (W, H), where (W, H) is the size of
the root surface. The root surface of ARC windows is sized to match
the Android display.

This CL computes the output_rect as the bounding box of the surface
tree, and resizes the host window to match the output_rect.

Bug: b:64893967
Test: Windows whose bounds exceed the bottom/right edges of the display
      are not clipped in overview mode.

Change-Id: I51ddf7405e703f5c546aec88a01cc004d105b18a
Reviewed-on: https://chromium-review.googlesource.com/639472
Commit-Queue: Dominik Laskowski <domlaskowski@chromium.org>
Reviewed-by: David Reveman <reveman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#505871}

components/exo/notification_surface.cc

@@ -35,20 +35,14 @@ const gfx::Size& NotificationSurface::GetContentSize() const {
 
 void NotificationSurface::OnSurfaceCommit() {
   SurfaceTreeHost::OnSurfaceCommit();
-  SubmitCompositorFrame();
-
-  gfx::Rect bounds = host_window()->bounds();
-  auto& size = host_window()->bounds().size();
-  if (bounds.size() != size) {
-    bounds.set_size(size);
-    host_window()->SetBounds(bounds);
-  }
 
   // Defer AddSurface until there are contents to show.
-  if (!added_to_manager_ && !size.IsEmpty()) {
+  if (!added_to_manager_ && !host_window()->bounds().IsEmpty()) {
     added_to_manager_ = true;
     manager_->AddSurface(this);
   }
+
+  SubmitCompositorFrame();
 }
 
 void NotificationSurface::OnSurfaceDestroying(Surface* surface) {

components/exo/pointer.cc

@@ -156,11 +156,12 @@ gfx::NativeCursor Pointer::GetCursor() {
 
 void Pointer::OnSurfaceCommit() {
   SurfaceTreeHost::OnSurfaceCommit();
-  SubmitCompositorFrame();
 
   // Capture new cursor to reflect result of commit.
-  if (focus_surface_)
+  if (focus_surface_ && !host_window()->bounds().IsEmpty())
     CaptureCursor(hotspot_);
+
+  SubmitCompositorFrame();
 }
 
 ////////////////////////////////////////////////////////////////////////////////

components/exo/shell_surface.cc

@@ -771,7 +771,7 @@ void ShellSurface::OnSurfaceCommit() {
 
   if (enabled() && !widget_) {
     // Defer widget creation until surface contains some contents.
-    if (root_surface()->content_size().IsEmpty()) {
+    if (host_window()->bounds().IsEmpty()) {
       Configure();
       return;
     }
@@ -1623,8 +1623,11 @@ bool ShellSurface::IsResizing() const {
 
 gfx::Rect ShellSurface::GetVisibleBounds() const {
   // Use |geometry_| if set, otherwise use the visual bounds of the surface.
-  return geometry_.IsEmpty() ? gfx::Rect(host_window()->bounds().size())
-                             : geometry_;
+  if (!geometry_.IsEmpty())
+    return geometry_;
+
+  return root_surface() ? gfx::Rect(root_surface()->content_size())
+                        : gfx::Rect();
 }
 
 gfx::Point ShellSurface::GetSurfaceOrigin() const {

components/exo/sub_surface.cc

@@ -100,8 +100,6 @@ void SubSurface::OnSurfaceCommit() {
   NOTIMPLEMENTED() << "Async subsurface is not supported!";
 }
 
-void SubSurface::OnSurfaceContentSizeChanged() {}
-
 bool SubSurface::IsSurfaceSynchronized() const {
   // A sub-surface is effectively synchronized if either its parent is
   // synchronized or itself is in synchronized mode.

components/exo/sub_surface.h

@@ -50,7 +50,6 @@ class SubSurface : public SurfaceDelegate, public SurfaceObserver {
 
   // Overridden from SurfaceDelegate:
   void OnSurfaceCommit() override;
-  void OnSurfaceContentSizeChanged() override;
   bool IsSurfaceSynchronized() const override;
   void OnSetFrame(SurfaceFrameType type) override {}
 

components/exo/surface.cc

@@ -433,8 +433,7 @@ void Surface::Commit() {
     delegate_->OnSurfaceCommit();
 }
 
-void Surface::CommitSurfaceHierarchy(
-    const gfx::Point& origin,
+gfx::Rect Surface::CommitSurfaceHierarchy(
     std::list<FrameCallback>* frame_callbacks,
     std::list<PresentationCallback>* presentation_callbacks) {
   if (needs_commit_surface_) {
@@ -517,16 +516,21 @@ void Surface::CommitSurfaceHierarchy(
     pending_damage_.setEmpty();
   }
 
+  gfx::Rect bounds(content_size_);
+
   // The top most sub-surface is at the front of the RenderPass's quad_list,
   // so we need composite sub-surface in reversed order.
   for (const auto& sub_surface_entry : base::Reversed(sub_surfaces_)) {
     auto* sub_surface = sub_surface_entry.first;
-    // Synchronsouly commit all pending state of the sub-surface and its
-    // decendents.
-    sub_surface->CommitSurfaceHierarchy(
-        origin + sub_surface_entry.second.OffsetFromOrigin(), frame_callbacks,
-        presentation_callbacks);
+    gfx::Point origin = sub_surface_entry.second;
+    // Synchronously commit all pending state of the sub-surface and its
+    // descendants.
+    bounds.Union(sub_surface->CommitSurfaceHierarchy(frame_callbacks,
+                                                     presentation_callbacks) +
+                 origin.OffsetFromOrigin());
   }
+
+  return bounds;
 }
 
 void Surface::AppendSurfaceHierarchyContentsToFrame(
@@ -762,12 +766,14 @@ void Surface::AppendContentsToFrame(const gfx::Point& origin,
   gfx::Rect output_rect(origin, content_size_);
   gfx::Rect quad_rect(0, 0, 1, 1);
 
-  // Surface uses DIP, but the |render_pass->damage_rect| uses pixels, so we
-  // need scale it beased on the |device_scale_factor|.
+  // Surface bounds are in DIPs, but |damage_rect| and |output_rect| are in
+  // pixels, so we need to scale by the |device_scale_factor|.
   gfx::Rect damage_rect = gfx::SkIRectToRect(damage_.getBounds());
   damage_rect.Offset(origin.x(), origin.y());
   render_pass->damage_rect.Union(
       gfx::ConvertRectToPixel(device_scale_factor, damage_rect));
+  render_pass->output_rect.Union(
+      gfx::ConvertRectToPixel(device_scale_factor, output_rect));
 
   // Compute the total transformation from post-transform buffer coordinates to
   // target coordinates.
@@ -791,8 +797,8 @@ void Surface::AppendContentsToFrame(const gfx::Point& origin,
   viz::SharedQuadState* quad_state =
       render_pass->CreateAndAppendSharedQuadState();
   quad_state->SetAll(
-      quad_to_target_transform, gfx::Rect(content_size_) /* quad_layer_rect */,
-      output_rect /* visible_quad_layer_rect */, gfx::Rect() /* clip_rect */,
+      quad_to_target_transform, quad_rect /* quad_layer_rect */,
+      quad_rect /* visible_quad_layer_rect */, gfx::Rect() /* clip_rect */,
       false /* is_clipped */, are_contents_opaque, state_.alpha /* opacity */,
       SkBlendMode::kSrcOver /* blend_mode */, 0 /* sorting_context_id */);
 
@@ -864,8 +870,6 @@ void Surface::UpdateContentSize() {
   if (content_size_ != content_size) {
     content_size_ = content_size;
     window_->SetBounds(gfx::Rect(window_->bounds().origin(), content_size_));
-    if (delegate_)
-      delegate_->OnSurfaceContentSizeChanged();
   }
 }
 

components/exo/surface.h

@@ -145,9 +145,9 @@ class Surface final : public ui::PropertyHandler {
 
   // This will synchronously commit all pending state of the surface and its
   // descendants by recursively calling CommitSurfaceHierarchy() for each
-  // sub-surface with pending state.
-  void CommitSurfaceHierarchy(
-      const gfx::Point& origin,
+  // sub-surface with pending state. Returns the bounding box of the surface
+  // and its descendants, in the local coordinate space of the surface.
+  gfx::Rect CommitSurfaceHierarchy(
       std::list<FrameCallback>* frame_callbacks,
       std::list<PresentationCallback>* presentation_callbacks);
 

components/exo/surface_delegate.h

@@ -16,9 +16,6 @@ class SurfaceDelegate {
   // Called when surface was requested to commit all double-buffered state.
   virtual void OnSurfaceCommit() = 0;
 
-  // Called when surface content size was changed.
-  virtual void OnSurfaceContentSizeChanged() = 0;
-
   // Returns true if surface is in synchronized mode. ie. commit of
   // double-buffered state should be synchronized with parent surface.
   virtual bool IsSurfaceSynchronized() const = 0;

components/exo/surface_tree_host.cc

@@ -143,8 +143,6 @@ void SurfaceTreeHost::SetRootSurface(Surface* root_surface) {
     root_surface_ = root_surface;
     root_surface_->SetSurfaceDelegate(this);
     host_window_->AddChild(root_surface_->window());
-    host_window_->SetBounds(gfx::Rect(host_window_->bounds().origin(),
-                                      root_surface_->content_size()));
     root_surface_->window()->Show();
   }
 }
@@ -202,13 +200,14 @@ void SurfaceTreeHost::UpdateNeedsBeginFrame() {
 // SurfaceDelegate overrides:
 
 void SurfaceTreeHost::OnSurfaceCommit() {
-  root_surface_->CommitSurfaceHierarchy(gfx::Point(), &frame_callbacks_,
-                                        &presentation_callbacks_);
-}
+  gfx::Rect bounds = root_surface_->CommitSurfaceHierarchy(
+      &frame_callbacks_, &presentation_callbacks_);
 
-void SurfaceTreeHost::OnSurfaceContentSizeChanged() {
-  host_window_->SetBounds(gfx::Rect(host_window_->bounds().origin(),
-                                    root_surface_->content_size()));
+  host_window_->SetBounds(
+      gfx::Rect(host_window_->bounds().origin(), bounds.size()));
+  host_window_->layer()->SetFillsBoundsOpaquely(
+      bounds.size() == root_surface_->content_size() &&
+      root_surface_->FillsBoundsOpaquely());
 }
 
 bool SurfaceTreeHost::IsSurfaceSynchronized() const {
@@ -307,24 +306,17 @@ void SurfaceTreeHost::SubmitCompositorFrame() {
     current_begin_frame_ack_.has_damage = true;
   }
   frame.metadata.begin_frame_ack = current_begin_frame_ack_;
+  frame.render_pass_list.push_back(viz::RenderPass::Create());
+  const std::unique_ptr<viz::RenderPass>& render_pass =
+      frame.render_pass_list.back();
   const int kRenderPassId = 1;
-  std::unique_ptr<viz::RenderPass> render_pass = viz::RenderPass::Create();
   render_pass->SetNew(kRenderPassId, gfx::Rect(), gfx::Rect(),
                       gfx::Transform());
-  frame.render_pass_list.push_back(std::move(render_pass));
   float device_scale_factor = host_window()->layer()->device_scale_factor();
+  frame.metadata.device_scale_factor = device_scale_factor;
   root_surface_->AppendSurfaceHierarchyContentsToFrame(
       gfx::Point(), device_scale_factor, layer_tree_frame_sink_holder_.get(),
       &frame);
-  // Surface uses DIP, but the |output_rect| uses pixels, so we need
-  // scale it beased on the |device_scale_factor|.
-  frame.render_pass_list.back()->output_rect =
-      gfx::Rect(gfx::ConvertSizeToPixel(device_scale_factor,
-                                        root_surface_->content_size()));
-
-  host_window_->layer()->SetFillsBoundsOpaquely(
-      root_surface_->FillsBoundsOpaquely());
-  frame.metadata.device_scale_factor = device_scale_factor;
   layer_tree_frame_sink_holder_->frame_sink()->SubmitCompositorFrame(
       std::move(frame));
 

components/exo/surface_tree_host.h

@@ -83,7 +83,6 @@ class SurfaceTreeHost : public SurfaceDelegate,
 
   // Overridden from SurfaceDelegate:
   void OnSurfaceCommit() override;
-  void OnSurfaceContentSizeChanged() override;
   bool IsSurfaceSynchronized() const override;
   void OnSetFrame(SurfaceFrameType type) override {}