dont overwrite save layer bounds.

display_list/dl_builder.cc

@@ -620,7 +620,13 @@ void DisplayListBuilder::RestoreLayer() {
       content_bounds.intersect(layer_op->rect);
     }
   }
-  layer_op->rect = content_bounds;
+  // If the caller specified save layer bounds, preserve those
+  // instead of overwriting with content bounds. The caller
+  // bounds may clip the contents or otherwise limit the bounds
+  // of backdrop entities.
+  if (!layer_op->options.bounds_from_caller()) {
+    layer_op->rect = content_bounds;
+  }
   layer_op->max_blend_mode = current_layer().max_blend_mode;
 
   if (current_layer().contains_backdrop_filter) {

impeller/display_list/dl_dispatcher.cc

@@ -622,11 +622,7 @@ void DlDispatcherBase::saveLayer(const SkRect& bounds,
   auto promise = options.content_is_clipped()
                      ? ContentBoundsPromise::kMayClipContents
                      : ContentBoundsPromise::kContainsContents;
-  std::optional<Rect> impeller_bounds;
-  if (!options.content_is_unbounded() || options.bounds_from_caller()) {
-    impeller_bounds = skia_conversions::ToRect(bounds);
-  }
-
+  std::optional<Rect> impeller_bounds = skia_conversions::ToRect(bounds);
   GetCanvas().SaveLayer(paint, impeller_bounds, ToImageFilter(backdrop),
                         promise, total_content_depth,
                         options.can_distribute_opacity(),

impeller/entity/save_layer_utils.cc

@@ -22,7 +22,6 @@ std::optional<Rect> ComputeSaveLayerCoverage(
   // developer, in this case we still use the content coverage even if the
   // saveLayer itself is unbounded.
   bool save_layer_is_unbounded = has_backdrop_filter || destructive_blend;
-
   // Otherwise, the save layer is bounded by either its contents or by
   // a specified coverage limit. In these cases the coverage value is used
   // and intersected with the coverage limit.
@@ -40,22 +39,17 @@ std::optional<Rect> ComputeSaveLayerCoverage(
   // into any computed bounds. That is, a canvas scaling transform of 0.5
   // changes the coverage of the contained entities directly and doesnt need to
   // be additionally incorporated into the coverage computation here.
-  std::optional<Rect> result_bounds;
   if (image_filter) {
     std::optional<Rect> source_coverage_limit =
         image_filter->GetSourceCoverage(effect_transform, coverage_limit);
     if (!source_coverage_limit.has_value()) {
       // No intersection with parent coverage limit.
       return std::nullopt;
     }
-    result_bounds = input_coverage.Intersection(source_coverage_limit.value());
-
-    // Finally, transform the resulting bounds back into the global coordinate
-    // space.
-    if (result_bounds.has_value()) {
-      return result_bounds->TransformBounds(effect_transform);
-    }
-    return std::nullopt;
+    // Transform the input coverage into the global coordinate space before
+    // computing the bounds limit intersection.
+    return input_coverage.TransformBounds(effect_transform)
+        .Intersection(source_coverage_limit.value());
   }
 
   // If the input coverage is maximum, just return the coverage limit that