blob: 9bb35ebd9c77d07748c0b767d7e6b42c74615067 [file] [log] [blame]
// Copyright 2013 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "flutter/flow/display_list_canvas.h"
#include "flutter/flow/layers/physical_shape_layer.h"
#include "third_party/skia/include/core/SkColor.h"
#include "third_party/skia/include/core/SkImageInfo.h"
#include "third_party/skia/include/core/SkPath.h"
#include "third_party/skia/include/core/SkPictureRecorder.h"
#include "third_party/skia/include/core/SkRRect.h"
#include "third_party/skia/include/core/SkRSXform.h"
#include "third_party/skia/include/core/SkSurface.h"
#include "third_party/skia/include/core/SkTextBlob.h"
#include "third_party/skia/include/core/SkVertices.h"
#include "third_party/skia/include/effects/SkBlenders.h"
#include "third_party/skia/include/effects/SkDashPathEffect.h"
#include "third_party/skia/include/effects/SkDiscretePathEffect.h"
#include "third_party/skia/include/effects/SkGradientShader.h"
#include "third_party/skia/include/effects/SkImageFilters.h"
#include <cmath>
#include "gtest/gtest.h"
namespace flutter {
namespace testing {
constexpr int TestWidth = 200;
constexpr int TestHeight = 200;
constexpr int RenderWidth = 100;
constexpr int RenderHeight = 100;
constexpr int RenderHalfWidth = 50;
constexpr int RenderHalfHeight = 50;
constexpr int RenderLeft = (TestWidth - RenderWidth) / 2;
constexpr int RenderTop = (TestHeight - RenderHeight) / 2;
constexpr int RenderRight = RenderLeft + RenderWidth;
constexpr int RenderBottom = RenderTop + RenderHeight;
constexpr int RenderCenterX = (RenderLeft + RenderRight) / 2;
constexpr int RenderCenterY = (RenderTop + RenderBottom) / 2;
constexpr SkScalar RenderRadius = std::min(RenderWidth, RenderHeight) / 2.0;
constexpr SkScalar RenderCornerRadius = RenderRadius / 5.0;
constexpr SkPoint TestCenter = SkPoint::Make(TestWidth / 2, TestHeight / 2);
constexpr SkRect TestBounds = SkRect::MakeWH(TestWidth, TestHeight);
constexpr SkRect RenderBounds =
SkRect::MakeLTRB(RenderLeft, RenderTop, RenderRight, RenderBottom);
// The tests try 3 miter limit values, 0.0, 4.0 (the default), and 10.0
// These values will allow us to construct a diamond that spans the
// width or height of the render box and still show the miter for 4.0
// and 10.0.
// These values were discovered by drawing a diamond path in Skia fiddle
// and then playing with the cross-axis size until the miter was about
// as large as it could get before it got cut off.
// The X offsets which will be used for tall vertical diamonds are
// expressed in terms of the rendering height to obtain the proper angle
constexpr SkScalar MiterExtremeDiamondOffsetX = RenderHeight * 0.04;
constexpr SkScalar Miter10DiamondOffsetX = RenderHeight * 0.051;
constexpr SkScalar Miter4DiamondOffsetX = RenderHeight * 0.14;
// The Y offsets which will be used for long horizontal diamonds are
// expressed in terms of the rendering width to obtain the proper angle
constexpr SkScalar MiterExtremeDiamondOffsetY = RenderWidth * 0.04;
constexpr SkScalar Miter10DiamondOffsetY = RenderWidth * 0.051;
constexpr SkScalar Miter4DiamondOffsetY = RenderWidth * 0.14;
// Render 3 vertical and horizontal diamonds each
// designed to break at the tested miter limits
// 0.0, 4.0 and 10.0
constexpr SkScalar x_off_0 = RenderCenterX;
constexpr SkScalar x_off_l1 = RenderCenterX - Miter4DiamondOffsetX;
constexpr SkScalar x_off_l2 = x_off_l1 - Miter10DiamondOffsetX;
constexpr SkScalar x_off_l3 = x_off_l2 - Miter10DiamondOffsetX;
constexpr SkScalar x_off_r1 = RenderCenterX + Miter4DiamondOffsetX;
constexpr SkScalar x_off_r2 = x_off_r1 + MiterExtremeDiamondOffsetX;
constexpr SkScalar x_off_r3 = x_off_r2 + MiterExtremeDiamondOffsetX;
constexpr SkPoint VerticalMiterDiamondPoints[] = {
// Vertical diamonds:
// M10 M4 Mextreme
// /\ /|\ /\ top of RenderBounds
// / \ / | \ / \ to
// <----X--+--X----> RenderCenter
// \ / \ | / \ / to
// \/ \|/ \/ bottom of RenderBounds
// clang-format off
SkPoint::Make(x_off_l3, RenderCenterY),
SkPoint::Make(x_off_l2, RenderTop),
SkPoint::Make(x_off_l1, RenderCenterY),
SkPoint::Make(x_off_0, RenderTop),
SkPoint::Make(x_off_r1, RenderCenterY),
SkPoint::Make(x_off_r2, RenderTop),
SkPoint::Make(x_off_r3, RenderCenterY),
SkPoint::Make(x_off_r2, RenderBottom),
SkPoint::Make(x_off_r1, RenderCenterY),
SkPoint::Make(x_off_0, RenderBottom),
SkPoint::Make(x_off_l1, RenderCenterY),
SkPoint::Make(x_off_l2, RenderBottom),
SkPoint::Make(x_off_l3, RenderCenterY),
// clang-format on
};
const int VerticalMiterDiamondPointCount =
sizeof(VerticalMiterDiamondPoints) / sizeof(VerticalMiterDiamondPoints[0]);
constexpr SkScalar y_off_0 = RenderCenterY;
constexpr SkScalar y_off_u1 = RenderCenterY - Miter4DiamondOffsetY;
constexpr SkScalar y_off_u2 = y_off_u1 - Miter10DiamondOffsetY;
constexpr SkScalar y_off_u3 = y_off_u2 - Miter10DiamondOffsetY;
constexpr SkScalar y_off_d1 = RenderCenterY + Miter4DiamondOffsetY;
constexpr SkScalar y_off_d2 = y_off_d1 + MiterExtremeDiamondOffsetY;
constexpr SkScalar y_off_d3 = y_off_d2 + MiterExtremeDiamondOffsetY;
const SkPoint HorizontalMiterDiamondPoints[] = {
// Horizontal diamonds
// Same configuration as Vertical diamonds above but
// rotated 90 degrees
// clang-format off
SkPoint::Make(RenderCenterX, y_off_u3),
SkPoint::Make(RenderLeft, y_off_u2),
SkPoint::Make(RenderCenterX, y_off_u1),
SkPoint::Make(RenderLeft, y_off_0),
SkPoint::Make(RenderCenterX, y_off_d1),
SkPoint::Make(RenderLeft, y_off_d2),
SkPoint::Make(RenderCenterX, y_off_d3),
SkPoint::Make(RenderRight, y_off_d2),
SkPoint::Make(RenderCenterX, y_off_d1),
SkPoint::Make(RenderRight, y_off_0),
SkPoint::Make(RenderCenterX, y_off_u1),
SkPoint::Make(RenderRight, y_off_u2),
SkPoint::Make(RenderCenterX, y_off_u3),
// clang-format on
};
const int HorizontalMiterDiamondPointCount =
(sizeof(HorizontalMiterDiamondPoints) /
sizeof(HorizontalMiterDiamondPoints[0]));
// A class to specify how much tolerance to allow in bounds estimates.
// For some attributes, the machinery must make some conservative
// assumptions as to the extent of the bounds, but some of our test
// parameters do not produce bounds that expand by the full conservative
// estimates. This class provides a number of tweaks to apply to the
// pixel bounds to account for the conservative factors.
//
// An instance is passed along through the methods and if any test adds
// a paint attribute or other modifier that will cause a more conservative
// estimate for bounds, it can modify the factors here to account for it.
// Ideally, all tests will be executed with geometry that will trigger
// the conservative cases anyway and all attributes will be combined with
// other attributes that make their output more predictable, but in those
// cases where a given test sequence cannot really provide attributes to
// demonstrate the worst case scenario, they can modify these factors to
// avoid false bounds overflow notifications.
class BoundsTolerance {
public:
BoundsTolerance() : BoundsTolerance(0, 0, 1, 1, 0, 0, 0) {}
BoundsTolerance(SkScalar bounds_pad_x,
SkScalar bounds_pad_y,
SkScalar scale_x,
SkScalar scale_y,
SkScalar absolute_pad_x,
SkScalar absolute_pad_y,
SkScalar discrete_offset)
: bounds_pad_x_(bounds_pad_x),
bounds_pad_y_(bounds_pad_y),
scale_x_(scale_x),
scale_y_(scale_y),
absolute_pad_x_(absolute_pad_x),
absolute_pad_y_(absolute_pad_y),
discrete_offset_(discrete_offset) {}
BoundsTolerance addBoundsPadding(SkScalar bounds_pad_x,
SkScalar bounds_pad_y) const {
return {bounds_pad_x_ + bounds_pad_x,
bounds_pad_y_ + bounds_pad_y,
scale_x_,
scale_y_,
absolute_pad_x_,
absolute_pad_y_,
discrete_offset_};
}
BoundsTolerance addScale(SkScalar scale_x, SkScalar scale_y) const {
return {bounds_pad_x_, //
bounds_pad_y_, //
scale_x_ * scale_x, //
scale_y_ * scale_y, //
absolute_pad_x_, //
absolute_pad_y_, //
discrete_offset_};
}
BoundsTolerance addAbsolutePadding(SkScalar absolute_pad_x,
SkScalar absolute_pad_y) const {
return {bounds_pad_x_,
bounds_pad_y_,
scale_x_,
scale_y_,
absolute_pad_x_ + absolute_pad_x,
absolute_pad_y_ + absolute_pad_y,
discrete_offset_};
}
BoundsTolerance addDiscreteOffset(SkScalar discrete_offset) const {
return {bounds_pad_x_,
bounds_pad_y_,
scale_x_,
scale_y_,
absolute_pad_x_,
absolute_pad_y_,
discrete_offset_ + discrete_offset};
}
bool overflows(SkISize pix_size,
int worst_bounds_pad_x,
int worst_bounds_pad_y) const {
int scaled_bounds_pad_x =
std::ceil((pix_size.width() + bounds_pad_x_) * scale_x_);
int allowed_width = scaled_bounds_pad_x + absolute_pad_x_;
int scaled_bounds_pad_y =
std::ceil((pix_size.height() + bounds_pad_y_) * scale_y_);
int allowed_height = scaled_bounds_pad_y + absolute_pad_y_;
int allowed_pad_x = allowed_width - pix_size.width();
int allowed_pad_y = allowed_height - pix_size.height();
if (worst_bounds_pad_x > allowed_pad_x ||
worst_bounds_pad_y > allowed_pad_y) {
FML_LOG(ERROR) << "allowed pad: " //
<< allowed_pad_x << ", " << allowed_pad_y;
}
return (worst_bounds_pad_x > allowed_pad_x ||
worst_bounds_pad_y > allowed_pad_y);
}
SkScalar discrete_offset() const { return discrete_offset_; }
private:
SkScalar bounds_pad_x_;
SkScalar bounds_pad_y_;
SkScalar scale_x_;
SkScalar scale_y_;
SkScalar absolute_pad_x_;
SkScalar absolute_pad_y_;
SkScalar discrete_offset_;
};
class CanvasCompareTester {
private:
// If a test is using any shadow operations then we cannot currently
// record those in an SkCanvas and play it back into a DisplayList
// because internally the operation gets encapsulated in a Skia
// ShadowRec which is not exposed by their headers. For operations
// that use shadows, we can perform a lot of tests, but not the tests
// that require SkCanvas->DisplayList transfers.
// See: https://bugs.chromium.org/p/skia/issues/detail?id=12125
static bool TestingDrawShadows;
// The CPU renders nothing for drawVertices with a Blender.
// See: https://bugs.chromium.org/p/skia/issues/detail?id=12200
static bool TestingDrawVertices;
// The CPU renders nothing for drawAtlas with a Blender.
// See: https://bugs.chromium.org/p/skia/issues/detail?id=12199
static bool TestingDrawAtlas;
public:
typedef const std::function<void(SkCanvas*, SkPaint&)> CvRenderer;
typedef const std::function<void(DisplayListBuilder&)> DlRenderer;
typedef const std::function<const BoundsTolerance(const BoundsTolerance&,
const SkPaint&,
const SkMatrix&)>
ToleranceAdjuster;
static BoundsTolerance DefaultTolerance;
static const BoundsTolerance DefaultAdjuster(const BoundsTolerance& tolerance,
const SkPaint& paint,
const SkMatrix& matrix) {
return tolerance;
}
// All of the tests should eventually use this method except for the
// tests that call |RenderNoAttributes| because they do not use the
// SkPaint object.
// But there are a couple of conditions beyond our control which require
// the use of one of the variant methods below (|RenderShadows|,
// |RenderVertices|, |RenderAtlas|).
static void RenderAll(CvRenderer& cv_renderer,
DlRenderer& dl_renderer,
ToleranceAdjuster& adjuster = DefaultAdjuster,
const BoundsTolerance& tolerance = DefaultTolerance) {
RenderNoAttributes(cv_renderer, dl_renderer, adjuster, tolerance);
RenderWithAttributes(cv_renderer, dl_renderer, adjuster, tolerance);
}
// Used by the tests that render shadows to deal with a condition where
// we cannot recapture the shadow information from an SkCanvas stream
// due to the DrawShadowRec used by Skia is not properly exported.
// See: https://bugs.chromium.org/p/skia/issues/detail?id=12125
static void RenderShadows(
CvRenderer& cv_renderer,
DlRenderer& dl_renderer,
ToleranceAdjuster& adjuster = DefaultAdjuster,
const BoundsTolerance& tolerance = DefaultTolerance) {
TestingDrawShadows = true;
RenderNoAttributes(cv_renderer, dl_renderer, adjuster, tolerance);
TestingDrawShadows = false;
}
// Used by the tests that call drawVertices to avoid using an SkBlender
// during testing because the CPU renderer appears not to render anything.
// See: https://bugs.chromium.org/p/skia/issues/detail?id=12200
static void RenderVertices(CvRenderer& cv_renderer, DlRenderer& dl_renderer) {
TestingDrawVertices = true;
RenderAll(cv_renderer, dl_renderer);
TestingDrawVertices = false;
}
// Used by the tests that call drawAtlas to avoid using an SkBlender
// during testing because the CPU renderer appears not to render anything.
// See: https://bugs.chromium.org/p/skia/issues/detail?id=12199
static void RenderAtlas(CvRenderer& cv_renderer, DlRenderer& dl_renderer) {
TestingDrawAtlas = true;
RenderAll(cv_renderer, dl_renderer);
TestingDrawAtlas = false;
}
// Used by the tests that call a draw method that does not take a paint
// call. Those tests could use |RenderAll| but there would be a lot of
// wasted test runs that prepare an SkPaint that is never used.
static void RenderNoAttributes(
CvRenderer& cv_renderer,
DlRenderer& dl_renderer,
ToleranceAdjuster& adjuster = DefaultAdjuster,
const BoundsTolerance& tolerance = DefaultTolerance) {
RenderWith([=](SkCanvas*, SkPaint& p) {}, //
[=](DisplayListBuilder& d) {}, //
cv_renderer, dl_renderer, adjuster, tolerance, "Base Test");
RenderWithTransforms(cv_renderer, dl_renderer, adjuster, tolerance);
RenderWithClips(cv_renderer, dl_renderer, adjuster, tolerance);
RenderWithSaveRestore(cv_renderer, dl_renderer, adjuster, tolerance);
}
static void RenderWithSaveRestore(CvRenderer& cv_renderer,
DlRenderer& dl_renderer,
ToleranceAdjuster& adjuster,
const BoundsTolerance& tolerance) {
SkRect clip = SkRect::MakeLTRB(0, 0, 10, 10);
SkRect rect = SkRect::MakeLTRB(5, 5, 15, 15);
SkColor alpha_layer_color = SkColorSetARGB(0x7f, 0x00, 0xff, 0xff);
SkColor default_color = SkPaint().getColor();
CvRenderer cv_restored = [=](SkCanvas* cv, SkPaint& p) {
// Draw more than one primitive to disable peephole optimizations
cv->drawRect(RenderBounds.makeOutset(5, 5), p);
cv_renderer(cv, p);
cv->restore();
};
DlRenderer dl_restored = [=](DisplayListBuilder& b) {
// Draw more than one primitive to disable peephole optimizations
b.drawRect(RenderBounds.makeOutset(5, 5));
dl_renderer(b);
b.restore();
};
RenderWith(
[=](SkCanvas* cv, SkPaint& p) {
cv->save();
cv->clipRect(clip, SkClipOp::kIntersect, false);
cv->drawRect(rect, p);
cv->restore();
},
[=](DisplayListBuilder& b) {
b.save();
b.clipRect(clip, SkClipOp::kIntersect, false);
b.drawRect(rect);
b.restore();
},
cv_renderer, dl_renderer, adjuster, tolerance,
"With prior save/clip/restore");
RenderWith(
[=](SkCanvas* cv, SkPaint& p) { //
cv->saveLayer(nullptr, nullptr);
},
[=](DisplayListBuilder& b) { //
b.saveLayer(nullptr, false);
},
cv_restored, dl_restored, adjuster, tolerance,
"saveLayer no paint, no bounds");
RenderWith(
[=](SkCanvas* cv, SkPaint& p) { //
cv->saveLayer(RenderBounds, nullptr);
},
[=](DisplayListBuilder& b) { //
b.saveLayer(&RenderBounds, false);
},
cv_restored, dl_restored, adjuster, tolerance,
"saveLayer no paint, with bounds");
RenderWith(
[=](SkCanvas* cv, SkPaint& p) {
SkPaint save_p;
save_p.setColor(alpha_layer_color);
cv->saveLayer(nullptr, &save_p);
},
[=](DisplayListBuilder& b) {
b.setColor(alpha_layer_color);
b.saveLayer(nullptr, true);
b.setColor(default_color);
},
cv_restored, dl_restored, adjuster, tolerance,
"saveLayer with alpha, no bounds");
RenderWith(
[=](SkCanvas* cv, SkPaint& p) {
SkPaint save_p;
save_p.setColor(alpha_layer_color);
cv->saveLayer(RenderBounds, &save_p);
},
[=](DisplayListBuilder& b) {
b.setColor(alpha_layer_color);
b.saveLayer(&RenderBounds, true);
b.setColor(default_color);
},
cv_restored, dl_restored, adjuster, tolerance,
"saveLayer with alpha and bounds");
{
sk_sp<SkImageFilter> filter =
SkImageFilters::Blur(5.0, 5.0, SkTileMode::kDecal, nullptr, nullptr);
BoundsTolerance blur5Tolerance = tolerance.addBoundsPadding(4, 4);
{
RenderWith(
[=](SkCanvas* cv, SkPaint& p) {
SkPaint save_p;
save_p.setImageFilter(filter);
cv->saveLayer(nullptr, &save_p);
p.setStrokeWidth(5.0);
},
[=](DisplayListBuilder& b) {
b.setImageFilter(filter);
b.saveLayer(nullptr, true);
b.setImageFilter(nullptr);
b.setStrokeWidth(5.0);
},
cv_restored, dl_restored, adjuster, blur5Tolerance,
"saveLayer ImageFilter, no bounds");
}
ASSERT_TRUE(filter->unique())
<< "saveLayer ImageFilter, no bounds Cleanup";
{
RenderWith(
[=](SkCanvas* cv, SkPaint& p) {
SkPaint save_p;
save_p.setImageFilter(filter);
cv->saveLayer(RenderBounds, &save_p);
p.setStrokeWidth(5.0);
},
[=](DisplayListBuilder& b) {
b.setImageFilter(filter);
b.saveLayer(&RenderBounds, true);
b.setImageFilter(nullptr);
b.setStrokeWidth(5.0);
},
cv_restored, dl_restored, adjuster, blur5Tolerance,
"saveLayer ImageFilter and bounds");
}
ASSERT_TRUE(filter->unique())
<< "saveLayer ImageFilter and bounds Cleanup";
}
}
static void RenderWithAttributes(CvRenderer& cv_renderer,
DlRenderer& dl_renderer,
ToleranceAdjuster& adjuster,
const BoundsTolerance& tolerance) {
RenderWith([=](SkCanvas*, SkPaint& p) {}, //
[=](DisplayListBuilder& d) {}, //
cv_renderer, dl_renderer, adjuster, tolerance, "Base Test");
RenderWith([=](SkCanvas*, SkPaint& p) { p.setAntiAlias(true); }, //
[=](DisplayListBuilder& b) { b.setAntiAlias(true); }, //
cv_renderer, dl_renderer, adjuster, tolerance,
"AntiAlias == True");
RenderWith([=](SkCanvas*, SkPaint& p) { p.setAntiAlias(false); }, //
[=](DisplayListBuilder& b) { b.setAntiAlias(false); }, //
cv_renderer, dl_renderer, adjuster, tolerance,
"AntiAlias == False");
RenderWith([=](SkCanvas*, SkPaint& p) { p.setDither(true); }, //
[=](DisplayListBuilder& b) { b.setDither(true); }, //
cv_renderer, dl_renderer, adjuster, tolerance, "Dither == True");
RenderWith([=](SkCanvas*, SkPaint& p) { p.setDither(false); }, //
[=](DisplayListBuilder& b) { b.setDither(false); }, //
cv_renderer, dl_renderer, adjuster, tolerance, "Dither = False");
RenderWith([=](SkCanvas*, SkPaint& p) { p.setColor(SK_ColorBLUE); }, //
[=](DisplayListBuilder& b) { b.setColor(SK_ColorBLUE); }, //
cv_renderer, dl_renderer, adjuster, tolerance, "Color == Blue");
RenderWith([=](SkCanvas*, SkPaint& p) { p.setColor(SK_ColorGREEN); }, //
[=](DisplayListBuilder& b) { b.setColor(SK_ColorGREEN); }, //
cv_renderer, dl_renderer, adjuster, tolerance, "Color == Green");
RenderWithStrokes(cv_renderer, dl_renderer, adjuster, tolerance);
{
// half opaque cyan
SkColor blendableColor = SkColorSetARGB(0x7f, 0x00, 0xff, 0xff);
SkColor bg = SK_ColorWHITE;
RenderWith(
[=](SkCanvas*, SkPaint& p) {
p.setBlendMode(SkBlendMode::kSrcIn);
p.setColor(blendableColor);
},
[=](DisplayListBuilder& b) {
b.setBlendMode(SkBlendMode::kSrcIn);
b.setColor(blendableColor);
},
cv_renderer, dl_renderer, adjuster, tolerance, "Blend == SrcIn", &bg);
RenderWith(
[=](SkCanvas*, SkPaint& p) {
p.setBlendMode(SkBlendMode::kDstIn);
p.setColor(blendableColor);
},
[=](DisplayListBuilder& b) {
b.setBlendMode(SkBlendMode::kDstIn);
b.setColor(blendableColor);
},
cv_renderer, dl_renderer, adjuster, tolerance, "Blend == DstIn", &bg);
}
if (!(TestingDrawAtlas || TestingDrawVertices)) {
sk_sp<SkBlender> blender =
SkBlenders::Arithmetic(0.25, 0.25, 0.25, 0.25, false);
{
RenderWith([=](SkCanvas*, SkPaint& p) { p.setBlender(blender); },
[=](DisplayListBuilder& b) { b.setBlender(blender); },
cv_renderer, dl_renderer, adjuster, tolerance,
"ImageFilter == Blender Arithmetic 0.25-false");
}
ASSERT_TRUE(blender->unique()) << "Blender Cleanup";
blender = SkBlenders::Arithmetic(0.25, 0.25, 0.25, 0.25, true);
{
RenderWith([=](SkCanvas*, SkPaint& p) { p.setBlender(blender); },
[=](DisplayListBuilder& b) { b.setBlender(blender); },
cv_renderer, dl_renderer, adjuster, tolerance,
"ImageFilter == Blender Arithmetic 0.25-true");
}
ASSERT_TRUE(blender->unique()) << "Blender Cleanup";
}
{
sk_sp<SkImageFilter> filter =
SkImageFilters::Blur(5.0, 5.0, SkTileMode::kDecal, nullptr, nullptr);
BoundsTolerance blur5Tolerance = tolerance.addBoundsPadding(4, 4);
{
RenderWith(
[=](SkCanvas*, SkPaint& p) {
// Provide some non-trivial stroke size to get blurred
p.setStrokeWidth(5.0);
p.setImageFilter(filter);
},
[=](DisplayListBuilder& b) {
// Provide some non-trivial stroke size to get blurred
b.setStrokeWidth(5.0);
b.setImageFilter(filter);
},
cv_renderer, dl_renderer, adjuster, blur5Tolerance,
"ImageFilter == Decal Blur 5");
}
ASSERT_TRUE(filter->unique()) << "ImageFilter Cleanup";
filter =
SkImageFilters::Blur(5.0, 5.0, SkTileMode::kClamp, nullptr, nullptr);
{
RenderWith(
[=](SkCanvas*, SkPaint& p) {
// Provide some non-trivial stroke size to get blurred
p.setStrokeWidth(5.0);
p.setImageFilter(filter);
},
[=](DisplayListBuilder& b) {
// Provide some non-trivial stroke size to get blurred
b.setStrokeWidth(5.0);
b.setImageFilter(filter);
},
cv_renderer, dl_renderer, adjuster, blur5Tolerance,
"ImageFilter == Clamp Blur 5");
}
ASSERT_TRUE(filter->unique()) << "ImageFilter Cleanup";
}
{
// clang-format off
constexpr float rotate_color_matrix[20] = {
0, 1, 0, 0, 0,
0, 0, 1, 0, 0,
1, 0, 0, 0, 0,
0, 0, 0, 1, 0,
};
constexpr float invert_color_matrix[20] = {
-1.0, 0, 0, 1.0, 0,
0, -1.0, 0, 1.0, 0,
0, 0, -1.0, 1.0, 0,
1.0, 1.0, 1.0, 1.0, 0,
};
// clang-format on
sk_sp<SkColorFilter> filter = SkColorFilters::Matrix(rotate_color_matrix);
{
SkColor bg = SK_ColorWHITE;
RenderWith(
[=](SkCanvas*, SkPaint& p) {
p.setColor(SK_ColorYELLOW);
p.setColorFilter(filter);
},
[=](DisplayListBuilder& b) {
b.setColor(SK_ColorYELLOW);
b.setColorFilter(filter);
},
cv_renderer, dl_renderer, adjuster, tolerance,
"ColorFilter == RotateRGB", &bg);
}
ASSERT_TRUE(filter->unique()) << "ColorFilter == RotateRGB Cleanup";
filter = SkColorFilters::Matrix(invert_color_matrix);
{
SkColor bg = SK_ColorWHITE;
RenderWith(
[=](SkCanvas*, SkPaint& p) {
p.setColor(SK_ColorYELLOW);
p.setColorFilter(filter);
},
[=](DisplayListBuilder& b) {
b.setColor(SK_ColorYELLOW);
b.setInvertColors(true);
},
cv_renderer, dl_renderer, adjuster, tolerance,
"ColorFilter == Invert", &bg);
}
ASSERT_TRUE(filter->unique()) << "ColorFilter == Invert Cleanup";
}
{
sk_sp<SkPathEffect> effect = SkDiscretePathEffect::Make(3, 5);
{
// Discrete path effects need a stroke width for drawPointsAsPoints
// to do something realistic
RenderWith(
[=](SkCanvas*, SkPaint& p) {
p.setStrokeWidth(5.0);
// A Discrete(3, 5) effect produces miters that are near
// maximal for a miter limit of 3.0.
p.setStrokeMiter(3.0);
p.setPathEffect(effect);
},
[=](DisplayListBuilder& b) {
b.setStrokeWidth(5.0);
// A Discrete(3, 5) effect produces miters that are near
// maximal for a miter limit of 3.0.
b.setStrokeMiter(3.0);
b.setPathEffect(effect);
},
cv_renderer, dl_renderer, adjuster,
tolerance
// register the discrete offset so adjusters can compensate
.addDiscreteOffset(5)
// the miters in the 3-5 discrete effect don't always fill
// their conservative bounds, so tolerate a couple of pixels
.addBoundsPadding(2, 2),
"PathEffect == Discrete-3-5");
}
ASSERT_TRUE(effect->unique()) << "PathEffect == Discrete-3-5 Cleanup";
effect = SkDiscretePathEffect::Make(2, 3);
{
RenderWith(
[=](SkCanvas*, SkPaint& p) {
p.setStrokeWidth(5.0);
// A Discrete(2, 3) effect produces miters that are near
// maximal for a miter limit of 2.5.
p.setStrokeMiter(2.5);
p.setPathEffect(effect);
},
[=](DisplayListBuilder& b) {
b.setStrokeWidth(5.0);
// A Discrete(2, 3) effect produces miters that are near
// maximal for a miter limit of 2.5.
b.setStrokeMiter(2.5);
b.setPathEffect(effect);
},
cv_renderer, dl_renderer, adjuster,
tolerance
// register the discrete offset so adjusters can compensate
.addDiscreteOffset(3)
// the miters in the 3-5 discrete effect don't always fill
// their conservative bounds, so tolerate a couple of pixels
.addBoundsPadding(2, 2),
"PathEffect == Discrete-2-3");
}
ASSERT_TRUE(effect->unique()) << "PathEffect == Discrete-2-3 Cleanup";
}
{
sk_sp<SkMaskFilter> filter =
SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, 5.0);
BoundsTolerance blur5Tolerance = tolerance.addBoundsPadding(4, 4);
{
RenderWith(
[=](SkCanvas*, SkPaint& p) {
// Provide some non-trivial stroke size to get blurred
p.setStrokeWidth(5.0);
p.setMaskFilter(filter);
},
[=](DisplayListBuilder& b) {
// Provide some non-trivial stroke size to get blurred
b.setStrokeWidth(5.0);
b.setMaskFilter(filter);
},
cv_renderer, dl_renderer, adjuster, blur5Tolerance,
"MaskFilter == Blur 5");
}
ASSERT_TRUE(filter->unique()) << "MaskFilter == Blur 5 Cleanup";
{
RenderWith(
[=](SkCanvas*, SkPaint& p) {
// Provide some non-trivial stroke size to get blurred
p.setStrokeWidth(5.0);
p.setMaskFilter(filter);
},
[=](DisplayListBuilder& b) {
// Provide some non-trivial stroke size to get blurred
b.setStrokeWidth(5.0);
b.setMaskBlurFilter(kNormal_SkBlurStyle, 5.0);
},
cv_renderer, dl_renderer, adjuster, blur5Tolerance,
"MaskFilter == Blur(Normal, 5.0)");
}
ASSERT_TRUE(filter->unique())
<< "MaskFilter == Blur(Normal, 5.0) Cleanup";
}
{
SkPoint end_points[] = {
SkPoint::Make(RenderBounds.fLeft, RenderBounds.fTop),
SkPoint::Make(RenderBounds.fRight, RenderBounds.fBottom),
};
SkColor colors[] = {
SK_ColorGREEN,
SK_ColorYELLOW,
SK_ColorBLUE,
};
float stops[] = {
0.0,
0.5,
1.0,
};
sk_sp<SkShader> shader = SkGradientShader::MakeLinear(
end_points, colors, stops, 3, SkTileMode::kMirror, 0, nullptr);
{
RenderWith([=](SkCanvas*, SkPaint& p) { p.setShader(shader); },
[=](DisplayListBuilder& b) { b.setShader(shader); },
cv_renderer, dl_renderer, adjuster, tolerance,
"LinearGradient GYB");
}
ASSERT_TRUE(shader->unique()) << "LinearGradient GYB Cleanup";
}
}
static void RenderWithStrokes(CvRenderer& cv_renderer,
DlRenderer& dl_renderer,
ToleranceAdjuster& adjuster,
const BoundsTolerance& tolerance_in) {
// The test cases were generated with geometry that will try to fill
// out the various miter limits used for testing, but they can be off
// by a couple of pixels so we will relax bounds testing for strokes by
// a couple of pixels.
BoundsTolerance tolerance = tolerance_in.addBoundsPadding(2, 2);
RenderWith( //
[=](SkCanvas*, SkPaint& p) { p.setStyle(SkPaint::kFill_Style); },
[=](DisplayListBuilder& b) { b.setStyle(SkPaint::kFill_Style); },
cv_renderer, dl_renderer, adjuster, tolerance, "Fill");
RenderWith(
[=](SkCanvas*, SkPaint& p) { p.setStyle(SkPaint::kStroke_Style); },
[=](DisplayListBuilder& b) { b.setStyle(SkPaint::kStroke_Style); },
cv_renderer, dl_renderer, adjuster, tolerance, "Stroke + defaults");
RenderWith(
[=](SkCanvas*, SkPaint& p) {
p.setStyle(SkPaint::kFill_Style);
p.setStrokeWidth(10.0);
},
[=](DisplayListBuilder& b) {
b.setStyle(SkPaint::kFill_Style);
b.setStrokeWidth(10.0);
},
cv_renderer, dl_renderer, adjuster, tolerance,
"Fill + unnecessary StrokeWidth 10");
RenderWith(
[=](SkCanvas*, SkPaint& p) {
p.setStyle(SkPaint::kStroke_Style);
p.setStrokeWidth(10.0);
},
[=](DisplayListBuilder& b) {
b.setStyle(SkPaint::kStroke_Style);
b.setStrokeWidth(10.0);
},
cv_renderer, dl_renderer, adjuster, tolerance, "Stroke Width 10");
RenderWith(
[=](SkCanvas*, SkPaint& p) {
p.setStyle(SkPaint::kStroke_Style);
p.setStrokeWidth(5.0);
},
[=](DisplayListBuilder& b) {
b.setStyle(SkPaint::kStroke_Style);
b.setStrokeWidth(5.0);
},
cv_renderer, dl_renderer, adjuster, tolerance, "Stroke Width 5");
RenderWith(
[=](SkCanvas*, SkPaint& p) {
p.setStyle(SkPaint::kStroke_Style);
p.setStrokeWidth(5.0);
p.setStrokeCap(SkPaint::kButt_Cap);
},
[=](DisplayListBuilder& b) {
b.setStyle(SkPaint::kStroke_Style);
b.setStrokeWidth(5.0);
b.setStrokeCap(SkPaint::kButt_Cap);
},
cv_renderer, dl_renderer, adjuster, tolerance,
"Stroke Width 5, Butt Cap");
RenderWith(
[=](SkCanvas*, SkPaint& p) {
p.setStyle(SkPaint::kStroke_Style);
p.setStrokeWidth(5.0);
p.setStrokeCap(SkPaint::kRound_Cap);
},
[=](DisplayListBuilder& b) {
b.setStyle(SkPaint::kStroke_Style);
b.setStrokeWidth(5.0);
b.setStrokeCap(SkPaint::kRound_Cap);
},
cv_renderer, dl_renderer, adjuster, tolerance,
"Stroke Width 5, Round Cap");
RenderWith(
[=](SkCanvas*, SkPaint& p) {
p.setStyle(SkPaint::kStroke_Style);
p.setStrokeWidth(5.0);
p.setStrokeJoin(SkPaint::kBevel_Join);
},
[=](DisplayListBuilder& b) {
b.setStyle(SkPaint::kStroke_Style);
b.setStrokeWidth(5.0);
b.setStrokeJoin(SkPaint::kBevel_Join);
},
cv_renderer, dl_renderer, adjuster, tolerance,
"Stroke Width 5, Bevel Join");
RenderWith(
[=](SkCanvas*, SkPaint& p) {
p.setStyle(SkPaint::kStroke_Style);
p.setStrokeWidth(5.0);
p.setStrokeJoin(SkPaint::kRound_Join);
},
[=](DisplayListBuilder& b) {
b.setStyle(SkPaint::kStroke_Style);
b.setStrokeWidth(5.0);
b.setStrokeJoin(SkPaint::kRound_Join);
},
cv_renderer, dl_renderer, adjuster, tolerance,
"Stroke Width 5, Round Join");
RenderWith(
[=](SkCanvas*, SkPaint& p) {
p.setStyle(SkPaint::kStroke_Style);
p.setStrokeWidth(5.0);
p.setStrokeMiter(10.0);
p.setStrokeJoin(SkPaint::kMiter_Join);
// AA helps fill in the peaks of the really thin miters better
// for bounds accuracy testing
p.setAntiAlias(true);
},
[=](DisplayListBuilder& b) {
b.setStyle(SkPaint::kStroke_Style);
b.setStrokeWidth(5.0);
b.setStrokeMiter(10.0);
b.setStrokeJoin(SkPaint::kMiter_Join);
// AA helps fill in the peaks of the really thin miters better
// for bounds accuracy testing
b.setAntiAlias(true);
},
cv_renderer, dl_renderer, adjuster, tolerance,
"Stroke Width 5, Miter 10");
RenderWith(
[=](SkCanvas*, SkPaint& p) {
p.setStyle(SkPaint::kStroke_Style);
p.setStrokeWidth(5.0);
p.setStrokeMiter(0.0);
p.setStrokeJoin(SkPaint::kMiter_Join);
},
[=](DisplayListBuilder& b) {
b.setStyle(SkPaint::kStroke_Style);
b.setStrokeWidth(5.0);
b.setStrokeMiter(0.0);
b.setStrokeJoin(SkPaint::kMiter_Join);
},
cv_renderer, dl_renderer, adjuster, tolerance,
"Stroke Width 5, Miter 0");
{
const SkScalar TestDashes1[] = {29.0, 2.0};
const SkScalar TestDashes2[] = {17.0, 1.5};
sk_sp<SkPathEffect> effect = SkDashPathEffect::Make(TestDashes1, 2, 0.0f);
{
RenderWith(
[=](SkCanvas*, SkPaint& p) {
// Need stroke style to see dashing properly
p.setStyle(SkPaint::kStroke_Style);
// Provide some non-trivial stroke size to get dashed
p.setStrokeWidth(5.0);
p.setPathEffect(effect);
},
[=](DisplayListBuilder& b) {
// Need stroke style to see dashing properly
b.setStyle(SkPaint::kStroke_Style);
// Provide some non-trivial stroke size to get dashed
b.setStrokeWidth(5.0);
b.setPathEffect(effect);
},
cv_renderer, dl_renderer, adjuster, tolerance,
"PathEffect == Dash-29-2");
}
ASSERT_TRUE(effect->unique()) << "PathEffect == Dash-29-2 Cleanup";
effect = SkDashPathEffect::Make(TestDashes2, 2, 0.0f);
{
RenderWith(
[=](SkCanvas*, SkPaint& p) {
// Need stroke style to see dashing properly
p.setStyle(SkPaint::kStroke_Style);
// Provide some non-trivial stroke size to get dashed
p.setStrokeWidth(5.0);
p.setPathEffect(effect);
},
[=](DisplayListBuilder& b) {
// Need stroke style to see dashing properly
b.setStyle(SkPaint::kStroke_Style);
// Provide some non-trivial stroke size to get dashed
b.setStrokeWidth(5.0);
b.setPathEffect(effect);
},
cv_renderer, dl_renderer, adjuster, tolerance,
"PathEffect == Dash-17-1.5");
}
ASSERT_TRUE(effect->unique()) << "PathEffect == Dash-17-1.5 Cleanup";
}
}
static void RenderWithTransforms(CvRenderer& cv_renderer,
DlRenderer& dl_renderer,
ToleranceAdjuster& adjuster,
const BoundsTolerance& tolerance) {
// If there is bounds padding for some conservative bounds overestimate
// then that padding will be even more pronounced in rotated or skewed
// coordinate systems so we scale the padding by about 5% to compensate.
BoundsTolerance skewed_tolerance = tolerance.addScale(1.05, 1.05);
RenderWith([=](SkCanvas* c, SkPaint&) { c->translate(5, 10); }, //
[=](DisplayListBuilder& b) { b.translate(5, 10); }, //
cv_renderer, dl_renderer, adjuster, tolerance,
"Translate 5, 10");
RenderWith([=](SkCanvas* c, SkPaint&) { c->scale(1.05, 1.05); }, //
[=](DisplayListBuilder& b) { b.scale(1.05, 1.05); }, //
cv_renderer, dl_renderer, adjuster, tolerance, //
"Scale +5%");
RenderWith([=](SkCanvas* c, SkPaint&) { c->rotate(5); }, //
[=](DisplayListBuilder& b) { b.rotate(5); }, //
cv_renderer, dl_renderer, adjuster, skewed_tolerance,
"Rotate 5 degrees");
RenderWith([=](SkCanvas* c, SkPaint&) { c->skew(0.05, 0.05); }, //
[=](DisplayListBuilder& b) { b.skew(0.05, 0.05); }, //
cv_renderer, dl_renderer, adjuster, skewed_tolerance, //
"Skew 5%");
{
SkMatrix tx = SkMatrix::MakeAll(1.10, 0.10, 5, //
0.05, 1.05, 10, //
0, 0, 1);
RenderWith([=](SkCanvas* c, SkPaint&) { c->concat(tx); }, //
[=](DisplayListBuilder& b) {
b.transform2DAffine(tx[0], tx[1], tx[2], //
tx[3], tx[4], tx[5]);
}, //
cv_renderer, dl_renderer, adjuster, skewed_tolerance,
"Transform 2D Affine");
}
{
SkM44 m44 = SkM44(1, 0, 0, RenderCenterX, //
0, 1, 0, RenderCenterY, //
0, 0, 1, 0, //
0, 0, .001, 1);
m44.preConcat(SkM44::Rotate({1, 0, 0}, M_PI / 60)); // 3 degrees around X
m44.preConcat(SkM44::Rotate({0, 1, 0}, M_PI / 45)); // 4 degrees around Y
m44.preTranslate(-RenderCenterX, -RenderCenterY);
RenderWith([=](SkCanvas* c, SkPaint&) { c->concat(m44); }, //
[=](DisplayListBuilder& b) {
b.transformFullPerspective(
m44.rc(0, 0), m44.rc(0, 1), m44.rc(0, 2), m44.rc(0, 3),
m44.rc(1, 0), m44.rc(1, 1), m44.rc(1, 2), m44.rc(1, 3),
m44.rc(2, 0), m44.rc(2, 1), m44.rc(2, 2), m44.rc(2, 3),
m44.rc(3, 0), m44.rc(3, 1), m44.rc(3, 2), m44.rc(3, 3));
}, //
cv_renderer, dl_renderer, adjuster, skewed_tolerance,
"Transform Full Perspective");
}
}
static void RenderWithClips(CvRenderer& cv_renderer,
DlRenderer& dl_renderer,
ToleranceAdjuster& diff_adjuster,
const BoundsTolerance& diff_tolerance) {
SkRect r_clip = RenderBounds.makeInset(15.5, 15.5);
// For kIntersect clips we can be really strict on tolerance
ToleranceAdjuster& intersect_adjuster = DefaultAdjuster;
BoundsTolerance& intersect_tolerance = DefaultTolerance;
RenderWith(
[=](SkCanvas* c, SkPaint&) {
c->clipRect(r_clip, SkClipOp::kIntersect, false);
},
[=](DisplayListBuilder& b) {
b.clipRect(r_clip, SkClipOp::kIntersect, false);
},
cv_renderer, dl_renderer, intersect_adjuster, intersect_tolerance,
"Hard ClipRect inset by 15.5");
RenderWith(
[=](SkCanvas* c, SkPaint&) {
c->clipRect(r_clip, SkClipOp::kIntersect, true);
},
[=](DisplayListBuilder& b) {
b.clipRect(r_clip, SkClipOp::kIntersect, true);
},
cv_renderer, dl_renderer, intersect_adjuster, intersect_tolerance,
"AntiAlias ClipRect inset by 15.5");
RenderWith(
[=](SkCanvas* c, SkPaint&) {
c->clipRect(r_clip, SkClipOp::kDifference, false);
},
[=](DisplayListBuilder& b) {
b.clipRect(r_clip, SkClipOp::kDifference, false);
},
cv_renderer, dl_renderer, diff_adjuster, diff_tolerance,
"Hard ClipRect Diff, inset by 15.5");
SkRRect rr_clip = SkRRect::MakeRectXY(r_clip, 1.8, 2.7);
RenderWith(
[=](SkCanvas* c, SkPaint&) {
c->clipRRect(rr_clip, SkClipOp::kIntersect, false);
},
[=](DisplayListBuilder& b) {
b.clipRRect(rr_clip, SkClipOp::kIntersect, false);
},
cv_renderer, dl_renderer, intersect_adjuster, intersect_tolerance,
"Hard ClipRRect inset by 15.5");
RenderWith(
[=](SkCanvas* c, SkPaint&) {
c->clipRRect(rr_clip, SkClipOp::kIntersect, true);
},
[=](DisplayListBuilder& b) {
b.clipRRect(rr_clip, SkClipOp::kIntersect, true);
},
cv_renderer, dl_renderer, intersect_adjuster, intersect_tolerance,
"AntiAlias ClipRRect inset by 15.5");
RenderWith(
[=](SkCanvas* c, SkPaint&) {
c->clipRRect(rr_clip, SkClipOp::kDifference, false);
},
[=](DisplayListBuilder& b) {
b.clipRRect(rr_clip, SkClipOp::kDifference, false);
},
cv_renderer, dl_renderer, diff_adjuster, diff_tolerance,
"Hard ClipRRect Diff, inset by 15.5");
SkPath path_clip = SkPath();
path_clip.setFillType(SkPathFillType::kEvenOdd);
path_clip.addRect(r_clip);
path_clip.addCircle(RenderCenterX, RenderCenterY, 1.0);
RenderWith(
[=](SkCanvas* c, SkPaint&) {
c->clipPath(path_clip, SkClipOp::kIntersect, false);
},
[=](DisplayListBuilder& b) {
b.clipPath(path_clip, SkClipOp::kIntersect, false);
},
cv_renderer, dl_renderer, intersect_adjuster, intersect_tolerance,
"Hard ClipPath inset by 15.5");
RenderWith(
[=](SkCanvas* c, SkPaint&) {
c->clipPath(path_clip, SkClipOp::kIntersect, true);
},
[=](DisplayListBuilder& b) {
b.clipPath(path_clip, SkClipOp::kIntersect, true);
},
cv_renderer, dl_renderer, intersect_adjuster, intersect_tolerance,
"AntiAlias ClipPath inset by 15.5");
RenderWith(
[=](SkCanvas* c, SkPaint&) {
c->clipPath(path_clip, SkClipOp::kDifference, false);
},
[=](DisplayListBuilder& b) {
b.clipPath(path_clip, SkClipOp::kDifference, false);
},
cv_renderer, dl_renderer, diff_adjuster, diff_tolerance,
"Hard ClipPath Diff, inset by 15.5");
}
static sk_sp<SkPicture> getSkPicture(CvRenderer& cv_setup,
CvRenderer& cv_render) {
SkPictureRecorder recorder;
SkRTreeFactory rtree_factory;
SkCanvas* cv = recorder.beginRecording(TestBounds, &rtree_factory);
SkPaint p;
cv_setup(cv, p);
cv_render(cv, p);
return recorder.finishRecordingAsPicture();
}
static void RenderWith(CvRenderer& cv_setup,
DlRenderer& dl_setup,
CvRenderer& cv_render,
DlRenderer& dl_render,
ToleranceAdjuster& adjuster,
const BoundsTolerance& tolerance_in,
const std::string info,
const SkColor* bg = nullptr) {
// surface1 is direct rendering via SkCanvas to SkSurface
// DisplayList mechanisms are not involved in this operation
sk_sp<SkSurface> ref_surface = makeSurface(bg);
SkPaint paint1;
cv_setup(ref_surface->getCanvas(), paint1);
const BoundsTolerance tolerance = adjuster(
tolerance_in, paint1, ref_surface->getCanvas()->getTotalMatrix());
cv_render(ref_surface->getCanvas(), paint1);
sk_sp<SkPicture> ref_picture = getSkPicture(cv_setup, cv_render);
SkRect ref_bounds = ref_picture->cullRect();
SkPixmap ref_pixels;
ASSERT_TRUE(ref_surface->peekPixels(&ref_pixels)) << info;
ASSERT_EQ(ref_pixels.width(), TestWidth) << info;
ASSERT_EQ(ref_pixels.height(), TestHeight) << info;
ASSERT_EQ(ref_pixels.info().bytesPerPixel(), 4) << info;
checkPixels(&ref_pixels, ref_bounds, info + " (Skia reference)", bg);
{
// This sequence plays the provided equivalently constructed
// DisplayList onto the SkCanvas of the surface
// DisplayList => direct rendering
sk_sp<SkSurface> test_surface = makeSurface(bg);
DisplayListBuilder builder(TestBounds);
dl_setup(builder);
dl_render(builder);
sk_sp<DisplayList> display_list = builder.Build();
SkRect dl_bounds = display_list->bounds();
if (!ref_bounds.roundOut().contains(dl_bounds)) {
FML_LOG(ERROR) << "For " << info;
FML_LOG(ERROR) << "ref: " //
<< ref_bounds.fLeft << ", " << ref_bounds.fTop << " => "
<< ref_bounds.fRight << ", " << ref_bounds.fBottom;
FML_LOG(ERROR) << "dl: " //
<< dl_bounds.fLeft << ", " << dl_bounds.fTop << " => "
<< dl_bounds.fRight << ", " << dl_bounds.fBottom;
if (!dl_bounds.contains(ref_bounds)) {
FML_LOG(ERROR) << "DisplayList bounds are too small!";
}
if (!ref_bounds.roundOut().contains(dl_bounds.roundOut())) {
FML_LOG(ERROR) << "###### DisplayList bounds larger than reference!";
}
}
// This sometimes triggers, but when it triggers and I examine
// the ref_bounds, they are always unnecessarily large and
// since the pixel OOB tests in the compare method do not
// trigger, we will trust the DL bounds.
// EXPECT_TRUE(dl_bounds.contains(ref_bounds)) << info;
EXPECT_EQ(display_list->op_count(), ref_picture->approximateOpCount())
<< info;
display_list->RenderTo(test_surface->getCanvas());
compareToReference(test_surface.get(), &ref_pixels,
info + " (DisplayList built directly -> surface)",
&dl_bounds, &tolerance, bg);
}
// This test cannot work if the rendering is using shadows until
// we can access the Skia ShadowRec via public headers.
if (!TestingDrawShadows) {
// This sequence renders SkCanvas calls to a DisplayList and then
// plays them back on SkCanvas to SkSurface
// SkCanvas calls => DisplayList => rendering
sk_sp<SkSurface> test_surface = makeSurface(bg);
DisplayListCanvasRecorder dl_recorder(TestBounds);
SkPaint test_paint;
cv_setup(&dl_recorder, test_paint);
cv_render(&dl_recorder, test_paint);
dl_recorder.builder()->Build()->RenderTo(test_surface->getCanvas());
compareToReference(test_surface.get(), &ref_pixels,
info + " (Skia calls -> DisplayList -> surface)",
nullptr, nullptr, nullptr);
}
{
// This sequence renders the SkCanvas calls to an SkPictureRecorder and
// renders the DisplayList calls to a DisplayListBuilder and then
// renders both back under a transform (scale(2x)) to see if their
// rendering is affected differently by a change of matrix between
// recording time and rendering time.
const int TestWidth2 = TestWidth * 2;
const int TestHeight2 = TestHeight * 2;
const SkScalar TestScale = 2.0;
SkPictureRecorder sk_recorder;
SkCanvas* ref_canvas = sk_recorder.beginRecording(TestBounds);
SkPaint ref_paint;
cv_setup(ref_canvas, ref_paint);
cv_render(ref_canvas, ref_paint);
sk_sp<SkPicture> ref_picture = sk_recorder.finishRecordingAsPicture();
sk_sp<SkSurface> ref_surface2 = makeSurface(bg, TestWidth2, TestHeight2);
SkCanvas* ref_canvas2 = ref_surface2->getCanvas();
ref_canvas2->scale(TestScale, TestScale);
ref_picture->playback(ref_canvas2);
SkPixmap ref_pixels2;
ASSERT_TRUE(ref_surface2->peekPixels(&ref_pixels2)) << info;
ASSERT_EQ(ref_pixels2.width(), TestWidth2) << info;
ASSERT_EQ(ref_pixels2.height(), TestHeight2) << info;
ASSERT_EQ(ref_pixels2.info().bytesPerPixel(), 4) << info;
DisplayListBuilder builder(TestBounds);
dl_setup(builder);
dl_render(builder);
sk_sp<DisplayList> display_list = builder.Build();
sk_sp<SkSurface> test_surface = makeSurface(bg, TestWidth2, TestHeight2);
SkCanvas* test_canvas = test_surface->getCanvas();
test_canvas->scale(TestScale, TestScale);
display_list->RenderTo(test_canvas);
compareToReference(test_surface.get(), &ref_pixels2,
info + " (Both rendered scaled 2x)", nullptr, nullptr,
nullptr, TestWidth2, TestHeight2, false);
}
}
static void checkPixels(SkPixmap* ref_pixels,
SkRect ref_bounds,
const std::string info,
const SkColor* bg) {
SkPMColor untouched = (bg) ? SkPreMultiplyColor(*bg) : 0;
int pixels_touched = 0;
int pixels_oob = 0;
SkIRect i_bounds = ref_bounds.roundOut();
for (int y = 0; y < TestHeight; y++) {
const uint32_t* ref_row = ref_pixels->addr32(0, y);
for (int x = 0; x < TestWidth; x++) {
if (ref_row[x] != untouched) {
pixels_touched++;
if (!i_bounds.contains(x, y)) {
pixels_oob++;
}
}
}
}
ASSERT_EQ(pixels_oob, 0) << info;
ASSERT_GT(pixels_touched, 0) << info;
}
static void compareToReference(SkSurface* test_surface,
SkPixmap* reference,
const std::string info,
SkRect* bounds,
const BoundsTolerance* tolerance,
const SkColor* bg,
int width = TestWidth,
int height = TestHeight,
bool printMismatches = false) {
SkPMColor untouched = (bg) ? SkPreMultiplyColor(*bg) : 0;
SkPixmap test_pixels;
ASSERT_TRUE(test_surface->peekPixels(&test_pixels)) << info;
ASSERT_EQ(test_pixels.width(), width) << info;
ASSERT_EQ(test_pixels.height(), height) << info;
ASSERT_EQ(test_pixels.info().bytesPerPixel(), 4) << info;
SkIRect i_bounds =
bounds ? bounds->roundOut() : SkIRect::MakeWH(width, height);
int pixels_different = 0;
int pixels_oob = 0;
int minX = width;
int minY = height;
int maxX = 0;
int maxY = 0;
for (int y = 0; y < height; y++) {
const uint32_t* ref_row = reference->addr32(0, y);
const uint32_t* test_row = test_pixels.addr32(0, y);
for (int x = 0; x < width; x++) {
if (bounds && test_row[x] != untouched) {
if (minX > x)
minX = x;
if (minY > y)
minY = y;
if (maxX <= x)
maxX = x + 1;
if (maxY <= y)
maxY = y + 1;
if (!i_bounds.contains(x, y)) {
pixels_oob++;
}
}
if (test_row[x] != ref_row[x]) {
if (printMismatches) {
FML_LOG(ERROR) << "pix[" << x << ", " << y
<< "] mismatch: " << std::hex << test_row[x]
<< "(test) != (ref)" << ref_row[x] << std::dec;
}
pixels_different++;
}
}
}
if (pixels_oob > 0) {
FML_LOG(ERROR) << "pix bounds[" //
<< minX << ", " << minY << " => " << maxX << ", " << maxY
<< "]";
FML_LOG(ERROR) << "dl_bounds[" //
<< bounds->fLeft << ", " << bounds->fTop //
<< " => " //
<< bounds->fRight << ", " << bounds->fBottom //
<< "]";
} else if (bounds) {
showBoundsOverflow(info, i_bounds, tolerance, minX, minY, maxX, maxY);
}
ASSERT_EQ(pixels_oob, 0) << info;
ASSERT_EQ(pixels_different, 0) << info;
}
static void showBoundsOverflow(std::string info,
SkIRect& bounds,
const BoundsTolerance* tolerance,
int pixLeft,
int pixTop,
int pixRight,
int pixBottom) {
int pad_left = std::max(0, pixLeft - bounds.fLeft);
int pad_top = std::max(0, pixTop - bounds.fTop);
int pad_right = std::max(0, bounds.fRight - pixRight);
int pad_bottom = std::max(0, bounds.fBottom - pixBottom);
int pixWidth = pixRight - pixLeft;
int pixHeight = pixBottom - pixTop;
SkISize pixSize = SkISize::Make(pixWidth, pixHeight);
int worst_pad_x = std::max(pad_left, pad_right);
int worst_pad_y = std::max(pad_top, pad_bottom);
if (tolerance->overflows(pixSize, worst_pad_x, worst_pad_y)) {
FML_LOG(ERROR) << "Overflow for " << info;
FML_LOG(ERROR) << "pix bounds[" //
<< pixLeft << ", " << pixTop << " => " //
<< pixRight << ", " << pixBottom //
<< "]";
FML_LOG(ERROR) << "dl_bounds[" //
<< bounds.fLeft << ", " << bounds.fTop //
<< " => " //
<< bounds.fRight << ", " << bounds.fBottom //
<< "]";
FML_LOG(ERROR) << "Bounds overflowed by up to " //
<< worst_pad_x << ", " << worst_pad_y //
<< " (" << (worst_pad_x * 100.0 / pixWidth) //
<< "%, " << (worst_pad_y * 100.0 / pixHeight) << "%)";
int pix_area = pixSize.area();
int dl_area = bounds.width() * bounds.height();
FML_LOG(ERROR) << "Total overflow area: " << (dl_area - pix_area) //
<< " (+" << (dl_area * 100.0 / pix_area - 100.0) << "%)";
FML_LOG(ERROR);
}
}
static sk_sp<SkSurface> makeSurface(const SkColor* bg,
int width = TestWidth,
int height = TestHeight) {
sk_sp<SkSurface> surface = SkSurface::MakeRasterN32Premul(width, height);
if (bg) {
surface->getCanvas()->drawColor(*bg);
}
return surface;
}
static const sk_sp<SkImage> testImage;
static const sk_sp<SkImage> makeTestImage() {
sk_sp<SkSurface> surface =
SkSurface::MakeRasterN32Premul(RenderWidth, RenderHeight);
SkCanvas* canvas = surface->getCanvas();
SkPaint p0, p1;
p0.setStyle(SkPaint::kFill_Style);
p0.setColor(SK_ColorGREEN);
p1.setStyle(SkPaint::kFill_Style);
p1.setColor(SK_ColorBLUE);
// Some pixels need some transparency for DstIn testing
p1.setAlpha(128);
int cbdim = 5;
for (int y = 0; y < RenderHeight; y += cbdim) {
for (int x = 0; x < RenderWidth; x += cbdim) {
SkPaint& cellp = ((x + y) & 1) == 0 ? p0 : p1;
canvas->drawRect(SkRect::MakeXYWH(x, y, cbdim, cbdim), cellp);
}
}
return surface->makeImageSnapshot();
}
static sk_sp<SkTextBlob> MakeTextBlob(std::string string,
SkScalar font_height) {
SkFont font(SkTypeface::MakeFromName("ahem", SkFontStyle::Normal()),
font_height);
return SkTextBlob::MakeFromText(string.c_str(), string.size(), font,
SkTextEncoding::kUTF8);
}
};
bool CanvasCompareTester::TestingDrawShadows = false;
bool CanvasCompareTester::TestingDrawVertices = false;
bool CanvasCompareTester::TestingDrawAtlas = false;
BoundsTolerance CanvasCompareTester::DefaultTolerance =
BoundsTolerance().addAbsolutePadding(1, 1);
const sk_sp<SkImage> CanvasCompareTester::testImage =
CanvasCompareTester::makeTestImage();
TEST(DisplayListCanvas, DrawPaint) {
CanvasCompareTester::RenderAll(
[=](SkCanvas* canvas, SkPaint& paint) { //
canvas->drawPaint(paint);
},
[=](DisplayListBuilder& builder) { //
builder.drawPaint();
});
}
TEST(DisplayListCanvas, DrawColor) {
CanvasCompareTester::RenderNoAttributes( //
[=](SkCanvas* canvas, SkPaint& paint) { //
canvas->drawColor(SK_ColorMAGENTA);
},
[=](DisplayListBuilder& builder) { //
builder.drawColor(SK_ColorMAGENTA, SkBlendMode::kSrcOver);
});
}
BoundsTolerance lineTolerance(const BoundsTolerance& tolerance,
const SkPaint& paint,
const SkMatrix& matrix,
bool is_horizontal,
bool is_vertical,
bool ignores_butt_cap) {
SkScalar adjust = 0.0;
SkScalar half_width = paint.getStrokeWidth() * 0.5f;
if (tolerance.discrete_offset() > 0) {
// When a discrete path effect is added, the bounds calculations must allow
// for miters in any direction, but a horizontal line will not have
// miters in the horizontal direction, similarly for vertical
// lines, and diagonal lines will have miters off at a "45 degree" angle
// that don't expand the bounds much at all.
// Also, the discrete offset will not move any points parallel with
// the line, so provide tolerance for both miters and offset.
adjust = half_width * paint.getStrokeMiter() + tolerance.discrete_offset();
}
if (paint.getStrokeCap() == SkPaint::kButt_Cap && !ignores_butt_cap) {
adjust = std::max(adjust, half_width);
}
if (adjust == 0) {
return CanvasCompareTester::DefaultAdjuster(tolerance, paint, matrix);
}
SkScalar hTolerance;
SkScalar vTolerance;
if (is_horizontal) {
FML_DCHECK(!is_vertical);
hTolerance = adjust;
vTolerance = 0;
} else if (is_vertical) {
hTolerance = 0;
vTolerance = adjust;
} else {
// The perpendicular miters just do not impact the bounds of
// diagonal lines at all as they are aimed in the wrong direction
// to matter. So allow tolerance in both axes.
hTolerance = vTolerance = adjust;
}
BoundsTolerance new_tolerance =
tolerance.addBoundsPadding(hTolerance, vTolerance);
return CanvasCompareTester::DefaultAdjuster(new_tolerance, paint, matrix);
}
// For drawing horizontal lines
BoundsTolerance hLineTolerance(const BoundsTolerance& tolerance,
const SkPaint& paint,
const SkMatrix& matrix) {
return lineTolerance(tolerance, paint, matrix, true, false, false);
}
// For drawing vertical lines
BoundsTolerance vLineTolerance(const BoundsTolerance& tolerance,
const SkPaint& paint,
const SkMatrix& matrix) {
return lineTolerance(tolerance, paint, matrix, false, true, false);
}
// For drawing diagonal lines
BoundsTolerance dLineTolerance(const BoundsTolerance& tolerance,
const SkPaint& paint,
const SkMatrix& matrix) {
return lineTolerance(tolerance, paint, matrix, false, false, false);
}
// For drawing individual points (drawPoints(Point_Mode))
BoundsTolerance pointsTolerance(const BoundsTolerance& tolerance,
const SkPaint& paint,
const SkMatrix& matrix) {
return lineTolerance(tolerance, paint, matrix, false, false, true);
}
TEST(DisplayListCanvas, DrawDiagonalLines) {
SkPoint p1 = SkPoint::Make(RenderLeft, RenderTop);
SkPoint p2 = SkPoint::Make(RenderRight, RenderBottom);
SkPoint p3 = SkPoint::Make(RenderLeft, RenderBottom);
SkPoint p4 = SkPoint::Make(RenderRight, RenderTop);
CanvasCompareTester::RenderAll(
[=](SkCanvas* canvas, SkPaint& paint) { //
// Skia requires kStroke style on horizontal and vertical
// lines to get the bounds correct.
// See https://bugs.chromium.org/p/skia/issues/detail?id=12446
SkPaint p = paint;
p.setStyle(SkPaint::kStroke_Style);
canvas->drawLine(p1, p2, p);
canvas->drawLine(p3, p4, p);
},
[=](DisplayListBuilder& builder) { //
builder.drawLine(p1, p2);
builder.drawLine(p3, p4);
},
dLineTolerance);
}
TEST(DisplayListCanvas, DrawHorizontalLine) {
SkPoint p1 = SkPoint::Make(RenderLeft, RenderCenterY);
SkPoint p2 = SkPoint::Make(RenderRight, RenderCenterY);
CanvasCompareTester::RenderAll(
[=](SkCanvas* canvas, SkPaint& paint) { //
// Skia requires kStroke style on horizontal and vertical
// lines to get the bounds correct.
// See https://bugs.chromium.org/p/skia/issues/detail?id=12446
SkPaint p = paint;
p.setStyle(SkPaint::kStroke_Style);
canvas->drawLine(p1, p2, p);
},
[=](DisplayListBuilder& builder) { //
builder.drawLine(p1, p2);
},
hLineTolerance);
}
TEST(DisplayListCanvas, DrawVerticalLine) {
SkPoint p1 = SkPoint::Make(RenderCenterX, RenderTop);
SkPoint p2 = SkPoint::Make(RenderCenterY, RenderBottom);
CanvasCompareTester::RenderAll(
[=](SkCanvas* canvas, SkPaint& paint) { //
// Skia requires kStroke style on horizontal and vertical
// lines to get the bounds correct.
// See https://bugs.chromium.org/p/skia/issues/detail?id=12446
SkPaint p = paint;
p.setStyle(SkPaint::kStroke_Style);
canvas->drawLine(p1, p2, p);
},
[=](DisplayListBuilder& builder) { //
builder.drawLine(p1, p2);
},
vLineTolerance);
}
TEST(DisplayListCanvas, DrawRect) {
CanvasCompareTester::RenderAll(
[=](SkCanvas* canvas, SkPaint& paint) { //
canvas->drawRect(RenderBounds, paint);
},
[=](DisplayListBuilder& builder) { //
builder.drawRect(RenderBounds);
});
}
TEST(DisplayListCanvas, DrawOval) {
SkRect rect = RenderBounds.makeInset(0, 10);
CanvasCompareTester::RenderAll(
[=](SkCanvas* canvas, SkPaint& paint) { //
canvas->drawOval(rect, paint);
},
[=](DisplayListBuilder& builder) { //
builder.drawOval(rect);
});
}
TEST(DisplayListCanvas, DrawCircle) {
CanvasCompareTester::RenderAll(
[=](SkCanvas* canvas, SkPaint& paint) { //
canvas->drawCircle(TestCenter, RenderRadius, paint);
},
[=](DisplayListBuilder& builder) { //
builder.drawCircle(TestCenter, RenderRadius);
});
}
TEST(DisplayListCanvas, DrawRRect) {
SkRRect rrect =
SkRRect::MakeRectXY(RenderBounds, RenderCornerRadius, RenderCornerRadius);
CanvasCompareTester::RenderAll(
[=](SkCanvas* canvas, SkPaint& paint) { //
canvas->drawRRect(rrect, paint);
},
[=](DisplayListBuilder& builder) { //
builder.drawRRect(rrect);
});
}
TEST(DisplayListCanvas, DrawDRRect) {
SkRRect outer =
SkRRect::MakeRectXY(RenderBounds, RenderCornerRadius, RenderCornerRadius);
SkRect innerBounds = RenderBounds.makeInset(30.0, 30.0);
SkRRect inner =
SkRRect::MakeRectXY(innerBounds, RenderCornerRadius, RenderCornerRadius);
CanvasCompareTester::RenderAll(
[=](SkCanvas* canvas, SkPaint& paint) { //
canvas->drawDRRect(outer, inner, paint);
},
[=](DisplayListBuilder& builder) { //
builder.drawDRRect(outer, inner);
});
}
TEST(DisplayListCanvas, DrawPath) {
SkPath path;
path.addRect(RenderBounds);
path.moveTo(VerticalMiterDiamondPoints[0]);
for (int i = 1; i < VerticalMiterDiamondPointCount; i++) {
path.lineTo(VerticalMiterDiamondPoints[i]);
}
path.close();
path.moveTo(HorizontalMiterDiamondPoints[0]);
for (int i = 1; i < HorizontalMiterDiamondPointCount; i++) {
path.lineTo(HorizontalMiterDiamondPoints[i]);
}
path.close();
CanvasCompareTester::RenderAll(
[=](SkCanvas* canvas, SkPaint& paint) { //
canvas->drawPath(path, paint);
},
[=](DisplayListBuilder& builder) { //
builder.drawPath(path);
});
}
TEST(DisplayListCanvas, DrawArc) {
CanvasCompareTester::RenderAll(
[=](SkCanvas* canvas, SkPaint& paint) { //
canvas->drawArc(RenderBounds, 60, 330, false, paint);
},
[=](DisplayListBuilder& builder) { //
builder.drawArc(RenderBounds, 60, 330, false);
});
}
TEST(DisplayListCanvas, DrawArcCenter) {
CanvasCompareTester::RenderAll(
[=](SkCanvas* canvas, SkPaint& paint) { //
canvas->drawArc(RenderBounds, 60, 330, true, paint);
},
[=](DisplayListBuilder& builder) { //
builder.drawArc(RenderBounds, 60, 330, true);
});
}
TEST(DisplayListCanvas, DrawPointsAsPoints) {
// The +/- 16 points are designed to fall just inside the clips
// that are tested against so we avoid lots of undrawn pixels
// in the accumulated bounds.
const SkScalar x0 = RenderLeft;
const SkScalar x1 = RenderLeft + 16;
const SkScalar x2 = (RenderLeft + RenderCenterX) * 0.5;
const SkScalar x3 = RenderCenterX;
const SkScalar x4 = (RenderRight + RenderCenterX) * 0.5;
const SkScalar x5 = RenderRight - 16;
const SkScalar x6 = RenderRight;
const SkScalar y0 = RenderTop;
const SkScalar y1 = RenderTop + 16;
const SkScalar y2 = (RenderTop + RenderCenterY) * 0.5;
const SkScalar y3 = RenderCenterY;
const SkScalar y4 = (RenderBottom + RenderCenterY) * 0.5;
const SkScalar y5 = RenderBottom - 16;
const SkScalar y6 = RenderBottom;
// clang-format off
const SkPoint points[] = {
{x0, y0}, {x1, y0}, {x2, y0}, {x3, y0}, {x4, y0}, {x5, y0}, {x6, y0},
{x0, y1}, {x1, y1}, {x2, y1}, {x3, y1}, {x4, y1}, {x5, y1}, {x6, y1},
{x0, y2}, {x1, y2}, {x2, y2}, {x3, y2}, {x4, y2}, {x5, y2}, {x6, y2},
{x0, y3}, {x1, y3}, {x2, y3}, {x3, y3}, {x4, y3}, {x5, y3}, {x6, y3},
{x0, y4}, {x1, y4}, {x2, y4}, {x3, y4}, {x4, y4}, {x5, y4}, {x6, y4},
{x0, y5}, {x1, y5}, {x2, y5}, {x3, y5}, {x4, y5}, {x5, y5}, {x6, y5},
{x0, y6}, {x1, y6}, {x2, y6}, {x3, y6}, {x4, y6}, {x5, y6}, {x6, y6},
};
// clang-format on
const int count = sizeof(points) / sizeof(points[0]);
CanvasCompareTester::RenderAll(
[=](SkCanvas* canvas, SkPaint& paint) { //
// Skia requires kStroke style on horizontal and vertical
// lines to get the bounds correct.
// See https://bugs.chromium.org/p/skia/issues/detail?id=12446
SkPaint p = paint;
p.setStyle(SkPaint::kStroke_Style);
canvas->drawPoints(SkCanvas::kPoints_PointMode, count, points, p);
},
[=](DisplayListBuilder& builder) { //
builder.drawPoints(SkCanvas::kPoints_PointMode, count, points);
},
pointsTolerance);
}
TEST(DisplayListCanvas, DrawPointsAsLines) {
const SkScalar x0 = RenderLeft + 1;
const SkScalar x1 = RenderLeft + 16;
const SkScalar x2 = RenderRight - 16;
const SkScalar x3 = RenderRight - 1;
const SkScalar y0 = RenderTop;
const SkScalar y1 = RenderTop + 16;
const SkScalar y2 = RenderBottom - 16;
const SkScalar y3 = RenderBottom;
// clang-format off
const SkPoint points[] = {
// Outer box
{x0, y0}, {x3, y0},
{x3, y0}, {x3, y3},
{x3, y3}, {x0, y3},
{x0, y3}, {x0, y0},
// Diagonals
{x0, y0}, {x3, y3}, {x3, y0}, {x0, y3},
// Inner box
{x1, y1}, {x2, y1},
{x2, y1}, {x2, y2},
{x2, y2}, {x1, y2},
{x1, y2}, {x1, y1},
};
// clang-format on
const int count = sizeof(points) / sizeof(points[0]);
ASSERT_TRUE((count & 1) == 0);
CanvasCompareTester::RenderAll(
[=](SkCanvas* canvas, SkPaint& paint) { //
// Skia requires kStroke style on horizontal and vertical
// lines to get the bounds correct.
// See https://bugs.chromium.org/p/skia/issues/detail?id=12446
SkPaint p = paint;
p.setStyle(SkPaint::kStroke_Style);
canvas->drawPoints(SkCanvas::kLines_PointMode, count, points, p);
},
[=](DisplayListBuilder& builder) { //
builder.drawPoints(SkCanvas::kLines_PointMode, count, points);
});
}
TEST(DisplayListCanvas, DrawPointsAsPolygon) {
const SkPoint points1[] = {
// RenderBounds box with a diagonal
SkPoint::Make(RenderLeft, RenderTop),
SkPoint::Make(RenderRight, RenderTop),
SkPoint::Make(RenderRight, RenderBottom),
SkPoint::Make(RenderLeft, RenderBottom),
SkPoint::Make(RenderLeft, RenderTop),
SkPoint::Make(RenderRight, RenderBottom),
};
const int count1 = sizeof(points1) / sizeof(points1[0]);
CanvasCompareTester::RenderAll(
[=](SkCanvas* canvas, SkPaint& paint) { //
// Skia requires kStroke style on horizontal and vertical
// lines to get the bounds correct.
// See https://bugs.chromium.org/p/skia/issues/detail?id=12446
SkPaint p = paint;
p.setStyle(SkPaint::kStroke_Style);
canvas->drawPoints(SkCanvas::kPolygon_PointMode, count1, points1, p);
},
[=](DisplayListBuilder& builder) { //
builder.drawPoints(SkCanvas::kPolygon_PointMode, count1, points1);
});
}
TEST(DisplayListCanvas, DrawVerticesWithColors) {
// Cover as many sides of the box with only 6 vertices:
// +----------+
// |xxxxxxxxxx|
// | xxxxxx|
// | xxx|
// |xxx |
// |xxxxxx |
// |xxxxxxxxxx|
// +----------|
const SkPoint pts[6] = {
// Upper-Right corner, full top, half right coverage
SkPoint::Make(RenderLeft, RenderTop),
SkPoint::Make(RenderRight, RenderTop),
SkPoint::Make(RenderRight, RenderCenterY),
// Lower-Left corner, full bottom, half left coverage
SkPoint::Make(RenderLeft, RenderBottom),
SkPoint::Make(RenderLeft, RenderCenterY),
SkPoint::Make(RenderRight, RenderBottom),
};
const SkColor colors[6] = {
SK_ColorRED, SK_ColorBLUE, SK_ColorGREEN,
SK_ColorCYAN, SK_ColorYELLOW, SK_ColorMAGENTA,
};
const sk_sp<SkVertices> vertices = SkVertices::MakeCopy(
SkVertices::kTriangles_VertexMode, 6, pts, nullptr, colors);
CanvasCompareTester::RenderVertices(
[=](SkCanvas* canvas, SkPaint& paint) { //
canvas->drawVertices(vertices.get(), SkBlendMode::kSrcOver, paint);
},
[=](DisplayListBuilder& builder) { //
builder.drawVertices(vertices, SkBlendMode::kSrcOver);
});
ASSERT_TRUE(vertices->unique());
}
TEST(DisplayListCanvas, DrawVerticesWithImage) {
// Cover as many sides of the box with only 6 vertices:
// +----------+
// |xxxxxxxxxx|
// | xxxxxx|
// | xxx|
// |xxx |
// |xxxxxx |
// |xxxxxxxxxx|
// +----------|
const SkPoint pts[6] = {
// Upper-Right corner, full top, half right coverage
SkPoint::Make(RenderLeft, RenderTop),
SkPoint::Make(RenderRight, RenderTop),
SkPoint::Make(RenderRight, RenderCenterY),
// Lower-Left corner, full bottom, half left coverage
SkPoint::Make(RenderLeft, RenderBottom),
SkPoint::Make(RenderLeft, RenderCenterY),
SkPoint::Make(RenderRight, RenderBottom),
};
const SkPoint tex[6] = {
SkPoint::Make(RenderWidth / 2.0, 0),
SkPoint::Make(0, RenderHeight),
SkPoint::Make(RenderWidth, RenderHeight),
SkPoint::Make(RenderWidth / 2, RenderHeight),
SkPoint::Make(0, 0),
SkPoint::Make(RenderWidth, 0),
};
const sk_sp<SkVertices> vertices = SkVertices::MakeCopy(
SkVertices::kTriangles_VertexMode, 6, pts, tex, nullptr);
const sk_sp<SkShader> shader = CanvasCompareTester::testImage->makeShader(
SkTileMode::kRepeat, SkTileMode::kRepeat, SkSamplingOptions());
CanvasCompareTester::RenderVertices(
[=](SkCanvas* canvas, SkPaint& paint) { //
paint.setShader(shader);
canvas->drawVertices(vertices.get(), SkBlendMode::kSrcOver, paint);
},
[=](DisplayListBuilder& builder) { //
builder.setShader(shader);
builder.drawVertices(vertices, SkBlendMode::kSrcOver);
});
ASSERT_TRUE(vertices->unique());
ASSERT_TRUE(shader->unique());
}
TEST(DisplayListCanvas, DrawImageNearest) {
CanvasCompareTester::RenderAll(
[=](SkCanvas* canvas, SkPaint& paint) { //
canvas->drawImage(CanvasCompareTester::testImage, RenderLeft, RenderTop,
DisplayList::NearestSampling, &paint);
},
[=](DisplayListBuilder& builder) { //
builder.drawImage(CanvasCompareTester::testImage,
SkPoint::Make(RenderLeft, RenderTop),
DisplayList::NearestSampling, true);
});
}
TEST(DisplayListCanvas, DrawImageNearestNoPaint) {
CanvasCompareTester::RenderAll(
[=](SkCanvas* canvas, SkPaint& paint) { //
canvas->drawImage(CanvasCompareTester::testImage, RenderLeft, RenderTop,
DisplayList::NearestSampling, nullptr);
},
[=](DisplayListBuilder& builder) { //
builder.drawImage(CanvasCompareTester::testImage,
SkPoint::Make(RenderLeft, RenderTop),
DisplayList::NearestSampling, false);
});
}
TEST(DisplayListCanvas, DrawImageLinear) {
CanvasCompareTester::RenderAll(
[=](SkCanvas* canvas, SkPaint& paint) { //
canvas->drawImage(CanvasCompareTester::testImage, RenderLeft, RenderTop,
DisplayList::LinearSampling, &paint);
},
[=](DisplayListBuilder& builder) { //
builder.drawImage(CanvasCompareTester::testImage,
SkPoint::Make(RenderLeft, RenderTop),
DisplayList::LinearSampling, true);
});
}
TEST(DisplayListCanvas, DrawImageRectNearest) {
SkRect src = SkRect::MakeIWH(RenderWidth, RenderHeight).makeInset(5, 5);
SkRect dst = RenderBounds.makeInset(15.5, 10.5);
CanvasCompareTester::RenderAll(
[=](SkCanvas* canvas, SkPaint& paint) { //
canvas->drawImageRect(CanvasCompareTester::testImage, src, dst,
DisplayList::NearestSampling, &paint,
SkCanvas::kFast_SrcRectConstraint);
},
[=](DisplayListBuilder& builder) { //
builder.drawImageRect(CanvasCompareTester::testImage, src, dst,
DisplayList::NearestSampling, true);
});
}
TEST(DisplayListCanvas, DrawImageRectNearestNoPaint) {
SkRect src = SkRect::MakeIWH(RenderWidth, RenderHeight).makeInset(5, 5);
SkRect dst = RenderBounds.makeInset(15.5, 10.5);
CanvasCompareTester::RenderAll(
[=](SkCanvas* canvas, SkPaint& paint) { //
canvas->drawImageRect(CanvasCompareTester::testImage, src, dst,
DisplayList::NearestSampling, nullptr,
SkCanvas::kFast_SrcRectConstraint);
},
[=](DisplayListBuilder& builder) { //
builder.drawImageRect(CanvasCompareTester::testImage, src, dst,
DisplayList::NearestSampling, false);
});
}
TEST(DisplayListCanvas, DrawImageRectLinear) {
SkRect src = SkRect::MakeIWH(RenderWidth, RenderHeight).makeInset(5, 5);
SkRect dst = RenderBounds.makeInset(15.5, 10.5);
CanvasCompareTester::RenderAll(
[=](SkCanvas* canvas, SkPaint& paint) { //
canvas->drawImageRect(CanvasCompareTester::testImage, src, dst,
DisplayList::LinearSampling, &paint,
SkCanvas::kFast_SrcRectConstraint);
},
[=](DisplayListBuilder& builder) { //
builder.drawImageRect(CanvasCompareTester::testImage, src, dst,
DisplayList::LinearSampling, true);
});
}
TEST(DisplayListCanvas, DrawImageNineNearest) {
SkIRect src = SkIRect::MakeWH(RenderWidth, RenderHeight).makeInset(5, 5);
SkRect dst = RenderBounds.makeInset(15.5, 10.5);
CanvasCompareTester::RenderAll(
[=](SkCanvas* canvas, SkPaint& paint) { //
canvas->drawImageNine(CanvasCompareTester::testImage.get(), src, dst,
SkFilterMode::kNearest, &paint);
},
[=](DisplayListBuilder& builder) { //
builder.drawImageNine(CanvasCompareTester::testImage, src, dst,
SkFilterMode::kNearest, true);
});
}
TEST(DisplayListCanvas, DrawImageNineNearestNoPaint) {
SkIRect src = SkIRect::MakeWH(RenderWidth, RenderHeight).makeInset(5, 5);
SkRect dst = RenderBounds.makeInset(15.5, 10.5);
CanvasCompareTester::RenderAll(
[=](SkCanvas* canvas, SkPaint& paint) { //
canvas->drawImageNine(CanvasCompareTester::testImage.get(), src, dst,
SkFilterMode::kNearest, nullptr);
},
[=](DisplayListBuilder& builder) { //
builder.drawImageNine(CanvasCompareTester::testImage, src, dst,
SkFilterMode::kNearest, false);
});
}
TEST(DisplayListCanvas, DrawImageNineLinear) {
SkIRect src = SkIRect::MakeWH(RenderWidth, RenderHeight).makeInset(5, 5);
SkRect dst = RenderBounds.makeInset(15.5, 10.5);
CanvasCompareTester::RenderAll(
[=](SkCanvas* canvas, SkPaint& paint) { //
canvas->drawImageNine(CanvasCompareTester::testImage.get(), src, dst,
SkFilterMode::kLinear, &paint);
},
[=](DisplayListBuilder& builder) { //
builder.drawImageNine(CanvasCompareTester::testImage, src, dst,
SkFilterMode::kLinear, true);
});
}
TEST(DisplayListCanvas, DrawImageLatticeNearest) {
const SkRect dst = RenderBounds.makeInset(15.5, 10.5);
const int divX[] = {
(RenderLeft + RenderCenterX) / 2,
RenderCenterX,
(RenderRight + RenderCenterX) / 2,
};
const int divY[] = {
(RenderTop + RenderCenterY) / 2,
RenderCenterY,
(RenderBottom + RenderCenterY) / 2,
};
SkCanvas::Lattice lattice = {
divX, divY, nullptr, 3, 3, nullptr, nullptr,
};
CanvasCompareTester::RenderAll(
[=](SkCanvas* canvas, SkPaint& paint) { //
canvas->drawImageLattice(CanvasCompareTester::testImage.get(), lattice,
dst, SkFilterMode::kNearest, &paint);
},
[=](DisplayListBuilder& builder) { //
builder.drawImageLattice(CanvasCompareTester::testImage, lattice, //
dst, SkFilterMode::kNearest, true);
});
}
TEST(DisplayListCanvas, DrawImageLatticeNearestNoPaint) {
const SkRect dst = RenderBounds.makeInset(15.5, 10.5);
const int divX[] = {
(RenderLeft + RenderCenterX) / 2,
RenderCenterX,
(RenderRight + RenderCenterX) / 2,
};
const int divY[] = {
(RenderTop + RenderCenterY) / 2,
RenderCenterY,
(RenderBottom + RenderCenterY) / 2,
};
SkCanvas::Lattice lattice = {
divX, divY, nullptr, 3, 3, nullptr, nullptr,
};
CanvasCompareTester::RenderAll(
[=](SkCanvas* canvas, SkPaint& paint) { //
canvas->drawImageLattice(CanvasCompareTester::testImage.get(), lattice,
dst, SkFilterMode::kNearest, nullptr);
},
[=](DisplayListBuilder& builder) { //
builder.drawImageLattice(CanvasCompareTester::testImage, lattice, //
dst, SkFilterMode::kNearest, false);
});
}
TEST(DisplayListCanvas, DrawImageLatticeLinear) {
const SkRect dst = RenderBounds.makeInset(15.5, 10.5);
const int divX[] = {
(RenderLeft + RenderCenterX) / 2,
RenderCenterX,
(RenderRight + RenderCenterX) / 2,
};
const int divY[] = {
(RenderTop + RenderCenterY) / 2,
RenderCenterY,
(RenderBottom + RenderCenterY) / 2,
};
SkCanvas::Lattice lattice = {
divX, divY, nullptr, 3, 3, nullptr, nullptr,
};
CanvasCompareTester::RenderAll(
[=](SkCanvas* canvas, SkPaint& paint) { //
canvas->drawImageLattice(CanvasCompareTester::testImage.get(), lattice,
dst, SkFilterMode::kLinear, &paint);
},
[=](DisplayListBuilder& builder) { //
builder.drawImageLattice(CanvasCompareTester::testImage, lattice, //
dst, SkFilterMode::kLinear, true);
});
}
TEST(DisplayListCanvas, DrawAtlasNearest) {
const SkRSXform xform[] = {
// clang-format off
{ 1.2f, 0.0f, RenderLeft, RenderTop},
{ 0.0f, 1.2f, RenderRight, RenderTop},
{-1.2f, 0.0f, RenderRight, RenderBottom},
{ 0.0f, -1.2f, RenderLeft, RenderBottom},
// clang-format on
};
const SkRect tex[] = {
// clang-format off
{0, 0, RenderHalfWidth, RenderHalfHeight},
{RenderHalfWidth, 0, RenderWidth, RenderHalfHeight},
{RenderHalfWidth, RenderHalfHeight, RenderWidth, RenderHeight},
{0, RenderHalfHeight, RenderHalfWidth, RenderHeight},
// clang-format on
};
const SkColor colors[] = {
SK_ColorBLUE,
SK_ColorGREEN,
SK_ColorYELLOW,
SK_ColorMAGENTA,
};
const sk_sp<SkImage> image = CanvasCompareTester::testImage;
CanvasCompareTester::RenderAtlas(
[=](SkCanvas* canvas, SkPaint& paint) {
canvas->drawAtlas(image.get(), xform, tex, colors, 4,
SkBlendMode::kSrcOver, DisplayList::NearestSampling,
nullptr, &paint);
},
[=](DisplayListBuilder& builder) {
builder.drawAtlas(image, xform, tex, colors, 4, //
SkBlendMode::kSrcOver, DisplayList::NearestSampling,
nullptr, true);
});
}
TEST(DisplayListCanvas, DrawAtlasNearestNoPaint) {
const SkRSXform xform[] = {
// clang-format off
{ 1.2f, 0.0f, RenderLeft, RenderTop},
{ 0.0f, 1.2f, RenderRight, RenderTop},
{-1.2f, 0.0f, RenderRight, RenderBottom},
{ 0.0f, -1.2f, RenderLeft, RenderBottom},
// clang-format on
};
const SkRect tex[] = {
// clang-format off
{0, 0, RenderHalfWidth, RenderHalfHeight},
{RenderHalfWidth, 0, RenderWidth, RenderHalfHeight},
{RenderHalfWidth, RenderHalfHeight, RenderWidth, RenderHeight},
{0, RenderHalfHeight, RenderHalfWidth, RenderHeight},
// clang-format on
};
const SkColor colors[] = {
SK_ColorBLUE,
SK_ColorGREEN,
SK_ColorYELLOW,
SK_ColorMAGENTA,
};
const sk_sp<SkImage> image = CanvasCompareTester::testImage;
CanvasCompareTester::RenderAtlas(
[=](SkCanvas* canvas, SkPaint& paint) {
canvas->drawAtlas(image.get(), xform, tex, colors, 4,
SkBlendMode::kSrcOver, DisplayList::NearestSampling,
nullptr, nullptr);
},
[=](DisplayListBuilder& builder) {
builder.drawAtlas(image, xform, tex, colors, 4, //
SkBlendMode::kSrcOver, DisplayList::NearestSampling,
nullptr, false);
});
}
TEST(DisplayListCanvas, DrawAtlasLinear) {
const SkRSXform xform[] = {
// clang-format off
{ 1.2f, 0.0f, RenderLeft, RenderTop},
{ 0.0f, 1.2f, RenderRight, RenderTop},
{-1.2f, 0.0f, RenderRight, RenderBottom},
{ 0.0f, -1.2f, RenderLeft, RenderBottom},
// clang-format on
};
const SkRect tex[] = {
// clang-format off
{0, 0, RenderHalfWidth, RenderHalfHeight},
{RenderHalfWidth, 0, RenderWidth, RenderHalfHeight},
{RenderHalfWidth, RenderHalfHeight, RenderWidth, RenderHeight},
{0, RenderHalfHeight, RenderHalfWidth, RenderHeight},
// clang-format on
};
const SkColor colors[] = {
SK_ColorBLUE,
SK_ColorGREEN,
SK_ColorYELLOW,
SK_ColorMAGENTA,
};
const sk_sp<SkImage> image = CanvasCompareTester::testImage;
CanvasCompareTester::RenderAtlas(
[=](SkCanvas* canvas, SkPaint& paint) {
canvas->drawAtlas(image.get(), xform, tex, colors, 2, //
SkBlendMode::kSrcOver, DisplayList::LinearSampling,
nullptr, &paint);
},
[=](DisplayListBuilder& builder) {
builder.drawAtlas(image, xform, tex, colors, 2, //
SkBlendMode::kSrcOver, DisplayList::LinearSampling,
nullptr, true);
});
}
sk_sp<SkPicture> makeTestPicture() {
SkPictureRecorder recorder;
SkCanvas* cv = recorder.beginRecording(RenderBounds);
SkPaint p;
p.setStyle(SkPaint::kFill_Style);
SkScalar x_coords[] = {
RenderLeft,
RenderCenterX,
RenderRight,
};
SkScalar y_coords[] = {
RenderTop,
RenderCenterY,
RenderBottom,
};
SkColor colors[][2] = {
{
SK_ColorRED,
SK_ColorBLUE,
},
{
SK_ColorGREEN,
SK_ColorYELLOW,
},
};
for (int j = 0; j < 2; j++) {
for (int i = 0; i < 2; i++) {
SkRect rect = {
x_coords[i],
y_coords[j],
x_coords[i + 1],
y_coords[j + 1],
};
p.setColor(colors[i][j]);
cv->drawOval(rect, p);
}
}
return recorder.finishRecordingAsPicture();
}
TEST(DisplayListCanvas, DrawPicture) {
sk_sp<SkPicture> picture = makeTestPicture();
CanvasCompareTester::RenderNoAttributes(
[=](SkCanvas* canvas, SkPaint& paint) { //
canvas->drawPicture(picture, nullptr, nullptr);
},
[=](DisplayListBuilder& builder) { //
builder.drawPicture(picture, nullptr, false);
});
}
TEST(DisplayListCanvas, DrawPictureWithMatrix) {
sk_sp<SkPicture> picture = makeTestPicture();
SkMatrix matrix = SkMatrix::Scale(0.95, 0.95);
CanvasCompareTester::RenderNoAttributes(
[=](SkCanvas* canvas, SkPaint& paint) { //
canvas->drawPicture(picture, &matrix, nullptr);
},
[=](DisplayListBuilder& builder) { //
builder.drawPicture(picture, &matrix, false);
});
}
TEST(DisplayListCanvas, DrawPictureWithPaint) {
sk_sp<SkPicture> picture = makeTestPicture();
CanvasCompareTester::RenderAll(
[=](SkCanvas* canvas, SkPaint& paint) { //
canvas->drawPicture(picture, nullptr, &paint);
},
[=](DisplayListBuilder& builder) { //
builder.drawPicture(picture, nullptr, true);
});
}
TEST(DisplayListCanvas, DrawDisplayList) {
DisplayListBuilder builder;
builder.setStyle(SkPaint::kFill_Style);
builder.setColor(SK_ColorBLUE);
builder.drawOval(RenderBounds);
sk_sp<DisplayList> display_list = builder.Build();
CanvasCompareTester::RenderNoAttributes(
[=](SkCanvas* canvas, SkPaint& paint) { //
display_list->RenderTo(canvas);
},
[=](DisplayListBuilder& builder) { //
builder.drawDisplayList(display_list);
});
}
TEST(DisplayListCanvas, DrawTextBlob) {
// TODO(https://github.com/flutter/flutter/issues/82202): Remove once the
// performance overlay can use Fuchsia's font manager instead of the empty
// default.
#if defined(OS_FUCHSIA)
GTEST_SKIP() << "Rendering comparisons require a valid default font manager";
#endif // OS_FUCHSIA
sk_sp<SkTextBlob> blob =
CanvasCompareTester::MakeTextBlob("Testing", RenderHeight * 0.33f);
SkScalar RenderY1_3 = RenderTop + RenderHeight * 0.33;
SkScalar RenderY2_3 = RenderTop + RenderHeight * 0.66;
CanvasCompareTester::RenderNoAttributes(
[=](SkCanvas* canvas, SkPaint& paint) { //
canvas->drawTextBlob(blob, RenderLeft, RenderY1_3, paint);
canvas->drawTextBlob(blob, RenderLeft, RenderY2_3, paint);
canvas->drawTextBlob(blob, RenderLeft, RenderBottom, paint);
},
[=](DisplayListBuilder& builder) { //
builder.drawTextBlob(blob, RenderLeft, RenderY1_3);
builder.drawTextBlob(blob, RenderLeft, RenderY2_3);
builder.drawTextBlob(blob, RenderLeft, RenderBottom);
},
CanvasCompareTester::DefaultAdjuster,
// From examining the bounds differential for the "Default" case, the
// SkTextBlob adds a padding of ~31 on the left, ~30 on the right,
// ~12 on top and ~8 on the bottom, so we add 32h & 13v allowed
// padding to the tolerance
CanvasCompareTester::DefaultTolerance.addBoundsPadding(32, 13));
}
const BoundsTolerance shadowTolerance(const BoundsTolerance& tolerance,
const SkPaint& paint,
const SkMatrix& matrix) {
// Shadow primitives could use just a little more horizontal bounds
// tolerance when drawn with a perspective transform.
return CanvasCompareTester::DefaultAdjuster(
matrix.hasPerspective() ? tolerance.addScale(1.04, 1.0) : tolerance,
paint, matrix);
}
TEST(DisplayListCanvas, DrawShadow) {
SkPath path;
path.addRoundRect(
{
RenderLeft + 10,
RenderTop,
RenderRight - 10,
RenderBottom - 20,
},
RenderCornerRadius, RenderCornerRadius);
const SkColor color = SK_ColorDKGRAY;
const SkScalar elevation = 5;
CanvasCompareTester::RenderShadows(
[=](SkCanvas* canvas, SkPaint& paint) { //
PhysicalShapeLayer::DrawShadow(canvas, path, color, elevation, false,
1.0);
},
[=](DisplayListBuilder& builder) { //
builder.drawShadow(path, color, elevation, false, 1.0);
},
shadowTolerance,
CanvasCompareTester::DefaultTolerance.addBoundsPadding(3, 3));
}
TEST(DisplayListCanvas, DrawShadowTransparentOccluder) {
SkPath path;
path.addRoundRect(
{
RenderLeft + 10,
RenderTop,
RenderRight - 10,
RenderBottom - 20,
},
RenderCornerRadius, RenderCornerRadius);
const SkColor color = SK_ColorDKGRAY;
const SkScalar elevation = 5;
CanvasCompareTester::RenderShadows(
[=](SkCanvas* canvas, SkPaint& paint) { //
PhysicalShapeLayer::DrawShadow(canvas, path, color, elevation, true,
1.0);
},
[=](DisplayListBuilder& builder) { //
builder.drawShadow(path, color, elevation, true, 1.0);
},
shadowTolerance,