fixed coverage test and turned it back on

Author: gaaclarke

impeller/entity/contents/filters/gaussian_blur_filter_contents.cc

@@ -359,24 +359,28 @@ std::optional<Rect> GaussianBlurFilterContents::GetFilterCoverage(
     return {};
   }
 
-  std::optional<Rect> input_coverage = inputs[0]->GetCoverage(entity);
-  if (!input_coverage.has_value()) {
+  Entity snapshot_entity = entity.Clone();
+  snapshot_entity.SetTransform(Matrix());
+  std::optional<Rect> source_coverage = inputs[0]->GetCoverage(snapshot_entity);
+  if (!source_coverage.has_value()) {
     return {};
   }
 
-  Vector2 entity_scale_x = entity.GetTransform().Basis() * Vector2(1.0, 0.0);
-  Vector2 entity_scale_y = entity.GetTransform().Basis() * Vector2(0.0, 1.0);
-  Vector2 scaled_sigma = (Matrix::MakeScale({entity_scale_x.GetLength(),
-                                             entity_scale_y.GetLength(), 1.0}) *
+  Vector2 scaled_sigma = (effect_transform.Basis() *
                           Vector2(ScaleSigma(sigma_x_), ScaleSigma(sigma_y_)))
                              .Abs();
   scaled_sigma.x = std::min(scaled_sigma.x, kMaxSigma);
   scaled_sigma.y = std::min(scaled_sigma.y, kMaxSigma);
   Vector2 blur_radius = Vector2(CalculateBlurRadius(scaled_sigma.x),
                                 CalculateBlurRadius(scaled_sigma.y));
   Vector2 padding(ceil(blur_radius.x), ceil(blur_radius.y));
-  Vector2 local_padding = (entity.GetTransform().Basis() * padding).Abs();
-  return input_coverage.value().Expand(Point(local_padding.x, local_padding.y));
+  std::optional<Rect> expanded_source_coverage =
+      source_coverage->Expand(Point(padding.x, padding.y));
+  if (expanded_source_coverage.has_value()) {
+    return expanded_source_coverage->TransformBounds(entity.GetTransform());
+  }
+
+  return std::nullopt;
 }
 
 std::optional<Entity> GaussianBlurFilterContents::RenderFilter(

impeller/entity/contents/filters/gaussian_blur_filter_contents_unittests.cc

@@ -369,43 +369,42 @@ TEST_P(GaussianBlurFilterContentsTest, TextureContentsWithDestinationRect) {
   }
 }
 
-// TEST_P(GaussianBlurFilterContentsTest,
-//        TextureContentsWithDestinationRectScaled) {
-//   std::shared_ptr<Texture> texture = MakeTexture(ISize(100, 100));
-//   auto texture_contents = std::make_shared<TextureContents>();
-//   texture_contents->SetSourceRect(Rect::MakeSize(texture->GetSize()));
-//   texture_contents->SetTexture(texture);
-//   texture_contents->SetDestinationRect(Rect::MakeXYWH(
-//       50, 40, texture->GetSize().width, texture->GetSize().height));
-
-//   fml::StatusOr<Scalar> sigma_radius_1 =
-//       CalculateSigmaForBlurRadius(1.0, Matrix());
-//   auto contents = std::make_unique<GaussianBlurFilterContents>(
-//       sigma_radius_1.value(), sigma_radius_1.value(),
-//       Entity::TileMode::kDecal, FilterContents::BlurStyle::kNormal,
-//       /*mask_geometry=*/nullptr);
-//   contents->SetInputs({FilterInput::Make(texture_contents)});
-//   std::shared_ptr<ContentContext> renderer = GetContentContext();
-
-//   Entity entity;
-//   entity.SetTransform(Matrix::MakeScale({2.0, 2.0, 1.0}));
-//   std::optional<Entity> result =
-//       contents->GetEntity(*renderer, entity, /*coverage_hint=*/{});
-//   EXPECT_TRUE(result.has_value());
-//   if (result.has_value()) {
-//     EXPECT_EQ(result.value().GetBlendMode(), BlendMode::kSourceOver);
-//     std::optional<Rect> result_coverage = result.value().GetCoverage();
-//     std::optional<Rect> contents_coverage = contents->GetCoverage(entity);
-//     EXPECT_TRUE(result_coverage.has_value());
-//     EXPECT_TRUE(contents_coverage.has_value());
-//     if (result_coverage.has_value() && contents_coverage.has_value()) {
-//       EXPECT_TRUE(RectNear(result_coverage.value(),
-//       contents_coverage.value()));
-//       EXPECT_TRUE(RectNear(contents_coverage.value(),
-//                            Rect::MakeXYWH(94.f, 74.f, 212.f, 212.f)));
-//     }
-//   }
-// }
+TEST_P(GaussianBlurFilterContentsTest,
+       TextureContentsWithDestinationRectScaled) {
+  std::shared_ptr<Texture> texture = MakeTexture(ISize(100, 100));
+  auto texture_contents = std::make_shared<TextureContents>();
+  texture_contents->SetSourceRect(Rect::MakeSize(texture->GetSize()));
+  texture_contents->SetTexture(texture);
+  texture_contents->SetDestinationRect(Rect::MakeXYWH(
+      50, 40, texture->GetSize().width, texture->GetSize().height));
+
+  fml::StatusOr<Scalar> sigma_radius_1 =
+      CalculateSigmaForBlurRadius(1.0, Matrix());
+  auto contents = std::make_unique<GaussianBlurFilterContents>(
+      sigma_radius_1.value(), sigma_radius_1.value(), Entity::TileMode::kDecal,
+      FilterContents::BlurStyle::kNormal,
+      /*mask_geometry=*/nullptr);
+  contents->SetInputs({FilterInput::Make(texture_contents)});
+  std::shared_ptr<ContentContext> renderer = GetContentContext();
+
+  Entity entity;
+  entity.SetTransform(Matrix::MakeScale({2.0, 2.0, 1.0}));
+  std::optional<Entity> result =
+      contents->GetEntity(*renderer, entity, /*coverage_hint=*/{});
+  EXPECT_TRUE(result.has_value());
+  if (result.has_value()) {
+    EXPECT_EQ(result.value().GetBlendMode(), BlendMode::kSourceOver);
+    std::optional<Rect> result_coverage = result.value().GetCoverage();
+    std::optional<Rect> contents_coverage = contents->GetCoverage(entity);
+    EXPECT_TRUE(result_coverage.has_value());
+    EXPECT_TRUE(contents_coverage.has_value());
+    if (result_coverage.has_value() && contents_coverage.has_value()) {
+      EXPECT_TRUE(RectNear(result_coverage.value(), contents_coverage.value()));
+      EXPECT_TRUE(RectNear(contents_coverage.value(),
+                           Rect::MakeXYWH(98.f, 78.f, 204.0f, 204.f)));
+    }
+  }
+}
 
 TEST_P(GaussianBlurFilterContentsTest, TextureContentsWithEffectTransform) {
   Matrix effect_transform = Matrix::MakeScale({2.0, 2.0, 1.0});