DEV/flutter_flutter
1
0
Fork 0
mirror of https://github.com/flutter/flutter.git synced 2026-02-20 02:29:02 +08:00
Code Issues Packages Projects Releases Wiki Activity

cleanup fractional translation ifdefs and config (flutter/engine#34198)

Browse Source
This commit is contained in:
Jonah Williams 2022-06-22 09:00:57 -07:00 committed by GitHub
parent 1086b6e0a9
commit a184d04005
27 changed files with 137 additions and 587 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
engine/src/flutter/BUILD.gn
View File

@ -114,7 +114,6 @@ group("flutter") {
if (build_engine_artifacts) {
public_deps += [
"//flutter/shell/testing",
"//flutter/shell/testing:testing_fractional_translation",
"//flutter/tools/const_finder",
"//flutter/tools/font-subset",
]

5
engine/src/flutter/build/archives/BUILD.gn
View File

@ -13,7 +13,6 @@ if (build_engine_artifacts) {
"//flutter/impeller/tessellator:tessellator_shared",
"//flutter/lib/snapshot:generate_snapshot_bin",
"//flutter/shell/testing:testing",
"//flutter/shell/testing:testing_fractional_translation",
]
if (is_mac) {
# TODO(godofredoc): Remove after paths are standardized flutter/flutter#105351.
@ -61,10 +60,6 @@ if (build_engine_artifacts) {
source = "$root_out_dir/flutter_tester$exe"
destination = "flutter_tester$exe"
},
{
source = "$root_out_dir/flutter_tester_fractional_translation$exe"
destination = "flutter_tester_fractional_translation$exe"
},
{
source = "$root_out_dir/impellerc$exe"
destination = "impellerc$exe"

7
engine/src/flutter/common/config.gni
View File

@ -22,9 +22,6 @@ declare_args() {
# Whether to use a prebuilt Dart SDK instead of building one.
flutter_prebuilt_dart_sdk = false
# Whether layers can be drawn at fractional pixel boundaries.
support_fractional_translation = true
}
# feature_defines_list ---------------------------------------------------------
@ -59,10 +56,6 @@ if (flutter_runtime_mode == "debug") {
feature_defines_list += [ "FLUTTER_RUNTIME_MODE=0" ]
}
if (support_fractional_translation) {
feature_defines_list += [ "SUPPORT_FRACTIONAL_TRANSLATION=1" ]
}
if (is_ios || is_mac) {
flutter_cflags_objc = [
"-Werror=overriding-method-mismatch",

9
engine/src/flutter/flow/layers/checkerboard_layertree_unittests.cc
View File

@ -59,9 +59,6 @@ TEST_F(CheckerBoardLayerTest, ClipRectSaveLayerNotCheckBoard) {
MockCanvas::DrawCall{
1, MockCanvas::ClipRectData{layer_bounds, SkClipOp::kIntersect,
MockCanvas::kSoft_ClipEdgeStyle}},
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
MockCanvas::DrawCall{1, MockCanvas::SetMatrixData{SkM44()}},
#endif
MockCanvas::DrawCall{
1, MockCanvas::SaveLayerData{layer->paint_bounds(), clip_paint,
nullptr, 2}},
@ -153,9 +150,6 @@ TEST_F(CheckerBoardLayerTest, ClipPathSaveLayerNotCheckBoard) {
MockCanvas::DrawCall{
1, MockCanvas::ClipRectData{layer_bounds, SkClipOp::kIntersect,
MockCanvas::kSoft_ClipEdgeStyle}},
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
MockCanvas::DrawCall{1, MockCanvas::SetMatrixData{SkM44()}},
#endif
MockCanvas::DrawCall{
1,
MockCanvas::SaveLayerData{child_bounds, clip_paint, nullptr, 2}},
@ -238,9 +232,6 @@ TEST_F(CheckerBoardLayerTest, ClipRRectSaveLayerNotCheckBoard) {
MockCanvas::DrawCall{
1, MockCanvas::ClipRectData{layer_bounds, SkClipOp::kIntersect,
MockCanvas::kSoft_ClipEdgeStyle}},
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
MockCanvas::DrawCall{1, MockCanvas::SetMatrixData{SkM44()}},
#endif
MockCanvas::DrawCall{
1,
MockCanvas::SaveLayerData{child_bounds, clip_paint, nullptr, 2}},

19
engine/src/flutter/flow/layers/clip_path_layer_unittests.cc
View File

@ -391,18 +391,11 @@ TEST_F(ClipPathLayerTest, OpacityInheritancePainting) {
opacity_layer->Preroll(context, SkMatrix::I());
EXPECT_TRUE(opacity_layer->children_can_accept_opacity());
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
auto opacity_integer_transform = SkM44::Translate(offset.fX, offset.fY);
#endif
DisplayListBuilder expected_builder;
/* OpacityLayer::Paint() */ {
expected_builder.save();
{
expected_builder.translate(offset.fX, offset.fY);
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
expected_builder.transformReset();
expected_builder.transform(opacity_integer_transform);
#endif
/* ClipRectLayer::Paint() */ {
expected_builder.save();
expected_builder.clipPath(layer_clip, SkClipOp::kIntersect, true);
@ -464,26 +457,14 @@ TEST_F(ClipPathLayerTest, OpacityInheritanceSaveLayerPainting) {
opacity_layer->Preroll(context, SkMatrix::I());
EXPECT_TRUE(opacity_layer->children_can_accept_opacity());
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
auto opacity_integer_transform = SkM44::Translate(offset.fX, offset.fY);
#endif
DisplayListBuilder expected_builder;
/* OpacityLayer::Paint() */ {
expected_builder.save();
{
expected_builder.translate(offset.fX, offset.fY);
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
expected_builder.transformReset();
expected_builder.transform(opacity_integer_transform);
#endif
/* ClipRectLayer::Paint() */ {
expected_builder.save();
expected_builder.clipPath(layer_clip, SkClipOp::kIntersect, true);
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
/* ClipShapeLayer::Paint() Integer CTM */
expected_builder.transformReset();
expected_builder.transform(opacity_integer_transform);
#endif
expected_builder.setColor(opacity_alpha << 24);
expected_builder.saveLayer(&children_bounds, true);
/* child layer1 paint */ {

21
engine/src/flutter/flow/layers/clip_rect_layer_unittests.cc
View File

@ -384,18 +384,12 @@ TEST_F(ClipRectLayerTest, OpacityInheritancePainting) {
context->subtree_can_inherit_opacity = false;
opacity_layer->Preroll(context, SkMatrix::I());
EXPECT_TRUE(opacity_layer->children_can_accept_opacity());
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
auto opacity_integer_transform = SkM44::Translate(offset.fX, offset.fY);
#endif
DisplayListBuilder expected_builder;
/* OpacityLayer::Paint() */ {
expected_builder.save();
{
expected_builder.translate(offset.fX, offset.fY);
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
expected_builder.transformReset();
expected_builder.transform(opacity_integer_transform);
#endif
/* ClipRectLayer::Paint() */ {
expected_builder.save();
expected_builder.clipRect(clip_rect, SkClipOp::kIntersect, true);
@ -454,26 +448,15 @@ TEST_F(ClipRectLayerTest, OpacityInheritanceSaveLayerPainting) {
context->subtree_can_inherit_opacity = false;
opacity_layer->Preroll(context, SkMatrix::I());
EXPECT_TRUE(opacity_layer->children_can_accept_opacity());
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
auto opacity_integer_transform = SkM44::Translate(offset.fX, offset.fY);
#endif
DisplayListBuilder expected_builder;
/* OpacityLayer::Paint() */ {
expected_builder.save();
{
expected_builder.translate(offset.fX, offset.fY);
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
expected_builder.transformReset();
expected_builder.transform(opacity_integer_transform);
#endif
/* ClipRectLayer::Paint() */ {
expected_builder.save();
expected_builder.clipRect(clip_rect, SkClipOp::kIntersect, true);
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
/* ClipShapeLayer::Paint() Integer CTM */
expected_builder.transformReset();
expected_builder.transform(opacity_integer_transform);
#endif
expected_builder.setColor(opacity_alpha << 24);
expected_builder.saveLayer(&children_bounds, true);
/* child layer1 paint */ {

19
engine/src/flutter/flow/layers/clip_rrect_layer_unittests.cc
View File

@ -392,18 +392,11 @@ TEST_F(ClipRRectLayerTest, OpacityInheritancePainting) {
opacity_layer->Preroll(context, SkMatrix::I());
EXPECT_TRUE(opacity_layer->children_can_accept_opacity());
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
auto opacity_integer_transform = SkM44::Translate(offset.fX, offset.fY);
#endif
DisplayListBuilder expected_builder;
/* OpacityLayer::Paint() */ {
expected_builder.save();
{
expected_builder.translate(offset.fX, offset.fY);
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
expected_builder.transformReset();
expected_builder.transform(opacity_integer_transform);
#endif
/* ClipRectLayer::Paint() */ {
expected_builder.save();
expected_builder.clipRRect(clip_r_rect, SkClipOp::kIntersect, true);
@ -464,26 +457,14 @@ TEST_F(ClipRRectLayerTest, OpacityInheritanceSaveLayerPainting) {
opacity_layer->Preroll(context, SkMatrix::I());
EXPECT_TRUE(opacity_layer->children_can_accept_opacity());
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
auto opacity_integer_transform = SkM44::Translate(offset.fX, offset.fY);
#endif
DisplayListBuilder expected_builder;
/* OpacityLayer::Paint() */ {
expected_builder.save();
{
expected_builder.translate(offset.fX, offset.fY);
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
expected_builder.transformReset();
expected_builder.transform(opacity_integer_transform);
#endif
/* ClipRectLayer::Paint() */ {
expected_builder.save();
expected_builder.clipRRect(clip_r_rect, SkClipOp::kIntersect, true);
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
/* ClipShapeLayer::Paint() Integer CTM */
expected_builder.transformReset();
expected_builder.transform(opacity_integer_transform);
#endif
expected_builder.setColor(opacity_alpha << 24);
expected_builder.saveLayer(&children_bounds, true);
/* child layer1 paint */ {

15
engine/src/flutter/flow/layers/clip_shape_layer.h
View File

@ -31,12 +31,7 @@ class ClipShapeLayer : public ContainerLayer {
context->MarkSubtreeDirty(context->GetOldLayerPaintRegion(old_layer));
}
}
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
if (UsesSaveLayer()) {
context->SetTransform(
RasterCache::GetIntegralTransCTM(context->GetTransform()));
}
#endif
if (context->PushCullRect(clip_shape_bounds())) {
DiffChildren(context, prev);
}
@ -68,9 +63,6 @@ class ClipShapeLayer : public ContainerLayer {
context->subtree_can_inherit_opacity = true;
if (render_count_ >= kMinimumRendersBeforeCachingLayer) {
SkMatrix child_matrix(matrix);
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
child_matrix = RasterCache::GetIntegralTransCTM(child_matrix);
#endif
TryToPrepareRasterCache(context, this, child_matrix,
RasterCacheLayerStrategy::kLayer);
} else {
@ -93,11 +85,6 @@ class ClipShapeLayer : public ContainerLayer {
return;
}
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
context.internal_nodes_canvas->setMatrix(RasterCache::GetIntegralTransCTM(
context.leaf_nodes_canvas->getTotalMatrix()));
#endif
AutoCachePaint cache_paint(context);
if (context.raster_cache &&
context.raster_cache->Draw(this, *context.leaf_nodes_canvas,

13
engine/src/flutter/flow/layers/color_filter_layer.cc
View File

@ -19,11 +19,6 @@ void ColorFilterLayer::Diff(DiffContext* context, const Layer* old_layer) {
}
}
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
context->SetTransform(
RasterCache::GetIntegralTransCTM(context->GetTransform()));
#endif
DiffChildren(context, prev);
context->SetLayerPaintRegion(this, context->CurrentSubtreeRegion());
@ -40,9 +35,6 @@ void ColorFilterLayer::Preroll(PrerollContext* context,
context->subtree_can_inherit_opacity = true;
SkMatrix child_matrix(matrix);
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
child_matrix = RasterCache::GetIntegralTransCTM(child_matrix);
#endif
if (render_count_ >= kMinimumRendersBeforeCachingFilterLayer) {
TryToPrepareRasterCache(context, this, child_matrix,
@ -60,11 +52,6 @@ void ColorFilterLayer::Paint(PaintContext& context) const {
AutoCachePaint cache_paint(context);
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
context.internal_nodes_canvas->setMatrix(RasterCache::GetIntegralTransCTM(
context.leaf_nodes_canvas->getTotalMatrix()));
#endif
if (context.raster_cache) {
if (context.raster_cache->Draw(this, *context.leaf_nodes_canvas,
RasterCacheLayerStrategy::kLayer,

106
engine/src/flutter/flow/layers/color_filter_layer_unittests.cc
View File

@ -63,17 +63,14 @@ TEST_F(ColorFilterLayerTest, EmptyFilter) {
SkPaint filter_paint;
filter_paint.setColorFilter(nullptr);
layer->Paint(paint_context());
EXPECT_EQ(mock_canvas().draw_calls(),
std::vector({
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
MockCanvas::DrawCall{0, MockCanvas::SetMatrixData{SkM44()}},
#endif
MockCanvas::DrawCall{
0, MockCanvas::SaveLayerData{child_bounds, filter_paint,
nullptr, 1}},
MockCanvas::DrawCall{
1, MockCanvas::DrawPathData{child_path, child_paint}},
MockCanvas::DrawCall{1, MockCanvas::RestoreData{0}}}));
EXPECT_EQ(
mock_canvas().draw_calls(),
std::vector({MockCanvas::DrawCall{
0, MockCanvas::SaveLayerData{child_bounds, filter_paint,
nullptr, 1}},
MockCanvas::DrawCall{
1, MockCanvas::DrawPathData{child_path, child_paint}},
MockCanvas::DrawCall{1, MockCanvas::RestoreData{0}}}));
}
TEST_F(ColorFilterLayerTest, SimpleFilter) {
@ -96,17 +93,14 @@ TEST_F(ColorFilterLayerTest, SimpleFilter) {
SkPaint filter_paint;
filter_paint.setColorFilter(layer_filter);
layer->Paint(paint_context());
EXPECT_EQ(mock_canvas().draw_calls(),
std::vector({
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
MockCanvas::DrawCall{0, MockCanvas::SetMatrixData{SkM44()}},
#endif
MockCanvas::DrawCall{
0, MockCanvas::SaveLayerData{child_bounds, filter_paint,
nullptr, 1}},
MockCanvas::DrawCall{
1, MockCanvas::DrawPathData{child_path, child_paint}},
MockCanvas::DrawCall{1, MockCanvas::RestoreData{0}}}));
EXPECT_EQ(
mock_canvas().draw_calls(),
std::vector({MockCanvas::DrawCall{
0, MockCanvas::SaveLayerData{child_bounds, filter_paint,
nullptr, 1}},
MockCanvas::DrawCall{
1, MockCanvas::DrawPathData{child_path, child_paint}},
MockCanvas::DrawCall{1, MockCanvas::RestoreData{0}}}));
}
TEST_F(ColorFilterLayerTest, MultipleChildren) {
@ -141,19 +135,16 @@ TEST_F(ColorFilterLayerTest, MultipleChildren) {
SkPaint filter_paint;
filter_paint.setColorFilter(layer_filter);
layer->Paint(paint_context());
EXPECT_EQ(mock_canvas().draw_calls(),
std::vector({
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
MockCanvas::DrawCall{0, MockCanvas::SetMatrixData{SkM44()}},
#endif
MockCanvas::DrawCall{
0, MockCanvas::SaveLayerData{children_bounds, filter_paint,
nullptr, 1}},
MockCanvas::DrawCall{
1, MockCanvas::DrawPathData{child_path1, child_paint1}},
MockCanvas::DrawCall{
1, MockCanvas::DrawPathData{child_path2, child_paint2}},
MockCanvas::DrawCall{1, MockCanvas::RestoreData{0}}}));
EXPECT_EQ(
mock_canvas().draw_calls(),
std::vector({MockCanvas::DrawCall{
0, MockCanvas::SaveLayerData{children_bounds,
filter_paint, nullptr, 1}},
MockCanvas::DrawCall{
1, MockCanvas::DrawPathData{child_path1, child_paint1}},
MockCanvas::DrawCall{
1, MockCanvas::DrawPathData{child_path2, child_paint2}},
MockCanvas::DrawCall{1, MockCanvas::RestoreData{0}}}));
}
TEST_F(ColorFilterLayerTest, Nested) {
@ -196,26 +187,20 @@ TEST_F(ColorFilterLayerTest, Nested) {
filter_paint1.setColorFilter(layer_filter1);
filter_paint2.setColorFilter(layer_filter2);
layer1->Paint(paint_context());
EXPECT_EQ(mock_canvas().draw_calls(),
std::vector({
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
MockCanvas::DrawCall{0, MockCanvas::SetMatrixData{SkM44()}},
#endif
MockCanvas::DrawCall{
0, MockCanvas::SaveLayerData{children_bounds, filter_paint1,
nullptr, 1}},
MockCanvas::DrawCall{
1, MockCanvas::DrawPathData{child_path1, child_paint1}},
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
MockCanvas::DrawCall{1, MockCanvas::SetMatrixData{SkM44()}},
#endif
MockCanvas::DrawCall{
1, MockCanvas::SaveLayerData{child_path2.getBounds(),
filter_paint2, nullptr, 2}},
MockCanvas::DrawCall{
2, MockCanvas::DrawPathData{child_path2, child_paint2}},
MockCanvas::DrawCall{2, MockCanvas::RestoreData{1}},
MockCanvas::DrawCall{1, MockCanvas::RestoreData{0}}}));
EXPECT_EQ(
mock_canvas().draw_calls(),
std::vector({MockCanvas::DrawCall{
0, MockCanvas::SaveLayerData{children_bounds,
filter_paint1, nullptr, 1}},
MockCanvas::DrawCall{
1, MockCanvas::DrawPathData{child_path1, child_paint1}},
MockCanvas::DrawCall{
1, MockCanvas::SaveLayerData{child_path2.getBounds(),
filter_paint2, nullptr, 2}},
MockCanvas::DrawCall{
2, MockCanvas::DrawPathData{child_path2, child_paint2}},
MockCanvas::DrawCall{2, MockCanvas::RestoreData{1}},
MockCanvas::DrawCall{1, MockCanvas::RestoreData{0}}}));
}
TEST_F(ColorFilterLayerTest, Readback) {
@ -366,22 +351,11 @@ TEST_F(ColorFilterLayerTest, OpacityInheritance) {
opacity_layer->Preroll(context, SkMatrix::I());
EXPECT_TRUE(opacity_layer->children_can_accept_opacity());
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
auto opacity_integer_transform = RasterCache::GetIntegralTransCTM(
SkMatrix::Translate(offset.fX, offset.fY));
#endif
DisplayListBuilder expected_builder;
/* OpacityLayer::Paint() */ {
expected_builder.save();
{
expected_builder.translate(offset.fX, offset.fY);
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
expected_builder.transformReset();
expected_builder.transform(opacity_integer_transform);
/* Integer CTM in ColorFilterLayer::Paint() */
expected_builder.transformReset();
expected_builder.transform(opacity_integer_transform);
#endif
/* ColorFilterLayer::Paint() */ {
expected_builder.setColor(opacity_alpha << 24);
expected_builder.setColorFilter(&layer_filter);

8
engine/src/flutter/flow/layers/display_list_layer.cc
View File

@ -44,10 +44,6 @@ void DisplayListLayer::Diff(DiffContext* context, const Layer* old_layer) {
#endif
}
context->PushTransform(SkMatrix::Translate(offset_.x(), offset_.y()));
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
context->SetTransform(
RasterCache::GetIntegralTransCTM(context->GetTransform()));
#endif
context->AddLayerBounds(display_list()->bounds());
context->SetLayerPaintRegion(this, context->CurrentSubtreeRegion());
}
@ -121,10 +117,6 @@ void DisplayListLayer::Paint(PaintContext& context) const {
SkAutoCanvasRestore save(context.leaf_nodes_canvas, true);
context.leaf_nodes_canvas->translate(offset_.x(), offset_.y());
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
context.leaf_nodes_canvas->setMatrix(RasterCache::GetIntegralTransCTM(
context.leaf_nodes_canvas->getTotalMatrix()));
#endif
if (context.raster_cache) {
AutoCachePaint cache_paint(context);

53
engine/src/flutter/flow/layers/display_list_layer_unittests.cc
View File

@ -12,10 +12,6 @@
#include "flutter/fml/macros.h"
#include "flutter/testing/mock_canvas.h"
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
#include "flutter/flow/raster_cache.h"
#endif
namespace flutter {
namespace testing {
@ -96,11 +92,6 @@ TEST_F(DisplayListLayerTest, SimpleDisplayList) {
{MockCanvas::DrawCall{0, MockCanvas::SaveData{1}},
MockCanvas::DrawCall{
1, MockCanvas::ConcatMatrixData{SkM44(layer_offset_matrix)}},
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
MockCanvas::DrawCall{
1, MockCanvas::SetMatrixData{SkM44(
RasterCache::GetIntegralTransCTM(layer_offset_matrix))}},
#endif
MockCanvas::DrawCall{
1, MockCanvas::DrawRectData{picture_bounds, SkPaint()}},
MockCanvas::DrawCall{1, MockCanvas::RestoreData{0}}});
@ -137,31 +128,15 @@ TEST_F(DisplayListLayerTest, SimpleDisplayListOpacityInheritance) {
auto save_layer_bounds =
picture_bounds.makeOffset(layer_offset.fX, layer_offset.fY);
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
auto opacity_integral_matrix =
RasterCache::GetIntegralTransCTM(SkMatrix::Translate(opacity_offset));
SkMatrix layer_offset_matrix = opacity_integral_matrix;
layer_offset_matrix.postTranslate(layer_offset.fX, layer_offset.fY);
auto layer_offset_integral_matrix =
RasterCache::GetIntegralTransCTM(layer_offset_matrix);
#endif
DisplayListBuilder expected_builder;
/* opacity_layer::Paint() */ {
expected_builder.save();
{
expected_builder.translate(opacity_offset.fX, opacity_offset.fY);
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
expected_builder.transformReset();
expected_builder.transform(opacity_integral_matrix);
#endif
/* display_list_layer::Paint() */ {
expected_builder.save();
{
expected_builder.translate(layer_offset.fX, layer_offset.fY);
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
expected_builder.transformReset();
expected_builder.transform(layer_offset_integral_matrix);
#endif
expected_builder.setColor(opacity_alpha << 24);
expected_builder.saveLayer(&save_layer_bounds, true);
/* display_list contents */ { //
@ -216,23 +191,11 @@ TEST_F(DisplayListLayerTest, IncompatibleDisplayListOpacityInheritance) {
auto save_layer_bounds =
display_list_bounds.makeOffset(layer_offset.fX, layer_offset.fY);
save_layer_bounds.roundOut(&save_layer_bounds);
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
auto opacity_integral_matrix =
RasterCache::GetIntegralTransCTM(SkMatrix::Translate(opacity_offset));
SkMatrix layer_offset_matrix = opacity_integral_matrix;
layer_offset_matrix.postTranslate(layer_offset.fX, layer_offset.fY);
auto layer_offset_integral_matrix =
RasterCache::GetIntegralTransCTM(layer_offset_matrix);
#endif
DisplayListBuilder expected_builder;
/* opacity_layer::Paint() */ {
expected_builder.save();
{
expected_builder.translate(opacity_offset.fX, opacity_offset.fY);
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
expected_builder.transformReset();
expected_builder.transform(opacity_integral_matrix);
#endif
expected_builder.setColor(opacity_alpha << 24);
expected_builder.saveLayer(&save_layer_bounds, true);
{
@ -240,10 +203,6 @@ TEST_F(DisplayListLayerTest, IncompatibleDisplayListOpacityInheritance) {
expected_builder.save();
{
expected_builder.translate(layer_offset.fX, layer_offset.fY);
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
expected_builder.transformReset();
expected_builder.transform(layer_offset_integral_matrix);
#endif
expected_builder.drawDisplayList(child_display_list);
}
expected_builder.restore();
@ -318,18 +277,10 @@ TEST_F(DisplayListLayerTest, CachedIncompatibleDisplayListOpacityInheritance) {
// recorder.save();
// {
// recorder.translate(opacity_offset.fX, opacity_offset.fY);
// #ifndef SUPPORT_FRACTIONAL_TRANSLATION
// recorder.resetMatrix();
// recorder.concat(opacity_integral_matrix);
// #endif
// /* display_list_layer::Paint() */ {
// recorder.save();
// {
// recorder.translate(layer_offset.fX, layer_offset.fY);
// #ifndef SUPPORT_FRACTIONAL_TRANSLATION
// recorder.resetMatrix();
// recorder.concat(layer_offset_integral_matrix);
// #endif
// SkPaint p;
// p.setAlpha(opacity_alpha);
// context->raster_cache->Draw(*display_list, recorder, &p);
@ -375,11 +326,7 @@ TEST_F(DisplayListLayerDiffTest, FractionalTranslation) {
CreateDisplayListLayer(display_list, SkPoint::Make(0.5, 0.5)));
auto damage = DiffLayerTree(tree1, MockLayerTree());
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(11, 11, 61, 61));
#else
EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(10, 10, 61, 61));
#endif
}
TEST_F(DisplayListLayerDiffTest, DisplayListCompare) {

13
engine/src/flutter/flow/layers/image_filter_layer.cc
View File

@ -21,11 +21,6 @@ void ImageFilterLayer::Diff(DiffContext* context, const Layer* old_layer) {
}
}
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
context->SetTransform(
RasterCache::GetIntegralTransCTM(context->GetTransform()));
#endif
if (filter_) {
auto filter = filter_->makeWithLocalMatrix(context->GetTransform());
if (filter) {
@ -68,9 +63,6 @@ void ImageFilterLayer::Preroll(PrerollContext* context,
set_paint_bounds(child_bounds);
SkMatrix child_matrix(matrix);
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
child_matrix = RasterCache::GetIntegralTransCTM(child_matrix);
#endif
transformed_filter_ = nullptr;
if (render_count_ >= kMinimumRendersBeforeCachingFilterLayer) {
@ -112,11 +104,6 @@ void ImageFilterLayer::Paint(PaintContext& context) const {
AutoCachePaint cache_paint(context);
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
context.internal_nodes_canvas->setMatrix(RasterCache::GetIntegralTransCTM(
context.leaf_nodes_canvas->getTotalMatrix()));
#endif
if (context.raster_cache) {
if (context.raster_cache->Draw(this, *context.leaf_nodes_canvas,
RasterCacheLayerStrategy::kLayer,

50
engine/src/flutter/flow/layers/image_filter_layer_unittests.cc
View File

@ -63,9 +63,6 @@ TEST_F(ImageFilterLayerTest, EmptyFilter) {
layer->Paint(paint_context());
EXPECT_EQ(mock_canvas().draw_calls(),
std::vector({
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
MockCanvas::DrawCall{0, MockCanvas::SetMatrixData{SkM44()}},
#endif
MockCanvas::DrawCall{
0, MockCanvas::SaveLayerData{child_bounds, filter_paint,
nullptr, 1}},
@ -101,9 +98,6 @@ TEST_F(ImageFilterLayerTest, SimpleFilter) {
layer->Paint(paint_context());
EXPECT_EQ(mock_canvas().draw_calls(),
std::vector({
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
MockCanvas::DrawCall{0, MockCanvas::SetMatrixData{SkM44()}},
#endif
MockCanvas::DrawCall{
0, MockCanvas::SaveLayerData{child_bounds, filter_paint,
nullptr, 1}},
@ -139,9 +133,6 @@ TEST_F(ImageFilterLayerTest, SimpleFilterBounds) {
layer->Paint(paint_context());
EXPECT_EQ(mock_canvas().draw_calls(),
std::vector({
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
MockCanvas::DrawCall{0, MockCanvas::SetMatrixData{SkM44()}},
#endif
MockCanvas::DrawCall{
0, MockCanvas::SaveLayerData{child_bounds, filter_paint,
nullptr, 1}},
@ -186,19 +177,16 @@ TEST_F(ImageFilterLayerTest, MultipleChildren) {
SkPaint filter_paint;
filter_paint.setImageFilter(layer_filter);
layer->Paint(paint_context());
EXPECT_EQ(mock_canvas().draw_calls(),
std::vector({
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
MockCanvas::DrawCall{0, MockCanvas::SetMatrixData{SkM44()}},
#endif
MockCanvas::DrawCall{
0, MockCanvas::SaveLayerData{children_bounds, filter_paint,
nullptr, 1}},
MockCanvas::DrawCall{
1, MockCanvas::DrawPathData{child_path1, child_paint1}},
MockCanvas::DrawCall{
1, MockCanvas::DrawPathData{child_path2, child_paint2}},
MockCanvas::DrawCall{1, MockCanvas::RestoreData{0}}}));
EXPECT_EQ(
mock_canvas().draw_calls(),
std::vector({MockCanvas::DrawCall{
0, MockCanvas::SaveLayerData{children_bounds,
filter_paint, nullptr, 1}},
MockCanvas::DrawCall{
1, MockCanvas::DrawPathData{child_path1, child_paint1}},
MockCanvas::DrawCall{
1, MockCanvas::DrawPathData{child_path2, child_paint2}},
MockCanvas::DrawCall{1, MockCanvas::RestoreData{0}}}));
}
TEST_F(ImageFilterLayerTest, Nested) {
@ -250,18 +238,11 @@ TEST_F(ImageFilterLayerTest, Nested) {
layer1->Paint(paint_context());
EXPECT_EQ(mock_canvas().draw_calls(),
std::vector({
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
MockCanvas::DrawCall{0, MockCanvas::SetMatrixData{SkM44()}},
#endif
MockCanvas::DrawCall{
0, MockCanvas::SaveLayerData{children_bounds, filter_paint1,
nullptr, 1}},
MockCanvas::DrawCall{
1, MockCanvas::DrawPathData{child_path1, child_paint1}},
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
MockCanvas::DrawCall{1, MockCanvas::SetMatrixData{SkM44()}},
#endif
MockCanvas::DrawCall{
1, MockCanvas::SaveLayerData{child_path2.getBounds(),
filter_paint2, nullptr, 2}},
@ -420,23 +401,12 @@ TEST_F(ImageFilterLayerTest, OpacityInheritance) {
opacity_layer->Preroll(context, SkMatrix::I());
EXPECT_TRUE(opacity_layer->children_can_accept_opacity());
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
auto opacity_integer_transform = RasterCache::GetIntegralTransCTM(
SkMatrix::Translate(offset.fX, offset.fY));
#endif
auto dl_image_filter = DlImageFilter::From(layer_filter);
DisplayListBuilder expected_builder;
/* OpacityLayer::Paint() */ {
expected_builder.save();
{
expected_builder.translate(offset.fX, offset.fY);
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
expected_builder.transformReset();
expected_builder.transform(opacity_integer_transform);
/* Integer CTM in ImageFilterLayer::Paint() */
expected_builder.transformReset();
expected_builder.transform(opacity_integer_transform);
#endif
/* ImageFilterLayer::Paint() */ {
expected_builder.setColor(opacity_alpha << 24);
expected_builder.setImageFilter(dl_image_filter.get());

12
engine/src/flutter/flow/layers/opacity_layer.cc
View File

@ -22,10 +22,6 @@ void OpacityLayer::Diff(DiffContext* context, const Layer* old_layer) {
}
}
context->PushTransform(SkMatrix::Translate(offset_.fX, offset_.fY));
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
context->SetTransform(
RasterCache::GetIntegralTransCTM(context->GetTransform()));
#endif
DiffChildren(context, prev);
context->SetLayerPaintRegion(this, context->CurrentSubtreeRegion());
}
@ -68,9 +64,6 @@ void OpacityLayer::Preroll(PrerollContext* context, const SkMatrix& matrix) {
set_paint_bounds(paint_bounds().makeOffset(offset_.fX, offset_.fY));
if (!children_can_accept_opacity()) {
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
child_matrix = RasterCache::GetIntegralTransCTM(child_matrix);
#endif
TryToPrepareRasterCache(context, this, child_matrix,
RasterCacheLayerStrategy::kLayerChildren);
}
@ -86,11 +79,6 @@ void OpacityLayer::Paint(PaintContext& context) const {
SkAutoCanvasRestore save(context.internal_nodes_canvas, true);
context.internal_nodes_canvas->translate(offset_.fX, offset_.fY);
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
context.internal_nodes_canvas->setMatrix(RasterCache::GetIntegralTransCTM(
context.leaf_nodes_canvas->getTotalMatrix()));
#endif
SkScalar inherited_opacity = context.inherited_opacity;
SkScalar subtree_opacity = opacity() * inherited_opacity;

83
engine/src/flutter/flow/layers/opacity_layer_unittests.cc
View File

@ -178,10 +178,6 @@ TEST_F(OpacityLayerTest, FullyOpaque) {
const SkMatrix initial_transform = SkMatrix::Translate(0.5f, 0.5f);
const SkMatrix layer_transform =
SkMatrix::Translate(layer_offset.fX, layer_offset.fY);
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
const SkMatrix integral_layer_transform = RasterCache::GetIntegralTransCTM(
SkMatrix::Concat(initial_transform, layer_transform));
#endif
const SkPaint child_paint = SkPaint(SkColors::kGreen);
const SkRect expected_layer_bounds =
layer_transform.mapRect(child_path.getBounds());
@ -204,21 +200,17 @@ TEST_F(OpacityLayerTest, FullyOpaque) {
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)}},
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
MockCanvas::DrawCall{
1, MockCanvas::SetMatrixData{SkM44(integral_layer_transform)}},
#endif
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}}});
auto expected_draw_calls =
std::vector({MockCanvas::DrawCall{0, MockCanvas::SaveData{1}},
MockCanvas::DrawCall{
1, MockCanvas::ConcatMatrixData{SkM44(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);
}
@ -229,10 +221,6 @@ TEST_F(OpacityLayerTest, FullyTransparent) {
const SkMatrix initial_transform = SkMatrix::Translate(0.5f, 0.5f);
const SkMatrix layer_transform =
SkMatrix::Translate(layer_offset.fX, layer_offset.fY);
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
const SkMatrix integral_layer_transform = RasterCache::GetIntegralTransCTM(
SkMatrix::Concat(initial_transform, layer_transform));
#endif
const SkPaint child_paint = SkPaint(SkColors::kGreen);
const SkRect expected_layer_bounds =
layer_transform.mapRect(child_path.getBounds());
@ -257,10 +245,6 @@ TEST_F(OpacityLayerTest, FullyTransparent) {
{MockCanvas::DrawCall{0, MockCanvas::SaveData{1}},
MockCanvas::DrawCall{
1, MockCanvas::ConcatMatrixData{SkM44(layer_transform)}},
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
MockCanvas::DrawCall{
1, MockCanvas::SetMatrixData{SkM44(integral_layer_transform)}},
#endif
MockCanvas::DrawCall{1, MockCanvas::SaveData{2}},
MockCanvas::DrawCall{
2, MockCanvas::ClipRectData{kEmptyRect, SkClipOp::kIntersect,
@ -277,10 +261,6 @@ TEST_F(OpacityLayerTest, HalfTransparent) {
const SkMatrix initial_transform = SkMatrix::Translate(0.5f, 0.5f);
const SkMatrix layer_transform =
SkMatrix::Translate(layer_offset.fX, layer_offset.fY);
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
const SkMatrix integral_layer_transform = RasterCache::GetIntegralTransCTM(
SkMatrix::Concat(initial_transform, layer_transform));
#endif
const SkPaint child_paint = SkPaint(SkColors::kGreen);
const SkRect expected_layer_bounds =
layer_transform.mapRect(child_path.getBounds());
@ -309,10 +289,6 @@ TEST_F(OpacityLayerTest, HalfTransparent) {
auto expected_builder = DisplayListBuilder();
expected_builder.save();
expected_builder.translate(layer_offset.fX, layer_offset.fY);
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
expected_builder.transformReset();
expected_builder.transform(SkM44(integral_layer_transform));
#endif
expected_builder.saveLayer(&opacity_bounds, &save_paint);
expected_builder.drawPath(child_path, child_dl_paint);
expected_builder.restore();
@ -334,13 +310,6 @@ TEST_F(OpacityLayerTest, Nested) {
SkMatrix::Translate(layer1_offset.fX, layer1_offset.fY);
const SkMatrix layer2_transform =
SkMatrix::Translate(layer2_offset.fX, layer2_offset.fY);
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
const SkMatrix integral_layer1_transform = RasterCache::GetIntegralTransCTM(
SkMatrix::Concat(initial_transform, layer1_transform));
const SkMatrix integral_layer2_transform = RasterCache::GetIntegralTransCTM(
SkMatrix::Concat(SkMatrix::Concat(initial_transform, layer1_transform),
layer2_transform));
#endif
const SkPaint child1_paint = SkPaint(SkColors::kRed);
const SkPaint child2_paint = SkPaint(SkColors::kBlue);
const SkPaint child3_paint = SkPaint(SkColors::kGreen);
@ -404,10 +373,6 @@ TEST_F(OpacityLayerTest, Nested) {
{MockCanvas::DrawCall{0, MockCanvas::SaveData{1}},
MockCanvas::DrawCall{
1, MockCanvas::ConcatMatrixData{SkM44(layer1_transform)}},
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
MockCanvas::DrawCall{
1, MockCanvas::SetMatrixData{SkM44(integral_layer1_transform)}},
#endif
MockCanvas::DrawCall{
1, MockCanvas::SaveLayerData{opacity1_bounds, opacity1_paint,
nullptr, 2}},
@ -416,10 +381,6 @@ TEST_F(OpacityLayerTest, Nested) {
MockCanvas::DrawCall{2, MockCanvas::SaveData{3}},
MockCanvas::DrawCall{
3, MockCanvas::ConcatMatrixData{SkM44(layer2_transform)}},
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
MockCanvas::DrawCall{
3, MockCanvas::SetMatrixData{SkM44(integral_layer2_transform)}},
#endif
MockCanvas::DrawCall{
3, MockCanvas::SaveLayerData{opacity2_bounds, opacity2_paint,
nullptr, 4}},
@ -570,19 +531,10 @@ TEST_F(OpacityLayerTest, OpacityInheritanceNestedWithCompatibleChild) {
expected_builder.save();
{
expected_builder.translate(offset1.fX, offset1.fY);
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
expected_builder.transformReset();
expected_builder.transform(SkM44::Translate(offset1.fX, offset1.fY));
#endif
/* opacityLayer2::Paint */ {
expected_builder.save();
{
expected_builder.translate(offset2.fX, offset2.fY);
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
expected_builder.transformReset();
expected_builder.transform(SkM44::Translate(offset1.fX + offset2.fX,
offset1.fY + offset2.fY));
#endif
/* mockLayer::Paint */ {
expected_builder.setColor(saveLayerPaint.getAlpha() << 24);
expected_builder.saveLayer(&mockPath.getBounds(), true);
@ -630,19 +582,10 @@ TEST_F(OpacityLayerTest, OpacityInheritanceNestedWithIncompatibleChild) {
expected_builder.save();
{
expected_builder.translate(offset1.fX, offset1.fY);
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
expected_builder.transformReset();
expected_builder.transform(SkM44::Translate(offset1.fX, offset1.fY));
#endif
/* opacityLayer2::Paint */ {
expected_builder.save();
{
expected_builder.translate(offset2.fX, offset2.fY);
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
expected_builder.transformReset();
expected_builder.transform(SkM44::Translate(offset1.fX + offset2.fX,
offset1.fY + offset2.fY));
#endif
expected_builder.setColor(saveLayerPaint.getAlpha() << 24);
expected_builder.saveLayer(&mockLayer->paint_bounds(), true);
/* mockLayer::Paint */ {
@ -671,11 +614,7 @@ TEST_F(OpacityLayerDiffTest, FractionalTranslation) {
tree1.root()->Add(layer);
auto damage = DiffLayerTree(tree1, MockLayerTree());
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(11, 11, 61, 61));
#else
EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(10, 10, 61, 61));
#endif
}
} // namespace testing

8
engine/src/flutter/flow/layers/picture_layer.cc
View File

@ -40,10 +40,6 @@ void PictureLayer::Diff(DiffContext* context, const Layer* old_layer) {
#endif
}
context->PushTransform(SkMatrix::Translate(offset_.x(), offset_.y()));
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
context->SetTransform(
RasterCache::GetIntegralTransCTM(context->GetTransform()));
#endif
context->AddLayerBounds(picture()->cullRect());
context->SetLayerPaintRegion(this, context->CurrentSubtreeRegion());
}
@ -137,10 +133,6 @@ void PictureLayer::Paint(PaintContext& context) const {
SkAutoCanvasRestore save(context.leaf_nodes_canvas, true);
context.leaf_nodes_canvas->translate(offset_.x(), offset_.y());
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
context.leaf_nodes_canvas->setMatrix(RasterCache::GetIntegralTransCTM(
context.leaf_nodes_canvas->getTotalMatrix()));
#endif
if (context.raster_cache) {
AutoCachePaint cache_paint(context);

13
engine/src/flutter/flow/layers/picture_layer_unittests.cc
View File

@ -12,10 +12,6 @@
#include "flutter/testing/mock_canvas.h"
#include "third_party/skia/include/core/SkPicture.h"
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
#include "flutter/flow/raster_cache.h"
#endif
namespace flutter {
namespace testing {
@ -88,11 +84,6 @@ TEST_F(PictureLayerTest, SimplePicture) {
{MockCanvas::DrawCall{0, MockCanvas::SaveData{1}},
MockCanvas::DrawCall{
1, MockCanvas::ConcatMatrixData{SkM44(layer_offset_matrix)}},
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
MockCanvas::DrawCall{
1, MockCanvas::SetMatrixData{SkM44(
RasterCache::GetIntegralTransCTM(layer_offset_matrix))}},
#endif
MockCanvas::DrawCall{1, MockCanvas::RestoreData{0}}});
EXPECT_EQ(mock_canvas().draw_calls(), expected_draw_calls);
}
@ -184,11 +175,7 @@ TEST_F(PictureLayerDiffTest, FractionalTranslation) {
tree1.root()->Add(CreatePictureLayer(picture, SkPoint::Make(0.5, 0.5)));
auto damage = DiffLayerTree(tree1, MockLayerTree());
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(11, 11, 61, 61));
#else
EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(10, 10, 61, 61));
#endif
}
TEST_F(PictureLayerDiffTest, PictureCompare) {

14
engine/src/flutter/flow/layers/shader_mask_layer.cc
View File

@ -25,11 +25,6 @@ void ShaderMaskLayer::Diff(DiffContext* context, const Layer* old_layer) {
}
}
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
context->SetTransform(
RasterCache::GetIntegralTransCTM(context->GetTransform()));
#endif
DiffChildren(context, prev);
context->SetLayerPaintRegion(this, context->CurrentSubtreeRegion());
@ -45,10 +40,6 @@ void ShaderMaskLayer::Preroll(PrerollContext* context, const SkMatrix& matrix) {
context->subtree_can_inherit_opacity = true;
SkMatrix child_matrix(matrix);
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
child_matrix = RasterCache::GetIntegralTransCTM(child_matrix);
#endif
if (render_count_ >= kMinimumRendersBeforeCachingFilterLayer) {
TryToPrepareRasterCache(context, this, child_matrix,
RasterCacheLayerStrategy::kLayer);
@ -63,11 +54,6 @@ void ShaderMaskLayer::Paint(PaintContext& context) const {
AutoCachePaint cache_paint(context);
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
context.internal_nodes_canvas->setMatrix(RasterCache::GetIntegralTransCTM(
context.leaf_nodes_canvas->getTotalMatrix()));
#endif
if (context.raster_cache &&
context.raster_cache->Draw(this, *context.leaf_nodes_canvas,
RasterCacheLayerStrategy::kLayer,

164
engine/src/flutter/flow/layers/shader_mask_layer_unittests.cc
View File

@ -71,22 +71,20 @@ TEST_F(ShaderMaskLayerTest, EmptyFilter) {
layer->Paint(paint_context());
EXPECT_EQ(
mock_canvas().draw_calls(),
std::vector({
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
MockCanvas::DrawCall{0, MockCanvas::SetMatrixData{SkM44()}},
#endif
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}}}));
std::vector({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}}}));
}
TEST_F(ShaderMaskLayerTest, SimpleFilter) {
@ -114,22 +112,20 @@ TEST_F(ShaderMaskLayerTest, SimpleFilter) {
layer->Paint(paint_context());
EXPECT_EQ(
mock_canvas().draw_calls(),
std::vector({
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
MockCanvas::DrawCall{0, MockCanvas::SetMatrixData{SkM44()}},
#endif
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}}}));
std::vector({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}}}));
}
TEST_F(ShaderMaskLayerTest, MultipleChildren) {
@ -169,24 +165,22 @@ TEST_F(ShaderMaskLayerTest, MultipleChildren) {
layer->Paint(paint_context());
EXPECT_EQ(
mock_canvas().draw_calls(),
std::vector({
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
MockCanvas::DrawCall{0, MockCanvas::SetMatrixData{SkM44()}},
#endif
MockCanvas::DrawCall{
0, MockCanvas::SaveLayerData{children_bounds, SkPaint(), nullptr,
1}},
MockCanvas::DrawCall{
1, MockCanvas::DrawPathData{child_path1, child_paint1}},
MockCanvas::DrawCall{
1, MockCanvas::DrawPathData{child_path2, child_paint2}},
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}}}));
std::vector({MockCanvas::DrawCall{
0, MockCanvas::SaveLayerData{children_bounds, SkPaint(),
nullptr, 1}},
MockCanvas::DrawCall{
1, MockCanvas::DrawPathData{child_path1, child_paint1}},
MockCanvas::DrawCall{
1, MockCanvas::DrawPathData{child_path2, child_paint2}},
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}}}));
}
TEST_F(ShaderMaskLayerTest, Nested) {
@ -236,37 +230,35 @@ TEST_F(ShaderMaskLayerTest, Nested) {
layer1->Paint(paint_context());
EXPECT_EQ(
mock_canvas().draw_calls(),
std::vector({
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
MockCanvas::DrawCall{0, MockCanvas::SetMatrixData{SkM44()}},
#endif
MockCanvas::DrawCall{
0, MockCanvas::SaveLayerData{children_bounds, SkPaint(), nullptr,
1}},
MockCanvas::DrawCall{
1, MockCanvas::DrawPathData{child_path1, child_paint1}},
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
MockCanvas::DrawCall{1, MockCanvas::SetMatrixData{SkM44()}},
#endif
MockCanvas::DrawCall{
1, MockCanvas::SaveLayerData{child_path2.getBounds(), SkPaint(),
nullptr, 2}},
MockCanvas::DrawCall{
2, MockCanvas::DrawPathData{child_path2, child_paint2}},
MockCanvas::DrawCall{2, MockCanvas::ConcatMatrixData{SkM44::Translate(
layer_bounds.fLeft, layer_bounds.fTop)}},
MockCanvas::DrawCall{
2, MockCanvas::DrawRectData{SkRect::MakeWH(layer_bounds.width(),
layer_bounds.height()),
filter_paint2}},
MockCanvas::DrawCall{2, MockCanvas::RestoreData{1}},
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_paint1}},
MockCanvas::DrawCall{1, MockCanvas::RestoreData{0}}}));
std::vector(
{MockCanvas::DrawCall{
0, MockCanvas::SaveLayerData{children_bounds, SkPaint(), nullptr,
1}},
MockCanvas::DrawCall{
1, MockCanvas::DrawPathData{child_path1, child_paint1}},
MockCanvas::DrawCall{
1, MockCanvas::SaveLayerData{child_path2.getBounds(), SkPaint(),
nullptr, 2}},
MockCanvas::DrawCall{
2, MockCanvas::DrawPathData{child_path2, child_paint2}},
MockCanvas::DrawCall{2,
MockCanvas::ConcatMatrixData{SkM44::Translate(
layer_bounds.fLeft, layer_bounds.fTop)}},
MockCanvas::DrawCall{
2,
MockCanvas::DrawRectData{
SkRect::MakeWH(layer_bounds.width(), layer_bounds.height()),
filter_paint2}},
MockCanvas::DrawCall{2, MockCanvas::RestoreData{1}},
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_paint1}},
MockCanvas::DrawCall{1, MockCanvas::RestoreData{0}}}));
}
TEST_F(ShaderMaskLayerTest, Readback) {
@ -351,21 +343,11 @@ TEST_F(ShaderMaskLayerTest, OpacityInheritance) {
opacity_layer->Preroll(context, SkMatrix::I());
EXPECT_TRUE(opacity_layer->children_can_accept_opacity());
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
auto opacity_integer_transform = SkM44::Translate(offset.fX, offset.fY);
#endif
DisplayListBuilder expected_builder;
/* OpacityLayer::Paint() */ {
expected_builder.save();
{
expected_builder.translate(offset.fX, offset.fY);
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
expected_builder.transformReset();
expected_builder.transform(opacity_integer_transform);
/* Integer CTM in ShaderMaskLayer::Paint() */
expected_builder.transformReset();
expected_builder.transform(opacity_integer_transform);
#endif
/* ShaderMaskLayer::Paint() */ {
expected_builder.setColor(opacity_alpha << 24);
expected_builder.saveLayer(&child_path.getBounds(), true);

7
engine/src/flutter/flow/layers/transform_layer_unittests.cc
View File

@ -311,18 +311,11 @@ TEST_F(TransformLayerTest, OpacityInheritancePainting) {
opacity_layer->Preroll(context, SkMatrix::I());
EXPECT_TRUE(opacity_layer->children_can_accept_opacity());
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
auto opacity_integer_transform = SkM44::Translate(offset.fX, offset.fY);
#endif
DisplayListBuilder expected_builder;
/* opacity_layer paint */ {
expected_builder.save();
{
expected_builder.translate(offset.fX, offset.fY);
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
expected_builder.transformReset();
expected_builder.transform(opacity_integer_transform);
#endif
/* transform_layer paint */ {
expected_builder.save();
expected_builder.transform(transform);

6
engine/src/flutter/flow/raster_cache.cc
View File

@ -314,9 +314,6 @@ bool RasterCache::Prepare(PrerollContext* context,
// GetIntegralTransCTM effect for matrix which only contains scale,
// translate, so it won't affect result of matrix decomposition and cache
// key.
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
transformation_matrix = GetIntegralTransCTM(transformation_matrix);
#endif
entry.image =
RasterizePicture(picture, context->gr_context, transformation_matrix,
context->dst_color_space, checkerboard_images_);
@ -369,9 +366,6 @@ bool RasterCache::Prepare(PrerollContext* context,
// GetIntegralTransCTM effect for matrix which only contains scale,
// translate, so it won't affect result of matrix decomposition and cache
// key.
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
transformation_matrix = GetIntegralTransCTM(transformation_matrix);
#endif
entry.image = RasterizeDisplayList(
display_list, context->gr_context, transformation_matrix,
context->dst_color_space, checkerboard_images_);

24
engine/src/flutter/flow/raster_cache.h
View File

@ -152,33 +152,9 @@ class RasterCache {
static SkRect GetDeviceBounds(const SkRect& rect, const SkMatrix& ctm) {
SkRect device_rect;
ctm.mapRect(&device_rect, rect);
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
device_rect.roundOut(&device_rect);
#endif
return device_rect;
}
/**
* @brief Snap the translation components of the matrix to integers.
*
* The snapping will only happen if the matrix only has scale and translation
* transformations.
*
* @param ctm the current transformation matrix.
* @return SkMatrix the snapped transformation matrix.
*/
static SkMatrix GetIntegralTransCTM(const SkMatrix& ctm) {
// Avoid integral snapping if the matrix has complex transformation to avoid
// the artifact observed in https://github.com/flutter/flutter/issues/41654.
if (!ctm.isScaleTranslate()) {
return ctm;
}
SkMatrix result = ctm;
result[SkMatrix::kMTransX] = SkScalarRoundToScalar(ctm.getTranslateX());
result[SkMatrix::kMTransY] = SkScalarRoundToScalar(ctm.getTranslateY());
return result;
}
// Return true if the cache is generated.
//
// We may return false and not generate the cache if

6
engine/src/flutter/flow/raster_cache_unittests.cc
View File

@ -330,17 +330,11 @@ TEST(RasterCache, DeviceRectRoundOutForSkPicture) {
ASSERT_TRUE(cache.Draw(*picture, canvas));
}
// The device rect is pixel snapped if SUPPORT_FRACTIONAL_TRANSLATION
// is disabled.
TEST(RasterCache, ComputeDeviceRectBasedOnFractionalTranslation) {
SkRect logical_rect = SkRect::MakeLTRB(0, 0, 300.2, 300.3);
SkMatrix ctm = SkMatrix::MakeAll(2.0, 0, 0, 0, 2.0, 0, 0, 0, 1);
auto result = RasterCache::GetDeviceBounds(logical_rect, ctm);
#ifndef SUPPORT_FRACTIONAL_TRANSLATION
ASSERT_EQ(result, SkRect::MakeLTRB(0.0, 0.0, 601.0, 601.0));
#else
ASSERT_EQ(result, SkRect::MakeLTRB(0.0, 0.0, 600.4, 600.6));
#endif
}
// Construct a cache result whose device target rectangle rounds out to be one

38
engine/src/flutter/shell/testing/BUILD.gn
View File

@ -36,41 +36,3 @@ executable("testing") {
"//third_party/skia",
]
}
# A second tester binary with SUPPORT_FRACTIONAL_TRANSLATION enabled
# and the raster cache disabled.
executable("testing_fractional_translation") {
output_name = "flutter_tester_fractional_translation"
public_configs = [
"//flutter:config",
"//flutter:export_dynamic_symbols",
]
sources = [ "tester_main.cc" ]
if (is_win) {
libs = [
"psapi.lib",
"user32.lib",
"FontSub.lib",
"shlwapi.lib",
]
}
defines = []
deps = [
"//flutter/assets",
"//flutter/common",
"//flutter/flow",
"//flutter/fml",
"//flutter/lib/snapshot",
"//flutter/shell/common",
"//flutter/shell/gpu:gpu_surface_software",
"//flutter/third_party/tonic",
"//third_party/dart/runtime:libdart_jit",
"//third_party/dart/runtime/bin:dart_io_api",
"//third_party/skia",
]
}

3
engine/src/flutter/shell/testing/tester_main.cc
View File

@ -68,10 +68,7 @@ class TesterGPUSurfaceSoftware : public GPUSurfaceSoftware {
bool render_to_surface)
: GPUSurfaceSoftware(delegate, render_to_surface) {}
#if SUPPORT_FRACTIONAL_TRANSLATION
// |Surface|
bool EnableRasterCache() const override { return false; }
#endif // SUPPORT_FRACTIONAL_TRANSLATION
};
class TesterPlatformView : public PlatformView,

7
engine/src/flutter/testing/run_tests.py
View File

@ -468,8 +468,6 @@ def GatherDartTest(
threading = 'single-threaded'
tester_name = 'flutter_tester'
if alternative_tester:
tester_name = 'flutter_tester_fractional_translation'
print(
"Running test '%s' using '%s' (%s)" %
(kernel_file_name, tester_name, threading)
@ -700,11 +698,6 @@ def GatherDartTests(build_dir, filter, verbose_dart_snapshot):
build_dir, test_packages, dart_test_file, verbose_dart_snapshot,
False, True
)
# Smoke test with tester variant that has no raster cache and enabled fractional translation
yield GatherDartTest(
build_dir, test_packages, dart_test_file, verbose_dart_snapshot,
False, True, True
)
for dart_test_file in dart_tests:
if filter is not None and os.path.basename(dart_test_file) not in filter: