[Impeller] separate algorithm for computing render target size.

ci/licenses_golden/excluded_files

@@ -173,6 +173,7 @@
 ../../../flutter/impeller/entity/entity_unittests.cc
 ../../../flutter/impeller/entity/geometry/geometry_unittests.cc
 ../../../flutter/impeller/entity/render_target_cache_unittests.cc
+../../../flutter/impeller/entity/save_layer_utils_unittests.cc
 ../../../flutter/impeller/fixtures
 ../../../flutter/impeller/geometry/README.md
 ../../../flutter/impeller/geometry/geometry_unittests.cc

ci/licenses_golden/licenses_flutter

@@ -42871,6 +42871,8 @@ ORIGIN: ../../../flutter/impeller/entity/inline_pass_context.cc + ../../../flutt
 ORIGIN: ../../../flutter/impeller/entity/inline_pass_context.h + ../../../flutter/LICENSE
 ORIGIN: ../../../flutter/impeller/entity/render_target_cache.cc + ../../../flutter/LICENSE
 ORIGIN: ../../../flutter/impeller/entity/render_target_cache.h + ../../../flutter/LICENSE
+ORIGIN: ../../../flutter/impeller/entity/save_layer_utils.cc + ../../../flutter/LICENSE
+ORIGIN: ../../../flutter/impeller/entity/save_layer_utils.h + ../../../flutter/LICENSE
 ORIGIN: ../../../flutter/impeller/entity/shaders/blending/advanced_blend.frag + ../../../flutter/LICENSE
 ORIGIN: ../../../flutter/impeller/entity/shaders/blending/advanced_blend.vert + ../../../flutter/LICENSE
 ORIGIN: ../../../flutter/impeller/entity/shaders/blending/blend_select.glsl + ../../../flutter/LICENSE
@@ -45759,6 +45761,8 @@ FILE: ../../../flutter/impeller/entity/inline_pass_context.cc
 FILE: ../../../flutter/impeller/entity/inline_pass_context.h
 FILE: ../../../flutter/impeller/entity/render_target_cache.cc
 FILE: ../../../flutter/impeller/entity/render_target_cache.h
+FILE: ../../../flutter/impeller/entity/save_layer_utils.cc
+FILE: ../../../flutter/impeller/entity/save_layer_utils.h
 FILE: ../../../flutter/impeller/entity/shaders/blending/advanced_blend.frag
 FILE: ../../../flutter/impeller/entity/shaders/blending/advanced_blend.vert
 FILE: ../../../flutter/impeller/entity/shaders/blending/blend_select.glsl

impeller/aiks/aiks_blend_unittests.cc

