PlatformView Blur for Backdrop Filter

flow/embedded_views.h

@@ -248,6 +248,11 @@ class EmbeddedViewParams {
   // Clippings are ignored.
   const SkRect& finalBoundingRect() const { return final_bounding_rect_; }
 
+  // Pushes the stored DlImageFilter object to the mutators stack.
+  void PushImageFilter(std::shared_ptr<const DlImageFilter> filter) {
+    mutators_stack_.PushBackdropFilter(filter);
+  }
+
   // Whether the embedder should construct DisplayList objects to hold the
   // rendering commands for each between-view slice of the layer tree.
   bool display_list_enabled() const { return display_list_enabled_; }
@@ -439,6 +444,18 @@ class ExternalViewEmbedder {
   // 'EndFrame', otherwise returns false.
   bool GetUsedThisFrame() const { return used_this_frame_; }
 
+  // Pushes the platform view id of a visited platform view to a list of
+  // visited platform views.
+  virtual void PushVisitedPlatformView(int64_t view_id) {}
+
+  // Pushes a DlImageFilter object to each platform view within a list of
+  // visited platform views.
+  //
+  // See also: |PushVisitedPlatformView| for pushing platform view ids to the
+  // visited platform views list.
+  virtual void PushFilterToVisitedPlatformViews(
+      std::shared_ptr<const DlImageFilter> filter) {}
+
  private:
   bool used_this_frame_ = false;
 

flow/layers/backdrop_filter_layer.cc

@@ -43,6 +43,9 @@ void BackdropFilterLayer::Preroll(PrerollContext* context,
                                   const SkMatrix& matrix) {
   Layer::AutoPrerollSaveLayerState save =
       Layer::AutoPrerollSaveLayerState::Create(context, true, bool(filter_));
+  if (context->view_embedder != nullptr) {
+    context->view_embedder->PushFilterToVisitedPlatformViews(filter_);
+  }
   SkRect child_paint_bounds = SkRect::MakeEmpty();
   PrerollChildren(context, matrix, &child_paint_bounds);
   child_paint_bounds.join(context->cull_rect);

flow/layers/platform_view_layer.cc

@@ -29,6 +29,7 @@ void PlatformViewLayer::Preroll(PrerollContext* context,
                                            context->display_list_enabled);
   context->view_embedder->PrerollCompositeEmbeddedView(view_id_,
                                                        std::move(params));
+  context->view_embedder->PushVisitedPlatformView(view_id_);
 }
 
 void PlatformViewLayer::Paint(PaintContext& context) const {

flow/mutators_stack_unittests.cc

@@ -163,6 +163,8 @@ TEST(MutatorsStack, Equality) {
   stack.PushClipPath(path);
   int alpha = 240;
   stack.PushOpacity(alpha);
+  auto filter = std::make_shared<DlBlurImageFilter>(5, 5, DlTileMode::kClamp);
+  stack.PushBackdropFilter(filter);
 
   MutatorsStack stackOther;
   SkMatrix matrixOther = SkMatrix::Scale(1, 1);
@@ -175,6 +177,9 @@ TEST(MutatorsStack, Equality) {
   stackOther.PushClipPath(otherPath);
   int otherAlpha = 240;
   stackOther.PushOpacity(otherAlpha);
+  auto otherFilter =
+      std::make_shared<DlBlurImageFilter>(5, 5, DlTileMode::kClamp);
+  stackOther.PushBackdropFilter(otherFilter);
 
   ASSERT_TRUE(stack == stackOther);
 }
@@ -204,6 +209,11 @@ TEST(Mutator, Initialization) {
   int alpha = 240;
   Mutator mutator5 = Mutator(alpha);
   ASSERT_TRUE(mutator5.GetType() == MutatorType::kOpacity);
+
+  auto filter = std::make_shared<DlBlurImageFilter>(5, 5, DlTileMode::kClamp);
+  Mutator mutator6 = Mutator(filter);
+  ASSERT_TRUE(mutator6.GetType() == MutatorType::kBackdropFilter);
+  ASSERT_TRUE(mutator6.GetFilter() == *filter);
 }
 
 TEST(Mutator, CopyConstructor) {
@@ -232,6 +242,11 @@ TEST(Mutator, CopyConstructor) {
   Mutator mutator5 = Mutator(alpha);
   Mutator copy5 = Mutator(mutator5);
   ASSERT_TRUE(mutator5 == copy5);
+
+  auto filter = std::make_shared<DlBlurImageFilter>(5, 5, DlTileMode::kClamp);
+  Mutator mutator6 = Mutator(filter);
+  Mutator copy6 = Mutator(mutator6);
+  ASSERT_TRUE(mutator6 == copy6);
 }
 
 TEST(Mutator, Equality) {
@@ -260,6 +275,11 @@ TEST(Mutator, Equality) {
   Mutator mutator5 = Mutator(alpha);
   Mutator otherMutator5 = Mutator(alpha);
   ASSERT_TRUE(mutator5 == otherMutator5);
+
+  auto filter = std::make_shared<DlBlurImageFilter>(5, 5, DlTileMode::kClamp);
+  Mutator mutator6 = Mutator(filter);
+  Mutator otherMutator6 = Mutator(filter);
+  ASSERT_TRUE(mutator6 == otherMutator6);
 }
 
 TEST(Mutator, UnEquality) {
@@ -275,6 +295,13 @@ TEST(Mutator, UnEquality) {
   Mutator mutator2 = Mutator(alpha);
   Mutator otherMutator2 = Mutator(alpha2);
   ASSERT_TRUE(mutator2 != otherMutator2);
+
+  auto filter = std::make_shared<DlBlurImageFilter>(5, 5, DlTileMode::kClamp);
+  auto filter2 =
+      std::make_shared<DlBlurImageFilter>(10, 10, DlTileMode::kClamp);
+  Mutator mutator3 = Mutator(filter);
+  Mutator otherMutator3 = Mutator(filter2);
+  ASSERT_TRUE(mutator3 != otherMutator3);
 }
 
 }  // namespace testing

shell/common/shell_test_external_view_embedder.cc

@@ -28,6 +28,14 @@ SkISize ShellTestExternalViewEmbedder::GetLastSubmittedFrameSize() {
   return last_submitted_frame_size_;
 }
 
+std::vector<int64_t> ShellTestExternalViewEmbedder::GetVisitedPlatformViews() {
+  return visited_platform_views_;
+}
+
+MutatorsStack ShellTestExternalViewEmbedder::GetStack(int64_t view_id) {
+  return mutators_stacks_[view_id];
+}
+
 // |ExternalViewEmbedder|
 void ShellTestExternalViewEmbedder::CancelFrame() {}
 
@@ -41,7 +49,16 @@ void ShellTestExternalViewEmbedder::BeginFrame(
 // |ExternalViewEmbedder|
 void ShellTestExternalViewEmbedder::PrerollCompositeEmbeddedView(
     int view_id,
-    std::unique_ptr<EmbeddedViewParams> params) {}
+    std::unique_ptr<EmbeddedViewParams> params) {
+  SkRect view_bounds = SkRect::Make(frame_size_);
+  std::unique_ptr<EmbedderViewSlice> view;
+  if (params->display_list_enabled()) {
+    view = std::make_unique<DisplayListEmbedderViewSlice>(view_bounds);
+  } else {
+    view = std::make_unique<SkPictureEmbedderViewSlice>(view_bounds);
+  }
+  slices_.insert_or_assign(view_id, std::move(view));
+}
 
 // |ExternalViewEmbedder|
 PostPrerollResult ShellTestExternalViewEmbedder::PostPrerollAction(
@@ -62,9 +79,24 @@ ShellTestExternalViewEmbedder::GetCurrentBuilders() {
 }
 
 // |ExternalViewEmbedder|
+void ShellTestExternalViewEmbedder::PushVisitedPlatformView(int64_t view_id) {
+  visited_platform_views_.push_back(view_id);
+}
+
+// |ExternalViewEmbedder|
+void ShellTestExternalViewEmbedder::PushFilterToVisitedPlatformViews(
+    std::shared_ptr<const DlImageFilter> filter) {
+  for (int64_t id : visited_platform_views_) {
+    EmbeddedViewParams params = current_composition_params_[id];
+    params.PushImageFilter(filter);
+    current_composition_params_[id] = params;
+    mutators_stacks_[id] = params.mutatorsStack();
+  }
+}
+
 EmbedderPaintContext ShellTestExternalViewEmbedder::CompositeEmbeddedView(
     int view_id) {
-  return {nullptr, nullptr};
+  return {slices_[view_id]->canvas(), slices_[view_id]->builder()};
 }
 
 // |ExternalViewEmbedder|

shell/common/shell_test_external_view_embedder.h

@@ -7,6 +7,7 @@
 
 #include "flutter/flow/embedded_views.h"
 #include "flutter/fml/raster_thread_merger.h"
+#include "third_party/skia/include/core/SkPictureRecorder.h"
 
 namespace flutter {
 
@@ -32,9 +33,15 @@ class ShellTestExternalViewEmbedder final : public ExternalViewEmbedder {
   // the external view embedder.
   int GetSubmittedFrameCount();
 
-  // Returns the size of last submitted frame surface
+  // Returns the size of last submitted frame surface.
   SkISize GetLastSubmittedFrameSize();
 
+  // Returns the mutators stack for the given platform view.
+  MutatorsStack GetStack(int64_t);
+
+  // Returns the list of visited platform views.
+  std::vector<int64_t> GetVisitedPlatformViews();
+
  private:
   // |ExternalViewEmbedder|
   void CancelFrame() override;
@@ -64,6 +71,13 @@ class ShellTestExternalViewEmbedder final : public ExternalViewEmbedder {
   // |ExternalViewEmbedder|
   EmbedderPaintContext CompositeEmbeddedView(int view_id) override;
 
+  // |ExternalViewEmbedder|
+  void PushVisitedPlatformView(int64_t view_id) override;
+
+  // |ExternalViewEmbedder|
+  void PushFilterToVisitedPlatformViews(
+      std::shared_ptr<const DlImageFilter> filter) override;
+
   // |ExternalViewEmbedder|
   void SubmitFrame(GrDirectContext* context,
                    std::unique_ptr<SurfaceFrame> frame) override;
@@ -84,7 +98,11 @@ class ShellTestExternalViewEmbedder final : public ExternalViewEmbedder {
   PostPrerollResult post_preroll_result_;
 
   bool support_thread_merging_;
-
+  SkISize frame_size_;
+  std::map<int64_t, std::unique_ptr<EmbedderViewSlice>> slices_;
+  std::map<int64_t, MutatorsStack> mutators_stacks_;
+  std::map<int64_t, EmbeddedViewParams> current_composition_params_;
+  std::vector<int64_t> visited_platform_views_;
   std::atomic<int> submitted_frame_count_;
   std::atomic<SkISize> last_submitted_frame_size_;
 

shell/common/shell_unittests.cc

@@ -13,8 +13,10 @@
 
 #include "assets/directory_asset_bundle.h"
 #include "common/graphics/persistent_cache.h"
+#include "flutter/flow/layers/backdrop_filter_layer.h"
 #include "flutter/flow/layers/display_list_layer.h"
 #include "flutter/flow/layers/layer_raster_cache_item.h"
+#include "flutter/flow/layers/platform_view_layer.h"
 #include "flutter/flow/layers/transform_layer.h"
 #include "flutter/fml/command_line.h"
 #include "flutter/fml/dart/dart_converter.h"
@@ -765,12 +767,66 @@ TEST_F(ShellTest, ExternalEmbedderNoThreadMerger) {
 
   PumpOneFrame(shell.get(), 100, 100, builder);
   end_frame_latch.Wait();
-
   ASSERT_TRUE(end_frame_called);
 
   DestroyShell(std::move(shell));
 }
 
+TEST_F(ShellTest, PushBackdropFilterToVisitedPlatformViews) {
+  auto settings = CreateSettingsForFixture();
+  fml::AutoResetWaitableEvent end_frame_latch;
+  bool end_frame_called = false;
+  auto end_frame_callback =
+      [&](bool should_resubmit_frame,
+          fml::RefPtr<fml::RasterThreadMerger> raster_thread_merger) {
+        ASSERT_TRUE(raster_thread_merger.get() == nullptr);
+        ASSERT_FALSE(should_resubmit_frame);
+        end_frame_called = true;
+        end_frame_latch.Signal();
+      };
+  auto external_view_embedder = std::make_shared<ShellTestExternalViewEmbedder>(
+      end_frame_callback, PostPrerollResult::kResubmitFrame, false);
+  auto shell = CreateShell(std::move(settings), GetTaskRunnersForFixture(),
+                           false, external_view_embedder);
+
+  // Create the surface needed by rasterizer
+  PlatformViewNotifyCreated(shell.get());
+
+  auto configuration = RunConfiguration::InferFromSettings(settings);
+  configuration.SetEntrypoint("emptyMain");
+
+  RunEngine(shell.get(), std::move(configuration));
+
+  LayerTreeBuilder builder = [&](std::shared_ptr<ContainerLayer> root) {
+    auto platform_view_layer = std::make_shared<PlatformViewLayer>(
+        SkPoint::Make(10, 10), SkSize::Make(10, 10), 50);
+    root->Add(platform_view_layer);
+    auto filter = std::make_shared<DlBlurImageFilter>(5, 5, DlTileMode::kClamp);
+    auto backdrop_filter_layer =
+        std::make_shared<BackdropFilterLayer>(filter, DlBlendMode::kSrcOver);
+    root->Add(backdrop_filter_layer);
+    auto platform_view_layer2 = std::make_shared<PlatformViewLayer>(
+        SkPoint::Make(10, 10), SkSize::Make(10, 10), 75);
+    backdrop_filter_layer->Add(platform_view_layer2);
+  };
+
+  PumpOneFrame(shell.get(), 100, 100, builder);
+  end_frame_latch.Wait();
+  ASSERT_EQ(external_view_embedder->GetVisitedPlatformViews().size(),
+            (const unsigned long)2);
+  ASSERT_EQ(external_view_embedder->GetVisitedPlatformViews()[0], 50);
+  ASSERT_EQ(external_view_embedder->GetVisitedPlatformViews()[1], 75);
+  ASSERT_TRUE(external_view_embedder->GetStack(75).is_empty());
+  ASSERT_FALSE(external_view_embedder->GetStack(50).is_empty());
+
+  auto filter = DlBlurImageFilter(5, 5, DlTileMode::kClamp);
+  auto mutator = *external_view_embedder->GetStack(50).Begin();
+  ASSERT_EQ(mutator->GetType(), MutatorType::kBackdropFilter);
+  ASSERT_EQ(mutator->GetFilter(), filter);
+
+  DestroyShell(std::move(shell));
+}
+
 // TODO(https://github.com/flutter/flutter/issues/59816): Enable on fuchsia.
 TEST_F(ShellTest,
 #if defined(OS_FUCHSIA)

shell/platform/darwin/ios/framework/Source/FlutterPlatformViews.mm

@@ -33,6 +33,8 @@ - (BOOL)flt_hasFirstResponderInViewHierarchySubtree {
 @end
 
 namespace flutter {
+// Becomes NO if Apple's API changes and blurred backdrop filters cannot be applied.
+BOOL canApplyBlurBackdrop = YES;
 
 std::shared_ptr<FlutterPlatformViewLayer> FlutterPlatformViewLayerPool::GetLayer(
     GrDirectContext* gr_context,
@@ -318,6 +320,15 @@ - (BOOL)flt_hasFirstResponderInViewHierarchySubtree {
   }
 }
 
+void FlutterPlatformViewsController::PushFilterToVisitedPlatformViews(
+    std::shared_ptr<const DlImageFilter> filter) {
+  for (int64_t id : visited_platform_views_) {
+    EmbeddedViewParams params = current_composition_params_[id];
+    params.PushImageFilter(filter);
+    current_composition_params_[id] = params;
+  }
+}
+
 void FlutterPlatformViewsController::PrerollCompositeEmbeddedView(
     int view_id,
     std::unique_ptr<EmbeddedViewParams> params) {
@@ -414,6 +425,8 @@ - (BOOL)flt_hasFirstResponderInViewHierarchySubtree {
                                CGRectGetWidth(flutter_view.bounds),
                                CGRectGetHeight(flutter_view.bounds))] autorelease];
 
+  NSMutableArray* blurRadii = [[[NSMutableArray alloc] init] autorelease];
+
   auto iter = mutators_stack.Begin();
   while (iter != mutators_stack.End()) {
     switch ((*iter)->GetType()) {
@@ -434,11 +447,25 @@ - (BOOL)flt_hasFirstResponderInViewHierarchySubtree {
       case kOpacity:
         embedded_view.alpha = (*iter)->GetAlphaFloat() * embedded_view.alpha;
         break;
-      case kBackdropFilter:
+      case kBackdropFilter: {
+        // We only support DlBlurImageFilter for BackdropFilter.
+        if ((*iter)->GetFilter().asBlur() && canApplyBlurBackdrop) {
+          // sigma_x is arbitrarily chosen as the radius value because Quartz sets
+          // sigma_x and sigma_y equal to each other. DlBlurImageFilter's Tile Mode
+          // is not supported in Quartz's gaussianBlur CAFilter, so it is not used
+          // to blur the PlatformView.
+          [blurRadii addObject:@((*iter)->GetFilter().asBlur()->sigma_x())];
+        }
         break;
+      }
     }
     ++iter;
   }
+
+  if (canApplyBlurBackdrop) {
+    canApplyBlurBackdrop = [clipView applyBlurBackdropFilters:blurRadii];
+  }
+
   // Reverse the offset of the clipView.
   // The clipView's frame includes the final translate of the final transform matrix.
   // So we need to revese this translate so the platform view can layout at the correct offset.
@@ -517,6 +544,7 @@ - (BOOL)flt_hasFirstResponderInViewHierarchySubtree {
   clip_count_.clear();
   views_to_recomposite_.clear();
   layer_pool_->RecycleLayers();
+  visited_platform_views_.clear();
 }
 
 SkRect FlutterPlatformViewsController::GetPlatformViewRect(int view_id) {
@@ -777,6 +805,7 @@ - (BOOL)flt_hasFirstResponderInViewHierarchySubtree {
 void FlutterPlatformViewsController::ResetFrameState() {
   slices_.clear();
   composition_order_.clear();
+  visited_platform_views_.clear();
 }
 
 }  // namespace flutter