Dont snap in pre-roll (#36173)

flow/layers/color_filter_layer.cc

@@ -38,12 +38,12 @@ void ColorFilterLayer::Preroll(PrerollContext* context,
                                const SkMatrix& matrix) {
   Layer::AutoPrerollSaveLayerState save =
       Layer::AutoPrerollSaveLayerState::Create(context);
-  AutoCache cache = AutoCache(layer_raster_cache_item_.get(), context, matrix);
-
   SkMatrix child_matrix = matrix;
   if (context->raster_cache) {
     child_matrix = RasterCacheUtil::GetIntegralTransCTM(child_matrix);
   }
+  AutoCache cache =
+      AutoCache(layer_raster_cache_item_.get(), context, child_matrix);
 
   ContainerLayer::Preroll(context, child_matrix);
   // We always use a saveLayer (or a cached rendering), so we

flow/layers/image_filter_layer.cc

@@ -50,14 +50,16 @@ void ImageFilterLayer::Preroll(PrerollContext* context,
 
   Layer::AutoPrerollSaveLayerState save =
       Layer::AutoPrerollSaveLayerState::Create(context);
-
-  AutoCache cache = AutoCache(layer_raster_cache_item_.get(), context, matrix);
-
-  SkRect child_bounds = SkRect::MakeEmpty();
   SkMatrix child_matrix = matrix;
   if (context->raster_cache) {
     child_matrix = RasterCacheUtil::GetIntegralTransCTM(child_matrix);
   }
+
+  AutoCache cache =
+      AutoCache(layer_raster_cache_item_.get(), context, child_matrix);
+
+  SkRect child_bounds = SkRect::MakeEmpty();
+
   PrerollChildren(context, child_matrix, &child_bounds);
   context->subtree_can_inherit_opacity = true;
 

flow/layers/opacity_layer.cc

@@ -42,6 +42,9 @@ void OpacityLayer::Preroll(PrerollContext* context, const SkMatrix& matrix) {
 
   SkMatrix child_matrix = matrix;
   child_matrix.preTranslate(offset_.fX, offset_.fY);
+  if (context->raster_cache) {
+    child_matrix = RasterCacheUtil::GetIntegralTransCTM(child_matrix);
+  }
 
   // Similar to what's done in TransformLayer::Preroll, we have to apply the
   // reverse transformation to the cull rect to properly cull child layers.
@@ -52,7 +55,7 @@ void OpacityLayer::Preroll(PrerollContext* context, const SkMatrix& matrix) {
   context->mutators_stack.PushOpacity(alpha_);
 
   AutoCache auto_cache =
-      AutoCache(layer_raster_cache_item_.get(), context, matrix);
+      AutoCache(layer_raster_cache_item_.get(), context, child_matrix);
   Layer::AutoPrerollSaveLayerState save =
       Layer::AutoPrerollSaveLayerState::Create(context);
 

flow/layers/opacity_layer_unittests.cc

@@ -8,6 +8,7 @@
 #include "flutter/flow/layers/image_filter_layer.h"
 #include "flutter/flow/layers/layer_tree.h"
 #include "flutter/flow/layers/transform_layer.h"
+#include "flutter/flow/raster_cache_util.h"
 #include "flutter/flow/testing/diff_context_test.h"
 #include "flutter/flow/testing/layer_test.h"
 #include "flutter/flow/testing/mock_layer.h"
@@ -662,5 +663,43 @@ TEST_F(OpacityLayerDiffTest, FractionalTranslationWithRasterCache) {
   EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(11, 11, 61, 61));
 }
 
+TEST_F(OpacityLayerTest, FullyOpaqueWithFractionalValues) {
+  use_mock_raster_cache();  // Ensure non-fractional alignment.
+
+  const SkPath child_path = SkPath().addRect(SkRect::MakeWH(5.0f, 5.0f));
+  const SkPoint layer_offset = SkPoint::Make(0.5f, 1.5f);
+  const SkMatrix initial_transform = SkMatrix::Translate(0.5f, 0.5f);
+  const SkMatrix layer_transform =
+      SkMatrix::Translate(layer_offset.fX, layer_offset.fY);
+  const SkPaint child_paint = SkPaint(SkColors::kGreen);
+  const SkRect expected_layer_bounds =
+      layer_transform.mapRect(child_path.getBounds());
+  auto mock_layer = std::make_shared<MockLayer>(child_path, child_paint);
+  auto layer = std::make_shared<OpacityLayer>(SK_AlphaOPAQUE, layer_offset);
+  layer->Add(mock_layer);
+  layer->Preroll(preroll_context(), initial_transform);
+
+  const SkPaint opacity_paint = SkPaint(SkColors::kBlack);  // A = 1.0f
+  SkRect opacity_bounds;
+  expected_layer_bounds.makeOffset(-layer_offset.fX, -layer_offset.fY)
+      .roundOut(&opacity_bounds);
+  auto expected_draw_calls = std::vector(
+      {MockCanvas::DrawCall{0, MockCanvas::SaveData{1}},
+       MockCanvas::DrawCall{
+           1, MockCanvas::ConcatMatrixData{SkM44(layer_transform)}},
+       MockCanvas::DrawCall{
+           1, MockCanvas::SetMatrixData{SkM44(
+                  RasterCacheUtil::GetIntegralTransCTM(layer_transform))}},
+       MockCanvas::DrawCall{
+           1, MockCanvas::SaveLayerData{opacity_bounds, opacity_paint, nullptr,
+                                        2}},
+       MockCanvas::DrawCall{2,
+                            MockCanvas::DrawPathData{child_path, child_paint}},
+       MockCanvas::DrawCall{2, MockCanvas::RestoreData{1}},
+       MockCanvas::DrawCall{1, MockCanvas::RestoreData{0}}});
+  layer->Paint(paint_context());
+  EXPECT_EQ(mock_canvas().draw_calls(), expected_draw_calls);
+}
+
 }  // namespace testing
 }  // namespace flutter

flow/layers/shader_mask_layer.cc

@@ -38,10 +38,15 @@ void ShaderMaskLayer::Diff(DiffContext* context, const Layer* old_layer) {
 void ShaderMaskLayer::Preroll(PrerollContext* context, const SkMatrix& matrix) {
   Layer::AutoPrerollSaveLayerState save =
       Layer::AutoPrerollSaveLayerState::Create(context);
+  SkMatrix child_matrix = matrix;
+  if (context->raster_cache) {
+    child_matrix = RasterCacheUtil::GetIntegralTransCTM(child_matrix);
+  }
 
-  AutoCache cache = AutoCache(layer_raster_cache_item_.get(), context, matrix);
+  AutoCache cache =
+      AutoCache(layer_raster_cache_item_.get(), context, child_matrix);
 
-  ContainerLayer::Preroll(context, matrix);
+  ContainerLayer::Preroll(context, child_matrix);
   // We always paint with a saveLayer (or a cached rendering),
   // so we can always apply opacity in any of those cases.
   context->subtree_can_inherit_opacity = true;

flow/layers/shader_mask_layer_unittests.cc

@@ -7,6 +7,7 @@
 #include "flutter/flow/layers/layer_tree.h"
 #include "flutter/flow/layers/opacity_layer.h"
 #include "flutter/flow/raster_cache.h"
+#include "flutter/flow/raster_cache_util.h"
 #include "flutter/flow/testing/layer_test.h"
 #include "flutter/flow/testing/mock_layer.h"
 #include "flutter/fml/macros.h"
@@ -389,5 +390,45 @@ TEST_F(ShaderMaskLayerTest, OpacityInheritance) {
   EXPECT_TRUE(DisplayListsEQ_Verbose(expected_builder.Build(), display_list()));
 }
 
+TEST_F(ShaderMaskLayerTest, SimpleFilterWithRasterCache) {
+  use_mock_raster_cache();  // Ensure non-fractional alignment.
+
+  const SkMatrix initial_transform = SkMatrix::Translate(0.5f, 1.0f);
+  const SkRect child_bounds = SkRect::MakeLTRB(5.0f, 6.0f, 20.5f, 21.5f);
+  const SkRect layer_bounds = SkRect::MakeLTRB(2.0f, 4.0f, 6.5f, 6.5f);
+  const SkPath child_path = SkPath().addRect(child_bounds);
+  const SkPaint child_paint = SkPaint(SkColors::kYellow);
+  auto layer_filter =
+      SkPerlinNoiseShader::MakeFractalNoise(1.0f, 1.0f, 1, 1.0f);
+  auto mock_layer = std::make_shared<MockLayer>(child_path, child_paint);
+  auto layer = std::make_shared<ShaderMaskLayer>(layer_filter, layer_bounds,
+                                                 SkBlendMode::kSrc);
+  layer->Add(mock_layer);
+  layer->Preroll(preroll_context(), initial_transform);
+
+  SkPaint filter_paint;
+  filter_paint.setBlendMode(SkBlendMode::kSrc);
+  filter_paint.setShader(layer_filter);
+  layer->Paint(paint_context());
+  EXPECT_EQ(
+      mock_canvas().draw_calls(),
+      std::vector({MockCanvas::DrawCall{0, MockCanvas::SetMatrixData{SkM44(
+                                               SkMatrix::Translate(0.0, 0.0))}},
+                   MockCanvas::DrawCall{
+                       0, MockCanvas::SaveLayerData{child_bounds, SkPaint(),
+                                                    nullptr, 1}},
+                   MockCanvas::DrawCall{
+                       1, MockCanvas::DrawPathData{child_path, child_paint}},
+                   MockCanvas::DrawCall{
+                       1, MockCanvas::ConcatMatrixData{SkM44::Translate(
+                              layer_bounds.fLeft, layer_bounds.fTop)}},
+                   MockCanvas::DrawCall{
+                       1, MockCanvas::DrawRectData{SkRect::MakeWH(
+                                                       layer_bounds.width(),
+                                                       layer_bounds.height()),
+                                                   filter_paint}},
+                   MockCanvas::DrawCall{1, MockCanvas::RestoreData{0}}}));
+}
+
 }  // namespace testing
 }  // namespace flutter

flow/testing/mock_layer.cc

@@ -70,18 +70,27 @@ void MockCacheableContainerLayer::Preroll(PrerollContext* context,
                                           const SkMatrix& matrix) {
   Layer::AutoPrerollSaveLayerState save =
       Layer::AutoPrerollSaveLayerState::Create(context);
-  auto cache = AutoCache(layer_raster_cache_item_.get(), context, matrix);
+  SkMatrix child_matrix = matrix;
+  if (context->raster_cache) {
+    child_matrix = RasterCacheUtil::GetIntegralTransCTM(child_matrix);
+  }
+
+  auto cache = AutoCache(layer_raster_cache_item_.get(), context, child_matrix);
 
-  ContainerLayer::Preroll(context, matrix);
+  ContainerLayer::Preroll(context, child_matrix);
 }
 
 void MockCacheableLayer::Preroll(PrerollContext* context,
                                  const SkMatrix& matrix) {
   Layer::AutoPrerollSaveLayerState save =
       Layer::AutoPrerollSaveLayerState::Create(context);
-  auto cache = AutoCache(raster_cache_item_.get(), context, matrix);
+  SkMatrix child_matrix = matrix;
+  if (context->raster_cache) {
+    child_matrix = RasterCacheUtil::GetIntegralTransCTM(child_matrix);
+  }
+  auto cache = AutoCache(raster_cache_item_.get(), context, child_matrix);
 
-  MockLayer::Preroll(context, matrix);
+  MockLayer::Preroll(context, child_matrix);
 }
 
 }  // namespace testing