[Impeller] add mechanism for sharing bdf inputs. (#55701)

Introduces a mechanism to allow backdrop filters to 1) share backdrop inputs and 2) fuse filter applications for faster blurs.

This is a proposed solution to flutter/flutter#131568

Implemented:
* Developer can specify a "backdrop id" which indicates that a backdrop layer should share the input texture and potentially cached filter for a layer.
* Removes second save layer for each backdrop filter
* Removes save layer trace event for backdrop filter
* Can fuse backdrop filters if there is more than one identical filter

TBD:
* Adjust heruristic to avoid applying bdf filter to entire screen

Suggestions: applying a bdf should be a distinct operation from a save layer in the DL builder/dispatcher. The saveLayer implmenentation in the impeller dispatcher is super convoluted because it needs to handle both.

### Video

Video starts with normal bdf then I hot reload to specify that the bdfs share inputs/filters. This is running on a pixel 8 pro

Change to the macrobenchmark app is just:
```dart
  Widget build(BuildContext context) {
    Widget addBlur(Widget child, bool shouldBlur) {
      if (shouldBlur) {
        return ClipRect(
          child: BackdropFilter(
            filter: ImageFilter.blur(sigmaX: 5, sigmaY: 5),
            backdropId: 1, // Added ID
            child: child,
          ),
        );
      } else {
        return child;
      }
    }
```

https://github.com/user-attachments/assets/22707f97-5825-43f1-91b4-1a02a43437f5

Requires framework changes in https://github.com/jonahwilliams/flutter/pull/new/backdrop_id

Author: Jonah Williams

display_list/benchmarking/dl_complexity_gl.cc

@@ -51,7 +51,8 @@ unsigned int DisplayListGLComplexityCalculator::GLHelper::BatchedComplexity() {
 void DisplayListGLComplexityCalculator::GLHelper::saveLayer(
     const DlRect& bounds,
     const SaveLayerOptions options,
-    const DlImageFilter* backdrop) {
+    const DlImageFilter* backdrop,
+    std::optional<int64_t> backdrop_id) {
   if (IsComplex()) {
     return;
   }
@@ -627,7 +628,8 @@ void DisplayListGLComplexityCalculator::GLHelper::drawDisplayList(
   GLHelper helper(Ceiling() - CurrentComplexityScore());
   if (opacity < SK_Scalar1 && !display_list->can_apply_group_opacity()) {
     auto bounds = display_list->GetBounds();
-    helper.saveLayer(bounds, SaveLayerOptions::kWithAttributes, nullptr);
+    helper.saveLayer(bounds, SaveLayerOptions::kWithAttributes, nullptr,
+                     /*backdrop_id=*/-1);
   }
   display_list->Dispatch(helper);
   AccumulateComplexity(helper.ComplexityScore());

display_list/benchmarking/dl_complexity_gl.h

@@ -37,7 +37,8 @@ class DisplayListGLComplexityCalculator
 
     void saveLayer(const DlRect& bounds,
                    const SaveLayerOptions options,
-                   const DlImageFilter* backdrop) override;
+                   const DlImageFilter* backdrop,
+                   std::optional<int64_t> backdrop_id) override;
 
     void drawLine(const DlPoint& p0, const DlPoint& p1) override;
     void drawDashedLine(const DlPoint& p0,

display_list/benchmarking/dl_complexity_metal.cc

@@ -65,7 +65,8 @@ DisplayListMetalComplexityCalculator::MetalHelper::BatchedComplexity() {
 void DisplayListMetalComplexityCalculator::MetalHelper::saveLayer(
     const DlRect& bounds,
     const SaveLayerOptions options,
-    const DlImageFilter* backdrop) {
+    const DlImageFilter* backdrop,
+    std::optional<int64_t> backdrop_id) {
   if (IsComplex()) {
     return;
   }
@@ -571,7 +572,8 @@ void DisplayListMetalComplexityCalculator::MetalHelper::drawDisplayList(
   MetalHelper helper(Ceiling() - CurrentComplexityScore());
   if (opacity < SK_Scalar1 && !display_list->can_apply_group_opacity()) {
     auto bounds = display_list->GetBounds();
-    helper.saveLayer(bounds, SaveLayerOptions::kWithAttributes, nullptr);
+    helper.saveLayer(bounds, SaveLayerOptions::kWithAttributes, nullptr,
+                     /*backdrop_id=*/-1);
   }
   display_list->Dispatch(helper);
   AccumulateComplexity(helper.ComplexityScore());

display_list/benchmarking/dl_complexity_metal.h

@@ -37,7 +37,8 @@ class DisplayListMetalComplexityCalculator
 
     void saveLayer(const DlRect& bounds,
                    const SaveLayerOptions options,
-                   const DlImageFilter* backdrop) override;
+                   const DlImageFilter* backdrop,
+                   std::optional<int64_t> backdrop_id) override;
 
     void drawLine(const DlPoint& p0, const DlPoint& p1) override;
     void drawDashedLine(const DlPoint& p0,

display_list/display_list_unittests.cc

@@ -1483,15 +1483,17 @@ class SaveLayerExpector : public virtual DlOpReceiver,
 
   void saveLayer(const DlRect& bounds,
                  const SaveLayerOptions options,
-                 const DlImageFilter* backdrop) override {
+                 const DlImageFilter* backdrop,
+                 std::optional<int64_t> backdrop_id) override {
     FML_UNREACHABLE();
   }
 
   virtual void saveLayer(const DlRect& bounds,
                          const SaveLayerOptions& options,
                          uint32_t total_content_depth,
                          DlBlendMode max_content_blend_mode,
-                         const DlImageFilter* backdrop = nullptr) {
+                         const DlImageFilter* backdrop = nullptr,
+                         std::optional<int64_t> backdrop_id = std::nullopt) {
     ASSERT_LT(save_layer_count_, expected_.size()) << label();
     auto expect = expected_[save_layer_count_];
     if (expect.options.has_value()) {
@@ -3666,7 +3668,8 @@ class SaveLayerBoundsExpector : public virtual DlOpReceiver,
 
   void saveLayer(const DlRect& bounds,
                  const SaveLayerOptions options,
-                 const DlImageFilter* backdrop) override {
+                 const DlImageFilter* backdrop,
+                 std::optional<int64_t> backdrop_id) override {
     ASSERT_LT(save_layer_count_, expected_.size());
     auto expected = expected_[save_layer_count_];
     EXPECT_EQ(options.bounds_from_caller(),
@@ -4131,7 +4134,8 @@ class DepthExpector : public virtual DlOpReceiver,
 
   void saveLayer(const DlRect& bounds,
                  SaveLayerOptions options,
-                 const DlImageFilter* backdrop) override {
+                 const DlImageFilter* backdrop,
+                 std::optional<int64_t> backdrop_id) override {
     // This method should not be called since we override the variant with
     // the total_content_depth parameter.
     FAIL() << "saveLayer(no depth parameter) method should not be called";
@@ -4141,7 +4145,8 @@ class DepthExpector : public virtual DlOpReceiver,
                  const SaveLayerOptions& options,
                  uint32_t total_content_depth,
                  DlBlendMode max_content_mode,
-                 const DlImageFilter* backdrop) override {
+                 const DlImageFilter* backdrop,
+                 std::optional<int64_t> backdrop_id) override {
     ASSERT_LT(index_, depth_expectations_.size());
     EXPECT_EQ(depth_expectations_[index_], total_content_depth)
         << "at index " << index_;

display_list/dl_builder.cc

@@ -409,7 +409,8 @@ void DisplayListBuilder::Save() {
 
 void DisplayListBuilder::saveLayer(const DlRect& bounds,
                                    const SaveLayerOptions in_options,
-                                   const DlImageFilter* backdrop) {
+                                   const DlImageFilter* backdrop,
+                                   std::optional<int64_t> backdrop_id) {
   SaveLayerOptions options = in_options.without_optimizations();
   DisplayListAttributeFlags flags = options.renders_with_attributes()
                                         ? kSaveLayerWithPaintFlags
@@ -524,7 +525,8 @@ void DisplayListBuilder::saveLayer(const DlRect& bounds,
     }
 
     if (backdrop) {
-      Push<SaveLayerBackdropOp>(0, options, record_bounds, backdrop);
+      Push<SaveLayerBackdropOp>(0, options, record_bounds, backdrop,
+                                backdrop_id);
     } else {
       Push<SaveLayerOp>(0, options, record_bounds);
     }
@@ -542,7 +544,8 @@ void DisplayListBuilder::saveLayer(const DlRect& bounds,
 }
 void DisplayListBuilder::SaveLayer(std::optional<const DlRect>& bounds,
                                    const DlPaint* paint,
-                                   const DlImageFilter* backdrop) {
+                                   const DlImageFilter* backdrop,
+                                   std::optional<int64_t> backdrop_id) {
   SaveLayerOptions options;
   DlRect temp_bounds;
   if (bounds.has_value()) {
@@ -556,7 +559,7 @@ void DisplayListBuilder::SaveLayer(std::optional<const DlRect>& bounds,
     SetAttributesFromPaint(*paint,
                            DisplayListOpFlags::kSaveLayerWithPaintFlags);
   }
-  saveLayer(temp_bounds, options, backdrop);
+  saveLayer(temp_bounds, options, backdrop, backdrop_id);
 }
 
 void DisplayListBuilder::Restore() {

display_list/dl_builder.h

@@ -54,7 +54,8 @@ class DisplayListBuilder final : public virtual DlCanvas,
   // |DlCanvas|
   void SaveLayer(std::optional<const DlRect>& bounds,
                  const DlPaint* paint = nullptr,
-                 const DlImageFilter* backdrop = nullptr) override;
+                 const DlImageFilter* backdrop = nullptr,
+                 std::optional<int64_t> backdrop_id = std::nullopt) override;
   // |DlCanvas|
   void Restore() override;
   // |DlCanvas|
@@ -354,7 +355,8 @@ class DisplayListBuilder final : public virtual DlCanvas,
   // |DlOpReceiver|
   void saveLayer(const DlRect& bounds,
                  const SaveLayerOptions options,
-                 const DlImageFilter* backdrop) override;
+                 const DlImageFilter* backdrop,
+                 std::optional<int64_t> backdrop_id) override;
   // |DlOpReceiver|
   void restore() override { Restore(); }
 

display_list/dl_canvas.h

@@ -62,7 +62,8 @@ class DlCanvas {
   virtual void Save() = 0;
   virtual void SaveLayer(std::optional<const DlRect>& bounds,
                          const DlPaint* paint = nullptr,
-                         const DlImageFilter* backdrop = nullptr) = 0;
+                         const DlImageFilter* backdrop = nullptr,
+                         std::optional<int64_t> backdrop_id = std::nullopt) = 0;
   virtual void Restore() = 0;
   virtual int GetSaveCount() const = 0;
   virtual void RestoreToCount(int restore_count) = 0;
@@ -233,9 +234,10 @@ class DlCanvas {
 
   void SaveLayer(const SkRect* bounds,
                  const DlPaint* paint = nullptr,
-                 const DlImageFilter* backdrop = nullptr) {
+                 const DlImageFilter* backdrop = nullptr,
+                 std::optional<int64_t> backdrop_id = std::nullopt) {
     auto optional_bounds = ToOptDlRect(bounds);
-    SaveLayer(optional_bounds, paint, backdrop);
+    SaveLayer(optional_bounds, paint, backdrop, backdrop_id);
   }
 
   void Transform(const SkMatrix* matrix) {

display_list/dl_op_receiver.h

@@ -17,8 +17,6 @@
 #include "flutter/display_list/effects/dl_mask_filter.h"
 #include "flutter/display_list/image/dl_image.h"
 
-#include "flutter/impeller/geometry/path.h"
-
 namespace flutter {
 
 class DisplayList;
@@ -143,15 +141,17 @@ class DlOpReceiver {
   // layer before further rendering happens.
   virtual void saveLayer(const DlRect& bounds,
                          const SaveLayerOptions options,
-                         const DlImageFilter* backdrop = nullptr) = 0;
+                         const DlImageFilter* backdrop = nullptr,
+                         std::optional<int64_t> backdrop_id = std::nullopt) = 0;
   // Optional variant of saveLayer() that passes the total depth count of
   // all rendering operations that occur until the next restore() call.
   virtual void saveLayer(const DlRect& bounds,
                          const SaveLayerOptions& options,
                          uint32_t total_content_depth,
                          DlBlendMode max_content_blend_mode,
-                         const DlImageFilter* backdrop = nullptr) {
-    saveLayer(bounds, options, backdrop);
+                         const DlImageFilter* backdrop = nullptr,
+                         std::optional<int64_t> backdrop_id = std::nullopt) {
+    saveLayer(bounds, options, backdrop, backdrop_id);
   }
   virtual void restore() = 0;
 
@@ -170,13 +170,17 @@ class DlOpReceiver {
   // public DisplayListBuilder/DlCanvas public interfaces where possible,
   // as tracked in:
   // https://github.com/flutter/flutter/issues/144070
-  virtual void saveLayer(const DlRect* bounds,
-                         const SaveLayerOptions options,
-                         const DlImageFilter* backdrop = nullptr) final {
+  virtual void saveLayer(
+      const DlRect* bounds,
+      const SaveLayerOptions options,
+      const DlImageFilter* backdrop = nullptr,
+      std::optional<int64_t> backdrop_id = std::nullopt) final {
     if (bounds) {
-      saveLayer(*bounds, options.with_bounds_from_caller(), backdrop);
+      saveLayer(*bounds, options.with_bounds_from_caller(), backdrop,
+                backdrop_id);
     } else {
-      saveLayer(DlRect(), options.without_bounds_from_caller(), backdrop);
+      saveLayer(DlRect(), options.without_bounds_from_caller(), backdrop,
+                backdrop_id);
     }
   }
   // ---------------------------------------------------------------------

display_list/dl_op_records.h

@@ -310,19 +310,24 @@ struct SaveLayerBackdropOp final : SaveLayerOpBase {
 
   SaveLayerBackdropOp(const SaveLayerOptions& options,
                       const DlRect& rect,
-                      const DlImageFilter* backdrop)
-      : SaveLayerOpBase(options, rect), backdrop(backdrop->shared()) {}
+                      const DlImageFilter* backdrop,
+                      std::optional<int64_t> backdrop_id)
+      : SaveLayerOpBase(options, rect),
+        backdrop(backdrop->shared()),
+        backdrop_id_(backdrop_id) {}
 
   const std::shared_ptr<DlImageFilter> backdrop;
+  std::optional<int64_t> backdrop_id_;
 
   void dispatch(DlOpReceiver& receiver) const {
     receiver.saveLayer(rect, options, total_content_depth, max_blend_mode,
-                       backdrop.get());
+                       backdrop.get(), backdrop_id_);
   }
 
   DisplayListCompare equals(const SaveLayerBackdropOp* other) const {
     return (options == other->options && rect == other->rect &&
-            Equals(backdrop, other->backdrop))
+            Equals(backdrop, other->backdrop) &&
+            backdrop_id_ == other->backdrop_id_)
                ? DisplayListCompare::kEqual
                : DisplayListCompare::kNotEqual;
   }