firka/flutter
firka/flutter
4
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Delete last usages of MockCanvas test mechanism (flutter/engine#55840)

Browse Source 
The MockCanvas API was originally used to test the output of rendering methods to match them against a reference set of "MockData" structures. This API has been superseded by just using a DisplayListBuilder to record reference operations and then to compare the resulting DisplayList objects.

This PR deletes the last remaining uses of MockCanvas as well as the mechanism itself.
This commit is contained in:
Jim Graham 2024-10-11 22:15:17 -07:00 committed by GitHub
parent 8da20b0a97
commit 9e747c2eb6
20 changed files with 159 additions and 1127 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -196,7 +196,6 @@ group("unittests") {
"//flutter/shell/platform/embedder:embedder_a11y_unittests",
"//flutter/shell/platform/embedder:embedder_proctable_unittests",
"//flutter/shell/platform/embedder:embedder_unittests",
"//flutter/testing:testing_unittests",
"//flutter/testing/dart",
"//flutter/testing/smoke_test_failure",
"//flutter/third_party/tonic/tests:tonic_unittests",

1
engine/src/flutter/CONTRIBUTING.md
View File

@ -270,7 +270,6 @@ $ ./run_tests.py --variant=host_debug_unopt_arm64 --type=engine
| runtime_unittests | engine | |
| shell_unittests | engine(not windows) | |
| scenario_app | android | Integration and golden tests for Android, iOS |
| testing_unittests | engine | |
| tonic_unittests | engine | Unit tests for //third_party/tonic |
| txt_unittests | engine(linux) | |
| ui_unittests | engine | |

3
engine/src/flutter/display_list/dl_builder.h
View File

@ -38,6 +38,9 @@ class DisplayListBuilder final : public virtual DlCanvas,
explicit DisplayListBuilder(const SkRect& cull_rect = kMaxCullRect,
bool prepare_rtree = false);
DisplayListBuilder(DlScalar width, DlScalar height)
: DisplayListBuilder(SkRect::MakeWH(width, height)) {}
~DisplayListBuilder();
// |DlCanvas|

62
engine/src/flutter/flow/layers/layer_tree_unittests.cc
View File

@ -11,17 +11,19 @@
#include "flutter/flow/testing/mock_layer.h"
#include "flutter/fml/macros.h"
#include "flutter/testing/canvas_test.h"
#include "flutter/testing/mock_canvas.h"
#include "flutter/testing/display_list_testing.h"
#include "gtest/gtest.h"
namespace flutter {
namespace testing {
class LayerTreeTest : public CanvasTest {
public:
LayerTreeTest()
: root_transform_(SkMatrix::Translate(1.0f, 1.0f)),
builder_(DisplayListBuilder::kMaxCullRect),
scoped_frame_(compositor_context_.AcquireFrame(nullptr,
&mock_canvas(),
&builder_,
nullptr,
root_transform_,
false,
@ -31,6 +33,7 @@ class LayerTreeTest : public CanvasTest {
CompositorContext::ScopedFrame& frame() { return *scoped_frame_.get(); }
const SkMatrix& root_transform() { return root_transform_; }
sk_sp<DisplayList> display_list() { return builder_.Build(); }
std::unique_ptr<LayerTree> BuildLayerTree(
const std::shared_ptr<Layer>& root_layer) {
@ -40,6 +43,7 @@ class LayerTreeTest : public CanvasTest {
private:
CompositorContext compositor_context_;
SkMatrix root_transform_;
DisplayListBuilder builder_;
std::unique_ptr<CompositorContext::ScopedFrame> scoped_frame_;
};
@ -62,13 +66,17 @@ TEST_F(LayerTreeTest, PaintBeforePrerollDies) {
layer->Add(mock_layer);
auto layer_tree = BuildLayerTree(layer);
EXPECT_EQ(mock_layer->paint_bounds(), kEmptyRect);
EXPECT_EQ(layer->paint_bounds(), kEmptyRect);
EXPECT_EQ(mock_layer->paint_bounds(), SkRect::MakeEmpty());
EXPECT_EQ(layer->paint_bounds(), SkRect::MakeEmpty());
EXPECT_TRUE(mock_layer->is_empty());
EXPECT_TRUE(layer->is_empty());
layer_tree->Paint(frame());
EXPECT_EQ(mock_canvas().draw_calls(), std::vector<MockCanvas::DrawCall>());
DisplayListBuilder expected_builder;
auto expected_dl = expected_builder.Build();
EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_dl));
}
TEST_F(LayerTreeTest, Simple) {
@ -88,9 +96,12 @@ TEST_F(LayerTreeTest, Simple) {
EXPECT_EQ(mock_layer->parent_matrix(), root_transform());
layer_tree->Paint(frame());
EXPECT_EQ(mock_canvas().draw_calls(),
std::vector({MockCanvas::DrawCall{
0, MockCanvas::DrawPathData{child_path, child_paint}}}));
DisplayListBuilder expected_builder;
expected_builder.DrawPath(DlPath(child_path), child_paint);
auto expected_dl = expected_builder.Build();
EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_dl));
}
TEST_F(LayerTreeTest, Multiple) {
@ -122,12 +133,13 @@ TEST_F(LayerTreeTest, Multiple) {
kGiantRect); // Siblings are independent
layer_tree->Paint(frame());
EXPECT_EQ(
mock_canvas().draw_calls(),
std::vector({MockCanvas::DrawCall{
0, MockCanvas::DrawPathData{child_path1, child_paint1}},
MockCanvas::DrawCall{0, MockCanvas::DrawPathData{
child_path2, child_paint2}}}));
DisplayListBuilder expected_builder;
expected_builder.DrawPath(DlPath(child_path1), child_paint1);
expected_builder.DrawPath(DlPath(child_path2), child_paint2);
auto expected_dl = expected_builder.Build();
EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_dl));
}
TEST_F(LayerTreeTest, MultipleWithEmpty) {
@ -154,9 +166,12 @@ TEST_F(LayerTreeTest, MultipleWithEmpty) {
EXPECT_EQ(mock_layer2->parent_cull_rect(), kGiantRect);
layer_tree->Paint(frame());
EXPECT_EQ(mock_canvas().draw_calls(),
std::vector({MockCanvas::DrawCall{
0, MockCanvas::DrawPathData{child_path1, child_paint1}}}));
DisplayListBuilder expected_builder;
expected_builder.DrawPath(DlPath(child_path1), child_paint1);
auto expected_dl = expected_builder.Build();
EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_dl));
}
TEST_F(LayerTreeTest, NeedsSystemComposite) {
@ -186,12 +201,13 @@ TEST_F(LayerTreeTest, NeedsSystemComposite) {
EXPECT_EQ(mock_layer2->parent_cull_rect(), kGiantRect);
layer_tree->Paint(frame());
EXPECT_EQ(
mock_canvas().draw_calls(),
std::vector({MockCanvas::DrawCall{
0, MockCanvas::DrawPathData{child_path1, child_paint1}},
MockCanvas::DrawCall{0, MockCanvas::DrawPathData{
child_path2, child_paint2}}}));
DisplayListBuilder expected_builder;
expected_builder.DrawPath(DlPath(child_path1), child_paint1);
expected_builder.DrawPath(DlPath(child_path2), child_paint2);
auto expected_dl = expected_builder.Build();
EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_dl));
}
TEST_F(LayerTreeTest, PrerollContextInitialization) {

88
engine/src/flutter/flow/layers/performance_overlay_layer_unittests.cc
View File

@ -7,11 +7,11 @@
#include <cstdint>
#include <sstream>
#include "flutter/display_list/utils/dl_receiver_utils.h"
#include "flutter/flow/flow_test_utils.h"
#include "flutter/flow/raster_cache.h"
#include "flutter/flow/testing/layer_test.h"
#include "flutter/shell/common/base64.h"
#include "flutter/testing/mock_canvas.h"
#include "third_party/skia/include/core/SkData.h"
#include "third_party/skia/include/core/SkImage.h"
#include "third_party/skia/include/core/SkSerialProcs.h"
@ -131,6 +131,36 @@ static void TestPerformanceOverlayLayerGold(int refresh_rate) {
using PerformanceOverlayLayerTest = LayerTest;
class ImageSizeTextBlobInspector : public virtual DlOpReceiver,
virtual IgnoreAttributeDispatchHelper,
virtual IgnoreTransformDispatchHelper,
virtual IgnoreClipDispatchHelper,
virtual IgnoreDrawDispatchHelper {
public:
void drawImage(const sk_sp<DlImage> image,
const DlPoint& point,
DlImageSampling sampling,
bool render_with_attributes) override {
sizes_.push_back(image->GetBounds().GetSize());
}
void drawTextBlob(const sk_sp<SkTextBlob> blob,
DlScalar x,
DlScalar y) override {
text_blobs_.push_back(blob);
text_positions_.push_back(DlPoint(x, y));
}
const std::vector<DlISize>& sizes() { return sizes_; }
const std::vector<sk_sp<SkTextBlob>> text_blobs() { return text_blobs_; }
const std::vector<DlPoint> text_positions() { return text_positions_; }
private:
std::vector<DlISize> sizes_;
std::vector<sk_sp<SkTextBlob>> text_blobs_;
std::vector<DlPoint> text_positions_;
};
TEST_F(PerformanceOverlayLayerTest, PaintingEmptyLayerDies) {
const uint64_t overlay_opts = kVisualizeRasterizerStatistics;
auto layer = std::make_shared<PerformanceOverlayLayer>(overlay_opts);
@ -157,8 +187,12 @@ TEST_F(PerformanceOverlayLayerTest, InvalidOptions) {
EXPECT_TRUE(layer->needs_painting(paint_context()));
// Nothing is drawn if options are invalid (0).
layer->Paint(paint_context());
EXPECT_EQ(mock_canvas().draw_calls(), std::vector<MockCanvas::DrawCall>());
layer->Paint(display_list_paint_context());
DisplayListBuilder expected_builder;
auto expected_dl = expected_builder.Build();
EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_dl));
}
TEST_F(PerformanceOverlayLayerTest, SimpleRasterizerStatistics) {
@ -174,13 +208,15 @@ TEST_F(PerformanceOverlayLayerTest, SimpleRasterizerStatistics) {
EXPECT_EQ(layer->paint_bounds(), layer_bounds);
EXPECT_TRUE(layer->needs_painting(paint_context()));
layer->Paint(paint_context());
layer->Paint(display_list_paint_context());
auto overlay_text = PerformanceOverlayLayer::MakeStatisticsText(
paint_context().raster_time, "Raster", "");
display_list_paint_context().raster_time, "Raster", "");
auto overlay_text_data = overlay_text->serialize(SkSerialProcs{});
// Historically SK_ColorGRAY (== 0xFF888888) was used here
DlPaint text_paint(DlColor(0xFF888888));
SkPoint text_position = SkPoint::Make(16.0f, 22.0f);
DlPoint text_position = DlPoint(16.0f, 22.0f);
ImageSizeTextBlobInspector inspector;
display_list()->Dispatch(inspector);
// TODO(https://github.com/flutter/flutter/issues/82202): Remove once the
// performance overlay can use Fuchsia's font manager instead of the empty
@ -188,10 +224,12 @@ TEST_F(PerformanceOverlayLayerTest, SimpleRasterizerStatistics) {
#if defined(OS_FUCHSIA)
GTEST_SKIP() << "Expectation requires a valid default font manager";
#endif // OS_FUCHSIA
EXPECT_EQ(mock_canvas().draw_calls(),
std::vector({MockCanvas::DrawCall{
0, MockCanvas::DrawTextData{overlay_text_data, text_paint,
text_position}}}));
ASSERT_EQ(inspector.sizes().size(), 0u);
ASSERT_EQ(inspector.text_blobs().size(), 1u);
ASSERT_EQ(inspector.text_positions().size(), 1u);
auto text_data = inspector.text_blobs().front()->serialize(SkSerialProcs{});
EXPECT_TRUE(text_data->equals(overlay_text_data.get()));
EXPECT_EQ(inspector.text_positions().front(), text_position);
}
TEST_F(PerformanceOverlayLayerTest, MarkAsDirtyWhenResized) {
@ -202,21 +240,31 @@ TEST_F(PerformanceOverlayLayerTest, MarkAsDirtyWhenResized) {
auto layer = std::make_shared<PerformanceOverlayLayer>(overlay_opts);
layer->set_paint_bounds(SkRect::MakeLTRB(0.0f, 0.0f, 48.0f, 48.0f));
layer->Preroll(preroll_context());
layer->Paint(paint_context());
auto data = mock_canvas().draw_calls().front().data;
auto image_data = std::get<MockCanvas::DrawImageDataNoPaint>(data);
auto first_draw_width = image_data.image->width();
layer->Paint(display_list_paint_context());
DlISize first_draw_size;
{
ImageSizeTextBlobInspector inspector;
display_list()->Dispatch(inspector);
ASSERT_EQ(inspector.sizes().size(), 1u);
ASSERT_EQ(inspector.text_blobs().size(), 0u);
ASSERT_EQ(inspector.text_positions().size(), 0u);
first_draw_size = inspector.sizes().front();
}
// Create a second PerformanceOverlayLayer with different bounds.
layer = std::make_shared<PerformanceOverlayLayer>(overlay_opts);
layer->set_paint_bounds(SkRect::MakeLTRB(0.0f, 0.0f, 64.0f, 64.0f));
layer->Preroll(preroll_context());
layer->Paint(paint_context());
data = mock_canvas().draw_calls().back().data;
image_data = std::get<MockCanvas::DrawImageDataNoPaint>(data);
auto refreshed_draw_width = image_data.image->width();
EXPECT_NE(first_draw_width, refreshed_draw_width);
reset_display_list();
layer->Paint(display_list_paint_context());
{
ImageSizeTextBlobInspector inspector;
display_list()->Dispatch(inspector);
ASSERT_EQ(inspector.sizes().size(), 1u);
ASSERT_EQ(inspector.text_blobs().size(), 0u);
ASSERT_EQ(inspector.text_positions().size(), 0u);
EXPECT_NE(first_draw_size, inspector.sizes().front());
}
}
TEST(PerformanceOverlayLayerDefault, Gold) {

43
engine/src/flutter/flow/layers/platform_view_layer_unittests.cc
View File

@ -10,7 +10,6 @@
#include "flutter/flow/testing/mock_embedder.h"
#include "flutter/flow/testing/mock_layer.h"
#include "flutter/fml/macros.h"
#include "flutter/testing/mock_canvas.h"
namespace flutter {
namespace testing {
@ -34,9 +33,12 @@ TEST_F(PlatformViewLayerTest, NullViewEmbedderDoesntPrerollCompositeOrPaint) {
EXPECT_TRUE(layer->needs_painting(paint_context()));
EXPECT_FALSE(layer->subtree_has_platform_view());
layer->Paint(paint_context());
EXPECT_EQ(paint_context().canvas, &mock_canvas());
EXPECT_EQ(mock_canvas().draw_calls(), std::vector<MockCanvas::DrawCall>());
layer->Paint(display_list_paint_context());
DisplayListBuilder expected_builder;
auto expected_dl = expected_builder.Build();
EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_dl));
}
TEST_F(PlatformViewLayerTest, ClippedPlatformViewPrerollsAndPaintsNothing) {
@ -69,21 +71,24 @@ TEST_F(PlatformViewLayerTest, ClippedPlatformViewPrerollsAndPaintsNothing) {
EXPECT_TRUE(child_clip_layer->subtree_has_platform_view());
EXPECT_TRUE(parent_clip_layer->subtree_has_platform_view());
parent_clip_layer->Paint(paint_context());
EXPECT_EQ(paint_context().canvas, &mock_canvas());
EXPECT_EQ(
mock_canvas().draw_calls(),
std::vector(
{MockCanvas::DrawCall{0, MockCanvas::SaveData{1}},
MockCanvas::DrawCall{
1, MockCanvas::ClipRectData{parent_clip, ClipOp::kIntersect,
MockCanvas::kHardClipEdgeStyle}},
MockCanvas::DrawCall{1, MockCanvas::SaveData{2}},
MockCanvas::DrawCall{
2, MockCanvas::ClipRectData{child_clip, ClipOp::kIntersect,
MockCanvas::kHardClipEdgeStyle}},
MockCanvas::DrawCall{2, MockCanvas::RestoreData{1}},
MockCanvas::DrawCall{1, MockCanvas::RestoreData{0}}}));
parent_clip_layer->Paint(display_list_paint_context());
DisplayListBuilder expected_builder;
expected_builder.Save();
expected_builder.ClipRect(parent_clip, ClipOp::kIntersect, false);
// In reality the following save/clip/restore are elided due to reaching
// a nop state (and the save is then unnecessary), but this is the order
// of operations that the layers will do...
expected_builder.Save();
expected_builder.ClipRect(child_clip, ClipOp::kIntersect, false);
expected_builder.Restore();
// End of section that gets ignored during recording
expected_builder.Restore();
auto expected_dl = expected_builder.Build();
EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_dl));
}
TEST_F(PlatformViewLayerTest, OpacityInheritance) {

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

@ -39,7 +39,7 @@ TEST(RasterCache, MetricsOmitUnpopulatedEntries) {
auto display_list = GetSampleDisplayList();
MockCanvas dummy_canvas(1000, 1000);
DisplayListBuilder dummy_canvas(1000, 1000);
DlPaint paint;
LayerStateStack preroll_state_stack;
@ -99,7 +99,7 @@ TEST(RasterCache, ThresholdIsRespectedForDisplayList) {
auto display_list = GetSampleDisplayList();
MockCanvas dummy_canvas(1000, 1000);
DisplayListBuilder dummy_canvas(1000, 1000);
DlPaint paint;
LayerStateStack preroll_state_stack;
@ -151,7 +151,7 @@ TEST(RasterCache, AccessThresholdOfZeroDisablesCachingForDisplayList) {
auto display_list = GetSampleDisplayList();
MockCanvas dummy_canvas(1000, 1000);
DisplayListBuilder dummy_canvas(1000, 1000);
DlPaint paint;
LayerStateStack preroll_state_stack;
@ -185,7 +185,7 @@ TEST(RasterCache, PictureCacheLimitPerFrameIsRespectedWhenZeroForDisplayList) {
auto display_list = GetSampleDisplayList();
MockCanvas dummy_canvas(1000, 1000);
DisplayListBuilder dummy_canvas(1000, 1000);
DlPaint paint;
LayerStateStack preroll_state_stack;
@ -229,7 +229,7 @@ TEST(RasterCache, EvictUnusedCacheEntries) {
auto display_list_1 = GetSampleDisplayList();
auto display_list_2 = GetSampleDisplayList();
MockCanvas dummy_canvas(1000, 1000);
DisplayListBuilder dummy_canvas(1000, 1000);
DlPaint paint;
LayerStateStack preroll_state_stack;
@ -342,7 +342,7 @@ TEST(RasterCache, DeviceRectRoundOutForDisplayList) {
SkMatrix ctm = SkMatrix::MakeAll(1.3312, 0, 233, 0, 1.3312, 206, 0, 0, 1);
DlPaint paint;
MockCanvas canvas(1000, 1000);
DisplayListBuilder canvas(1000, 1000);
canvas.SetTransform(ctm);
LayerStateStack preroll_state_stack;
@ -389,7 +389,7 @@ TEST(RasterCache, NestedOpCountMetricUsedForDisplayList) {
ASSERT_EQ(display_list->op_count(), 1u);
ASSERT_EQ(display_list->op_count(true), 36u);
MockCanvas dummy_canvas(1000, 1000);
DisplayListBuilder dummy_canvas(1000, 1000);
DlPaint paint;
LayerStateStack preroll_state_stack;
@ -440,7 +440,7 @@ TEST(RasterCache, NaiveComplexityScoringDisplayList) {
ASSERT_EQ(display_list->op_count(), 5u);
ASSERT_FALSE(calculator->ShouldBeCached(complexity_score));
MockCanvas dummy_canvas(1000, 1000);
DisplayListBuilder dummy_canvas(1000, 1000);
DlPaint paint;
LayerStateStack preroll_state_stack;
@ -510,7 +510,7 @@ TEST(RasterCache, DisplayListWithSingularMatrixIsNotCached) {
auto display_list = GetSampleDisplayList();
MockCanvas dummy_canvas(1000, 1000);
DisplayListBuilder dummy_canvas(1000, 1000);
DlPaint paint;
LayerStateStack preroll_state_stack;
@ -567,7 +567,7 @@ TEST(RasterCache, PrepareLayerTransform) {
size_t threshold = 2;
MockRasterCache cache(threshold);
MockCanvas dummy_canvas(1000, 1000);
DisplayListBuilder dummy_canvas(1000, 1000);
LayerStateStack preroll_state_stack;
preroll_state_stack.set_preroll_delegate(kGiantRect, matrix);

21
engine/src/flutter/flow/testing/layer_test.h
View File

@ -17,7 +17,6 @@
#include "flutter/testing/assertions_skia.h"
#include "flutter/testing/canvas_test.h"
#include "flutter/testing/display_list_testing.h"
#include "flutter/testing/mock_canvas.h"
#include "third_party/skia/include/core/SkCanvas.h"
#include "third_party/skia/include/core/SkImageInfo.h"
#include "third_party/skia/include/utils/SkNWayCanvas.h"
@ -25,6 +24,8 @@
namespace flutter {
namespace testing {
static constexpr SkRect kEmptyRect = SkRect::MakeEmpty();
// This fixture allows generating tests which can |Paint()| and |Preroll()|
// |Layer|'s.
// |LayerTest| is a default implementation based on |::testing::Test|.
@ -61,18 +62,6 @@ class LayerTestBase : public CanvasTestBase<BaseT> {
.raster_cached_entries = &cacheable_items_,
// clang-format on
},
paint_context_{
// clang-format off
.state_stack = paint_state_stack_,
.canvas = &TestT::mock_canvas(),
.gr_context = nullptr,
.view_embedder = nullptr,
.raster_time = raster_time_,
.ui_time = ui_time_,
.texture_registry = texture_registry_,
.raster_cache = nullptr,
// clang-format on
},
display_list_builder_(k_dl_bounds_),
display_list_paint_context_{
// clang-format off
@ -88,7 +77,6 @@ class LayerTestBase : public CanvasTestBase<BaseT> {
} {
use_null_raster_cache();
preroll_state_stack_.set_preroll_delegate(kGiantRect, SkMatrix::I());
paint_state_stack_.set_delegate(&TestT::mock_canvas());
display_list_state_stack_.set_delegate(&display_list_builder_);
}
@ -148,7 +136,7 @@ class LayerTestBase : public CanvasTestBase<BaseT> {
}
RasterCache* raster_cache() { return raster_cache_.get(); }
PrerollContext* preroll_context() { return &preroll_context_; }
PaintContext& paint_context() { return paint_context_; }
PaintContext& paint_context() { return display_list_paint_context_; }
PaintContext& display_list_paint_context() {
return display_list_paint_context_;
}
@ -172,19 +160,16 @@ class LayerTestBase : public CanvasTestBase<BaseT> {
void set_raster_cache_(std::unique_ptr<RasterCache> raster_cache) {
raster_cache_ = std::move(raster_cache);
preroll_context_.raster_cache = raster_cache_.get();
paint_context_.raster_cache = raster_cache_.get();
display_list_paint_context_.raster_cache = raster_cache_.get();
}
LayerStateStack preroll_state_stack_;
LayerStateStack paint_state_stack_;
FixedRefreshRateStopwatch raster_time_;
FixedRefreshRateStopwatch ui_time_;
std::shared_ptr<TextureRegistry> texture_registry_;
std::unique_ptr<RasterCache> raster_cache_;
PrerollContext preroll_context_;
PaintContext paint_context_;
DisplayListBuilder display_list_builder_;
LayerStateStack display_list_state_stack_;
sk_sp<DisplayList> display_list_;

2
engine/src/flutter/flow/testing/mock_layer.cc
View File

@ -8,7 +8,9 @@
#include "flutter/flow/layers/container_layer.h"
#include "flutter/flow/layers/layer.h"
#include "flutter/flow/testing/layer_test.h"
#include "flutter/flow/testing/mock_raster_cache.h"
namespace flutter {
namespace testing {

12
engine/src/flutter/flow/testing/mock_layer_unittests.cc
View File

@ -6,7 +6,6 @@
#include "flutter/flow/testing/layer_test.h"
#include "flutter/fml/macros.h"
#include "flutter/testing/mock_canvas.h"
namespace flutter {
namespace testing {
@ -58,10 +57,13 @@ TEST_F(MockLayerTest, SimpleParams) {
EXPECT_EQ(layer->parent_cull_rect(), local_cull_rect);
EXPECT_EQ(layer->parent_has_platform_view(), parent_has_platform_view);
layer->Paint(paint_context());
EXPECT_EQ(mock_canvas().draw_calls(),
std::vector({MockCanvas::DrawCall{
0, MockCanvas::DrawPathData{path, paint}}}));
layer->Paint(display_list_paint_context());
DisplayListBuilder expected_builder;
expected_builder.DrawPath(DlPath(path), paint);
auto expected_dl = expected_builder.Build();
EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_dl));
}
TEST_F(MockLayerTest, FakePlatformView) {

5
engine/src/flutter/flow/testing/mock_raster_cache.h
View File

@ -10,7 +10,6 @@
#include "flutter/flow/raster_cache.h"
#include "flutter/flow/raster_cache_item.h"
#include "flutter/flow/testing/mock_layer.h"
#include "flutter/testing/mock_canvas.h"
#include "third_party/skia/include/core/SkColorSpace.h"
#include "third_party/skia/include/core/SkRefCnt.h"
#include "third_party/skia/include/core/SkSize.h"
@ -63,7 +62,7 @@ class MockRasterCache : public RasterCache {
: RasterCache(access_threshold,
picture_and_display_list_cache_limit_per_frame) {
preroll_state_stack_.set_preroll_delegate(SkMatrix::I());
paint_state_stack_.set_delegate(&mock_canvas_);
paint_state_stack_.set_delegate(&builder_);
}
void AddMockLayer(int width, int height);
@ -72,7 +71,7 @@ class MockRasterCache : public RasterCache {
private:
LayerStateStack preroll_state_stack_;
LayerStateStack paint_state_stack_;
MockCanvas mock_canvas_;
DisplayListBuilder builder_;
sk_sp<SkColorSpace> color_space_ = SkColorSpace::MakeSRGB();
MutatorsStack mutators_stack_;
FixedRefreshRateStopwatch raster_time_;

3
engine/src/flutter/shell/common/shell_unittests.cc
View File

@ -44,7 +44,6 @@
#include "flutter/shell/common/vsync_waiter_fallback.h"
#include "flutter/shell/common/vsync_waiters_test.h"
#include "flutter/shell/version/version.h"
#include "flutter/testing/mock_canvas.h"
#include "flutter/testing/testing.h"
#include "gmock/gmock.h"
#include "impeller/core/runtime_types.h"
@ -2542,7 +2541,7 @@ TEST_F(ShellTest, OnServiceProtocolEstimateRasterCacheMemoryWorks) {
// 2.1. Rasterize the picture. Call Draw multiple times to pass the
// access threshold (default to 3) so a cache can be generated.
MockCanvas dummy_canvas;
DisplayListBuilder dummy_canvas;
DlPaint paint;
bool picture_cache_generated;
DisplayListRasterCacheItem display_list_raster_cache_item(

7
engine/src/flutter/shell/platform/fuchsia/flutter/BUILD.gn
View File

@ -743,12 +743,6 @@ if (enable_unittests) {
resources += vulkan_icds
}
fuchsia_test_archive("testing_tests") {
deps = [ "//flutter/testing:testing_unittests" ]
gen_cml_file = true
binary = "testing_unittests"
}
fuchsia_test_archive("txt_tests") {
deps = [ "//flutter/third_party/txt:txt_unittests" ]
gen_cml_file = true
@ -912,7 +906,6 @@ if (enable_unittests) {
":fml_tests",
":runtime_tests",
":shell_tests",
":testing_tests",
":txt_tests",
":ui_tests",
"tests/integration",

27
engine/src/flutter/testing/BUILD.gn
View File

@ -23,8 +23,6 @@ source_set("testing_lib") {
"display_list_testing.h",
"logger_listener.cc",
"logger_listener.h",
"mock_canvas.cc",
"mock_canvas.h",
"post_task_sync.cc",
"post_task_sync.h",
"stream_capture.cc",
@ -180,31 +178,6 @@ if (enable_unittests) {
test_fixtures("testing_fixtures") {
fixtures = []
}
# The //flutter/testing library provides utility methods to other test targets.
# This test target tests the testing utilities.
executable("testing_unittests") {
testonly = true
sources = [ "mock_canvas_unittests.cc" ]
deps = [
":skia",
":testing",
":testing_fixtures",
"//flutter/runtime:libdart",
]
if (shell_enable_metal) {
sources += [ "test_metal_surface_unittests.cc" ]
deps += [ ":metal" ]
}
if (shell_enable_vulkan) {
deps += [ "//flutter/vulkan" ]
}
}
}
# All targets on all platforms should be able to use the Metal utilities. On

3
engine/src/flutter/testing/canvas_test.h
View File

@ -6,7 +6,6 @@
#define FLUTTER_TESTING_CANVAS_TEST_H_
#include "flutter/fml/macros.h"
#include "flutter/testing/mock_canvas.h"
#include "gtest/gtest.h"
#include "third_party/skia/include/core/SkColorSpace.h"
@ -19,11 +18,9 @@ class CanvasTestBase : public BaseT {
public:
CanvasTestBase() = default;
MockCanvas& mock_canvas() { return canvas_; }
sk_sp<SkColorSpace> mock_color_space() { return color_space_; }
private:
MockCanvas canvas_;
sk_sp<SkColorSpace> color_space_ = SkColorSpace::MakeSRGB();
FML_DISALLOW_COPY_AND_ASSIGN(CanvasTestBase);

2
engine/src/flutter/testing/fuchsia/test_suites.yaml
View File

@ -26,8 +26,6 @@
- test_command: test run fuchsia-pkg://fuchsia.com/shell_tests#meta/shell_tests.cm
package: shell_tests-0.far
variant: debug_x64
- test_command: test run fuchsia-pkg://fuchsia.com/testing_tests#meta/testing_tests.cm
package: testing_tests-0.far
- test_command: test run fuchsia-pkg://fuchsia.com/txt_tests#meta/txt_tests.cm -- --gtest_filter=-ParagraphTest.*
package: txt_tests-0.far
variant: debug

575
engine/src/flutter/testing/mock_canvas.cc
View File

@ -1,575 +0,0 @@
// Copyright 2013 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "flutter/testing/mock_canvas.h"
#include "flutter/fml/logging.h"
#include "flutter/testing/display_list_testing.h"
#include "third_party/skia/include/core/SkImageInfo.h"
#include "third_party/skia/include/core/SkSerialProcs.h"
#include "third_party/skia/include/core/SkSize.h"
#include "third_party/skia/include/core/SkTextBlob.h"
namespace flutter {
namespace testing {
constexpr SkISize kSize = SkISize::Make(64, 64);
MockCanvas::MockCanvas() : MockCanvas(kSize.fWidth, kSize.fHeight) {}
MockCanvas::MockCanvas(int width, int height)
: base_layer_size_(width, height), current_layer_(0) {
state_stack_.emplace_back(DlRect::MakeXYWH(0, 0, width, height), DlMatrix());
}
MockCanvas::~MockCanvas() {
EXPECT_EQ(current_layer_, 0);
}
DlISize MockCanvas::GetBaseLayerDimensions() const {
return base_layer_size_;
}
SkImageInfo MockCanvas::GetImageInfo() const {
return SkImageInfo::MakeUnknown(base_layer_size_.width,
base_layer_size_.height);
}
void MockCanvas::Save() {
draw_calls_.emplace_back(
DrawCall{current_layer_, SaveData{current_layer_ + 1}});
state_stack_.emplace_back(state_stack_.back());
current_layer_++; // Must go here; func params order of eval is undefined
}
void MockCanvas::SaveLayer(std::optional<const DlRect>& bounds,
const DlPaint* paint,
const DlImageFilter* backdrop) {
draw_calls_.emplace_back(DrawCall{
current_layer_,
SaveLayerData{bounds.has_value() ? ToSkRect(bounds.value()) : SkRect(),
paint ? *paint : DlPaint(),
backdrop ? backdrop->shared() : nullptr,
current_layer_ + 1}});
state_stack_.emplace_back(state_stack_.back());
current_layer_++; // Must go here; func params order of eval is undefined
}
void MockCanvas::Restore() {
FML_DCHECK(current_layer_ > 0);
draw_calls_.emplace_back(
DrawCall{current_layer_, RestoreData{current_layer_ - 1}});
state_stack_.pop_back();
current_layer_--; // Must go here; func params order of eval is undefined
}
// clang-format off
// 2x3 2D affine subset of a 4x4 transform in row major order
void MockCanvas::Transform2DAffine(SkScalar mxx, SkScalar mxy, SkScalar mxt,
SkScalar myx, SkScalar myy, SkScalar myt) {
Transform(DlMatrix::MakeRow(mxx, mxy, 0, mxt,
myx, myy, 0, myt,
0, 0, 1, 0,
0, 0, 0, 1));
}
// full 4x4 transform in row major order
void MockCanvas::TransformFullPerspective(
SkScalar mxx, SkScalar mxy, SkScalar mxz, SkScalar mxt,
SkScalar myx, SkScalar myy, SkScalar myz, SkScalar myt,
SkScalar mzx, SkScalar mzy, SkScalar mzz, SkScalar mzt,
SkScalar mwx, SkScalar mwy, SkScalar mwz, SkScalar mwt) {
Transform(DlMatrix::MakeRow(mxx, mxy, mxz, mxt,
myx, myy, myz, myt,
mzx, mzy, mzz, mzt,
mwx, mwy, mwz, mwt));
}
// clang-format on
void MockCanvas::Transform(const DlMatrix& matrix) {
draw_calls_.emplace_back(
DrawCall{current_layer_, ConcatMatrixData{ToSkM44(matrix)}});
state_stack_.back().transform(matrix);
}
void MockCanvas::SetTransform(const DlMatrix& matrix) {
draw_calls_.emplace_back(
DrawCall{current_layer_, SetMatrixData{ToSkM44(matrix)}});
state_stack_.back().setTransform(matrix);
}
void MockCanvas::TransformReset() {
draw_calls_.emplace_back(DrawCall{current_layer_, SetMatrixData{SkM44()}});
state_stack_.back().setIdentity();
}
void MockCanvas::Translate(SkScalar x, SkScalar y) {
this->Transform(DlMatrix::MakeTranslation({x, y, 0}));
}
void MockCanvas::Scale(SkScalar x, SkScalar y) {
this->Transform(DlMatrix::MakeScale({x, y, 1}));
}
void MockCanvas::Rotate(SkScalar degrees) {
this->Transform(DlMatrix::MakeRotationZ(DlDegrees(degrees)));
}
void MockCanvas::Skew(SkScalar sx, SkScalar sy) {
this->Transform(DlMatrix::MakeSkew(sx, sy));
}
DlMatrix MockCanvas::GetMatrix() const {
return state_stack_.back().matrix();
}
void MockCanvas::DrawTextBlob(const sk_sp<SkTextBlob>& text,
SkScalar x,
SkScalar y,
const DlPaint& paint) {
// This duplicates existing logic in SkCanvas::onDrawPicture
// that should probably be split out so it doesn't need to be here as well.
// SkRect storage;
// if (paint.canComputeFastBounds()) {
// storage = text->bounds().makeOffset(x, y);
// SkRect tmp;
// if (this->quickReject(paint.computeFastBounds(storage, &tmp))) {
// return;
// }
// }
draw_calls_.emplace_back(DrawCall{
current_layer_, DrawTextData{text ? text->serialize(SkSerialProcs{})
: SkData::MakeUninitialized(0),
paint, SkPoint::Make(x, y)}});
}
void MockCanvas::DrawTextFrame(
const std::shared_ptr<impeller::TextFrame>& text_frame,
SkScalar x,
SkScalar y,
const DlPaint& paint) {
FML_DCHECK(false);
}
void MockCanvas::DrawRect(const DlRect& rect, const DlPaint& paint) {
draw_calls_.emplace_back(
DrawCall{current_layer_, DrawRectData{ToSkRect(rect), paint}});
}
void MockCanvas::DrawPath(const DlPath& path, const DlPaint& paint) {
draw_calls_.emplace_back(
DrawCall{current_layer_, DrawPathData{path.GetSkPath(), paint}});
}
void MockCanvas::DrawShadow(const DlPath& path,
const DlColor color,
const SkScalar elevation,
bool transparent_occluder,
SkScalar dpr) {
draw_calls_.emplace_back(DrawCall{
current_layer_, DrawShadowData{path.GetSkPath(), color, elevation,
transparent_occluder, dpr}});
}
void MockCanvas::DrawImage(const sk_sp<DlImage>& image,
const DlPoint& point,
const DlImageSampling options,
const DlPaint* paint) {
if (paint) {
draw_calls_.emplace_back(
DrawCall{current_layer_,
DrawImageData{image, point.x, point.y, options, *paint}});
} else {
draw_calls_.emplace_back(
DrawCall{current_layer_,
DrawImageDataNoPaint{image, point.x, point.y, options}});
}
}
void MockCanvas::DrawDisplayList(const sk_sp<DisplayList> display_list,
SkScalar opacity) {
draw_calls_.emplace_back(
DrawCall{current_layer_, DrawDisplayListData{display_list, opacity}});
}
void MockCanvas::ClipRect(const DlRect& rect, ClipOp op, bool is_aa) {
ClipEdgeStyle style = is_aa ? kSoftClipEdgeStyle : kHardClipEdgeStyle;
draw_calls_.emplace_back(
DrawCall{current_layer_, ClipRectData{ToSkRect(rect), op, style}});
state_stack_.back().clipRect(rect, op, is_aa);
}
void MockCanvas::ClipOval(const DlRect& bounds, ClipOp op, bool is_aa) {
ClipEdgeStyle style = is_aa ? kSoftClipEdgeStyle : kHardClipEdgeStyle;
draw_calls_.emplace_back(
DrawCall{current_layer_, ClipOvalData{ToSkRect(bounds), op, style}});
state_stack_.back().clipOval(bounds, op, is_aa);
}
void MockCanvas::ClipRRect(const SkRRect& rrect, ClipOp op, bool is_aa) {
ClipEdgeStyle style = is_aa ? kSoftClipEdgeStyle : kHardClipEdgeStyle;
draw_calls_.emplace_back(
DrawCall{current_layer_, ClipRRectData{rrect, op, style}});
state_stack_.back().clipRRect(rrect, op, is_aa);
}
void MockCanvas::ClipPath(const DlPath& path, ClipOp op, bool is_aa) {
ClipEdgeStyle style = is_aa ? kSoftClipEdgeStyle : kHardClipEdgeStyle;
draw_calls_.emplace_back(
DrawCall{current_layer_, ClipPathData{path.GetSkPath(), op, style}});
state_stack_.back().clipPath(path, op, is_aa);
}
DlRect MockCanvas::GetDestinationClipCoverage() const {
return state_stack_.back().GetDeviceCullCoverage();
}
DlRect MockCanvas::GetLocalClipCoverage() const {
return state_stack_.back().GetLocalCullCoverage();
}
bool MockCanvas::QuickReject(const DlRect& bounds) const {
return state_stack_.back().content_culled(bounds);
}
void MockCanvas::DrawDRRect(const SkRRect&, const SkRRect&, const DlPaint&) {
FML_DCHECK(false);
}
void MockCanvas::DrawPaint(const DlPaint& paint) {
draw_calls_.emplace_back(DrawCall{current_layer_, DrawPaintData{paint}});
}
void MockCanvas::DrawColor(DlColor color, DlBlendMode mode) {
DrawPaint(DlPaint(color).setBlendMode(mode));
}
void MockCanvas::DrawLine(const DlPoint& p0,
const DlPoint& p1,
const DlPaint& paint) {
FML_DCHECK(false);
}
void MockCanvas::DrawDashedLine(const DlPoint& p0,
const DlPoint& p1,
DlScalar on_length,
DlScalar off_length,
const DlPaint& paint) {
FML_DCHECK(false);
}
void MockCanvas::DrawPoints(PointMode,
uint32_t,
const DlPoint[],
const DlPaint&) {
FML_DCHECK(false);
}
void MockCanvas::DrawOval(const DlRect&, const DlPaint&) {
FML_DCHECK(false);
}
void MockCanvas::DrawCircle(const DlPoint& center,
SkScalar radius,
const DlPaint& paint) {
FML_DCHECK(false);
}
void MockCanvas::DrawArc(const DlRect&,
SkScalar,
SkScalar,
bool,
const DlPaint&) {
FML_DCHECK(false);
}
void MockCanvas::DrawRRect(const SkRRect&, const DlPaint&) {
FML_DCHECK(false);
}
void MockCanvas::DrawImageRect(const sk_sp<DlImage>&,
const DlRect&,
const DlRect&,
const DlImageSampling,
const DlPaint*,
SrcRectConstraint constraint) {
FML_DCHECK(false);
}
void MockCanvas::DrawImageNine(const sk_sp<DlImage>& image,
const DlIRect& center,
const DlRect& dst,
DlFilterMode filter,
const DlPaint* paint) {
FML_DCHECK(false);
}
void MockCanvas::DrawVertices(const std::shared_ptr<DlVertices>&,
DlBlendMode,
const DlPaint&) {
FML_DCHECK(false);
}
void MockCanvas::DrawAtlas(const sk_sp<DlImage>&,
const SkRSXform[],
const DlRect[],
const DlColor[],
int,
DlBlendMode,
const DlImageSampling,
const DlRect*,
const DlPaint*) {
FML_DCHECK(false);
}
void MockCanvas::Flush() {
FML_DCHECK(false);
}
// --------------------------------------------------------
// A few ostream operators duplicated from assertions_skia.cc
// In the short term, there are issues trying to include that file
// here because it appears in a skia-targeted testing source set
// and in the long term, DlCanvas, and therefore this file will
// eventually be cleaned of these SkObject dependencies and these
// ostream operators will be converted to their DL equivalents.
static std::ostream& operator<<(std::ostream& os, const SkPoint& r) {
return os << "XY: " << r.fX << ", " << r.fY;
}
static std::ostream& operator<<(std::ostream& os, const SkRect& r) {
return os << "LTRB: " << r.fLeft << ", " << r.fTop << ", " << r.fRight << ", "
<< r.fBottom;
}
static std::ostream& operator<<(std::ostream& os, const SkRRect& r) {
return os << "LTRB: " << r.rect().fLeft << ", " << r.rect().fTop << ", "
<< r.rect().fRight << ", " << r.rect().fBottom;
}
static std::ostream& operator<<(std::ostream& os, const SkPath& r) {
return os << "Valid: " << r.isValid()
<< ", FillType: " << static_cast<int>(r.getFillType())
<< ", Bounds: " << r.getBounds();
}
// --------------------------------------------------------
static std::ostream& operator<<(std::ostream& os, const SkM44& m) {
os << m.rc(0, 0) << ", " << m.rc(0, 1) << ", " << m.rc(0, 2) << ", "
<< m.rc(0, 3) << std::endl;
os << m.rc(1, 0) << ", " << m.rc(1, 1) << ", " << m.rc(1, 2) << ", "
<< m.rc(1, 3) << std::endl;
os << m.rc(2, 0) << ", " << m.rc(2, 1) << ", " << m.rc(2, 2) << ", "
<< m.rc(2, 3) << std::endl;
os << m.rc(3, 0) << ", " << m.rc(3, 1) << ", " << m.rc(3, 2) << ", "
<< m.rc(3, 3);
return os;
}
bool operator==(const MockCanvas::SaveData& a, const MockCanvas::SaveData& b) {
return a.save_to_layer == b.save_to_layer;
}
std::ostream& operator<<(std::ostream& os, const MockCanvas::SaveData& data) {
return os << data.save_to_layer;
}
bool operator==(const MockCanvas::SaveLayerData& a,
const MockCanvas::SaveLayerData& b) {
return a.save_bounds == b.save_bounds && a.restore_paint == b.restore_paint &&
Equals(a.backdrop_filter, b.backdrop_filter) &&
a.save_to_layer == b.save_to_layer;
}
std::ostream& operator<<(std::ostream& os,
const MockCanvas::SaveLayerData& data) {
return os << data.save_bounds << " " << data.restore_paint << " "
<< data.backdrop_filter << " " << data.save_to_layer;
}
bool operator==(const MockCanvas::RestoreData& a,
const MockCanvas::RestoreData& b) {
return a.restore_to_layer == b.restore_to_layer;
}
std::ostream& operator<<(std::ostream& os,
const MockCanvas::RestoreData& data) {
return os << data.restore_to_layer;
}
bool operator==(const MockCanvas::ConcatMatrixData& a,
const MockCanvas::ConcatMatrixData& b) {
return a.matrix == b.matrix;
}
std::ostream& operator<<(std::ostream& os,
const MockCanvas::ConcatMatrixData& data) {
return os << data.matrix;
}
bool operator==(const MockCanvas::SetMatrixData& a,
const MockCanvas::SetMatrixData& b) {
return a.matrix == b.matrix;
}
std::ostream& operator<<(std::ostream& os,
const MockCanvas::SetMatrixData& data) {
return os << data.matrix;
}
bool operator==(const MockCanvas::DrawRectData& a,
const MockCanvas::DrawRectData& b) {
return a.rect == b.rect && a.paint == b.paint;
}
std::ostream& operator<<(std::ostream& os,
const MockCanvas::DrawRectData& data) {
return os << data.rect << " " << data.paint;
}
bool operator==(const MockCanvas::DrawPathData& a,
const MockCanvas::DrawPathData& b) {
return a.path == b.path && a.paint == b.paint;
}
std::ostream& operator<<(std::ostream& os,
const MockCanvas::DrawPathData& data) {
return os << data.path << " " << data.paint;
}
bool operator==(const MockCanvas::DrawTextData& a,
const MockCanvas::DrawTextData& b) {
return a.serialized_text->equals(b.serialized_text.get()) &&
a.paint == b.paint && a.offset == b.offset;
}
std::ostream& operator<<(std::ostream& os,
const MockCanvas::DrawTextData& data) {
return os << data.serialized_text << " " << data.paint << " " << data.offset;
}
bool operator==(const MockCanvas::DrawImageData& a,
const MockCanvas::DrawImageData& b) {
return a.image == b.image && a.x == b.x && a.y == b.y &&
a.options == b.options && a.paint == b.paint;
}
std::ostream& operator<<(std::ostream& os,
const MockCanvas::DrawImageData& data) {
return os << data.image << " " << data.x << " " << data.y << " "
<< data.options << " " << data.paint;
}
bool operator==(const MockCanvas::DrawImageDataNoPaint& a,
const MockCanvas::DrawImageDataNoPaint& b) {
return a.image == b.image && a.x == b.x && a.y == b.y &&
a.options == b.options;
}
std::ostream& operator<<(std::ostream& os,
const MockCanvas::DrawImageDataNoPaint& data) {
return os << data.image << " " << data.x << " " << data.y << " "
<< data.options;
}
bool operator==(const MockCanvas::DrawDisplayListData& a,
const MockCanvas::DrawDisplayListData& b) {
return a.display_list->Equals(b.display_list) && a.opacity == b.opacity;
}
std::ostream& operator<<(std::ostream& os,
const MockCanvas::DrawDisplayListData& data) {
auto dl = data.display_list;
return os << "[" << dl->unique_id() << " " << dl->op_count() << " "
<< dl->bytes() << "] " << data.opacity;
}
bool operator==(const MockCanvas::DrawShadowData& a,
const MockCanvas::DrawShadowData& b) {
return a.path == b.path && a.color == b.color && a.elevation == b.elevation &&
a.transparent_occluder == b.transparent_occluder && a.dpr == b.dpr;
}
std::ostream& operator<<(std::ostream& os,
const MockCanvas::DrawShadowData& data) {
return os << data.path << " " << data.color << " " << data.elevation << " "
<< data.transparent_occluder << " " << data.dpr;
}
bool operator==(const MockCanvas::ClipRectData& a,
const MockCanvas::ClipRectData& b) {
return a.rect == b.rect && a.clip_op == b.clip_op && a.style == b.style;
}
static std::ostream& operator<<(std::ostream& os,
const MockCanvas::ClipEdgeStyle& style) {
return os << (style == MockCanvas::kSoftClipEdgeStyle ? "kSoftEdges"
: "kHardEdges");
}
std::ostream& operator<<(std::ostream& os,
const MockCanvas::ClipRectData& data) {
return os << data.rect << " " << data.clip_op << " " << data.style;
}
bool operator==(const MockCanvas::ClipOvalData& a,
const MockCanvas::ClipOvalData& b) {
return a.bounds == b.bounds && a.clip_op == b.clip_op && a.style == b.style;
}
std::ostream& operator<<(std::ostream& os,
const MockCanvas::ClipOvalData& data) {
return os << data.bounds << " " << data.clip_op << " " << data.style;
}
bool operator==(const MockCanvas::ClipRRectData& a,
const MockCanvas::ClipRRectData& b) {
return a.rrect == b.rrect && a.clip_op == b.clip_op && a.style == b.style;
}
std::ostream& operator<<(std::ostream& os,
const MockCanvas::ClipRRectData& data) {
return os << data.rrect << " " << data.clip_op << " " << data.style;
}
bool operator==(const MockCanvas::ClipPathData& a,
const MockCanvas::ClipPathData& b) {
return a.path == b.path && a.clip_op == b.clip_op && a.style == b.style;
}
std::ostream& operator<<(std::ostream& os,
const MockCanvas::ClipPathData& data) {
return os << data.path << " " << data.clip_op << " " << data.style;
}
std::ostream& operator<<(std::ostream& os,
const MockCanvas::DrawCallData& data) {
std::visit([&os](auto& d) { os << d; }, data);
return os;
}
bool operator==(const MockCanvas::DrawCall& a, const MockCanvas::DrawCall& b) {
return a.layer == b.layer && a.data == b.data;
}
std::ostream& operator<<(std::ostream& os, const MockCanvas::DrawCall& draw) {
return os << "[Layer: " << draw.layer << ", Data: " << draw.data << "]";
}
bool operator==(const MockCanvas::DrawPaintData& a,
const MockCanvas::DrawPaintData& b) {
return a.paint == b.paint;
}
std::ostream& operator<<(std::ostream& os,
const MockCanvas::DrawPaintData& data) {
return os << data.paint;
}
} // namespace testing
} // namespace flutter

378
engine/src/flutter/testing/mock_canvas.h
View File

@ -1,378 +0,0 @@
// Copyright 2013 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef FLUTTER_TESTING_MOCK_CANVAS_H_
#define FLUTTER_TESTING_MOCK_CANVAS_H_
#include <ostream>
#include <variant>
#include <vector>
#include "flutter/display_list/dl_canvas.h"
#include "flutter/display_list/utils/dl_matrix_clip_tracker.h"
#include "gtest/gtest.h"
#include "third_party/skia/include/core/SkCanvas.h"
#include "third_party/skia/include/core/SkCanvasVirtualEnforcer.h"
#include "third_party/skia/include/core/SkClipOp.h"
#include "third_party/skia/include/core/SkData.h"
#include "third_party/skia/include/core/SkImage.h"
#include "third_party/skia/include/core/SkImageFilter.h"
#include "third_party/skia/include/core/SkM44.h"
#include "third_party/skia/include/core/SkPath.h"
#include "third_party/skia/include/core/SkRRect.h"
#include "third_party/skia/include/core/SkRect.h"
#include "third_party/skia/include/utils/SkNWayCanvas.h"
namespace flutter {
namespace testing {
static constexpr SkRect kEmptyRect = SkRect::MakeEmpty();
// Mock |SkCanvas|, useful for writing tests that use Skia but do not interact
// with the GPU.
//
// The |MockCanvas| stores a list of |DrawCall| that the test can later verify
// against the expected list of primitives to be drawn.
class MockCanvas final : public DlCanvas {
public:
enum ClipEdgeStyle {
kHardClipEdgeStyle,
kSoftClipEdgeStyle,
};
struct SaveData {
int save_to_layer;
};
struct SaveLayerData {
SkRect save_bounds;
DlPaint restore_paint;
std::shared_ptr<DlImageFilter> backdrop_filter;
int save_to_layer;
};
struct RestoreData {
int restore_to_layer;
};
struct ConcatMatrixData {
SkM44 matrix;
};
struct SetMatrixData {
SkM44 matrix;
};
struct DrawRectData {
SkRect rect;
DlPaint paint;
};
struct DrawPathData {
SkPath path;
DlPaint paint;
};
struct DrawTextData {
sk_sp<SkData> serialized_text;
DlPaint paint;
SkPoint offset;
};
struct DrawImageDataNoPaint {
sk_sp<DlImage> image;
DlScalar x;
DlScalar y;
DlImageSampling options;
};
struct DrawImageData {
sk_sp<DlImage> image;
DlScalar x;
DlScalar y;
DlImageSampling options;
DlPaint paint;
};
struct DrawDisplayListData {
sk_sp<DisplayList> display_list;
DlScalar opacity;
};
struct DrawShadowData {
SkPath path;
DlColor color;
DlScalar elevation;
bool transparent_occluder;
DlScalar dpr;
};
struct ClipRectData {
SkRect rect;
ClipOp clip_op;
ClipEdgeStyle style;
};
struct ClipOvalData {
SkRect bounds;
ClipOp clip_op;
ClipEdgeStyle style;
};
struct ClipRRectData {
SkRRect rrect;
ClipOp clip_op;
ClipEdgeStyle style;
};
struct ClipPathData {
SkPath path;
ClipOp clip_op;
ClipEdgeStyle style;
};
struct DrawPaintData {
DlPaint paint;
};
// Discriminated union of all the different |DrawCall| types. It is roughly
// equivalent to the different methods in |SkCanvas|' public API.
using DrawCallData = std::variant<SaveData,
SaveLayerData,
RestoreData,
ConcatMatrixData,
SetMatrixData,
DrawRectData,
DrawPathData,
DrawTextData,
DrawImageDataNoPaint,
DrawImageData,
DrawDisplayListData,
DrawShadowData,
ClipRectData,
ClipOvalData,
ClipRRectData,
ClipPathData,
DrawPaintData>;
// A single call made against this canvas.
struct DrawCall {
int layer;
DrawCallData data;
};
MockCanvas();
MockCanvas(int width, int height);
~MockCanvas();
const std::vector<DrawCall>& draw_calls() const { return draw_calls_; }
void reset_draw_calls() { draw_calls_.clear(); }
DlISize GetBaseLayerDimensions() const override;
SkImageInfo GetImageInfo() const override;
void Save() override;
void SaveLayer(std::optional<const DlRect>& bounds,
const DlPaint* paint = nullptr,
const DlImageFilter* backdrop = nullptr) override;
void Restore() override;
int GetSaveCount() const { return current_layer_; }
void RestoreToCount(int restore_count) {
while (current_layer_ > restore_count) {
Restore();
}
}
// clang-format off
// 2x3 2D affine subset of a 4x4 transform in row major order
void Transform2DAffine(DlScalar mxx, DlScalar mxy, DlScalar mxt,
DlScalar myx, DlScalar myy, DlScalar myt) override;
// full 4x4 transform in row major order
void TransformFullPerspective(
DlScalar mxx, DlScalar mxy, DlScalar mxz, DlScalar mxt,
DlScalar myx, DlScalar myy, DlScalar myz, DlScalar myt,
DlScalar mzx, DlScalar mzy, DlScalar mzz, DlScalar mzt,
DlScalar mwx, DlScalar mwy, DlScalar mwz, DlScalar mwt) override;
// clang-format on
void Translate(DlScalar tx, DlScalar ty) override;
void Scale(DlScalar sx, DlScalar sy) override;
void Rotate(DlScalar degrees) override;
void Skew(DlScalar sx, DlScalar sy) override;
void TransformReset() override;
void Transform(const DlMatrix& matrix) override;
void SetTransform(const DlMatrix& matrix) override;
DlMatrix GetMatrix() const override;
void ClipRect(const DlRect& rect, ClipOp clip_op, bool is_aa) override;
void ClipOval(const DlRect& bounds, ClipOp clip_op, bool is_aa) override;
void ClipRRect(const SkRRect& rrect, ClipOp clip_op, bool is_aa) override;
void ClipPath(const DlPath& path, ClipOp clip_op, bool is_aa) override;
DlRect GetDestinationClipCoverage() const override;
DlRect GetLocalClipCoverage() const override;
bool QuickReject(const DlRect& bounds) const override;
void DrawPaint(const DlPaint& paint) override;
void DrawColor(DlColor color, DlBlendMode mode) override;
void DrawLine(const DlPoint& p0,
const DlPoint& p1,
const DlPaint& paint) override;
void DrawDashedLine(const DlPoint& p0,
const DlPoint& p1,
DlScalar on_length,
DlScalar off_length,
const DlPaint& paint) override;
void DrawRect(const DlRect& rect, const DlPaint& paint) override;
void DrawOval(const DlRect& bounds, const DlPaint& paint) override;
void DrawCircle(const DlPoint& center,
DlScalar radius,
const DlPaint& paint) override;
void DrawRRect(const SkRRect& rrect, const DlPaint& paint) override;
void DrawDRRect(const SkRRect& outer,
const SkRRect& inner,
const DlPaint& paint) override;
void DrawPath(const DlPath& path, const DlPaint& paint) override;
void DrawArc(const DlRect& bounds,
DlScalar start,
DlScalar sweep,
bool useCenter,
const DlPaint& paint) override;
void DrawPoints(PointMode mode,
uint32_t count,
const DlPoint pts[],
const DlPaint& paint) override;
void DrawVertices(const std::shared_ptr<DlVertices>& vertices,
DlBlendMode mode,
const DlPaint& paint) override;
void DrawImage(const sk_sp<DlImage>& image,
const DlPoint& point,
DlImageSampling sampling,
const DlPaint* paint = nullptr) override;
void DrawImageRect(
const sk_sp<DlImage>& image,
const DlRect& src,
const DlRect& dst,
DlImageSampling sampling,
const DlPaint* paint = nullptr,
SrcRectConstraint constraint = SrcRectConstraint::kFast) override;
void DrawImageNine(const sk_sp<DlImage>& image,
const DlIRect& center,
const DlRect& dst,
DlFilterMode filter,
const DlPaint* paint = nullptr) override;
void DrawAtlas(const sk_sp<DlImage>& atlas,
const SkRSXform xform[],
const DlRect tex[],
const DlColor colors[],
int count,
DlBlendMode mode,
DlImageSampling sampling,
const DlRect* cullRect,
const DlPaint* paint = nullptr) override;
void DrawDisplayList(const sk_sp<DisplayList> display_list,
DlScalar opacity) override;
void DrawTextBlob(const sk_sp<SkTextBlob>& blob,
DlScalar x,
DlScalar y,
const DlPaint& paint) override;
void DrawTextFrame(const std::shared_ptr<impeller::TextFrame>& text_frame,
DlScalar x,
DlScalar y,
const DlPaint& paint) override;
void DrawShadow(const DlPath& path,
const DlColor color,
const DlScalar elevation,
bool transparent_occluder,
DlScalar dpr) override;
void Flush() override;
ENABLE_DL_CANVAS_BACKWARDS_COMPATIBILITY
private:
DlISize base_layer_size_;
std::vector<DisplayListMatrixClipState> state_stack_;
std::vector<DrawCall> draw_calls_;
int current_layer_;
};
extern bool operator==(const MockCanvas::SaveData& a,
const MockCanvas::SaveData& b);
extern std::ostream& operator<<(std::ostream& os,
const MockCanvas::SaveData& data);
extern bool operator==(const MockCanvas::SaveLayerData& a,
const MockCanvas::SaveLayerData& b);
extern std::ostream& operator<<(std::ostream& os,
const MockCanvas::SaveLayerData& data);
extern bool operator==(const MockCanvas::RestoreData& a,
const MockCanvas::RestoreData& b);
extern std::ostream& operator<<(std::ostream& os,
const MockCanvas::RestoreData& data);
extern bool operator==(const MockCanvas::ConcatMatrixData& a,
const MockCanvas::ConcatMatrixData& b);
extern std::ostream& operator<<(std::ostream& os,
const MockCanvas::ConcatMatrixData& data);
extern bool operator==(const MockCanvas::SetMatrixData& a,
const MockCanvas::SetMatrixData& b);
extern std::ostream& operator<<(std::ostream& os,
const MockCanvas::SetMatrixData& data);
extern bool operator==(const MockCanvas::DrawRectData& a,
const MockCanvas::DrawRectData& b);
extern std::ostream& operator<<(std::ostream& os,
const MockCanvas::DrawRectData& data);
extern bool operator==(const MockCanvas::DrawPathData& a,
const MockCanvas::DrawPathData& b);
extern std::ostream& operator<<(std::ostream& os,
const MockCanvas::DrawPathData& data);
extern bool operator==(const MockCanvas::DrawTextData& a,
const MockCanvas::DrawTextData& b);
extern std::ostream& operator<<(std::ostream& os,
const MockCanvas::DrawTextData& data);
extern bool operator==(const MockCanvas::DrawImageData& a,
const MockCanvas::DrawImageData& b);
extern std::ostream& operator<<(std::ostream& os,
const MockCanvas::DrawImageData& data);
extern bool operator==(const MockCanvas::DrawImageDataNoPaint& a,
const MockCanvas::DrawImageDataNoPaint& b);
extern std::ostream& operator<<(std::ostream& os,
const MockCanvas::DrawImageDataNoPaint& data);
extern bool operator==(const MockCanvas::DrawDisplayListData& a,
const MockCanvas::DrawDisplayListData& b);
extern std::ostream& operator<<(std::ostream& os,
const MockCanvas::DrawDisplayListData& data);
extern bool operator==(const MockCanvas::DrawShadowData& a,
const MockCanvas::DrawShadowData& b);
extern std::ostream& operator<<(std::ostream& os,
const MockCanvas::DrawShadowData& data);
extern bool operator==(const MockCanvas::ClipRectData& a,
const MockCanvas::ClipRectData& b);
extern std::ostream& operator<<(std::ostream& os,
const MockCanvas::ClipRectData& data);
extern bool operator==(const MockCanvas::ClipRRectData& a,
const MockCanvas::ClipRRectData& b);
extern std::ostream& operator<<(std::ostream& os,
const MockCanvas::ClipRRectData& data);
extern bool operator==(const MockCanvas::ClipPathData& a,
const MockCanvas::ClipPathData& b);
extern std::ostream& operator<<(std::ostream& os,
const MockCanvas::ClipPathData& data);
extern std::ostream& operator<<(std::ostream& os,
const MockCanvas::DrawCallData& data);
extern bool operator==(const MockCanvas::DrawCall& a,
const MockCanvas::DrawCall& b);
extern std::ostream& operator<<(std::ostream& os,
const MockCanvas::DrawCall& draw);
extern bool operator==(const MockCanvas::DrawPaintData& a,
const MockCanvas::DrawPaintData& b);
extern std::ostream& operator<<(std::ostream& os,
const MockCanvas::DrawPaintData& data);
} // namespace testing
} // namespace flutter
#endif // FLUTTER_TESTING_MOCK_CANVAS_H_

32
engine/src/flutter/testing/mock_canvas_unittests.cc
View File

@ -1,32 +0,0 @@
// Copyright 2013 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "flutter/testing/mock_canvas.h"
#include "flutter/testing/canvas_test.h"
#include "gtest/gtest.h"
namespace flutter {
namespace testing {
using MockCanvasTest = CanvasTest;
#ifndef NDEBUG
TEST_F(MockCanvasTest, DrawRRectDies) {
EXPECT_DEATH_IF_SUPPORTED(mock_canvas().DrawRRect(SkRRect(), DlPaint()), "");
}
#endif
TEST_F(MockCanvasTest, DrawCalls) {
const SkRect rect = SkRect::MakeWH(5.0f, 5.0f);
const DlPaint paint = DlPaint(DlColor::kGreen());
const auto expected_draw_calls = std::vector{
MockCanvas::DrawCall{0, MockCanvas::DrawRectData{rect, paint}}};
mock_canvas().DrawRect(rect, paint);
EXPECT_EQ(mock_canvas().draw_calls(), expected_draw_calls);
}
} // namespace testing
} // namespace flutter

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

@ -430,7 +430,6 @@ def run_cc_tests(build_dir, executable_filter, coverage, capture_core_dump):
make_test('fml_arc_unittests'),
make_test('no_dart_plugin_registrant_unittests'),
make_test('runtime_unittests'),
make_test('testing_unittests'),
make_test('tonic_unittests'),
# The image release unit test can take a while on slow machines.
make_test('ui_unittests', flags=repeat_flags + ['--timeout=90']),