oh boy here we go.

impeller/aiks/BUILD.gn

@@ -26,8 +26,6 @@ impeller_component("aiks") {
     "paint_pass_delegate.h",
     "picture.cc",
     "picture.h",
-    "save_layer_utils.cc",
-    "save_layer_utils.h",
   ]
 
   public_deps = [
@@ -114,10 +112,7 @@ template("aiks_unittests_component") {
 }
 
 aiks_unittests_component("aiks_unittests") {
-  sources = [
-    "canvas_unittests.cc",
-    "save_layer_utils_unittests.cc",
-  ]
+  sources = [ "canvas_unittests.cc" ]
 }
 
 aiks_unittests_component("aiks_unittests_golden") {

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 || !image->GetTexture()) {
         return std::nullopt;
       }
-      color_wheel_image = std::make_shared<Image>(snapshot->texture);
-      color_wheel_transform = snapshot->transform;
+      color_wheel_image = std::make_shared<Image>(image->GetTexture());
+      color_wheel_transform = Matrix();
     }
 
     Canvas canvas;

impeller/aiks/canvas.cc

@@ -837,7 +837,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, bounds_from_caller);
   }
 
   // When applying a save layer, absorb any pending distributed opacity.

impeller/aiks/canvas_unittests.cc

@@ -5,7 +5,6 @@
 #include "flutter/testing/testing.h"
 #include "impeller/aiks/canvas.h"
 #include "impeller/aiks/image_filter.h"
-#include "impeller/aiks/save_layer_utils.h"
 #include "impeller/geometry/color.h"
 #include "impeller/geometry/path_builder.h"
 

impeller/aiks/experimental_canvas.cc

@@ -10,10 +10,12 @@
 #include "impeller/base/validation.h"
 #include "impeller/core/allocator.h"
 #include "impeller/core/formats.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"
 
@@ -310,11 +312,6 @@ void ExperimentalCanvas::SaveLayer(
     bool bounds_from_caller) {
   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.
@@ -338,13 +335,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;
@@ -359,12 +349,32 @@ 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,                    //
+      /*destructive_blend=*/Entity::IsBlendModeDestructive(paint.blend_mode),
+      /*has_backdrop_filter=*/!!backdrop_filter,
+      /*bounds_from_caller=*/bounds_from_caller);
+
+  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,
@@ -397,21 +407,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/picture.cc

@@ -14,19 +14,19 @@
 
 namespace impeller {
 
-std::optional<Snapshot> Picture::Snapshot(AiksContext& context) {
-  auto coverage = pass->GetElementsCoverage(std::nullopt);
-  if (!coverage.has_value() || coverage->IsEmpty()) {
-    return std::nullopt;
-  }
+// 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())};
-}
+//   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<Image> Picture::ToImage(AiksContext& context,
                                         ISize size) const {

impeller/aiks/picture.h

@@ -17,7 +17,7 @@ namespace impeller {
 struct Picture {
   std::unique_ptr<EntityPass> pass;
 
-  std::optional<Snapshot> Snapshot(AiksContext& context);
+  // std::optional<Snapshot> Snapshot(AiksContext& context);
 
   std::shared_ptr<Image> ToImage(AiksContext& context, ISize size) const;
 

impeller/display_list/dl_dispatcher.cc

@@ -627,14 +627,6 @@ void DlDispatcherBase::saveLayer(const SkRect& bounds,
     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(),

impeller/entity/BUILD.gn

@@ -204,6 +204,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 = [
@@ -257,6 +259,7 @@ impeller_component("entity_unittests") {
     "entity_unittests.cc",
     "geometry/geometry_unittests.cc",
     "render_target_cache_unittests.cc",
+    "save_layer_utils_unittests.cc",
   ]
 
   deps = [