@@ -127,12 +127,13 @@ TEST_P(AiksTest, ColorWheel) {
 
       draw_color_wheel(canvas);
       auto color_wheel_picture = canvas.EndRecordingAsPicture();
-      auto snapshot = color_wheel_picture.Snapshot(renderer);
-      if (!snapshot.has_value() || !snapshot->texture) {
+      auto image = color_wheel_picture.ToImage(
+          renderer, ISize{GetWindowSize().width, GetWindowSize().height});
+      if (!image) {
         return std::nullopt;
       }
-      color_wheel_image = snapshot->texture;
-      color_wheel_transform = snapshot->transform;
+      color_wheel_image = image;
+      color_wheel_transform = Matrix();
     }
 
     Canvas canvas;

impeller/aiks/canvas.cc

@@ -814,8 +814,7 @@ void Canvas::SaveLayer(const Paint& paint,
                        const std::shared_ptr<ImageFilter>& backdrop_filter,
                        ContentBoundsPromise bounds_promise,
                        uint32_t total_content_depth,
-                       bool can_distribute_opacity,
-                       bool bounds_from_caller) {
+                       bool can_distribute_opacity) {
   if (can_distribute_opacity && !backdrop_filter &&
       Paint::CanApplyOpacityPeephole(paint) &&
       bounds_promise != ContentBoundsPromise::kMayClipContents) {
@@ -837,7 +836,7 @@ void Canvas::SaveLayer(const Paint& paint,
 
   auto& new_layer_pass = GetCurrentPass();
   if (bounds) {
-    new_layer_pass.SetBoundsLimit(bounds, bounds_promise);
+    new_layer_pass.SetBoundsLimit(bounds);
   }
 
   // When applying a save layer, absorb any pending distributed opacity.

impeller/aiks/canvas.h

@@ -76,8 +76,7 @@ class Canvas {
       const std::shared_ptr<ImageFilter>& backdrop_filter = nullptr,
       ContentBoundsPromise bounds_promise = ContentBoundsPromise::kUnknown,
       uint32_t total_content_depth = kMaxDepth,
-      bool can_distribute_opacity = false,
-      bool bounds_from_caller = false);
+      bool can_distribute_opacity = false);
 
   virtual bool Restore();
 

impeller/aiks/experimental_canvas.cc

@@ -12,10 +12,12 @@
 #include "impeller/core/allocator.h"
 #include "impeller/core/formats.h"
 #include "impeller/entity/contents/clip_contents.h"
+#include "impeller/entity/contents/filters/filter_contents.h"
 #include "impeller/entity/contents/framebuffer_blend_contents.h"
 #include "impeller/entity/contents/text_contents.h"
 #include "impeller/entity/entity.h"
 #include "impeller/entity/entity_pass_clip_stack.h"
+#include "impeller/entity/save_layer_utils.h"
 #include "impeller/geometry/color.h"
 #include "impeller/renderer/render_target.h"
 
@@ -314,15 +316,9 @@ void ExperimentalCanvas::SaveLayer(
     const std::shared_ptr<ImageFilter>& backdrop_filter,
     ContentBoundsPromise bounds_promise,
     uint32_t total_content_depth,
-    bool can_distribute_opacity,
-    bool bounds_from_caller) {
+    bool can_distribute_opacity) {
   TRACE_EVENT0("flutter", "Canvas::saveLayer");
 
-  if (bounds.has_value() && bounds->IsEmpty()) {
-    Save(total_content_depth);
-    return;
-  }
-
   if (!clip_coverage_stack_.HasCoverage()) {
     // The current clip is empty. This means the pass texture won't be
     // visible, so skip it.
@@ -346,13 +342,6 @@ void ExperimentalCanvas::SaveLayer(
                                     ->GetSize()))
           .Intersection(current_clip_coverage);
 
-  if (!maybe_coverage_limit.has_value()) {
-    Save(total_content_depth);
-    return;
-  }
-  maybe_coverage_limit = maybe_coverage_limit->Intersection(
-      Rect::MakeSize(render_target_.GetRenderTargetSize()));
-
   if (!maybe_coverage_limit.has_value() || maybe_coverage_limit->IsEmpty()) {
     Save(total_content_depth);
     return;
@@ -367,12 +356,33 @@ void ExperimentalCanvas::SaveLayer(
     return;
   }
 
+  std::shared_ptr<FilterContents> filter_contents;
+  if (paint.image_filter) {
+    filter_contents = paint.image_filter->GetFilterContents();
+  }
+
+  std::optional<Rect> maybe_subpass_coverage = ComputeSaveLayerCoverage(
+      bounds.value_or(Rect::MakeMaximum()),
+      transform_stack_.back().transform,  //
+      coverage_limit,                     //
+      filter_contents,                    //
+      /*flood_output_coverage=*/
+      Entity::IsBlendModeDestructive(paint.blend_mode),  //
+      /*flood_input_coverage=*/!!backdrop_filter         //
+  );
+
+  if (!maybe_subpass_coverage.has_value() ||
+      maybe_subpass_coverage->IsEmpty()) {
+    Save(total_content_depth);
+    return;
+  }
+  auto subpass_coverage = maybe_subpass_coverage.value();
+
   // Backdrop filter state, ignored if there is no BDF.
   std::shared_ptr<FilterContents> backdrop_filter_contents;
   Point local_position = {0, 0};
   if (backdrop_filter) {
-    local_position =
-        current_clip_coverage.GetOrigin() - GetGlobalPassPosition();
+    local_position = subpass_coverage.GetOrigin() - GetGlobalPassPosition();
     EntityPass::BackdropFilterProc backdrop_filter_proc =
         [backdrop_filter = backdrop_filter->Clone()](
             const FilterInput::Ref& input, const Matrix& effect_transform,
@@ -409,21 +419,6 @@ void ExperimentalCanvas::SaveLayer(
   paint_copy.color.alpha *= transform_stack_.back().distributed_opacity;
   transform_stack_.back().distributed_opacity = 1.0;
 
-  // Backdrop Filter must expand bounds to at least the clip stack, otherwise
-  // the coverage of the parent render pass.
-  Rect subpass_coverage;
-  if (backdrop_filter_contents ||
-      Entity::IsBlendModeDestructive(paint.blend_mode) || !bounds.has_value()) {
-    subpass_coverage = coverage_limit;
-    // TODO(jonahwilliams): if we have tight bounds we should be able to reduce
-    // this size here. if (bounds.has_value() && bounds_from_caller) {
-    //   subpass_coverage =
-    //       coverage_limit.Intersection(bounds.value()).value_or(bounds.value());
-    // }
-  } else {
-    subpass_coverage = bounds->TransformBounds(GetCurrentTransform());
-  }
-
   render_passes_.push_back(LazyRenderingConfig(
       renderer_,                                             //
       CreateRenderTarget(renderer_,                          //

impeller/aiks/experimental_canvas.h

@@ -71,8 +71,7 @@ class ExperimentalCanvas : public Canvas {
                  const std::shared_ptr<ImageFilter>& backdrop_filter,
                  ContentBoundsPromise bounds_promise,
                  uint32_t total_content_depth,
-                 bool can_distribute_opacity,
-                 bool bounds_from_caller) override;
+                 bool can_distribute_opacity) override;
 
   bool Restore() override;
 

impeller/aiks/picture.cc

@@ -8,26 +8,10 @@
 #include <optional>
 
 #include "impeller/base/validation.h"
-#include "impeller/entity/entity.h"
 #include "impeller/renderer/render_target.h"
-#include "impeller/renderer/snapshot.h"
 
 namespace impeller {
 
-std::optional<Snapshot> Picture::Snapshot(AiksContext& context) {
-  auto coverage = pass->GetElementsCoverage(std::nullopt);
-  if (!coverage.has_value() || coverage->IsEmpty()) {
-    return std::nullopt;
-  }
-
-  const auto translate = Matrix::MakeTranslation(-coverage->GetOrigin());
-  auto texture =
-      RenderToTexture(context, ISize(coverage->GetSize()), translate);
-  return impeller::Snapshot{
-      .texture = std::move(texture),
-      .transform = Matrix::MakeTranslation(coverage->GetOrigin())};
-}
-
 std::shared_ptr<Texture> Picture::ToImage(AiksContext& context,
                                           ISize size) const {
   if (size.IsEmpty()) {

impeller/aiks/picture.h

@@ -16,8 +16,6 @@ namespace impeller {
 struct Picture {
   std::unique_ptr<EntityPass> pass;
 
-  std::optional<Snapshot> Snapshot(AiksContext& context);
-
   std::shared_ptr<Texture> ToImage(AiksContext& context, ISize size) const;
 
  private:

impeller/display_list/dl_dispatcher.cc

@@ -723,22 +723,18 @@ void DlDispatcherBase::saveLayer(const SkRect& bounds,
                      ? ContentBoundsPromise::kMayClipContents
                      : ContentBoundsPromise::kContainsContents;
   std::optional<Rect> impeller_bounds;
+  // If the content is unbounded but has developer specified bounds, we take
+  // the original bounds so that we clip the content as expected.
   if (!options.content_is_unbounded() || options.bounds_from_caller()) {
     impeller_bounds = skia_conversions::ToRect(bounds);
   }
 
-  // Empty bounds on a save layer that contains a BDF or destructive blend
-  // should be treated as unbounded. All other empty bounds can be skipped.
-  if (impeller_bounds.has_value() && impeller_bounds->IsEmpty() &&
-      (backdrop != nullptr ||
-       Entity::IsBlendModeDestructive(paint.blend_mode))) {
-    impeller_bounds = std::nullopt;
-  }
-
-  GetCanvas().SaveLayer(paint, impeller_bounds, ToImageFilter(backdrop),
-                        promise, total_content_depth,
-                        options.can_distribute_opacity(),
-                        options.bounds_from_caller());
+  GetCanvas().SaveLayer(
+      paint, impeller_bounds, ToImageFilter(backdrop), promise,
+      total_content_depth,
+      // Unbounded content can still have user specified bounds that require a
+      // saveLayer to be created to perform the clip.
+      options.can_distribute_opacity() && !options.content_is_unbounded());
 }
 
 // |flutter::DlOpReceiver|

impeller/entity/BUILD.gn

@@ -206,6 +206,8 @@ impeller_component("entity") {
     "inline_pass_context.h",
     "render_target_cache.cc",
     "render_target_cache.h",
+    "save_layer_utils.cc",
+    "save_layer_utils.h",
   ]
 
   public_deps = [
@@ -260,6 +262,7 @@ impeller_component("entity_unittests") {
     "entity_unittests.cc",
     "geometry/geometry_unittests.cc",
     "render_target_cache_unittests.cc",
+    "save_layer_utils_unittests.cc",
   ]
 
   deps = [