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

[DisplayList] Delete all legacy Skia-oriented method overloads in DlCanvas (#164054)

Browse Source 
Delete remaining DlCanvas method overloads that were allowing the use of
Skia geometry objects in rendering code.

The only remaining uses of Skia classes in the DlCanvas interface are
SkImageInfo and SkTextBlob.
This commit is contained in:
Jim Graham 2025-02-25 16:44:27 -08:00 committed by GitHub
parent 7d56be4c8d
commit f825cccda2
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
57 changed files with 347 additions and 637 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
engine/src/flutter/common/graphics/texture.h
View File

@ -10,8 +10,6 @@
#include "flutter/display_list/dl_canvas.h"
#include "flutter/fml/macros.h"
#include "flutter/fml/synchronization/waitable_event.h"
#include "third_party/skia/include/core/SkCanvas.h"
#include "third_party/skia/include/core/SkSamplingOptions.h"
class GrDirectContext;
@ -50,7 +48,7 @@ class Texture : public ContextListener {
// Called from raster thread.
virtual void Paint(PaintContext& context,
const SkRect& bounds,
const DlRect& bounds,
bool freeze,
const DlImageSampling sampling) = 0;

6
engine/src/flutter/display_list/dl_builder.cc
View File

@ -1077,9 +1077,9 @@ void DisplayListBuilder::ClipPath(const DlPath& path,
ClipOval(rect, clip_op, is_aa);
return;
}
SkRRect rrect;
if (path.IsSkRRect(&rrect)) {
ClipRRect(rrect, clip_op, is_aa);
DlRoundRect rrect;
if (path.IsRoundRect(&rrect)) {
ClipRoundRect(rrect, clip_op, is_aa);
return;
}
}

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

@ -41,10 +41,6 @@ class DisplayListBuilder final : public virtual DlCanvas,
DisplayListBuilder(DlScalar width, DlScalar height)
: DisplayListBuilder(DlRect::MakeWH(width, height)) {}
explicit DisplayListBuilder(const SkRect& cull_rect,
bool prepare_rtree = false)
: DisplayListBuilder(ToDlRect(cull_rect), prepare_rtree) {}
~DisplayListBuilder();
// |DlCanvas|
@ -208,6 +204,9 @@ class DisplayListBuilder final : public virtual DlCanvas,
DlImageSampling sampling,
const DlPaint* paint = nullptr,
DlSrcRectConstraint constraint = DlSrcRectConstraint::kFast) override;
// include overloads from the virtual base class
using DlCanvas::DrawImageRect;
// |DlCanvas|
void DrawImageNine(const sk_sp<DlImage>& image,
const DlIRect& center,
@ -254,8 +253,6 @@ class DisplayListBuilder final : public virtual DlCanvas,
sk_sp<DisplayList> Build();
ENABLE_DL_CANVAS_BACKWARDS_COMPATIBILITY
private:
void Init(bool prepare_rtree);

202
engine/src/flutter/display_list/dl_canvas.h
View File

@ -14,11 +14,6 @@
#include "flutter/display_list/geometry/dl_path.h"
#include "flutter/display_list/image/dl_image.h"
#include "third_party/skia/include/core/SkM44.h"
#include "third_party/skia/include/core/SkMatrix.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/core/SkTextBlob.h"
#include "impeller/typographer/text_frame.h"
@ -215,203 +210,6 @@ class DlCanvas {
float elevation,
DlScalar dpr,
const DlMatrix& ctm);
// -----------------------------------------------------------------
// SkObject Compatibility section - deprecated...
// -----------------------------------------------------------------
SkISize GetBaseLayerSize() const {
return ToSkISize(GetBaseLayerDimensions());
}
void SaveLayer(const SkRect* bounds,
const DlPaint* paint = nullptr,
const DlImageFilter* backdrop = nullptr,
std::optional<int64_t> backdrop_id = std::nullopt) {
SaveLayer(ToOptDlRect(bounds), paint, backdrop, backdrop_id);
}
void Transform(const SkMatrix& matrix) { Transform(ToDlMatrix(matrix)); }
void Transform(const SkM44& m44) { Transform(ToDlMatrix(m44)); }
void SetTransform(const SkMatrix* matrix) {
if (matrix) {
SetTransform(*matrix);
}
}
void SetTransform(const SkM44* matrix44) {
if (matrix44) {
SetTransform(*matrix44);
}
}
void SetTransform(const SkMatrix& matrix) {
SetTransform(ToDlMatrix(matrix));
}
void SetTransform(const SkM44& m44) { SetTransform(ToDlMatrix(m44)); }
/// Returns the 4x4 full perspective transform representing all transform
/// operations executed so far in this DisplayList within the enclosing
/// save stack.
SkM44 GetTransformFullPerspective() const { return ToSkM44(GetMatrix()); }
/// Returns the 3x3 partial perspective transform representing all transform
/// operations executed so far in this DisplayList within the enclosing
/// save stack.
SkMatrix GetTransform() const { return ToSkMatrix(GetMatrix()); }
void ClipRect(const SkRect& rect,
DlClipOp clip_op = DlClipOp::kIntersect,
bool is_aa = false) {
ClipRect(ToDlRect(rect), clip_op, is_aa);
}
void ClipOval(const SkRect& bounds,
DlClipOp clip_op = DlClipOp::kIntersect,
bool is_aa = false) {
ClipOval(ToDlRect(bounds), clip_op, is_aa);
}
void ClipRRect(const SkRRect& rrect,
DlClipOp clip_op = DlClipOp::kIntersect,
bool is_aa = false) {
ClipRoundRect(ToDlRoundRect(rrect), clip_op, is_aa);
}
void ClipPath(const SkPath& path,
DlClipOp clip_op = DlClipOp::kIntersect,
bool is_aa = false) {
ClipPath(DlPath(path), clip_op, is_aa);
}
SkRect GetDestinationClipBounds() const {
return ToSkRect(GetDestinationClipCoverage());
}
SkRect GetLocalClipBounds() const { return ToSkRect(GetLocalClipCoverage()); }
bool QuickReject(const SkRect& bounds) const {
return QuickReject(ToDlRect(bounds));
}
void DrawLine(const SkPoint& p0, const SkPoint& p1, const DlPaint& paint) {
DrawLine(ToDlPoint(p0), ToDlPoint(p1), paint);
}
void DrawRect(const SkRect& rect, const DlPaint& paint) {
DrawRect(ToDlRect(rect), paint);
}
void DrawOval(const SkRect& bounds, const DlPaint& paint) {
DrawOval(ToDlRect(bounds), paint);
}
void DrawCircle(const SkPoint& center,
DlScalar radius,
const DlPaint& paint) {
DrawCircle(ToDlPoint(center), radius, paint);
}
void DrawRRect(const SkRRect& rrect, const DlPaint& paint) {
DrawRoundRect(ToDlRoundRect(rrect), paint);
}
void DrawDRRect(const SkRRect& outer,
const SkRRect& inner,
const DlPaint& paint) {
DrawDiffRoundRect(ToDlRoundRect(outer), ToDlRoundRect(inner), paint);
}
void DrawPath(const SkPath& path, const DlPaint& paint) {
DrawPath(DlPath(path), paint);
}
void DrawArc(const SkRect& bounds,
DlScalar start,
DlScalar sweep,
bool useCenter,
const DlPaint& paint) {
DrawArc(ToDlRect(bounds), start, sweep, useCenter, paint);
}
void DrawPoints(DlPointMode mode,
uint32_t count,
const SkPoint pts[],
const DlPaint& paint) {
DrawPoints(mode, count, ToDlPoints(pts), paint);
}
void DrawImage(const sk_sp<DlImage>& image,
const SkPoint& point,
DlImageSampling sampling,
const DlPaint* paint = nullptr) {
DrawImage(image, ToDlPoint(point), sampling, paint);
}
void DrawImageRect(
const sk_sp<DlImage>& image,
const SkRect& src,
const SkRect& dst,
DlImageSampling sampling,
const DlPaint* paint = nullptr,
DlSrcRectConstraint constraint = DlSrcRectConstraint::kFast) {
DrawImageRect(image, ToDlRect(src), ToDlRect(dst), sampling, paint,
constraint);
}
void DrawImageRect(
const sk_sp<DlImage>& image,
const SkIRect& src,
const SkRect& dst,
DlImageSampling sampling,
const DlPaint* paint = nullptr,
DlSrcRectConstraint constraint = DlSrcRectConstraint::kFast) {
DrawImageRect(image, ToDlRect(src), ToDlRect(dst), sampling, paint,
constraint);
}
void DrawImageRect(
const sk_sp<DlImage>& image,
const SkRect& dst,
DlImageSampling sampling,
const DlPaint* paint = nullptr,
DlSrcRectConstraint constraint = DlSrcRectConstraint::kFast) {
DrawImageRect(image, image->GetBounds(), ToDlRect(dst), sampling, paint,
constraint);
}
void DrawImageNine(const sk_sp<DlImage>& image,
const SkIRect& center,
const SkRect& dst,
DlFilterMode filter,
const DlPaint* paint = nullptr) {
DrawImageNine(image, ToDlIRect(center), ToDlRect(dst), filter, paint);
}
void DrawShadow(const SkPath& path,
const DlColor color,
const DlScalar elevation,
bool transparent_occluder,
DlScalar dpr) {
DrawShadow(DlPath(path), color, elevation, transparent_occluder, dpr);
}
static SkRect ComputeShadowBounds(const SkPath& path,
float elevation,
DlScalar dpr,
const SkMatrix& ctm) {
return ToSkRect(
ComputeShadowBounds(DlPath(path), elevation, dpr, ToDlMatrix(ctm)));
}
#define ENABLE_DL_CANVAS_BACKWARDS_COMPATIBILITY \
using DlCanvas::GetBaseLayerSize; \
\
using DlCanvas::SaveLayer; \
\
using DlCanvas::Transform; \
using DlCanvas::SetTransform; \
using DlCanvas::GetTransformFullPerspective; \
using DlCanvas::GetTransform; \
\
using DlCanvas::ClipRect; \
using DlCanvas::ClipOval; \
using DlCanvas::ClipPath; \
\
using DlCanvas::GetDestinationClipBounds; \
using DlCanvas::GetLocalClipBounds; \
using DlCanvas::QuickReject; \
\
using DlCanvas::DrawLine; \
using DlCanvas::DrawRect; \
using DlCanvas::DrawOval; \
using DlCanvas::DrawCircle; \
using DlCanvas::DrawPath; \
using DlCanvas::DrawArc; \
using DlCanvas::DrawPoints; \
using DlCanvas::DrawImage; \
using DlCanvas::DrawImageRect; \
using DlCanvas::DrawImageNine; \
using DlCanvas::DrawAtlas; \
using DlCanvas::DrawShadow;
};
class DlAutoCanvasRestore {

2
engine/src/flutter/display_list/skia/dl_sk_canvas.h
View File

@ -165,8 +165,6 @@ class DlSkCanvasAdapter final : public virtual DlCanvas {
void Flush() override;
ENABLE_DL_CANVAS_BACKWARDS_COMPATIBILITY
private:
SkCanvas* delegate_;
};

2
engine/src/flutter/display_list/testing/dl_test_snippets.h
View File

@ -203,7 +203,7 @@ static const std::shared_ptr<DlVertices> kTestVertices2 =
static sk_sp<DisplayList> MakeTestDisplayList(int w, int h, SkColor color) {
DisplayListBuilder builder;
builder.DrawRect(SkRect::MakeWH(w, h), DlPaint(DlColor(color)));
builder.DrawRect(DlRect::MakeWH(w, h), DlPaint(DlColor(color)));
return builder.Build();
}
static sk_sp<DisplayList> TestDisplayList1 =

4
engine/src/flutter/flow/compositor_context.cc
View File

@ -169,10 +169,10 @@ void CompositorContext::ScopedFrame::PaintLayerTreeSkia(
if (needs_save_layer) {
TRACE_EVENT0("flutter", "Canvas::saveLayer");
SkRect bounds = SkRect::Make(ToSkISize(layer_tree.frame_size()));
DlRect bounds = DlRect::MakeSize(layer_tree.frame_size());
DlPaint paint;
paint.setBlendMode(DlBlendMode::kSrc);
canvas()->SaveLayer(&bounds, &paint);
canvas()->SaveLayer(bounds, &paint);
}
canvas()->Clear(DlColor::kTransparent());
}

2
engine/src/flutter/flow/embedded_views.cc
View File

@ -8,7 +8,7 @@ namespace flutter {
DisplayListEmbedderViewSlice::DisplayListEmbedderViewSlice(SkRect view_bounds) {
builder_ = std::make_unique<DisplayListBuilder>(
/*bounds=*/view_bounds,
/*bounds=*/ToDlRect(view_bounds),
/*prepare_rtree=*/true);
}

28
engine/src/flutter/flow/layers/layer_state_stack_unittests.cc
View File

@ -91,41 +91,41 @@ TEST(LayerStateStack, OldDelegateIsRolledBack) {
DisplayListBuilder builder2;
DlCanvas& canvas = builder2;
ASSERT_TRUE(builder.GetTransform().isIdentity());
ASSERT_TRUE(canvas.GetTransform().isIdentity());
ASSERT_TRUE(builder.GetMatrix().IsIdentity());
ASSERT_TRUE(canvas.GetMatrix().IsIdentity());
state_stack.set_delegate(&builder);
ASSERT_TRUE(builder.GetTransform().isIdentity());
ASSERT_TRUE(canvas.GetTransform().isIdentity());
ASSERT_TRUE(builder.GetMatrix().IsIdentity());
ASSERT_TRUE(canvas.GetMatrix().IsIdentity());
auto mutator = state_stack.save();
mutator.translate({10, 10});
ASSERT_EQ(builder.GetTransform(), SkMatrix::Translate(10, 10));
ASSERT_TRUE(canvas.GetTransform().isIdentity());
ASSERT_EQ(builder.GetMatrix(), DlMatrix::MakeTranslation({10, 10}));
ASSERT_TRUE(canvas.GetMatrix().IsIdentity());
state_stack.set_delegate(&canvas);
ASSERT_TRUE(builder.GetTransform().isIdentity());
ASSERT_EQ(canvas.GetTransform(), SkMatrix::Translate(10, 10));
ASSERT_TRUE(builder.GetMatrix().IsIdentity());
ASSERT_EQ(canvas.GetMatrix(), DlMatrix::MakeTranslation({10, 10}));
state_stack.set_preroll_delegate(DlRect::MakeWH(100, 100));
ASSERT_TRUE(builder.GetTransform().isIdentity());
ASSERT_TRUE(canvas.GetTransform().isIdentity());
ASSERT_TRUE(builder.GetMatrix().IsIdentity());
ASSERT_TRUE(canvas.GetMatrix().IsIdentity());
state_stack.set_delegate(&builder);
state_stack.clear_delegate();
ASSERT_TRUE(builder.GetTransform().isIdentity());
ASSERT_TRUE(canvas.GetTransform().isIdentity());
ASSERT_TRUE(builder.GetMatrix().IsIdentity());
ASSERT_TRUE(canvas.GetMatrix().IsIdentity());
state_stack.set_delegate(&canvas);
state_stack.clear_delegate();
ASSERT_TRUE(builder.GetTransform().isIdentity());
ASSERT_TRUE(canvas.GetTransform().isIdentity());
ASSERT_TRUE(builder.GetMatrix().IsIdentity());
ASSERT_TRUE(canvas.GetMatrix().IsIdentity());
}
TEST(LayerStateStack, Opacity) {

2
engine/src/flutter/flow/layers/texture_layer.cc
View File

@ -63,7 +63,7 @@ void TextureLayer::Paint(PaintContext& context) const {
.aiks_context = context.aiks_context,
.paint = context.state_stack.fill(paint),
};
texture->Paint(ctx, ToSkRect(paint_bounds()), freeze_, sampling_);
texture->Paint(ctx, paint_bounds(), freeze_, sampling_);
}
} // namespace flutter

8
engine/src/flutter/flow/paint_utils.cc
View File

@ -13,9 +13,9 @@ namespace flutter {
namespace {
std::shared_ptr<DlColorSource> CreateCheckerboardShader(SkColor c1,
SkColor c2,
int size) {
static std::shared_ptr<DlColorSource> CreateCheckerboardShader(SkColor c1,
SkColor c2,
int size) {
SkBitmap bm;
bm.allocN32Pixels(2 * size, 2 * size);
bm.eraseColor(c1);
@ -29,7 +29,7 @@ std::shared_ptr<DlColorSource> CreateCheckerboardShader(SkColor c1,
} // anonymous namespace
void DrawCheckerboard(DlCanvas* canvas, const SkRect& rect) {
void DrawCheckerboard(DlCanvas* canvas, const DlRect& rect) {
// Draw a checkerboard
canvas->Save();
canvas->ClipRect(rect, DlClipOp::kIntersect, false);

5
engine/src/flutter/flow/paint_utils.h
View File

@ -6,13 +6,10 @@
#define FLUTTER_FLOW_PAINT_UTILS_H_
#include "flutter/display_list/dl_canvas.h"
#include "third_party/skia/include/core/SkCanvas.h"
#include "third_party/skia/include/core/SkColor.h"
#include "third_party/skia/include/core/SkRect.h"
namespace flutter {
void DrawCheckerboard(DlCanvas* canvas, const SkRect& rect);
void DrawCheckerboard(DlCanvas* canvas, const DlRect& rect);
} // namespace flutter

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

@ -40,7 +40,8 @@ void RasterCacheResult::draw(DlCanvas& canvas,
bool preserve_rtree) const {
DlAutoCanvasRestore auto_restore(&canvas, true);
auto matrix = RasterCacheUtil::GetIntegralTransCTM(canvas.GetTransform());
auto matrix =
RasterCacheUtil::GetIntegralTransCTM(ToSkMatrix(canvas.GetMatrix()));
SkRect bounds =
RasterCacheUtil::GetRoundedOutDeviceBounds(logical_rect_, matrix);
FML_DCHECK(std::abs(bounds.width() - image_->dimensions().width()) <= 1 &&
@ -48,7 +49,7 @@ void RasterCacheResult::draw(DlCanvas& canvas,
canvas.TransformReset();
flow_.Step();
if (!preserve_rtree || !rtree_) {
canvas.DrawImage(image_, SkPoint{bounds.fLeft, bounds.fTop},
canvas.DrawImage(image_, DlPoint(bounds.fLeft, bounds.fTop),
DlImageSampling::kNearestNeighbor, paint);
} else {
// On some platforms RTree from overlay layers is used for unobstructed
@ -61,9 +62,9 @@ void RasterCacheResult::draw(DlCanvas& canvas,
SkRect rtree_bounds = RasterCacheUtil::GetRoundedOutDeviceBounds(
ToSkRect(rtree_->bounds()), matrix);
for (auto rect : rects) {
SkRect device_rect = RasterCacheUtil::GetRoundedOutDeviceBounds(
SkRect::Make(ToSkIRect(rect)), matrix);
device_rect.offset(-rtree_bounds.fLeft, -rtree_bounds.fTop);
DlRect device_rect = ToDlRect(RasterCacheUtil::GetRoundedOutDeviceBounds(
SkRect::Make(ToSkIRect(rect)), matrix));
device_rect = device_rect.Shift(-rtree_bounds.fLeft, -rtree_bounds.fTop);
canvas.DrawImageRect(image_, device_rect, device_rect,
DlImageSampling::kNearestNeighbor, paint);
}
@ -80,7 +81,7 @@ std::unique_ptr<RasterCacheResult> RasterCache::Rasterize(
const RasterCache::Context& context,
sk_sp<const DlRTree> rtree,
const std::function<void(DlCanvas*)>& draw_function,
const std::function<void(DlCanvas*, const SkRect& rect)>& draw_checkerboard)
const std::function<void(DlCanvas*, const DlRect& rect)>& draw_checkerboard)
const {
auto matrix = RasterCacheUtil::GetIntegralTransCTM(context.matrix);
SkRect dest_rect =
@ -103,11 +104,11 @@ std::unique_ptr<RasterCacheResult> RasterCache::Rasterize(
canvas.Clear(DlColor::kTransparent());
canvas.Translate(-dest_rect.left(), -dest_rect.top());
canvas.Transform(matrix);
canvas.Transform(ToDlMatrix(matrix));
draw_function(&canvas);
if (checkerboard_images_) {
draw_checkerboard(&canvas, context.logical_rect);
draw_checkerboard(&canvas, ToDlRect(context.logical_rect));
}
auto image = DlImage::Make(surface->makeImageSnapshot());
@ -123,7 +124,7 @@ bool RasterCache::UpdateCacheEntry(
RasterCacheKey key = RasterCacheKey(id, raster_cache_context.matrix);
Entry& entry = cache_[key];
if (!entry.image) {
void (*func)(DlCanvas*, const SkRect& rect) = DrawCheckerboard;
void (*func)(DlCanvas*, const DlRect& rect) = DrawCheckerboard;
entry.image = Rasterize(raster_cache_context, std::move(rtree),
render_function, func);
if (entry.image != nullptr) {
@ -177,7 +178,7 @@ bool RasterCache::Draw(const RasterCacheKeyID& id,
DlCanvas& canvas,
const DlPaint* paint,
bool preserve_rtree) const {
auto it = cache_.find(RasterCacheKey(id, canvas.GetTransform()));
auto it = cache_.find(RasterCacheKey(id, ToSkMatrix(canvas.GetMatrix())));
if (it == cache_.end()) {
return false;
}

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

@ -133,7 +133,7 @@ class RasterCache {
const RasterCache::Context& context,
sk_sp<const DlRTree> rtree,
const std::function<void(DlCanvas*)>& draw_function,
const std::function<void(DlCanvas*, const SkRect& rect)>&
const std::function<void(DlCanvas*, const DlRect& rect)>&
draw_checkerboard) const;
explicit RasterCache(

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

@ -334,7 +334,7 @@ TEST(RasterCache, DeviceRectRoundOutForDisplayList) {
size_t threshold = 1;
flutter::RasterCache cache(threshold);
SkRect logical_rect = SkRect::MakeLTRB(28, 0, 354.56731, 310.288);
DlRect logical_rect = DlRect::MakeLTRB(28, 0, 354.56731, 310.288);
DisplayListBuilder builder(logical_rect);
builder.DrawRect(logical_rect, DlPaint(DlColor::kRed()));
sk_sp<DisplayList> display_list = builder.Build();

3
engine/src/flutter/flow/stopwatch_sk.cc
View File

@ -180,8 +180,7 @@ void SkStopwatchVisualizer::Visualize(DlCanvas* canvas,
// Draw the cached surface onto the output canvas.
auto image = DlImage::Make(visualize_cache_surface_->makeImageSnapshot());
canvas->DrawImage(image, SkPoint{rect.GetX(), rect.GetY()},
DlImageSampling::kNearestNeighbor);
canvas->DrawImage(image, rect.GetOrigin(), DlImageSampling::kNearestNeighbor);
}
} // namespace flutter

4
engine/src/flutter/flow/surface_frame.cc
View File

@ -43,8 +43,8 @@ SurfaceFrame::SurfaceFrame(sk_sp<SkSurface> surface,
// further culling during `DisplayList::Dispatch`. Further, this canvas
// will live underneath any platform views so we do not need to compute
// exact coverage to describe "pixel ownership" to the platform.
dl_builder_ = sk_make_sp<DisplayListBuilder>(SkRect::Make(frame_size),
/*prepare_rtree=*/false);
dl_builder_ = sk_make_sp<DisplayListBuilder>(
DlRect::MakeSize(ToDlISize(frame_size)), /*prepare_rtree=*/false);
canvas_ = dl_builder_.get();
}
}

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

@ -42,8 +42,8 @@ TEST(FlowTest, SurfaceFrameDoesNotHaveEmptyCanvas) {
/*context_result=*/nullptr,
/*display_list_fallback=*/true);
EXPECT_FALSE(frame.Canvas()->GetLocalClipBounds().isEmpty());
EXPECT_FALSE(frame.Canvas()->QuickReject(SkRect::MakeLTRB(10, 10, 50, 50)));
EXPECT_FALSE(frame.Canvas()->GetLocalClipCoverage().IsEmpty());
EXPECT_FALSE(frame.Canvas()->QuickReject(DlRect::MakeLTRB(10, 10, 50, 50)));
}
TEST(FlowTest, SurfaceFrameDoesNotPrepareRtree) {
@ -58,7 +58,7 @@ TEST(FlowTest, SurfaceFrameDoesNotPrepareRtree) {
/*frame_size=*/SkISize::Make(800, 600),
/*context_result=*/nullptr,
/*display_list_fallback=*/true);
surface_frame->Canvas()->DrawRect(SkRect::MakeWH(100, 100), DlPaint());
surface_frame->Canvas()->DrawRect(DlRect::MakeWH(100, 100), DlPaint());
EXPECT_FALSE(surface_frame->BuildDisplayList()->has_rtree());
}

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

@ -40,7 +40,7 @@ template <typename BaseT>
class LayerTestBase : public CanvasTestBase<BaseT> {
using TestT = CanvasTestBase<BaseT>;
const SkRect k_dl_bounds_ = SkRect::MakeWH(500, 500);
const DlRect k_dl_bounds_ = DlRect::MakeWH(500, 500);
public:
LayerTestBase()

6
engine/src/flutter/flow/testing/mock_raster_cache.cc
View File

@ -45,10 +45,8 @@ void MockRasterCache::AddMockLayer(int width, int height) {
void MockRasterCache::AddMockPicture(int width, int height) {
FML_DCHECK(access_threshold() > 0);
SkMatrix ctm = SkMatrix::I();
DisplayListBuilder builder(SkRect::MakeLTRB(0, 0, 200 + width, 200 + height));
SkPath path;
path.addRect(100, 100, 100 + width, 100 + height);
builder.DrawPath(path, DlPaint());
DisplayListBuilder builder(DlRect::MakeLTRB(0, 0, 200 + width, 200 + height));
builder.DrawPath(DlPath::MakeRectXYWH(100, 100, width, height), DlPaint());
sk_sp<DisplayList> display_list = builder.Build();
FixedRefreshRateStopwatch raster_time;

8
engine/src/flutter/flow/testing/mock_texture.cc
View File

@ -33,16 +33,16 @@ MockTexture::MockTexture(int64_t textureId, const sk_sp<DlImage>& texture)
: Texture(textureId), texture_(texture) {}
void MockTexture::Paint(PaintContext& context,
const SkRect& bounds,
const DlRect& bounds,
bool freeze,
const DlImageSampling sampling) {
// MockTexture objects that are not painted are allowed to have a null
// texture, but when we get to this method we must have a non-null texture.
FML_DCHECK(texture_ != nullptr);
SkRect src = SkRect::Make(texture_->bounds());
DlRect src = DlRect::Make(texture_->GetBounds());
if (freeze) {
FML_DCHECK(src.width() > 2.0f && src.height() > 2.0f);
src = src.makeInset(1.0f, 1.0f);
FML_DCHECK(src.GetWidth() > 2.0f && src.GetHeight() > 2.0f);
src = src.Expand(-1.0f, -1.0f);
}
context.canvas->DrawImageRect(texture_, src, bounds, sampling, context.paint);
}

2
engine/src/flutter/flow/testing/mock_texture.h
View File

@ -26,7 +26,7 @@ class MockTexture : public Texture {
// Called from raster thread.
void Paint(PaintContext& context,
const SkRect& bounds,
const DlRect& bounds,
bool freeze,
const DlImageSampling sampling) override;

16
engine/src/flutter/flow/testing/mock_texture_unittests.cc
View File

@ -29,8 +29,8 @@ TEST(MockTextureTest, Callbacks) {
TEST(MockTextureTest, PaintCalls) {
DisplayListBuilder builder;
const SkRect paint_bounds1 = SkRect::MakeWH(1.0f, 1.0f);
const SkRect paint_bounds2 = SkRect::MakeWH(2.0f, 2.0f);
const DlRect paint_bounds1 = DlRect::MakeWH(1.0f, 1.0f);
const DlRect paint_bounds2 = DlRect::MakeWH(2.0f, 2.0f);
const DlImageSampling sampling = DlImageSampling::kNearestNeighbor;
const auto texture_image = MockTexture::MakeTestTexture(20, 20, 5);
auto texture = std::make_shared<MockTexture>(0, texture_image);
@ -41,8 +41,8 @@ TEST(MockTextureTest, PaintCalls) {
texture->Paint(context, paint_bounds1, false, sampling);
texture->Paint(context, paint_bounds2, true, sampling);
SkRect src1 = SkRect::Make(texture_image->bounds());
SkRect src2 = src1.makeInset(1.0, 1.0f);
DlRect src1 = DlRect::Make(texture_image->GetBounds());
DlRect src2 = src1.Expand(-1.0f, -1.0f);
DisplayListBuilder expected_builder;
expected_builder.DrawImageRect(texture_image, src1, paint_bounds1, sampling);
@ -53,8 +53,8 @@ TEST(MockTextureTest, PaintCalls) {
TEST(MockTextureTest, PaintCallsWithLinearSampling) {
DisplayListBuilder builder;
const SkRect paint_bounds1 = SkRect::MakeWH(1.0f, 1.0f);
const SkRect paint_bounds2 = SkRect::MakeWH(2.0f, 2.0f);
const DlRect paint_bounds1 = DlRect::MakeWH(1.0f, 1.0f);
const DlRect paint_bounds2 = DlRect::MakeWH(2.0f, 2.0f);
const auto sampling = DlImageSampling::kLinear;
const auto texture_image = MockTexture::MakeTestTexture(20, 20, 5);
auto texture = std::make_shared<MockTexture>(0, texture_image);
@ -65,8 +65,8 @@ TEST(MockTextureTest, PaintCallsWithLinearSampling) {
texture->Paint(context, paint_bounds1, false, sampling);
texture->Paint(context, paint_bounds2, true, sampling);
SkRect src1 = SkRect::Make(texture_image->bounds());
SkRect src2 = src1.makeInset(1.0, 1.0f);
DlRect src1 = DlRect::Make(texture_image->GetBounds());
DlRect src2 = src1.Expand(-1.0f, -1.0f);
DisplayListBuilder expected_builder;
expected_builder.DrawImageRect(texture_image, src1, paint_bounds1, sampling);

12
engine/src/flutter/flow/view_slicer_unittests.cc
View File

@ -19,12 +19,12 @@ void AddSliceOfSize(
slices[id] = std::make_unique<DisplayListEmbedderViewSlice>(rect);
DlPaint paint;
paint.setColor(DlColor::kBlack());
slices[id]->canvas()->DrawRect(rect, paint);
slices[id]->canvas()->DrawRect(ToDlRect(rect), paint);
}
} // namespace
TEST(ViewSlicerTest, CanSlicerNonOverlappingViews) {
DisplayListBuilder builder(SkRect::MakeLTRB(0, 0, 100, 100));
DisplayListBuilder builder(DlRect::MakeLTRB(0, 0, 100, 100));
std::vector<int64_t> composition_order = {1};
std::unordered_map<int64_t, std::unique_ptr<EmbedderViewSlice>> slices;
@ -40,7 +40,7 @@ TEST(ViewSlicerTest, CanSlicerNonOverlappingViews) {
}
TEST(ViewSlicerTest, IgnoresFractionalOverlaps) {
DisplayListBuilder builder(SkRect::MakeLTRB(0, 0, 100, 100));
DisplayListBuilder builder(DlRect::MakeLTRB(0, 0, 100, 100));
std::vector<int64_t> composition_order = {1};
std::unordered_map<int64_t, std::unique_ptr<EmbedderViewSlice>> slices;
@ -56,7 +56,7 @@ TEST(ViewSlicerTest, IgnoresFractionalOverlaps) {
}
TEST(ViewSlicerTest, ComputesOverlapWith1PV) {
DisplayListBuilder builder(SkRect::MakeLTRB(0, 0, 100, 100));
DisplayListBuilder builder(DlRect::MakeLTRB(0, 0, 100, 100));
std::vector<int64_t> composition_order = {1};
std::unordered_map<int64_t, std::unique_ptr<EmbedderViewSlice>> slices;
@ -76,7 +76,7 @@ TEST(ViewSlicerTest, ComputesOverlapWith1PV) {
}
TEST(ViewSlicerTest, ComputesOverlapWith2PV) {
DisplayListBuilder builder(SkRect::MakeLTRB(0, 0, 100, 100));
DisplayListBuilder builder(DlRect::MakeLTRB(0, 0, 100, 100));
std::vector<int64_t> composition_order = {1, 2};
std::unordered_map<int64_t, std::unique_ptr<EmbedderViewSlice>> slices;
@ -104,7 +104,7 @@ TEST(ViewSlicerTest, ComputesOverlapWith2PV) {
}
TEST(ViewSlicerTest, OverlappingTwoPVs) {
DisplayListBuilder builder(SkRect::MakeLTRB(0, 0, 100, 100));
DisplayListBuilder builder(DlRect::MakeLTRB(0, 0, 100, 100));
std::vector<int64_t> composition_order = {1, 2};
std::unordered_map<int64_t, std::unique_ptr<EmbedderViewSlice>> slices;

26
engine/src/flutter/impeller/display_list/aiks_dl_basic_unittests.cc
View File

@ -339,7 +339,7 @@ TEST_P(AiksTest, CanSaveLayerStandalone) {
DlPaint alpha;
alpha.setColor(DlColor::kRed().modulateOpacity(0.5));
builder.SaveLayer(nullptr, &alpha);
builder.SaveLayer(std::nullopt, &alpha);
builder.DrawCircle(DlPoint(125, 125), 125, red);
@ -972,7 +972,7 @@ TEST_P(AiksTest, SubpassWithClearColorOptimization) {
paint.setColor(DlColor::kBlue());
paint.setBlendMode(DlBlendMode::kDstOver);
builder.SaveLayer(nullptr, &paint);
builder.SaveLayer(std::nullopt, &paint);
builder.Restore();
// This playground should appear blank on CI since we are only drawing
@ -992,7 +992,7 @@ TEST_P(AiksTest, MatrixImageFilterDoesntCullWhenTranslatedFromOffscreen) {
DlMatrix translate = DlMatrix::MakeTranslation({300, 0});
paint.setImageFilter(
DlImageFilter::MakeMatrix(translate, DlImageSampling::kLinear));
builder.SaveLayer(nullptr, &paint);
builder.SaveLayer(std::nullopt, &paint);
DlPaint circle_paint;
circle_paint.setColor(DlColor::kGreen());
@ -1015,7 +1015,7 @@ TEST_P(AiksTest,
paint.setImageFilter(DlImageFilter::MakeMatrix(
DlMatrix::MakeTranslation({300, 0}) * DlMatrix::MakeScale({2, 2, 1}),
DlImageSampling::kNearestNeighbor));
builder.SaveLayer(nullptr, &paint);
builder.SaveLayer(std::nullopt, &paint);
DlPaint circle_paint;
circle_paint.setColor(DlColor::kGreen());
@ -1038,7 +1038,7 @@ TEST_P(AiksTest, ClearColorOptimizationWhenSubpassIsBiggerThanParentPass) {
paint.setImageFilter(DlImageFilter::MakeMatrix(DlMatrix::MakeScale({2, 2, 1}),
DlImageSampling::kLinear));
builder.SaveLayer(nullptr, &paint);
builder.SaveLayer(std::nullopt, &paint);
// Draw a rectangle that would fully cover the parent pass size, but not
// the subpass that it is rendered in.
paint.setColor(DlColor::kGreen());
@ -1061,7 +1061,7 @@ TEST_P(AiksTest, EmptySaveLayerIgnoresPaint) {
builder.DrawPaint(paint);
builder.ClipRect(DlRect::MakeXYWH(100, 100, 200, 200));
paint.setColor(DlColor::kBlue());
builder.SaveLayer(nullptr, &paint);
builder.SaveLayer(std::nullopt, &paint);
builder.Restore();
ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
@ -1076,7 +1076,7 @@ TEST_P(AiksTest, EmptySaveLayerRendersWithClear) {
DlPaint paint;
paint.setBlendMode(DlBlendMode::kClear);
builder.SaveLayer(nullptr, &paint);
builder.SaveLayer(std::nullopt, &paint);
builder.Restore();
ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
@ -1144,7 +1144,7 @@ TEST_P(AiksTest, CoordinateConversionsAreCorrect) {
DlPaint alpha;
alpha.setColor(DlColor::kRed().modulateOpacity(0.5));
builder.SaveLayer(nullptr, &alpha);
builder.SaveLayer(std::nullopt, &alpha);
DlPaint paint;
paint.setColor(DlColor::kRed());
@ -1365,7 +1365,7 @@ TEST_P(AiksTest, SaveLayerDrawsBehindSubsequentEntities) {
builder.Translate(10, 10);
DlPaint save_paint;
builder.SaveLayer(nullptr, &save_paint);
builder.SaveLayer(std::nullopt, &save_paint);
paint.setColor(DlColor::kGreen());
builder.DrawRect(rect, paint);
@ -1453,7 +1453,7 @@ TEST_P(AiksTest, SaveLayerFiltersScaleWithTransform) {
auto texture = DlImageImpeller::Make(CreateTextureForFixture("boston.jpg"));
auto draw_image_layer = [&builder, &texture](const DlPaint& paint) {
builder.SaveLayer(nullptr, &paint);
builder.SaveLayer(std::nullopt, &paint);
builder.DrawImage(texture, DlPoint(), DlImageSampling::kLinear);
builder.Restore();
};
@ -1503,7 +1503,7 @@ TEST_P(AiksTest, PipelineBlendSingleParameter) {
// Should render a green square in the middle of a blue circle.
DlPaint paint;
builder.SaveLayer(nullptr, &paint);
builder.SaveLayer(std::nullopt, &paint);
{
builder.Translate(100, 100);
paint.setColor(DlColor::kBlue());
@ -1535,7 +1535,7 @@ TEST_P(AiksTest, MassiveScalingMatrixImageFilter) {
DlPaint paint;
paint.setImageFilter(filter);
builder.SaveLayer(nullptr, &paint);
builder.SaveLayer(std::nullopt, &paint);
{
DlPaint paint;
paint.setColor(DlColor::kRed());
@ -1614,7 +1614,7 @@ TEST_P(AiksTest, BackdropFilterOverUnclosedClip) {
builder.SaveLayer(std::nullopt, nullptr, image_filter.get());
}
builder.Restore();
builder.DrawCircle(SkPoint{100, 100}, 100,
builder.DrawCircle(DlPoint(100, 100), 100,
DlPaint().setColor(DlColor::kAqua()));
ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));

32
engine/src/flutter/impeller/display_list/aiks_dl_blend_unittests.cc
View File

@ -87,13 +87,13 @@ TEST_P(AiksTest, BlendModeShouldCoverWholeScreen) {
builder.DrawPaint(paint);
paint.setBlendMode(DlBlendMode::kSrcOver);
builder.SaveLayer(nullptr, &paint);
builder.SaveLayer(std::nullopt, &paint);
paint.setColor(DlColor::kWhite());
builder.DrawRect(DlRect::MakeXYWH(100, 100, 400, 400), paint);
paint.setBlendMode(DlBlendMode::kSrc);
builder.SaveLayer(nullptr, &paint);
builder.SaveLayer(std::nullopt, &paint);
paint.setColor(DlColor::kBlue());
builder.DrawRect(DlRect::MakeXYWH(200, 200, 200, 200), paint);
@ -408,7 +408,7 @@ TEST_P(AiksTest, BlendModePlusAlphaWideGamut) {
paint.setColor(DlColor::RGBA(0.9, 1, 0.9, 1.0));
builder.DrawPaint(paint);
builder.SaveLayer(nullptr);
builder.SaveLayer(std::nullopt);
paint.setBlendMode(DlBlendMode::kPlus);
paint.setColor(DlColor::kRed());
@ -444,7 +444,7 @@ TEST_P(AiksTest, BlendModePlusAlphaColorFilterWideGamut) {
DlPaint save_paint;
save_paint.setColorFilter(
DlColorFilter::MakeBlend(DlColor::RGBA(1, 0, 0, 1), DlBlendMode::kPlus));
builder.SaveLayer(nullptr, &save_paint);
builder.SaveLayer(std::nullopt, &save_paint);
paint.setColor(DlColor::kRed());
builder.DrawRect(DlRect::MakeXYWH(100, 100, 400, 400), paint);
@ -469,7 +469,7 @@ TEST_P(AiksTest, ForegroundBlendSubpassCollapseOptimization) {
DlPaint save_paint;
save_paint.setColorFilter(
DlColorFilter::MakeBlend(DlColor::kRed(), DlBlendMode::kColorDodge));
builder.SaveLayer(nullptr, &save_paint);
builder.SaveLayer(std::nullopt, &save_paint);
builder.Translate(500, 300);
builder.Rotate(120);
@ -534,7 +534,7 @@ static sk_sp<DisplayList> BlendModeTest(Vector2 content_scale,
// Perform the blend in a SaveLayer so that the initial backdrop color is
// fully transparent black. SourceOver blend the result onto the parent
// pass.
builder.SaveLayer({});
builder.SaveLayer(std::nullopt);
{
DlPaint draw_paint;
draw_paint.setColor(
@ -546,7 +546,7 @@ static sk_sp<DisplayList> BlendModeTest(Vector2 content_scale,
// pass.
DlPaint save_paint;
save_paint.setBlendMode(static_cast<DlBlendMode>(blend_mode));
builder.SaveLayer(nullptr, &save_paint);
builder.SaveLayer(std::nullopt, &save_paint);
{ //
DlPaint paint;
paint.setColor(
@ -570,7 +570,7 @@ static sk_sp<DisplayList> BlendModeTest(Vector2 content_scale,
builder.Translate(0, 100);
// Perform the blend in a SaveLayer so that the initial backdrop color is
// fully transparent black. SourceOver blend the result onto the parent pass.
builder.SaveLayer({});
builder.SaveLayer(std::nullopt);
for (const auto& color : source_colors) {
// Simply write the CPU blended color to the pass.
DlPaint paint;
@ -612,7 +612,7 @@ static sk_sp<DisplayList> BlendModeTest(Vector2 content_scale,
DlPaint paint;
paint.setBlendMode(DlBlendMode::kSrcOver);
builder.Save();
builder.SaveLayer(nullptr, &paint);
builder.SaveLayer(std::nullopt, &paint);
{
builder.DrawImage(dst_image, DlPoint(0, 0), DlImageSampling::kMipmapLinear,
&paint);
@ -629,7 +629,7 @@ static sk_sp<DisplayList> BlendModeTest(Vector2 content_scale,
builder.Save();
DlPaint save_paint;
builder.SaveLayer(nullptr, &save_paint);
builder.SaveLayer(std::nullopt, &save_paint);
{
builder.DrawImage(dst_image, DlPoint(400, 0),
DlImageSampling::kMipmapLinear, nullptr);
@ -637,7 +637,7 @@ static sk_sp<DisplayList> BlendModeTest(Vector2 content_scale,
DlPaint save_paint;
save_paint.setColor(DlColor::kWhite().withAlpha(src_alpha * 255));
save_paint.setBlendMode(static_cast<DlBlendMode>(blend_mode));
builder.SaveLayer(nullptr, &save_paint);
builder.SaveLayer(std::nullopt, &save_paint);
{
builder.DrawImage(src_image, DlPoint(400, 0),
DlImageSampling::kMipmapLinear, nullptr);
@ -841,13 +841,13 @@ TEST_P(AiksTest, ColorWheel) {
DlPaint paint;
paint.setColor(DlColor::kWhite().withAlpha(dst_alpha * 255));
paint.setBlendMode(DlBlendMode::kSrc);
builder.SaveLayer(nullptr, &paint);
builder.SaveLayer(std::nullopt, &paint);
{
DlPaint paint;
paint.setColor(DlColor::kWhite());
builder.DrawPaint(paint);
builder.SaveLayer(nullptr, nullptr);
builder.SaveLayer(std::nullopt, nullptr);
builder.Scale(GetContentScale().x, GetContentScale().y);
builder.Translate(500, 400);
builder.Scale(3, 3);
@ -865,7 +865,7 @@ TEST_P(AiksTest, ColorWheel) {
save_paint.setColor(DlColor::kWhite().withAlpha(src_alpha * 255));
save_paint.setBlendMode(static_cast<DlBlendMode>(
blend_modes.blend_mode_values[current_blend_index]));
builder.SaveLayer(nullptr, &save_paint);
builder.SaveLayer(std::nullopt, &save_paint);
{
DlPaint paint;
paint.setBlendMode(DlBlendMode::kPlus);
@ -896,7 +896,7 @@ TEST_P(AiksTest, DestructiveBlendColorFilterFloodsClip) {
DlPaint save_paint;
save_paint.setColorFilter(
DlColorFilter::MakeBlend(DlColor::kRed(), DlBlendMode::kSrc));
builder.SaveLayer(nullptr, &save_paint);
builder.SaveLayer(std::nullopt, &save_paint);
builder.Restore();
// Should be solid red as the destructive color filter floods the clip.
@ -912,7 +912,7 @@ TEST_P(AiksTest, AdvancedBlendColorFilterWithDestinationOpacity) {
save_paint.setOpacity(0.3);
save_paint.setColorFilter(DlColorFilter::MakeBlend(DlColor::kTransparent(),
DlBlendMode::kSaturation));
builder.SaveLayer(nullptr, &save_paint);
builder.SaveLayer(std::nullopt, &save_paint);
builder.DrawRect(DlRect::MakeXYWH(100, 100, 300, 300),
DlPaint(DlColor::kMaroon()));
builder.DrawRect(DlRect::MakeXYWH(200, 200, 300, 300),

28
engine/src/flutter/impeller/display_list/aiks_dl_blur_unittests.cc
View File

@ -228,7 +228,7 @@ TEST_P(AiksTest, CanRenderBackdropBlurInteractive) {
save_paint.setBlendMode(DlBlendMode::kSrc);
auto backdrop_filter = DlImageFilter::MakeBlur(20, 20, DlTileMode::kClamp);
builder.SaveLayer(nullptr, &save_paint, backdrop_filter.get());
builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter.get());
builder.Restore();
return builder.Build();
@ -260,7 +260,7 @@ TEST_P(AiksTest, CanRenderBackdropBlur) {
DlPaint save_paint;
save_paint.setBlendMode(DlBlendMode::kSrc);
auto backdrop_filter = DlImageFilter::MakeBlur(30, 30, DlTileMode::kClamp);
builder.SaveLayer(nullptr, &save_paint, backdrop_filter.get());
builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter.get());
builder.Restore();
ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
@ -283,7 +283,7 @@ TEST_P(AiksTest, CanRenderBackdropBlurWithSingleBackdropId) {
DlPaint save_paint;
save_paint.setBlendMode(DlBlendMode::kSrc);
auto backdrop_filter = DlImageFilter::MakeBlur(30, 30, DlTileMode::kClamp);
builder.SaveLayer(nullptr, &save_paint, backdrop_filter.get(),
builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter.get(),
/*backdrop_id=*/1);
builder.Restore();
builder.Restore();
@ -309,7 +309,7 @@ TEST_P(AiksTest, CanRenderMultipleBackdropBlurWithSingleBackdropId) {
DlPaint save_paint;
save_paint.setBlendMode(DlBlendMode::kSrc);
auto backdrop_filter = DlImageFilter::MakeBlur(30, 30, DlTileMode::kClamp);
builder.SaveLayer(nullptr, &save_paint, backdrop_filter.get(),
builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter.get(),
/*backdrop_id=*/1);
builder.Restore();
builder.Restore();
@ -338,7 +338,7 @@ TEST_P(AiksTest,
save_paint.setBlendMode(DlBlendMode::kSrc);
auto backdrop_filter =
DlImageFilter::MakeBlur(30 + i, 30, DlTileMode::kClamp);
builder.SaveLayer(nullptr, &save_paint, backdrop_filter.get(),
builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter.get(),
/*backdrop_id=*/1);
builder.Restore();
builder.Restore();
@ -359,7 +359,7 @@ TEST_P(AiksTest, CanRenderBackdropBlurHugeSigma) {
auto backdrop_filter =
DlImageFilter::MakeBlur(999999, 999999, DlTileMode::kClamp);
builder.SaveLayer(nullptr, &save_paint, backdrop_filter.get());
builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter.get());
builder.Restore();
ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
@ -812,7 +812,7 @@ TEST_P(AiksTest, GaussianBlurAtPeripheryVertical) {
auto backdrop_filter = DlImageFilter::MakeBlur(20, 20, DlTileMode::kClamp);
builder.SaveLayer(nullptr, &save_paint, backdrop_filter.get());
builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter.get());
builder.Restore();
ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
@ -841,7 +841,7 @@ TEST_P(AiksTest, GaussianBlurAtPeripheryHorizontal) {
save_paint.setBlendMode(DlBlendMode::kSrc);
auto backdrop_filter = DlImageFilter::MakeBlur(20, 20, DlTileMode::kClamp);
builder.SaveLayer(nullptr, &save_paint, backdrop_filter.get());
builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter.get());
builder.Restore();
ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
@ -888,7 +888,7 @@ TEST_P(AiksTest, GaussianBlurAnimatedBackdrop) {
auto backdrop_filter =
DlImageFilter::MakeBlur(sigma, sigma, DlTileMode::kClamp);
builder.SaveLayer(nullptr, &paint, backdrop_filter.get());
builder.SaveLayer(std::nullopt, &paint, backdrop_filter.get());
count += 1;
return builder.Build();
};
@ -1106,7 +1106,7 @@ TEST_P(AiksTest, GaussianBlurOneDimension) {
paint.setBlendMode(DlBlendMode::kSrc);
auto backdrop_filter = DlImageFilter::MakeBlur(50, 0, DlTileMode::kClamp);
builder.SaveLayer(nullptr, &paint, backdrop_filter.get());
builder.SaveLayer(std::nullopt, &paint, backdrop_filter.get());
builder.Restore();
ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}
@ -1369,7 +1369,7 @@ TEST_P(AiksTest,
if (i != 0) {
DlPaint paint;
paint.setColor(DlColor::kWhite().withAlphaF(0.95));
builder.SaveLayer(nullptr, &paint);
builder.SaveLayer(std::nullopt, &paint);
}
DlRoundRect rrect = DlRoundRect::MakeRectXY(
DlRect::MakeXYWH(50 + (i * 100), 250, 100, 100), 20, 20);
@ -1379,7 +1379,7 @@ TEST_P(AiksTest,
DlPaint save_paint;
save_paint.setBlendMode(DlBlendMode::kSrc);
auto backdrop_filter = DlImageFilter::MakeBlur(30, 30, DlTileMode::kClamp);
builder.SaveLayer(nullptr, &save_paint, backdrop_filter.get(),
builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter.get(),
/*backdrop_id=*/1);
builder.Restore();
builder.Restore();
@ -1403,12 +1403,12 @@ TEST_P(AiksTest, BlurGradientWithOpacity) {
DlPaint save_paint;
save_paint.setOpacity(0.5);
builder.SaveLayer(nullptr, &save_paint);
builder.SaveLayer(std::nullopt, &save_paint);
DlPaint paint;
paint.setColorSource(gradient);
paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 1));
builder.DrawRect(SkRect::MakeXYWH(100, 100, 200, 200), paint);
builder.DrawRect(DlRect::MakeXYWH(100, 100, 200, 200), paint);
builder.Restore();

4
engine/src/flutter/impeller/display_list/aiks_dl_opacity_unittests.cc
View File

@ -24,7 +24,7 @@ TEST_P(AiksTest, DrawOpacityPeephole) {
DlPaint alpha;
alpha.setColor(DlColor::kRed().modulateOpacity(0.5));
builder.SaveLayer(nullptr, &alpha);
builder.SaveLayer(std::nullopt, &alpha);
builder.DrawRect(DlRect::MakeXYWH(0, 0, 100, 100), green);
builder.Restore();
@ -44,7 +44,7 @@ TEST_P(AiksTest, CanRenderGroupOpacity) {
DlPaint alpha;
alpha.setColor(DlColor::kRed().modulateOpacity(0.5));
builder.SaveLayer(nullptr, &alpha);
builder.SaveLayer(std::nullopt, &alpha);
builder.DrawRect(DlRect::MakeXYWH(0, 0, 100, 100), red);
builder.DrawRect(DlRect::MakeXYWH(200, 200, 100, 100), green);
builder.DrawRect(DlRect::MakeXYWH(400, 400, 100, 100), blue);

4
engine/src/flutter/impeller/display_list/aiks_dl_text_unittests.cc
View File

@ -323,7 +323,7 @@ TEST_P(AiksTest, CanRenderTextInSaveLayer) {
// Blend the layer with the parent pass using kClear to expose the coverage.
paint.setBlendMode(DlBlendMode::kClear);
builder.SaveLayer(nullptr, &paint);
builder.SaveLayer(std::nullopt, &paint);
ASSERT_TRUE(RenderTextInCanvasSkia(
GetContext(), builder, "the quick brown fox jumped over the lazy dog!.?",
"Roboto-Regular.ttf"));
@ -441,7 +441,7 @@ TEST_P(AiksTest, CanRenderTextWithLargePerspectiveTransform) {
DisplayListBuilder builder;
DlPaint save_paint;
builder.SaveLayer(nullptr, &save_paint);
builder.SaveLayer(std::nullopt, &save_paint);
builder.Transform(Matrix(2000, 0, 0, 0, //
0, 2000, 0, 0, //
0, 0, -1, 9000, //

48
engine/src/flutter/impeller/display_list/aiks_dl_unittests.cc
View File

@ -44,7 +44,7 @@ TEST_P(AiksTest, CollapsedDrawPaintInSubpass) {
DlPaint save_paint;
save_paint.setBlendMode(DlBlendMode::kMultiply);
builder.SaveLayer(nullptr, &save_paint);
builder.SaveLayer(std::nullopt, &save_paint);
DlPaint draw_paint;
draw_paint.setColor(DlColor::kCornflowerBlue().modulateOpacity(0.75f));
@ -63,7 +63,7 @@ TEST_P(AiksTest, CollapsedDrawPaintInSubpassBackdropFilter) {
builder.DrawPaint(paint);
auto filter = DlImageFilter::MakeBlur(20.0, 20.0, DlTileMode::kDecal);
builder.SaveLayer(nullptr, nullptr, filter.get());
builder.SaveLayer(std::nullopt, nullptr, filter.get());
DlPaint draw_paint;
draw_paint.setColor(DlColor::kCornflowerBlue());
@ -85,7 +85,7 @@ TEST_P(AiksTest, ColorMatrixFilterSubpassCollapseOptimization) {
DlPaint paint;
paint.setColorFilter(filter);
builder.SaveLayer(nullptr, &paint);
builder.SaveLayer(std::nullopt, &paint);
builder.Translate(500, 300);
builder.Rotate(120); // 120 deg
@ -102,7 +102,7 @@ TEST_P(AiksTest, LinearToSrgbFilterSubpassCollapseOptimization) {
DlPaint paint;
paint.setColorFilter(DlColorFilter::MakeLinearToSrgbGamma());
builder.SaveLayer(nullptr, &paint);
builder.SaveLayer(std::nullopt, &paint);
builder.Translate(500, 300);
builder.Rotate(120); // 120 deg.
@ -119,7 +119,7 @@ TEST_P(AiksTest, SrgbToLinearFilterSubpassCollapseOptimization) {
DlPaint paint;
paint.setColorFilter(DlColorFilter::MakeLinearToSrgbGamma());
builder.SaveLayer(nullptr, &paint);
builder.SaveLayer(std::nullopt, &paint);
builder.Translate(500, 300);
builder.Rotate(120); // 120 deg
@ -140,7 +140,7 @@ TEST_P(AiksTest, TranslucentSaveLayerDrawsCorrectly) {
DlPaint save_paint;
save_paint.setColor(DlColor::kBlack().withAlpha(128));
builder.SaveLayer(nullptr, &save_paint);
builder.SaveLayer(std::nullopt, &save_paint);
builder.DrawRect(DlRect::MakeXYWH(100, 500, 300, 300), paint);
builder.Restore();
@ -160,7 +160,7 @@ TEST_P(AiksTest, TranslucentSaveLayerWithBlendColorFilterDrawsCorrectly) {
DlColorFilter::MakeBlend(DlColor::kRed(), DlBlendMode::kDstOver));
builder.Save();
builder.ClipRect(DlRect::MakeXYWH(100, 500, 300, 300));
builder.SaveLayer(nullptr, &paint);
builder.SaveLayer(std::nullopt, &paint);
DlPaint draw_paint;
draw_paint.setColor(DlColor::kBlue());
@ -183,7 +183,7 @@ TEST_P(AiksTest, TranslucentSaveLayerWithBlendImageFilterDrawsCorrectly) {
save_paint.setImageFilter(DlImageFilter::MakeColorFilter(
DlColorFilter::MakeBlend(DlColor::kRed(), DlBlendMode::kDstOver)));
builder.SaveLayer(nullptr, &save_paint);
builder.SaveLayer(std::nullopt, &save_paint);
DlPaint draw_paint;
draw_paint.setColor(DlColor::kBlue());
@ -206,7 +206,7 @@ TEST_P(AiksTest, TranslucentSaveLayerWithColorAndImageFilterDrawsCorrectly) {
DlColorFilter::MakeBlend(DlColor::kRed(), DlBlendMode::kDstOver));
builder.Save();
builder.ClipRect(DlRect::MakeXYWH(100, 500, 300, 300));
builder.SaveLayer(nullptr, &save_paint);
builder.SaveLayer(std::nullopt, &save_paint);
DlPaint draw_paint;
draw_paint.setColor(DlColor::kBlue());
@ -224,7 +224,7 @@ TEST_P(AiksTest, ImageFilteredUnboundedSaveLayerWithUnboundedContents) {
DlPaint save_paint;
save_paint.setImageFilter(
DlImageFilter::MakeBlur(10.0, 10.0, DlTileMode::kDecal));
builder.SaveLayer(nullptr, &save_paint);
builder.SaveLayer(std::nullopt, &save_paint);
{
// DrawPaint to verify correct behavior when the contents are unbounded.
@ -250,7 +250,7 @@ TEST_P(AiksTest, TranslucentSaveLayerImageDrawsCorrectly) {
DlPaint paint;
paint.setColor(DlColor::kBlack().withAlpha(128));
builder.SaveLayer(nullptr, &paint);
builder.SaveLayer(std::nullopt, &paint);
builder.DrawImage(image, DlPoint(100, 500), DlImageSampling::kMipmapLinear);
builder.Restore();
@ -272,7 +272,7 @@ TEST_P(AiksTest, TranslucentSaveLayerWithColorMatrixColorFilterDrawsCorrectly) {
DlPaint paint;
paint.setColor(DlColor::kBlack().withAlpha(128));
paint.setColorFilter(DlColorFilter::MakeMatrix(matrix));
builder.SaveLayer(nullptr, &paint);
builder.SaveLayer(std::nullopt, &paint);
builder.DrawImage(image, DlPoint(100, 500), {});
builder.Restore();
@ -294,7 +294,7 @@ TEST_P(AiksTest, TranslucentSaveLayerWithColorMatrixImageFilterDrawsCorrectly) {
DlPaint paint;
paint.setColor(DlColor::kBlack().withAlpha(128));
paint.setColorFilter(DlColorFilter::MakeMatrix(matrix));
builder.SaveLayer(nullptr, &paint);
builder.SaveLayer(std::nullopt, &paint);
builder.DrawImage(image, DlPoint(100, 500), {});
builder.Restore();
@ -320,7 +320,7 @@ TEST_P(AiksTest,
DlImageFilter::MakeColorFilter(DlColorFilter::MakeMatrix(matrix)));
paint.setColorFilter(
DlColorFilter::MakeBlend(DlColor::kGreen(), DlBlendMode::kModulate));
builder.SaveLayer(nullptr, &paint);
builder.SaveLayer(std::nullopt, &paint);
builder.DrawImage(image, DlPoint(100, 500), {});
builder.Restore();
@ -337,7 +337,7 @@ TEST_P(AiksTest, TranslucentSaveLayerWithAdvancedBlendModeDrawsCorrectly) {
DlPaint save_paint;
save_paint.setAlpha(128);
save_paint.setBlendMode(DlBlendMode::kLighten);
builder.SaveLayer(nullptr, &save_paint);
builder.SaveLayer(std::nullopt, &save_paint);
DlPaint draw_paint;
draw_paint.setColor(DlColor::kGreen());
@ -358,13 +358,13 @@ TEST_P(AiksTest, CanRenderTinyOverlappingSubpasses) {
builder.DrawPaint(paint);
// Draw two overlapping subpixel circles.
builder.SaveLayer({});
builder.SaveLayer(std::nullopt);
DlPaint yellow_paint;
yellow_paint.setColor(DlColor::kYellow());
builder.DrawCircle(DlPoint(100, 100), 0.1, yellow_paint);
builder.Restore();
builder.SaveLayer({});
builder.SaveLayer(std::nullopt);
builder.DrawCircle(DlPoint(100, 100), 0.1, yellow_paint);
builder.Restore();
@ -387,7 +387,7 @@ TEST_P(AiksTest, CanRenderDestructiveSaveLayer) {
DlPaint save_paint;
save_paint.setBlendMode(DlBlendMode::kSrc);
builder.SaveLayer(nullptr, &save_paint);
builder.SaveLayer(std::nullopt, &save_paint);
DlPaint draw_paint;
draw_paint.setColor(DlColor::kGreen());
@ -639,7 +639,7 @@ TEST_P(AiksTest, MatrixImageFilterMagnify) {
DlPaint paint;
paint.setImageFilter(
DlImageFilter::MakeMatrix(matrix, DlImageSampling::kLinear));
builder.SaveLayer(nullptr, &paint);
builder.SaveLayer(std::nullopt, &paint);
DlPaint rect_paint;
rect_paint.setAlpha(0.5 * 255);
@ -748,7 +748,7 @@ TEST_P(AiksTest, MatrixBackdropFilter) {
DlPaint paint;
paint.setColor(DlColor::kBlack());
builder.DrawPaint(paint);
builder.SaveLayer(nullptr, nullptr);
builder.SaveLayer(std::nullopt, nullptr);
{
DlPaint paint;
paint.setColor(DlColor::kGreen().withAlpha(0.5 * 255));
@ -768,7 +768,7 @@ TEST_P(AiksTest, MatrixBackdropFilter) {
DlMatrix::MakeTranslation({-100, -100});
auto backdrop_filter =
DlImageFilter::MakeMatrix(matrix, DlImageSampling::kLinear);
builder.SaveLayer(nullptr, nullptr, backdrop_filter.get());
builder.SaveLayer(std::nullopt, nullptr, backdrop_filter.get());
builder.Restore();
}
builder.Restore();
@ -782,7 +782,7 @@ TEST_P(AiksTest, MatrixSaveLayerFilter) {
DlPaint paint;
paint.setColor(DlColor::kBlack());
builder.DrawPaint(paint);
builder.SaveLayer(nullptr, nullptr);
builder.SaveLayer(std::nullopt, nullptr);
{
paint.setColor(DlColor::kGreen().withAlpha(255 * 0.5));
paint.setBlendMode(DlBlendMode::kPlus);
@ -798,7 +798,7 @@ TEST_P(AiksTest, MatrixSaveLayerFilter) {
save_paint.setImageFilter(
DlImageFilter::MakeMatrix(matrix, DlImageSampling::kLinear));
builder.SaveLayer(nullptr, &save_paint);
builder.SaveLayer(std::nullopt, &save_paint);
DlPaint circle_paint;
circle_paint.setColor(DlColor::kGreen().withAlpha(255 * 0.5));
@ -914,7 +914,7 @@ TEST_P(AiksTest, BackdropRestoreUsesCorrectCoverageForFirstRestoredClip) {
// Create a save layer with a backdrop blur filter.
auto backdrop_filter =
DlImageFilter::MakeBlur(10.0, 10.0, DlTileMode::kDecal);
builder.SaveLayer(nullptr, nullptr, backdrop_filter.get());
builder.SaveLayer(std::nullopt, nullptr, backdrop_filter.get());
}
}
builder.RestoreToCount(count);

4
engine/src/flutter/impeller/display_list/dl_golden_blur_unittests.cc
View File

@ -190,7 +190,7 @@ TEST_P(DlGoldenTest, LargeDownscaleRrect) {
paint.setColor(DlColor::kYellow());
paint.setMaskFilter(
DlBlurMaskFilter::Make(DlBlurStyle::kNormal, /*sigma=*/1000));
canvas->DrawCircle(SkPoint::Make(0, 0), 1200, paint);
canvas->DrawCircle(DlPoint(0, 0), 1200, paint);
canvas->Restore();
}
@ -198,7 +198,7 @@ TEST_P(DlGoldenTest, LargeDownscaleRrect) {
paint.setColor(DlColor::kYellow());
paint.setMaskFilter(
DlBlurMaskFilter::Make(DlBlurStyle::kNormal, /*sigma=*/250));
canvas->DrawCircle(SkPoint::Make(1024, 768), 300, paint);
canvas->DrawCircle(DlPoint(1024, 768), 300, paint);
};
DisplayListBuilder builder;

2
engine/src/flutter/impeller/display_list/dl_golden_unittests.cc
View File

@ -334,7 +334,7 @@ TEST_P(DlGoldenTest, SaveLayerAtFractionalValue) {
DisplayListBuilder builder;
builder.DrawPaint(DlPaint().setColor(DlColor::kWhite()));
auto save_paint = DlPaint().setAlpha(100);
builder.SaveLayer(nullptr, &save_paint);
builder.SaveLayer(std::nullopt, &save_paint);
builder.DrawRoundRect(DlRoundRect::MakeRectRadius(
DlRect::MakeLTRB(10.5, 10.5, 200.5, 200.5), 10),

14
engine/src/flutter/impeller/display_list/dl_unittests.cc
View File

@ -83,7 +83,7 @@ TEST_P(DisplayListTest, CanDrawTextWithSaveLayer) {
flutter::DlPaint save_paint;
float alpha = 0.5;
save_paint.setAlpha(static_cast<uint8_t>(255 * alpha));
builder.SaveLayer(nullptr, &save_paint);
builder.SaveLayer(std::nullopt, &save_paint);
builder.DrawTextBlob(SkTextBlob::MakeFromString("Hello with half alpha",
CreateTestFontOfSize(100)),
100, 300, flutter::DlPaint(flutter::DlColor::kRed()));
@ -514,7 +514,7 @@ TEST_P(DisplayListTest, IgnoreMaskFilterWhenSavingLayer) {
auto filter = flutter::DlBlurMaskFilter(flutter::DlBlurStyle::kNormal, 10.0f);
flutter::DlPaint paint;
paint.setMaskFilter(&filter);
builder.SaveLayer(nullptr, &paint);
builder.SaveLayer(std::nullopt, &paint);
builder.DrawImage(DlImageImpeller::Make(texture), DlPoint(100, 100),
flutter::DlImageSampling::kNearestNeighbor);
builder.Restore();
@ -994,7 +994,7 @@ TEST_P(DisplayListTest, CanDrawWithMatrixFilter) {
flutter::DlPaint paint;
if (enable_savelayer) {
builder.SaveLayer(nullptr, nullptr);
builder.SaveLayer(std::nullopt, nullptr);
}
{
auto content_scale = GetContentScale();
@ -1175,7 +1175,7 @@ TEST_P(DisplayListTest, CanBlendDstOverAndDstCorrectly) {
flutter::DisplayListBuilder builder;
{
builder.SaveLayer(nullptr, nullptr);
builder.SaveLayer(std::nullopt, nullptr);
builder.Translate(100, 100);
flutter::DlPaint paint;
paint.setColor(flutter::DlColor::kRed());
@ -1186,7 +1186,7 @@ TEST_P(DisplayListTest, CanBlendDstOverAndDstCorrectly) {
builder.Restore();
}
{
builder.SaveLayer(nullptr, nullptr);
builder.SaveLayer(std::nullopt, nullptr);
builder.Translate(300, 100);
flutter::DlPaint paint;
paint.setColor(flutter::DlColor::kBlue().withAlpha(127));
@ -1197,7 +1197,7 @@ TEST_P(DisplayListTest, CanBlendDstOverAndDstCorrectly) {
builder.Restore();
}
{
builder.SaveLayer(nullptr, nullptr);
builder.SaveLayer(std::nullopt, nullptr);
builder.Translate(100, 300);
flutter::DlPaint paint;
paint.setColor(flutter::DlColor::kRed());
@ -1208,7 +1208,7 @@ TEST_P(DisplayListTest, CanBlendDstOverAndDstCorrectly) {
builder.Restore();
}
{
builder.SaveLayer(nullptr, nullptr);
builder.SaveLayer(std::nullopt, nullptr);
builder.Translate(300, 300);
flutter::DlPaint paint;
paint.setColor(flutter::DlColor::kBlue().withAlpha(127));

2
engine/src/flutter/lib/ui/painting/canvas.cc
View File

@ -64,7 +64,7 @@ void Canvas::saveLayerWithoutBounds(Dart_Handle paint_objects,
paint.paint(dl_paint, kSaveLayerWithPaintFlags, DlTileMode::kDecal);
FML_DCHECK(save_paint);
TRACE_EVENT0("flutter", "ui.Canvas::saveLayer (Recorded)");
builder()->SaveLayer(nullptr, save_paint);
builder()->SaveLayer(std::nullopt, save_paint);
}
}

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

@ -2003,7 +2003,7 @@ class MockTexture : public Texture {
// Called from raster thread.
void Paint(PaintContext& context,
const SkRect& bounds,
const DlRect& bounds,
bool freeze,
const DlImageSampling) override {}

2
engine/src/flutter/shell/platform/android/external_view_embedder/external_view_embedder_2.cc
View File

@ -135,7 +135,7 @@ void AndroidExternalViewEmbedder2::SubmitFlutterView(
DlCanvas* overlay_canvas = overlay_frame->Canvas();
int restore_count = overlay_canvas->GetSaveCount();
overlay_canvas->Save();
overlay_canvas->ClipRect(overlay->second);
overlay_canvas->ClipRect(ToDlRect(overlay->second));
// For all following platform views that would cover this overlay,
// emulate the effect by adding a difference clip. This makes the

30
engine/src/flutter/shell/platform/android/external_view_embedder/external_view_embedder_unittests.cc
View File

@ -356,15 +356,15 @@ TEST(AndroidExternalViewEmbedder, SubmitFlutterView) {
// This is the recording canvas flow writes to.
auto canvas_1 = embedder->CompositeEmbeddedView(0);
auto rect_paint = DlPaint();
DlPaint rect_paint;
rect_paint.setColor(DlColor::kCyan());
rect_paint.setDrawStyle(DlDrawStyle::kFill);
// This simulates Flutter UI that doesn't intersect with the Android view.
canvas_1->DrawRect(SkRect::MakeXYWH(0, 0, 50, 50), rect_paint);
canvas_1->DrawRect(DlRect::MakeXYWH(0, 0, 50, 50), rect_paint);
// This simulates Flutter UI that intersects with the Android view.
canvas_1->DrawRect(SkRect::MakeXYWH(50, 50, 200, 200), rect_paint);
canvas_1->DrawRect(SkRect::MakeXYWH(150, 150, 100, 100), rect_paint);
canvas_1->DrawRect(DlRect::MakeXYWH(50, 50, 200, 200), rect_paint);
canvas_1->DrawRect(DlRect::MakeXYWH(150, 150, 100, 100), rect_paint);
// Create a new overlay surface.
EXPECT_CALL(*jni_mock, FlutterViewCreateOverlaySurface())
@ -427,15 +427,15 @@ TEST(AndroidExternalViewEmbedder, SubmitFlutterView) {
// This is the recording canvas flow writes to.
auto canvas_1 = embedder->CompositeEmbeddedView(0);
auto rect_paint = DlPaint();
DlPaint rect_paint;
rect_paint.setColor(DlColor::kCyan());
rect_paint.setDrawStyle(DlDrawStyle::kFill);
// This simulates Flutter UI that doesn't intersect with the Android view.
canvas_1->DrawRect(SkRect::MakeXYWH(0, 0, 50, 50), rect_paint);
canvas_1->DrawRect(DlRect::MakeXYWH(0, 0, 50, 50), rect_paint);
// This simulates Flutter UI that intersects with the Android view.
canvas_1->DrawRect(SkRect::MakeXYWH(50, 50, 200, 200), rect_paint);
canvas_1->DrawRect(SkRect::MakeXYWH(150, 150, 100, 100), rect_paint);
canvas_1->DrawRect(DlRect::MakeXYWH(50, 50, 200, 200), rect_paint);
canvas_1->DrawRect(DlRect::MakeXYWH(150, 150, 100, 100), rect_paint);
// Don't create a new overlay surface since it's recycled from the first
// frame.
@ -549,7 +549,7 @@ TEST(AndroidExternalViewEmbedder, OverlayCoverTwoPlatformViews) {
// finally merge The final size of the overlay will be smaller than the
// width and height of the rect.
embedder->CompositeEmbeddedView(1)->DrawRect(
SkRect::MakeXYWH(150, 50, 200, 200), rect_paint);
DlRect::MakeXYWH(150, 50, 200, 200), rect_paint);
EXPECT_CALL(*jni_mock, FlutterViewCreateOverlaySurface())
.WillRepeatedly([&]() {
@ -638,7 +638,7 @@ TEST(AndroidExternalViewEmbedder, SubmitFrameOverlayComposition) {
// This simulates Flutter UI that intersects with the first Android view.
embedder->CompositeEmbeddedView(0)->DrawRect(
SkRect::MakeXYWH(25, 25, 80, 150), rect_paint);
DlRect::MakeXYWH(25, 25, 80, 150), rect_paint);
{
// Add second Android view.
@ -654,11 +654,11 @@ TEST(AndroidExternalViewEmbedder, SubmitFrameOverlayComposition) {
}
// This simulates Flutter UI that intersects with the first and second Android
// views.
embedder->CompositeEmbeddedView(1)->DrawRect(SkRect::MakeXYWH(25, 25, 80, 50),
embedder->CompositeEmbeddedView(1)->DrawRect(DlRect::MakeXYWH(25, 25, 80, 50),
rect_paint);
embedder->CompositeEmbeddedView(1)->DrawRect(
SkRect::MakeXYWH(75, 75, 30, 100), rect_paint);
DlRect::MakeXYWH(75, 75, 30, 100), rect_paint);
EXPECT_CALL(*jni_mock, FlutterViewCreateOverlaySurface())
.WillRepeatedly([&]() {
@ -833,7 +833,7 @@ TEST(AndroidExternalViewEmbedder, DestroyOverlayLayersOnSizeChange) {
// This simulates Flutter UI that intersects with the Android view.
embedder->CompositeEmbeddedView(0)->DrawRect(
SkRect::MakeXYWH(50, 50, 200, 200), DlPaint());
DlRect::MakeXYWH(50, 50, 200, 200), DlPaint());
// Create a new overlay surface.
EXPECT_CALL(*jni_mock, FlutterViewCreateOverlaySurface())
@ -925,7 +925,7 @@ TEST(AndroidExternalViewEmbedder, DoesNotDestroyOverlayLayersOnSizeChange) {
// This simulates Flutter UI that intersects with the Android view.
embedder->CompositeEmbeddedView(0)->DrawRect(
SkRect::MakeXYWH(50, 50, 200, 200), DlPaint());
DlRect::MakeXYWH(50, 50, 200, 200), DlPaint());
// Create a new overlay surface.
EXPECT_CALL(*jni_mock, FlutterViewCreateOverlaySurface())
@ -1047,7 +1047,7 @@ TEST(AndroidExternalViewEmbedder, Teardown) {
// This simulates Flutter UI that intersects with the Android view.
embedder->CompositeEmbeddedView(0)->DrawRect(
SkRect::MakeXYWH(50, 50, 200, 200), DlPaint());
DlRect::MakeXYWH(50, 50, 200, 200), DlPaint());
// Create a new overlay surface.
EXPECT_CALL(*jni_mock, FlutterViewCreateOverlaySurface())

6
engine/src/flutter/shell/platform/android/image_external_texture.cc
View File

@ -25,7 +25,7 @@ ImageExternalTexture::~ImageExternalTexture() = default;
// Implementing flutter::Texture.
void ImageExternalTexture::Paint(PaintContext& context,
const SkRect& bounds,
const DlRect& bounds,
bool freeze,
const DlImageSampling sampling) {
if (state_ == AttachmentState::kDetached) {
@ -34,12 +34,12 @@ void ImageExternalTexture::Paint(PaintContext& context,
Attach(context);
const bool should_process_frame = !freeze;
if (should_process_frame) {
ProcessFrame(context, bounds);
ProcessFrame(context, ToSkRect(bounds));
}
if (dl_image_) {
context.canvas->DrawImageRect(
dl_image_, // image
SkRect::Make(dl_image_->bounds()), // source rect
DlRect::Make(dl_image_->GetBounds()), // source rect
bounds, // destination rect
sampling, // sampling
context.paint, // paint

2
engine/src/flutter/shell/platform/android/image_external_texture.h
View File

@ -84,7 +84,7 @@ class ImageExternalTexture : public flutter::Texture {
private:
// |flutter::Texture|.
void Paint(PaintContext& context,
const SkRect& bounds,
const DlRect& bounds,
bool freeze,
const DlImageSampling sampling) override;

10
engine/src/flutter/shell/platform/android/surface_texture_external_texture.cc
View File

@ -36,7 +36,7 @@ void SurfaceTextureExternalTexture::MarkNewFrameAvailable() {
}
void SurfaceTextureExternalTexture::Paint(PaintContext& context,
const SkRect& bounds,
const DlRect& bounds,
bool freeze,
const DlImageSampling sampling) {
if (state_ == AttachmentState::kDetached) {
@ -45,7 +45,7 @@ void SurfaceTextureExternalTexture::Paint(PaintContext& context,
const bool should_process_frame =
!freeze || ShouldUpdate() || dl_image_ == nullptr;
if (should_process_frame) {
ProcessFrame(context, bounds);
ProcessFrame(context, ToSkRect(bounds));
}
// If process frame failed, this may not be in attached state.
if (state_ != AttachmentState::kAttached) {
@ -58,7 +58,7 @@ void SurfaceTextureExternalTexture::Paint(PaintContext& context,
return;
}
DrawFrame(context, bounds, sampling);
DrawFrame(context, ToSkRect(bounds), sampling);
}
void SurfaceTextureExternalTexture::DrawFrame(
@ -75,7 +75,7 @@ void SurfaceTextureExternalTexture::DrawFrame(
// outside of the virtual "clip rect"), so we invert the incoming matrix.
if (transform.IsIdentity()) {
context.canvas->DrawImage(dl_image_, SkPoint{0, 0}, sampling,
context.canvas->DrawImage(dl_image_, DlPoint{0, 0}, sampling,
context.paint);
return;
}
@ -102,7 +102,7 @@ void SurfaceTextureExternalTexture::DrawFrame(
paintWithShader = *context.paint;
}
paintWithShader.setColorSource(source);
context.canvas->DrawRect(SkRect::MakeWH(1, 1), paintWithShader);
context.canvas->DrawRect(DlRect::MakeWH(1, 1), paintWithShader);
}
void SurfaceTextureExternalTexture::OnGrContextDestroyed() {

2
engine/src/flutter/shell/platform/android/surface_texture_external_texture.h
View File

@ -116,7 +116,7 @@ class SurfaceTextureExternalTexture : public flutter::Texture {
// |Texture|
void Paint(PaintContext& context,
const SkRect& bounds,
const DlRect& bounds,
bool freeze,
const DlImageSampling sampling) override;

14
engine/src/flutter/shell/platform/android/surface_texture_external_texture_vk_impeller.cc
View File

@ -122,16 +122,16 @@ void SurfaceTextureExternalTextureVKImpeller::ProcessFrame(
VALIDATION_LOG << "Invalid external texture.";
return;
}
SkMatrix matrix = context.canvas->GetTransform();
SkRect mapped_bounds = matrix.mapRect(bounds);
DlMatrix matrix = context.canvas->GetMatrix();
DlRect mapped_bounds = ToDlRect(bounds).TransformAndClipBounds(matrix);
const auto& surface_context =
SurfaceContextVK::Cast(*context.aiks_context->GetContext());
const auto& context_vk = ContextVK::Cast(*surface_context.GetParent());
auto dst_texture = GetCachedTextureSource(
surface_context.GetParent(), //
ISize::MakeWH(mapped_bounds.width(), mapped_bounds.height()) //
surface_context.GetParent(), //
ISize::MakeWH(mapped_bounds.GetWidth(), mapped_bounds.GetHeight()) //
);
if (!dst_texture || !dst_texture->IsValid()) {
VALIDATION_LOG << "Could not fetch trampoline texture target.";
@ -226,10 +226,8 @@ void SurfaceTextureExternalTextureVKImpeller::DrawFrame(
PaintContext& context,
const SkRect& bounds,
const DlImageSampling sampling) const {
context.canvas->DrawImageRect(
dl_image_,
SkRect::MakeSize(SkSize::Make(dl_image_->width(), dl_image_->height())),
bounds, sampling, context.paint);
context.canvas->DrawImageRect(dl_image_, ToDlRect(bounds), sampling,
context.paint);
}
} // namespace flutter

13
engine/src/flutter/shell/platform/darwin/graphics/FlutterDarwinExternalTextureMetal.mm
View File

@ -66,12 +66,13 @@ FLUTTER_ASSERT_ARC
}
if (_externalImage) {
context.canvas->DrawImageRect(_externalImage, // image
SkRect::Make(_externalImage->bounds()), // source rect
bounds, // destination rect
sampling, // sampling
context.paint, // paint
flutter::DlSrcRectConstraint::kStrict // enforce edges
context.canvas->DrawImageRect(
_externalImage, // image
flutter::DlRect::Make(_externalImage->GetBounds()), // source rect
flutter::ToDlRect(bounds), // destination rect
sampling, // sampling
context.paint, // paint
flutter::DlSrcRectConstraint::kStrict // enforce edges
);
}
}

2
engine/src/flutter/shell/platform/darwin/ios/framework/Source/FlutterPlatformViewsController.mm
View File

@ -742,7 +742,7 @@ static bool ClipRRectContainsPlatformViewBoundingRect(const SkRRect& clip_rrect,
flutter::DlCanvas* overlayCanvas = frame->Canvas();
int restoreCount = overlayCanvas->GetSaveCount();
overlayCanvas->Save();
overlayCanvas->ClipRect(overlay->second);
overlayCanvas->ClipRect(flutter::ToDlRect(overlay->second));
overlayCanvas->Clear(flutter::DlColor::kTransparent());
self.slices[viewId]->render_into(overlayCanvas);
overlayCanvas->RestoreToCount(restoreCount);

2
engine/src/flutter/shell/platform/darwin/ios/ios_external_texture_metal.h
View File

@ -24,7 +24,7 @@ class IOSExternalTextureMetal final : public Texture {
// |Texture|
void Paint(PaintContext& context,
const SkRect& bounds,
const DlRect& bounds,
bool freeze,
const DlImageSampling sampling) override;

4
engine/src/flutter/shell/platform/darwin/ios/ios_external_texture_metal.mm
View File

@ -17,11 +17,11 @@ IOSExternalTextureMetal::IOSExternalTextureMetal(
IOSExternalTextureMetal::~IOSExternalTextureMetal() = default;
void IOSExternalTextureMetal::Paint(PaintContext& context,
const SkRect& bounds,
const DlRect& bounds,
bool freeze,
const DlImageSampling sampling) {
[darwin_external_texture_metal_ paintContext:context
bounds:bounds
bounds:ToSkRect(bounds)
freeze:freeze
sampling:sampling];
}

20
engine/src/flutter/shell/platform/darwin/macos/framework/Source/FlutterEmbedderExternalTextureTest.mm
View File

@ -136,7 +136,7 @@ TEST_F(FlutterEmbedderExternalTextureTest, TestTextureResolution) {
// Render the texture.
std::unique_ptr<flutter::Texture> texture =
std::make_unique<EmbedderExternalTextureMetal>(texture_id, callback);
SkRect bounds = SkRect::MakeWH(info.width(), info.height());
DlRect bounds = DlRect::MakeWH(info.width(), info.height());
DlImageSampling sampling = DlImageSampling::kNearestNeighbor;
DlSkCanvasAdapter canvas(gpuSurface->getCanvas());
flutter::Texture::PaintContext context{
@ -190,7 +190,7 @@ TEST_F(FlutterEmbedderExternalTextureTest, TestPopulateExternalTexture) {
// Render the texture.
std::unique_ptr<flutter::Texture> texture =
std::make_unique<EmbedderExternalTextureMetal>(texture_id, callback);
SkRect bounds = SkRect::MakeWH(info.width(), info.height());
DlRect bounds = DlRect::MakeWH(info.width(), info.height());
DlImageSampling sampling = DlImageSampling::kNearestNeighbor;
DlSkCanvasAdapter canvas(gpuSurface->getCanvas());
flutter::Texture::PaintContext context{
@ -244,7 +244,7 @@ TEST_F(FlutterEmbedderExternalTextureTest, TestPopulateExternalTextureYUVA) {
// Render the texture.
std::unique_ptr<flutter::Texture> texture =
std::make_unique<EmbedderExternalTextureMetal>(texture_id, callback);
SkRect bounds = SkRect::MakeWH(info.width(), info.height());
DlRect bounds = DlRect::MakeWH(info.width(), info.height());
DlImageSampling sampling = DlImageSampling::kNearestNeighbor;
DlSkCanvasAdapter canvas(gpuSurface->getCanvas());
flutter::Texture::PaintContext context{
@ -298,7 +298,7 @@ TEST_F(FlutterEmbedderExternalTextureTest, TestPopulateExternalTextureYUVA2) {
// Render the texture.
std::unique_ptr<flutter::Texture> texture =
std::make_unique<EmbedderExternalTextureMetal>(texture_id, callback);
SkRect bounds = SkRect::MakeWH(info.width(), info.height());
DlRect bounds = DlRect::MakeWH(info.width(), info.height());
DlImageSampling sampling = DlImageSampling::kNearestNeighbor;
DlSkCanvasAdapter canvas(gpuSurface->getCanvas());
flutter::Texture::PaintContext context{
@ -346,7 +346,7 @@ TEST_F(FlutterEmbedderExternalTextureTest, TestPopulateUnsupportedExternalTextur
// Render the texture.
std::unique_ptr<flutter::Texture> texture =
std::make_unique<EmbedderExternalTextureMetal>(texture_id, callback);
SkRect bounds = SkRect::MakeWH(info.width(), info.height());
DlRect bounds = DlRect::MakeWH(info.width(), info.height());
DlImageSampling sampling = DlImageSampling::kNearestNeighbor;
DlSkCanvasAdapter canvas(gpuSurface->getCanvas());
flutter::Texture::PaintContext context{
@ -398,7 +398,7 @@ TEST_F(FlutterEmbedderExternalTextureTest, TestTextureResolutionImpeller) {
// Render the texture.
std::unique_ptr<flutter::Texture> texture =
std::make_unique<EmbedderExternalTextureMetal>(texture_id, callback);
SkRect bounds = SkRect::MakeWH(info.width(), info.height());
DlRect bounds = DlRect::MakeWH(info.width(), info.height());
DlImageSampling sampling = DlImageSampling::kNearestNeighbor;
DisplayListBuilder builder;
@ -448,7 +448,7 @@ TEST_F(FlutterEmbedderExternalTextureTest, TestPopulateExternalTextureImpeller)
// Render the texture.
std::unique_ptr<flutter::Texture> texture =
std::make_unique<EmbedderExternalTextureMetal>(texture_id, callback);
SkRect bounds = SkRect::MakeWH(info.width(), info.height());
DlRect bounds = DlRect::MakeWH(info.width(), info.height());
DlImageSampling sampling = DlImageSampling::kNearestNeighbor;
DisplayListBuilder builder;
@ -501,7 +501,7 @@ TEST_F(FlutterEmbedderExternalTextureTest, TestPopulateExternalTextureYUVAImpell
// Render the texture.
std::unique_ptr<flutter::Texture> texture =
std::make_unique<EmbedderExternalTextureMetal>(texture_id, callback);
SkRect bounds = SkRect::MakeWH(info.width(), info.height());
DlRect bounds = DlRect::MakeWH(info.width(), info.height());
DlImageSampling sampling = DlImageSampling::kNearestNeighbor;
DisplayListBuilder builder;
@ -551,7 +551,7 @@ TEST_F(FlutterEmbedderExternalTextureTest, TestPopulateExternalTextureYUVA2Impel
// Render the texture.
std::unique_ptr<flutter::Texture> texture =
std::make_unique<EmbedderExternalTextureMetal>(texture_id, callback);
SkRect bounds = SkRect::MakeWH(info.width(), info.height());
DlRect bounds = DlRect::MakeWH(info.width(), info.height());
DlImageSampling sampling = DlImageSampling::kNearestNeighbor;
DisplayListBuilder builder;
@ -595,7 +595,7 @@ TEST_F(FlutterEmbedderExternalTextureTest, TestPopulateUnsupportedExternalTextur
// Render the texture.
std::unique_ptr<flutter::Texture> texture =
std::make_unique<EmbedderExternalTextureMetal>(texture_id, callback);
SkRect bounds = SkRect::MakeWH(info.width(), info.height());
DlRect bounds = DlRect::MakeWH(info.width(), info.height());
DlImageSampling sampling = DlImageSampling::kNearestNeighbor;
DisplayListBuilder builder;

15
engine/src/flutter/shell/platform/embedder/embedder_external_texture_gl.cc
View File

@ -38,15 +38,15 @@ EmbedderExternalTextureGL::~EmbedderExternalTextureGL() = default;
// |flutter::Texture|
void EmbedderExternalTextureGL::Paint(PaintContext& context,
const SkRect& bounds,
const DlRect& bounds,
bool freeze,
const DlImageSampling sampling) {
if (last_image_ == nullptr) {
last_image_ =
ResolveTexture(Id(), //
context.gr_context, //
context.aiks_context, //
SkISize::Make(bounds.width(), bounds.height()) //
ResolveTexture(Id(), //
context.gr_context, //
context.aiks_context, //
SkISize::Make(bounds.GetWidth(), bounds.GetHeight()) //
);
}
@ -54,12 +54,11 @@ void EmbedderExternalTextureGL::Paint(PaintContext& context,
const DlPaint* paint = context.paint;
if (last_image_) {
SkRect image_bounds = SkRect::Make(last_image_->bounds());
DlRect image_bounds = DlRect::Make(last_image_->GetBounds());
if (bounds != image_bounds) {
canvas->DrawImageRect(last_image_, image_bounds, bounds, sampling, paint);
} else {
canvas->DrawImage(last_image_, SkPoint{bounds.x(), bounds.y()}, sampling,
paint);
canvas->DrawImage(last_image_, bounds.GetOrigin(), sampling, paint);
}
}
}

2
engine/src/flutter/shell/platform/embedder/embedder_external_texture_gl.h
View File

@ -41,7 +41,7 @@ class EmbedderExternalTextureGL : public flutter::Texture {
// |flutter::Texture|
void Paint(PaintContext& context,
const SkRect& bounds,
const DlRect& bounds,
bool freeze,
const DlImageSampling sampling) override;

2
engine/src/flutter/shell/platform/embedder/embedder_external_texture_metal.h
View File

@ -35,7 +35,7 @@ class EmbedderExternalTextureMetal : public flutter::Texture {
// |flutter::Texture|
void Paint(PaintContext& context,
const SkRect& bounds,
const DlRect& bounds,
bool freeze,
const DlImageSampling sampling) override;

8
engine/src/flutter/shell/platform/embedder/embedder_external_texture_metal.mm
View File

@ -33,23 +33,23 @@ EmbedderExternalTextureMetal::~EmbedderExternalTextureMetal() = default;
// |flutter::Texture|
void EmbedderExternalTextureMetal::Paint(PaintContext& context,
const SkRect& bounds,
const DlRect& bounds,
bool freeze,
const DlImageSampling sampling) {
if (last_image_ == nullptr) {
last_image_ = ResolveTexture(Id(), context.gr_context, context.aiks_context,
SkISize::Make(bounds.width(), bounds.height()));
SkISize::Make(bounds.GetWidth(), bounds.GetHeight()));
}
DlCanvas* canvas = context.canvas;
const DlPaint* paint = context.paint;
if (last_image_) {
SkRect image_bounds = SkRect::Make(last_image_->bounds());
DlRect image_bounds = DlRect::Make(last_image_->GetBounds());
if (bounds != image_bounds) {
canvas->DrawImageRect(last_image_, image_bounds, bounds, sampling, paint);
} else {
canvas->DrawImage(last_image_, SkPoint{bounds.x(), bounds.y()}, sampling, paint);
canvas->DrawImage(last_image_, DlPoint(bounds.GetX(), bounds.GetY()), sampling, paint);
}
}
}

4
engine/src/flutter/shell/platform/embedder/embedder_external_view.cc
View File

@ -124,7 +124,7 @@ bool EmbedderExternalView::Render(const EmbedderRenderTarget& render_target,
auto aiks_context = render_target.GetAiksContext();
auto dl_builder = DisplayListBuilder();
dl_builder.SetTransform(&surface_transformation_);
dl_builder.SetTransform(ToDlMatrix(surface_transformation_));
slice_->render_into(&dl_builder);
auto display_list = dl_builder.Build();
@ -182,7 +182,7 @@ bool EmbedderExternalView::Render(const EmbedderRenderTarget& render_target,
}
DlSkCanvasAdapter dl_canvas(canvas);
int restore_count = dl_canvas.GetSaveCount();
dl_canvas.SetTransform(surface_transformation_);
dl_canvas.SetTransform(ToDlMatrix(surface_transformation_));
if (clear_surface) {
dl_canvas.Clear(DlColor::kTransparent());
}

6
engine/src/flutter/shell/platform/embedder/tests/embedder_gl_unittests.cc
View File

@ -4585,19 +4585,19 @@ TEST_F(EmbedderTest, ExternalTextureGLRefreshedTooOften) {
.canvas = &canvas,
.gr_context = context.get(),
};
texture_->Paint(ctx, SkRect::MakeXYWH(0, 0, 100, 100), false,
texture_->Paint(ctx, DlRect::MakeXYWH(0, 0, 100, 100), false,
DlImageSampling::kLinear);
EXPECT_TRUE(resolve_called);
resolve_called = false;
texture_->Paint(ctx, SkRect::MakeXYWH(0, 0, 100, 100), false,
texture_->Paint(ctx, DlRect::MakeXYWH(0, 0, 100, 100), false,
DlImageSampling::kLinear);
EXPECT_FALSE(resolve_called);
texture_->MarkNewFrameAvailable();
texture_->Paint(ctx, SkRect::MakeXYWH(0, 0, 100, 100), false,
texture_->Paint(ctx, DlRect::MakeXYWH(0, 0, 100, 100), false,
DlImageSampling::kLinear);
EXPECT_TRUE(resolve_called);

6
engine/src/flutter/shell/platform/embedder/tests/embedder_metal_unittests.mm
View File

@ -595,18 +595,18 @@ TEST_F(EmbedderTest, ExternalTextureMetalRefreshedTooOften) {
.canvas = &canvas,
.gr_context = surface->GetGrContext().get(),
};
texture_->Paint(ctx, SkRect::MakeXYWH(0, 0, 100, 100), false, sampling);
texture_->Paint(ctx, DlRect::MakeXYWH(0, 0, 100, 100), false, sampling);
EXPECT_TRUE(resolve_called);
resolve_called = false;
texture_->Paint(ctx, SkRect::MakeXYWH(0, 0, 100, 100), false, sampling);
texture_->Paint(ctx, DlRect::MakeXYWH(0, 0, 100, 100), false, sampling);
EXPECT_FALSE(resolve_called);
texture_->MarkNewFrameAvailable();
texture_->Paint(ctx, SkRect::MakeXYWH(0, 0, 100, 100), false, sampling);
texture_->Paint(ctx, DlRect::MakeXYWH(0, 0, 100, 100), false, sampling);
EXPECT_TRUE(resolve_called);
}

2
engine/src/flutter/shell/platform/fuchsia/flutter/canvas_spy_unittests.cc
View File

@ -24,7 +24,7 @@ TEST(CanvasSpyTest, DrawingIsTracked) {
ASSERT_FALSE(canvas_spy.DidDrawIntoCanvas());
DlPaint paint;
spy->DrawCircle(SkPoint{0, 0}, 60, paint);
spy->DrawCircle(DlPoint(0, 0), 60, paint);
ASSERT_TRUE(canvas_spy.DidDrawIntoCanvas());
}

296
engine/src/flutter/shell/platform/fuchsia/flutter/tests/external_view_embedder_unittests.cc
View File

@ -34,6 +34,8 @@
#include "gmock/gmock.h" // For EXPECT_THAT and matchers
#include "gtest/gtest.h"
using flutter::DlRect;
using flutter::DlSize;
using fuchsia::scenic::scheduling::FramePresentedInfo;
using fuchsia::scenic::scheduling::FuturePresentationTimes;
using fuchsia::scenic::scheduling::PresentReceivedInfo;
@ -526,20 +528,15 @@ TEST_F(ExternalViewEmbedderTest, SimpleScene) {
const fuchsia::math::SizeU frame_size{
static_cast<uint32_t>(frame_size_signed.width()),
static_cast<uint32_t>(frame_size_signed.height())};
DrawSimpleFrame(external_view_embedder, frame_size_signed, 1.f,
[](flutter::DlCanvas* canvas) {
const SkISize layer_size = canvas->GetBaseLayerSize();
const SkSize canvas_size =
SkSize::Make(layer_size.width(), layer_size.height());
flutter::DlPaint rect_paint;
rect_paint.setColor(flutter::DlColor::kGreen());
canvas->Translate(canvas_size.width() / 4.f,
canvas_size.height() / 2.f);
canvas->DrawRect(
SkRect::MakeWH(canvas_size.width() / 32.f,
canvas_size.height() / 32.f),
rect_paint);
});
DrawSimpleFrame(
external_view_embedder, frame_size_signed, 1.f,
[](flutter::DlCanvas* canvas) {
const DlSize canvas_size(canvas->GetBaseLayerDimensions());
flutter::DlPaint rect_paint;
rect_paint.setColor(flutter::DlColor::kGreen());
canvas->Translate(canvas_size.width / 4.f, canvas_size.height / 2.f);
canvas->DrawRect(DlRect::MakeSize(canvas_size / 32.f), rect_paint);
});
EXPECT_THAT(fake_flatland().graph(),
IsFlutterGraph(parent_viewport_watcher, viewport_creation_token,
view_ref_clone));
@ -651,28 +648,19 @@ TEST_F(ExternalViewEmbedderTest, SceneWithOneView) {
external_view_embedder, frame_size_signed, kDPR, child_view_id,
child_view_params,
[](flutter::DlCanvas* canvas) {
const SkISize layer_size = canvas->GetBaseLayerSize();
const SkSize canvas_size =
SkSize::Make(layer_size.width(), layer_size.height());
const DlSize canvas_size(canvas->GetBaseLayerDimensions());
flutter::DlPaint rect_paint;
rect_paint.setColor(flutter::DlColor::kGreen());
canvas->Translate(canvas_size.width() / 4.f,
canvas_size.height() / 2.f);
canvas->DrawRect(SkRect::MakeWH(canvas_size.width() / 32.f,
canvas_size.height() / 32.f),
rect_paint);
canvas->Translate(canvas_size.width / 4.f, canvas_size.height / 2.f);
canvas->DrawRect(DlRect::MakeSize(canvas_size / 32.f), rect_paint);
},
[](flutter::DlCanvas* canvas) {
const SkISize layer_size = canvas->GetBaseLayerSize();
const SkSize canvas_size =
SkSize::Make(layer_size.width(), layer_size.height());
const DlSize canvas_size(canvas->GetBaseLayerDimensions());
flutter::DlPaint rect_paint;
rect_paint.setColor(flutter::DlColor::kRed());
canvas->Translate(canvas_size.width() * 3.f / 4.f,
canvas_size.height() / 2.f);
canvas->DrawRect(SkRect::MakeWH(canvas_size.width() / 32.f,
canvas_size.height() / 32.f),
rect_paint);
canvas->Translate(canvas_size.width * 3.f / 4.f,
canvas_size.height / 2.f);
canvas->DrawRect(DlRect::MakeSize(canvas_size / 32.f), rect_paint);
});
EXPECT_THAT(fake_flatland().graph(),
IsFlutterGraph(parent_viewport_watcher, viewport_creation_token,
@ -741,20 +729,15 @@ TEST_F(ExternalViewEmbedderTest, SceneWithOneView) {
{kInvDPR, kInvDPR}));
// Draw another frame without the view. The scene graph shouldn't change yet.
DrawSimpleFrame(external_view_embedder, frame_size_signed, 1.f,
[](flutter::DlCanvas* canvas) {
const SkISize layer_size = canvas->GetBaseLayerSize();
const SkSize canvas_size =
SkSize::Make(layer_size.width(), layer_size.height());
flutter::DlPaint rect_paint;
rect_paint.setColor(flutter::DlColor::kGreen());
canvas->Translate(canvas_size.width() / 4.f,
canvas_size.height() / 2.f);
canvas->DrawRect(
SkRect::MakeWH(canvas_size.width() / 32.f,
canvas_size.height() / 32.f),
rect_paint);
});
DrawSimpleFrame(
external_view_embedder, frame_size_signed, 1.f,
[](flutter::DlCanvas* canvas) {
const DlSize canvas_size(canvas->GetBaseLayerDimensions());
flutter::DlPaint rect_paint;
rect_paint.setColor(flutter::DlColor::kGreen());
canvas->Translate(canvas_size.width / 4.f, canvas_size.height / 2.f);
canvas->DrawRect(DlRect::MakeSize(canvas_size / 32.f), rect_paint);
});
EXPECT_THAT(
fake_flatland().graph(),
IsFlutterGraph(
@ -901,28 +884,19 @@ TEST_F(ExternalViewEmbedderTest, SceneWithOneClippedView) {
external_view_embedder, frame_size_signed, kDPR, child_view_id,
child_view_params,
[](flutter::DlCanvas* canvas) {
const SkISize layer_size = canvas->GetBaseLayerSize();
const SkSize canvas_size =
SkSize::Make(layer_size.width(), layer_size.height());
const DlSize canvas_size(canvas->GetBaseLayerDimensions());
flutter::DlPaint rect_paint;
rect_paint.setColor(flutter::DlColor::kGreen());
canvas->Translate(canvas_size.width() / 4.f,
canvas_size.height() / 2.f);
canvas->DrawRect(SkRect::MakeWH(canvas_size.width() / 32.f,
canvas_size.height() / 32.f),
rect_paint);
canvas->Translate(canvas_size.width / 4.f, canvas_size.height / 2.f);
canvas->DrawRect(DlRect::MakeSize(canvas_size / 32.f), rect_paint);
},
[](flutter::DlCanvas* canvas) {
const SkISize layer_size = canvas->GetBaseLayerSize();
const SkSize canvas_size =
SkSize::Make(layer_size.width(), layer_size.height());
const DlSize canvas_size(canvas->GetBaseLayerDimensions());
flutter::DlPaint rect_paint;
rect_paint.setColor(flutter::DlColor::kRed());
canvas->Translate(canvas_size.width() * 3.f / 4.f,
canvas_size.height() / 2.f);
canvas->DrawRect(SkRect::MakeWH(canvas_size.width() / 32.f,
canvas_size.height() / 32.f),
rect_paint);
canvas->Translate(canvas_size.width * 3.f / 4.f,
canvas_size.height / 2.f);
canvas->DrawRect(DlRect::MakeSize(canvas_size / 32.f), rect_paint);
});
EXPECT_THAT(fake_flatland().graph(),
IsFlutterGraph(parent_viewport_watcher, viewport_creation_token,
@ -977,28 +951,19 @@ TEST_F(ExternalViewEmbedderTest, SceneWithOneClippedView) {
external_view_embedder, frame_size_signed, kDPR, child_view_id,
new_child_view_params,
[](flutter::DlCanvas* canvas) {
const SkISize layer_size = canvas->GetBaseLayerSize();
const SkSize canvas_size =
SkSize::Make(layer_size.width(), layer_size.height());
const DlSize canvas_size(canvas->GetBaseLayerDimensions());
flutter::DlPaint rect_paint;
rect_paint.setColor(flutter::DlColor::kGreen());
canvas->Translate(canvas_size.width() / 4.f,
canvas_size.height() / 2.f);
canvas->DrawRect(SkRect::MakeWH(canvas_size.width() / 32.f,
canvas_size.height() / 32.f),
rect_paint);
canvas->Translate(canvas_size.width / 4.f, canvas_size.height / 2.f);
canvas->DrawRect(DlRect::MakeSize(canvas_size / 32.f), rect_paint);
},
[](flutter::DlCanvas* canvas) {
const SkISize layer_size = canvas->GetBaseLayerSize();
const SkSize canvas_size =
SkSize::Make(layer_size.width(), layer_size.height());
const DlSize canvas_size(canvas->GetBaseLayerDimensions());
flutter::DlPaint rect_paint;
rect_paint.setColor(flutter::DlColor::kRed());
canvas->Translate(canvas_size.width() * 3.f / 4.f,
canvas_size.height() / 2.f);
canvas->DrawRect(SkRect::MakeWH(canvas_size.width() / 32.f,
canvas_size.height() / 32.f),
rect_paint);
canvas->Translate(canvas_size.width * 3.f / 4.f,
canvas_size.height / 2.f);
canvas->DrawRect(DlRect::MakeSize(canvas_size / 32.f), rect_paint);
});
loop().RunUntilIdle();
fake_flatland().FireOnNextFrameBeginEvent(WithPresentCredits(1u));
@ -1033,20 +998,15 @@ TEST_F(ExternalViewEmbedderTest, SceneWithOneClippedView) {
// Destroy the view and draw another frame without the view.
external_view_embedder.DestroyView(
child_view_id, [](fuchsia::ui::composition::ContentId) {});
DrawSimpleFrame(external_view_embedder, frame_size_signed, 1.f,
[](flutter::DlCanvas* canvas) {
const SkISize layer_size = canvas->GetBaseLayerSize();
const SkSize canvas_size =
SkSize::Make(layer_size.width(), layer_size.height());
flutter::DlPaint rect_paint;
rect_paint.setColor(flutter::DlColor::kGreen());
canvas->Translate(canvas_size.width() / 4.f,
canvas_size.height() / 2.f);
canvas->DrawRect(
SkRect::MakeWH(canvas_size.width() / 32.f,
canvas_size.height() / 32.f),
rect_paint);
});
DrawSimpleFrame(
external_view_embedder, frame_size_signed, 1.f,
[](flutter::DlCanvas* canvas) {
const DlSize canvas_size(canvas->GetBaseLayerDimensions());
flutter::DlPaint rect_paint;
rect_paint.setColor(flutter::DlColor::kGreen());
canvas->Translate(canvas_size.width / 4.f, canvas_size.height / 2.f);
canvas->DrawRect(DlRect::MakeSize(canvas_size / 32.f), rect_paint);
});
loop().RunUntilIdle();
EXPECT_THAT(
fake_flatland().graph(),
@ -1139,16 +1099,11 @@ TEST_F(ExternalViewEmbedderTest, SceneWithOneView_NoOverlay) {
external_view_embedder, frame_size_signed, 1.f, child_view_id,
child_view_params,
[](flutter::DlCanvas* canvas) {
const SkISize layer_size = canvas->GetBaseLayerSize();
const SkSize canvas_size =
SkSize::Make(layer_size.width(), layer_size.height());
const DlSize canvas_size(canvas->GetBaseLayerDimensions());
flutter::DlPaint rect_paint;
rect_paint.setColor(flutter::DlColor::kGreen());
canvas->Translate(canvas_size.width() / 4.f,
canvas_size.height() / 2.f);
canvas->DrawRect(SkRect::MakeWH(canvas_size.width() / 32.f,
canvas_size.height() / 32.f),
rect_paint);
canvas->Translate(canvas_size.width / 4.f, canvas_size.height / 2.f);
canvas->DrawRect(DlRect::MakeSize(canvas_size / 32.f), rect_paint);
},
[](flutter::DlCanvas* canvas) {});
EXPECT_THAT(fake_flatland().graph(),
@ -1199,20 +1154,15 @@ TEST_F(ExternalViewEmbedderTest, SceneWithOneView_NoOverlay) {
kOpacityFloat)}));
// Draw another frame without the view. The scene graph shouldn't change yet.
DrawSimpleFrame(external_view_embedder, frame_size_signed, 1.f,
[](flutter::DlCanvas* canvas) {
const SkISize layer_size = canvas->GetBaseLayerSize();
const SkSize canvas_size =
SkSize::Make(layer_size.width(), layer_size.height());
flutter::DlPaint rect_paint;
rect_paint.setColor(flutter::DlColor::kGreen());
canvas->Translate(canvas_size.width() / 4.f,
canvas_size.height() / 2.f);
canvas->DrawRect(
SkRect::MakeWH(canvas_size.width() / 32.f,
canvas_size.height() / 32.f),
rect_paint);
});
DrawSimpleFrame(
external_view_embedder, frame_size_signed, 1.f,
[](flutter::DlCanvas* canvas) {
const DlSize canvas_size(canvas->GetBaseLayerDimensions());
flutter::DlPaint rect_paint;
rect_paint.setColor(flutter::DlColor::kGreen());
canvas->Translate(canvas_size.width / 4.f, canvas_size.height / 2.f);
canvas->DrawRect(DlRect::MakeSize(canvas_size / 32.f), rect_paint);
});
EXPECT_THAT(
fake_flatland().graph(),
@ -1302,20 +1252,15 @@ TEST_F(ExternalViewEmbedderTest, SceneWithOneView_DestroyBeforeDrawing) {
const fuchsia::math::SizeU frame_size{
static_cast<uint32_t>(frame_size_signed.width()),
static_cast<uint32_t>(frame_size_signed.height())};
DrawSimpleFrame(external_view_embedder, frame_size_signed, 1.f,
[](flutter::DlCanvas* canvas) {
const SkISize layer_size = canvas->GetBaseLayerSize();
const SkSize canvas_size =
SkSize::Make(layer_size.width(), layer_size.height());
flutter::DlPaint rect_paint;
rect_paint.setColor(flutter::DlColor().kGreen());
canvas->Translate(canvas_size.width() / 4.f,
canvas_size.height() / 2.f);
canvas->DrawRect(
SkRect::MakeWH(canvas_size.width() / 32.f,
canvas_size.height() / 32.f),
rect_paint);
});
DrawSimpleFrame(
external_view_embedder, frame_size_signed, 1.f,
[](flutter::DlCanvas* canvas) {
const DlSize canvas_size(canvas->GetBaseLayerDimensions());
flutter::DlPaint rect_paint;
rect_paint.setColor(flutter::DlColor().kGreen());
canvas->Translate(canvas_size.width / 4.f, canvas_size.height / 2.f);
canvas->DrawRect(DlRect::MakeSize(canvas_size / 32.f), rect_paint);
});
// Pump the message loop. The scene updates should propagate to flatland.
loop().RunUntilIdle();
@ -1360,20 +1305,15 @@ TEST_F(ExternalViewEmbedderTest, SceneWithOneView_DestroyBeforeDrawing) {
const fuchsia::math::SizeU new_frame_size{
static_cast<uint32_t>(new_frame_size_signed.width()),
static_cast<uint32_t>(new_frame_size_signed.height())};
DrawSimpleFrame(external_view_embedder, new_frame_size_signed, 1.f,
[](flutter::DlCanvas* canvas) {
const SkISize layer_size = canvas->GetBaseLayerSize();
const SkSize canvas_size =
SkSize::Make(layer_size.width(), layer_size.height());
flutter::DlPaint rect_paint;
rect_paint.setColor(flutter::DlColor::kGreen());
canvas->Translate(canvas_size.width() / 4.f,
canvas_size.height() / 2.f);
canvas->DrawRect(
SkRect::MakeWH(canvas_size.width() / 32.f,
canvas_size.height() / 32.f),
rect_paint);
});
DrawSimpleFrame(
external_view_embedder, new_frame_size_signed, 1.f,
[](flutter::DlCanvas* canvas) {
const DlSize canvas_size(canvas->GetBaseLayerDimensions());
flutter::DlPaint rect_paint;
rect_paint.setColor(flutter::DlColor::kGreen());
canvas->Translate(canvas_size.width / 4.f, canvas_size.height / 2.f);
canvas->DrawRect(DlRect::MakeSize(canvas_size / 32.f), rect_paint);
});
EXPECT_THAT(
fake_flatland().graph(),
IsFlutterGraph(
@ -1454,30 +1394,27 @@ TEST_F(ExternalViewEmbedderTest, SimpleScene_DisjointHitRegions) {
const fuchsia::math::SizeU frame_size{
static_cast<uint32_t>(frame_size_signed.width()),
static_cast<uint32_t>(frame_size_signed.height())};
DrawSimpleFrame(
external_view_embedder, frame_size_signed, 1.f,
[](flutter::DlCanvas* canvas) {
const SkISize layer_size = canvas->GetBaseLayerSize();
const SkSize canvas_size =
SkSize::Make(layer_size.width(), layer_size.height());
DrawSimpleFrame(external_view_embedder, frame_size_signed, 1.f,
[](flutter::DlCanvas* canvas) {
const DlSize canvas_size(canvas->GetBaseLayerDimensions());
SkRect paint_region_1, paint_region_2;
DlRect paint_region_1, paint_region_2;
paint_region_1 = SkRect::MakeXYWH(
canvas_size.width() / 4.f, canvas_size.height() / 2.f,
canvas_size.width() / 32.f, canvas_size.height() / 32.f);
paint_region_1 = DlRect::MakeXYWH(
canvas_size.width / 4.f, canvas_size.height / 2.f,
canvas_size.width / 32.f, canvas_size.height / 32.f);
flutter::DlPaint rect_paint;
rect_paint.setColor(flutter::DlColor::kGreen());
canvas->DrawRect(paint_region_1, rect_paint);
flutter::DlPaint rect_paint;
rect_paint.setColor(flutter::DlColor::kGreen());
canvas->DrawRect(paint_region_1, rect_paint);
paint_region_2 = SkRect::MakeXYWH(
canvas_size.width() * 3.f / 4.f, canvas_size.height() / 2.f,
canvas_size.width() / 32.f, canvas_size.height() / 32.f);
paint_region_2 = DlRect::MakeXYWH(
canvas_size.width * 3.f / 4.f, canvas_size.height / 2.f,
canvas_size.width / 32.f, canvas_size.height / 32.f);
rect_paint.setColor(flutter::DlColor::kRed());
canvas->DrawRect(paint_region_2, rect_paint);
});
rect_paint.setColor(flutter::DlColor::kRed());
canvas->DrawRect(paint_region_2, rect_paint);
});
EXPECT_THAT(fake_flatland().graph(),
IsFlutterGraph(parent_viewport_watcher, viewport_creation_token,
view_ref_clone));
@ -1559,23 +1496,21 @@ TEST_F(ExternalViewEmbedderTest, SimpleScene_OverlappingHitRegions) {
DrawSimpleFrame(
external_view_embedder, frame_size_signed, 1.f,
[](flutter::DlCanvas* canvas) {
const SkISize layer_size = canvas->GetBaseLayerSize();
const SkSize canvas_size =
SkSize::Make(layer_size.width(), layer_size.height());
const DlSize canvas_size(canvas->GetBaseLayerDimensions());
SkRect paint_region_1, paint_region_2;
DlRect paint_region_1, paint_region_2;
paint_region_1 = SkRect::MakeXYWH(
canvas_size.width() / 4.f, canvas_size.height() / 2.f,
3.f * canvas_size.width() / 8.f, canvas_size.height() / 4.f);
paint_region_1 = DlRect::MakeXYWH(
canvas_size.width / 4.f, canvas_size.height / 2.f,
3.f * canvas_size.width / 8.f, canvas_size.height / 4.f);
flutter::DlPaint rect_paint;
rect_paint.setColor(flutter::DlColor::kGreen());
canvas->DrawRect(paint_region_1, rect_paint);
paint_region_2 = SkRect::MakeXYWH(
canvas_size.width() * 3.f / 8.f, canvas_size.height() / 2.f,
3.f * canvas_size.width() / 8.f, canvas_size.height() / 4.f);
paint_region_2 = DlRect::MakeXYWH(
canvas_size.width * 3.f / 8.f, canvas_size.height / 2.f,
3.f * canvas_size.width / 8.f, canvas_size.height / 4.f);
rect_paint.setColor(flutter::DlColor::kRed());
canvas->DrawRect(paint_region_2, rect_paint);
@ -1693,28 +1628,19 @@ TEST_F(ExternalViewEmbedderTest, ViewportCoveredWithInputInterceptor) {
external_view_embedder, frame_size_signed, kDPR, child_view_id,
child_view_params,
[](flutter::DlCanvas* canvas) {
const SkISize layer_size = canvas->GetBaseLayerSize();
const SkSize canvas_size =
SkSize::Make(layer_size.width(), layer_size.height());
const DlSize canvas_size(canvas->GetBaseLayerDimensions());
flutter::DlPaint rect_paint;
rect_paint.setColor(flutter::DlColor::kGreen());
canvas->Translate(canvas_size.width() / 4.f,
canvas_size.height() / 2.f);
canvas->DrawRect(SkRect::MakeWH(canvas_size.width() / 32.f,
canvas_size.height() / 32.f),
rect_paint);
canvas->Translate(canvas_size.width / 4.f, canvas_size.height / 2.f);
canvas->DrawRect(DlRect::MakeSize(canvas_size / 32.f), rect_paint);
},
[](flutter::DlCanvas* canvas) {
const SkISize layer_size = canvas->GetBaseLayerSize();
const SkSize canvas_size =
SkSize::Make(layer_size.width(), layer_size.height());
const DlSize canvas_size(canvas->GetBaseLayerDimensions());
flutter::DlPaint rect_paint;
rect_paint.setColor(flutter::DlColor::kRed());
canvas->Translate(canvas_size.width() * 3.f / 4.f,
canvas_size.height() / 2.f);
canvas->DrawRect(SkRect::MakeWH(canvas_size.width() / 32.f,
canvas_size.height() / 32.f),
rect_paint);
canvas->Translate(canvas_size.width * 3.f / 4.f,
canvas_size.height / 2.f);
canvas->DrawRect(DlRect::MakeSize(canvas_size / 32.f), rect_paint);
});
EXPECT_THAT(fake_flatland().graph(),
IsFlutterGraph(parent_viewport_watcher, viewport_creation_token,

12
engine/src/flutter/third_party/txt/src/skia/paragraph_skia.cc vendored
View File

@ -100,7 +100,7 @@ class DisplayListParagraphPainter : public skt::ParagraphPainter {
auto transformed = path.makeTransform(SkMatrix::Translate(
x + blob->bounds().left(), y + blob->bounds().top()));
builder_->DrawPath(transformed, dl_paints_[paint_id]);
builder_->DrawPath(DlPath(transformed), dl_paints_[paint_id]);
return;
}
builder_->DrawTextFrame(impeller::MakeTextFrameFromTextBlobSkia(blob), x,
@ -136,18 +136,18 @@ class DisplayListParagraphPainter : public skt::ParagraphPainter {
void drawRect(const SkRect& rect, const SkPaintOrID& paint) override {
size_t paint_id = std::get<PaintID>(paint);
FML_DCHECK(paint_id < dl_paints_.size());
builder_->DrawRect(rect, dl_paints_[paint_id]);
builder_->DrawRect(ToDlRect(rect), dl_paints_[paint_id]);
}
void drawFilledRect(const SkRect& rect,
const DecorationStyle& decor_style) override {
DlPaint paint = toDlPaint(decor_style, DlDrawStyle::kFill);
builder_->DrawRect(rect, paint);
builder_->DrawRect(ToDlRect(rect), paint);
}
void drawPath(const SkPath& path,
const DecorationStyle& decor_style) override {
builder_->DrawPath(path, toDlPaint(decor_style));
builder_->DrawPath(DlPath(path), toDlPaint(decor_style));
}
void drawLine(SkScalar x0,
@ -163,12 +163,12 @@ class DisplayListParagraphPainter : public skt::ParagraphPainter {
dash_path_effect->fOnLength,
dash_path_effect->fOffLength, paint);
} else {
builder_->DrawLine(SkPoint::Make(x0, y0), SkPoint::Make(x1, y1), paint);
builder_->DrawLine(DlPoint(x0, y0), DlPoint(x1, y1), paint);
}
}
void clipRect(const SkRect& rect) override {
builder_->ClipRect(rect, DlClipOp::kIntersect, false);
builder_->ClipRect(ToDlRect(rect), DlClipOp::kIntersect, false);
}
void translate(SkScalar dx, SkScalar dy) override {