joshualitt | e49109f | 2015-07-17 12:47:39 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2015 Google Inc. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license that can be |
| 5 | * found in the LICENSE file. |
| 6 | */ |
| 7 | |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 8 | #include "tools/ToolUtils.h" |
joshualitt | 7f9c9eb | 2015-08-21 11:08:00 -0700 | [diff] [blame] | 9 | |
Herb Derby | 9830fc4 | 2019-09-12 10:58:26 -0400 | [diff] [blame] | 10 | #include <string> |
| 11 | |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 12 | #include "include/core/SkCanvas.h" |
| 13 | #include "include/core/SkFontMgr.h" |
| 14 | #include "include/core/SkGraphics.h" |
| 15 | #include "include/core/SkPaint.h" |
| 16 | #include "include/core/SkPoint.h" |
| 17 | #include "include/core/SkSurface.h" |
| 18 | #include "include/core/SkTextBlob.h" |
| 19 | #include "include/core/SkTypeface.h" |
| 20 | #include "src/core/SkGlyphRun.h" |
| 21 | #include "tools/fonts/RandomScalerContext.h" |
joshualitt | e49109f | 2015-07-17 12:47:39 -0700 | [diff] [blame] | 22 | |
| 23 | #ifdef SK_BUILD_FOR_WIN |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 24 | #include "include/ports/SkTypeface_win.h" |
joshualitt | e49109f | 2015-07-17 12:47:39 -0700 | [diff] [blame] | 25 | #endif |
| 26 | |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 27 | #include "tests/Test.h" |
joshualitt | e49109f | 2015-07-17 12:47:39 -0700 | [diff] [blame] | 28 | |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 29 | #include "include/gpu/GrContext.h" |
| 30 | #include "src/gpu/GrContextPriv.h" |
joshualitt | e49109f | 2015-07-17 12:47:39 -0700 | [diff] [blame] | 31 | |
fmalita | 37283c2 | 2016-09-13 10:00:23 -0700 | [diff] [blame] | 32 | static void draw(SkCanvas* canvas, int redraw, const SkTArray<sk_sp<SkTextBlob>>& blobs) { |
joshualitt | 404d9d6 | 2015-07-22 11:00:32 -0700 | [diff] [blame] | 33 | int yOffset = 0; |
joshualitt | e49109f | 2015-07-17 12:47:39 -0700 | [diff] [blame] | 34 | for (int r = 0; r < redraw; r++) { |
| 35 | for (int i = 0; i < blobs.count(); i++) { |
fmalita | 37283c2 | 2016-09-13 10:00:23 -0700 | [diff] [blame] | 36 | const auto& blob = blobs[i]; |
joshualitt | 404d9d6 | 2015-07-22 11:00:32 -0700 | [diff] [blame] | 37 | const SkRect& bounds = blob->bounds(); |
| 38 | yOffset += SkScalarCeilToInt(bounds.height()); |
joshualitt | e49109f | 2015-07-17 12:47:39 -0700 | [diff] [blame] | 39 | SkPaint paint; |
joshualitt | 404d9d6 | 2015-07-22 11:00:32 -0700 | [diff] [blame] | 40 | canvas->drawTextBlob(blob, 0, SkIntToScalar(yOffset), paint); |
joshualitt | e49109f | 2015-07-17 12:47:39 -0700 | [diff] [blame] | 41 | } |
| 42 | } |
| 43 | } |
| 44 | |
joshualitt | 11dfc8e | 2015-07-23 08:30:25 -0700 | [diff] [blame] | 45 | static const int kWidth = 1024; |
| 46 | static const int kHeight = 768; |
joshualitt | e49109f | 2015-07-17 12:47:39 -0700 | [diff] [blame] | 47 | |
Herb Derby | d3895d8 | 2018-09-04 13:27:00 -0400 | [diff] [blame] | 48 | static void setup_always_evict_atlas(GrContext* context) { |
Robert Phillips | 9da87e0 | 2019-02-04 13:26:26 -0500 | [diff] [blame] | 49 | context->priv().getAtlasManager()->setAtlasSizesToMinimum_ForTesting(); |
Herb Derby | d3895d8 | 2018-09-04 13:27:00 -0400 | [diff] [blame] | 50 | } |
| 51 | |
joshualitt | e49109f | 2015-07-17 12:47:39 -0700 | [diff] [blame] | 52 | // This test hammers the GPU textblobcache and font atlas |
kkinnunen | 1530283 | 2015-12-01 04:35:26 -0800 | [diff] [blame] | 53 | static void text_blob_cache_inner(skiatest::Reporter* reporter, GrContext* context, |
joshualitt | 7f9c9eb | 2015-08-21 11:08:00 -0700 | [diff] [blame] | 54 | int maxTotalText, int maxGlyphID, int maxFamilies, bool normal, |
| 55 | bool stressTest) { |
joshualitt | e49109f | 2015-07-17 12:47:39 -0700 | [diff] [blame] | 56 | // setup surface |
| 57 | uint32_t flags = 0; |
| 58 | SkSurfaceProps props(flags, SkSurfaceProps::kLegacyFontHost_InitType); |
| 59 | |
joshualitt | 7f9c9eb | 2015-08-21 11:08:00 -0700 | [diff] [blame] | 60 | // configure our context for maximum stressing of cache and atlas |
| 61 | if (stressTest) { |
Herb Derby | d3895d8 | 2018-09-04 13:27:00 -0400 | [diff] [blame] | 62 | setup_always_evict_atlas(context); |
Robert Phillips | dbaf317 | 2019-02-06 15:12:53 -0500 | [diff] [blame] | 63 | context->priv().testingOnly_setTextBlobCacheLimit(0); |
joshualitt | 7f9c9eb | 2015-08-21 11:08:00 -0700 | [diff] [blame] | 64 | } |
| 65 | |
Brian Osman | 7c59774 | 2019-03-26 11:10:11 -0400 | [diff] [blame] | 66 | SkImageInfo info = SkImageInfo::Make(kWidth, kHeight, kRGBA_8888_SkColorType, |
| 67 | kPremul_SkAlphaType); |
reed | e8f3062 | 2016-03-23 18:59:25 -0700 | [diff] [blame] | 68 | auto surface(SkSurface::MakeRenderTarget(context, SkBudgeted::kNo, info, 0, &props)); |
joshualitt | e49109f | 2015-07-17 12:47:39 -0700 | [diff] [blame] | 69 | REPORTER_ASSERT(reporter, surface); |
| 70 | if (!surface) { |
| 71 | return; |
| 72 | } |
| 73 | |
| 74 | SkCanvas* canvas = surface->getCanvas(); |
| 75 | |
Hal Canary | 342b7ac | 2016-11-04 11:49:42 -0400 | [diff] [blame] | 76 | sk_sp<SkFontMgr> fm(SkFontMgr::RefDefault()); |
joshualitt | e49109f | 2015-07-17 12:47:39 -0700 | [diff] [blame] | 77 | |
joshualitt | 65e96b4 | 2015-07-31 11:45:22 -0700 | [diff] [blame] | 78 | int count = SkMin32(fm->countFamilies(), maxFamilies); |
joshualitt | e49109f | 2015-07-17 12:47:39 -0700 | [diff] [blame] | 79 | |
| 80 | // make a ton of text |
joshualitt | 65e96b4 | 2015-07-31 11:45:22 -0700 | [diff] [blame] | 81 | SkAutoTArray<uint16_t> text(maxTotalText); |
| 82 | for (int i = 0; i < maxTotalText; i++) { |
| 83 | text[i] = i % maxGlyphID; |
joshualitt | e49109f | 2015-07-17 12:47:39 -0700 | [diff] [blame] | 84 | } |
| 85 | |
| 86 | // generate textblobs |
fmalita | 37283c2 | 2016-09-13 10:00:23 -0700 | [diff] [blame] | 87 | SkTArray<sk_sp<SkTextBlob>> blobs; |
joshualitt | e49109f | 2015-07-17 12:47:39 -0700 | [diff] [blame] | 88 | for (int i = 0; i < count; i++) { |
Mike Reed | 70914f5 | 2018-11-23 13:08:33 -0500 | [diff] [blame] | 89 | SkFont font; |
| 90 | font.setSize(48); // draw big glyphs to really stress the atlas |
joshualitt | e49109f | 2015-07-17 12:47:39 -0700 | [diff] [blame] | 91 | |
| 92 | SkString familyName; |
| 93 | fm->getFamilyName(i, &familyName); |
Hal Canary | 342b7ac | 2016-11-04 11:49:42 -0400 | [diff] [blame] | 94 | sk_sp<SkFontStyleSet> set(fm->createStyleSet(i)); |
joshualitt | e49109f | 2015-07-17 12:47:39 -0700 | [diff] [blame] | 95 | for (int j = 0; j < set->count(); ++j) { |
| 96 | SkFontStyle fs; |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 97 | set->getStyle(j, &fs, nullptr); |
joshualitt | e49109f | 2015-07-17 12:47:39 -0700 | [diff] [blame] | 98 | |
joshualitt | 65e96b4 | 2015-07-31 11:45:22 -0700 | [diff] [blame] | 99 | // We use a typeface which randomy returns unexpected mask formats to fuzz |
bungeman | 13b9c95 | 2016-05-12 10:09:30 -0700 | [diff] [blame] | 100 | sk_sp<SkTypeface> orig(set->createTypeface(j)); |
joshualitt | 65e96b4 | 2015-07-31 11:45:22 -0700 | [diff] [blame] | 101 | if (normal) { |
Mike Reed | 70914f5 | 2018-11-23 13:08:33 -0500 | [diff] [blame] | 102 | font.setTypeface(orig); |
joshualitt | 65e96b4 | 2015-07-31 11:45:22 -0700 | [diff] [blame] | 103 | } else { |
Mike Reed | 70914f5 | 2018-11-23 13:08:33 -0500 | [diff] [blame] | 104 | font.setTypeface(sk_make_sp<SkRandomTypeface>(orig, SkPaint(), true)); |
joshualitt | 65e96b4 | 2015-07-31 11:45:22 -0700 | [diff] [blame] | 105 | } |
joshualitt | e49109f | 2015-07-17 12:47:39 -0700 | [diff] [blame] | 106 | |
| 107 | SkTextBlobBuilder builder; |
| 108 | for (int aa = 0; aa < 2; aa++) { |
| 109 | for (int subpixel = 0; subpixel < 2; subpixel++) { |
| 110 | for (int lcd = 0; lcd < 2; lcd++) { |
Mike Reed | 70914f5 | 2018-11-23 13:08:33 -0500 | [diff] [blame] | 111 | font.setEdging(SkFont::Edging::kAlias); |
| 112 | if (aa) { |
| 113 | font.setEdging(SkFont::Edging::kAntiAlias); |
| 114 | if (lcd) { |
| 115 | font.setEdging(SkFont::Edging::kSubpixelAntiAlias); |
| 116 | } |
joshualitt | 65e96b4 | 2015-07-31 11:45:22 -0700 | [diff] [blame] | 117 | } |
Mike Reed | 70914f5 | 2018-11-23 13:08:33 -0500 | [diff] [blame] | 118 | font.setSubpixel(SkToBool(subpixel)); |
| 119 | if (!SkToBool(lcd)) { |
| 120 | font.setSize(160); |
| 121 | } |
| 122 | const SkTextBlobBuilder::RunBuffer& run = builder.allocRun(font, |
joshualitt | 65e96b4 | 2015-07-31 11:45:22 -0700 | [diff] [blame] | 123 | maxTotalText, |
joshualitt | e49109f | 2015-07-17 12:47:39 -0700 | [diff] [blame] | 124 | 0, 0, |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 125 | nullptr); |
joshualitt | 65e96b4 | 2015-07-31 11:45:22 -0700 | [diff] [blame] | 126 | memcpy(run.glyphs, text.get(), maxTotalText * sizeof(uint16_t)); |
joshualitt | e49109f | 2015-07-17 12:47:39 -0700 | [diff] [blame] | 127 | } |
| 128 | } |
| 129 | } |
fmalita | 37283c2 | 2016-09-13 10:00:23 -0700 | [diff] [blame] | 130 | blobs.emplace_back(builder.make()); |
joshualitt | e49109f | 2015-07-17 12:47:39 -0700 | [diff] [blame] | 131 | } |
| 132 | } |
| 133 | |
joshualitt | 11dfc8e | 2015-07-23 08:30:25 -0700 | [diff] [blame] | 134 | // create surface where LCD is impossible |
Brian Osman | 7c59774 | 2019-03-26 11:10:11 -0400 | [diff] [blame] | 135 | info = SkImageInfo::Make(kWidth, kHeight, kRGBA_8888_SkColorType, kPremul_SkAlphaType); |
joshualitt | 11dfc8e | 2015-07-23 08:30:25 -0700 | [diff] [blame] | 136 | SkSurfaceProps propsNoLCD(0, kUnknown_SkPixelGeometry); |
reed | e8f3062 | 2016-03-23 18:59:25 -0700 | [diff] [blame] | 137 | auto surfaceNoLCD(canvas->makeSurface(info, &propsNoLCD)); |
joshualitt | 11dfc8e | 2015-07-23 08:30:25 -0700 | [diff] [blame] | 138 | REPORTER_ASSERT(reporter, surface); |
| 139 | if (!surface) { |
| 140 | return; |
| 141 | } |
| 142 | |
| 143 | SkCanvas* canvasNoLCD = surfaceNoLCD->getCanvas(); |
| 144 | |
joshualitt | e49109f | 2015-07-17 12:47:39 -0700 | [diff] [blame] | 145 | // test redraw |
| 146 | draw(canvas, 2, blobs); |
joshualitt | 11dfc8e | 2015-07-23 08:30:25 -0700 | [diff] [blame] | 147 | draw(canvasNoLCD, 2, blobs); |
joshualitt | e49109f | 2015-07-17 12:47:39 -0700 | [diff] [blame] | 148 | |
| 149 | // test draw after free |
kkinnunen | 1530283 | 2015-12-01 04:35:26 -0800 | [diff] [blame] | 150 | context->freeGpuResources(); |
joshualitt | e49109f | 2015-07-17 12:47:39 -0700 | [diff] [blame] | 151 | draw(canvas, 1, blobs); |
| 152 | |
kkinnunen | 1530283 | 2015-12-01 04:35:26 -0800 | [diff] [blame] | 153 | context->freeGpuResources(); |
joshualitt | 11dfc8e | 2015-07-23 08:30:25 -0700 | [diff] [blame] | 154 | draw(canvasNoLCD, 1, blobs); |
| 155 | |
joshualitt | e49109f | 2015-07-17 12:47:39 -0700 | [diff] [blame] | 156 | // test draw after abandon |
kkinnunen | 1530283 | 2015-12-01 04:35:26 -0800 | [diff] [blame] | 157 | context->abandonContext(); |
joshualitt | e49109f | 2015-07-17 12:47:39 -0700 | [diff] [blame] | 158 | draw(canvas, 1, blobs); |
| 159 | } |
joshualitt | 65e96b4 | 2015-07-31 11:45:22 -0700 | [diff] [blame] | 160 | |
Brian Osman | 7c59774 | 2019-03-26 11:10:11 -0400 | [diff] [blame] | 161 | DEF_GPUTEST_FOR_MOCK_CONTEXT(TextBlobCache, reporter, ctxInfo) { |
bsalomon | 8b7451a | 2016-05-11 06:33:06 -0700 | [diff] [blame] | 162 | text_blob_cache_inner(reporter, ctxInfo.grContext(), 1024, 256, 30, true, false); |
joshualitt | 7f9c9eb | 2015-08-21 11:08:00 -0700 | [diff] [blame] | 163 | } |
| 164 | |
Brian Osman | 7c59774 | 2019-03-26 11:10:11 -0400 | [diff] [blame] | 165 | DEF_GPUTEST_FOR_MOCK_CONTEXT(TextBlobStressCache, reporter, ctxInfo) { |
Herb Derby | 278b067 | 2018-10-05 13:46:51 -0400 | [diff] [blame] | 166 | text_blob_cache_inner(reporter, ctxInfo.grContext(), 256, 256, 10, true, true); |
joshualitt | 65e96b4 | 2015-07-31 11:45:22 -0700 | [diff] [blame] | 167 | } |
| 168 | |
Brian Osman | 7c59774 | 2019-03-26 11:10:11 -0400 | [diff] [blame] | 169 | DEF_GPUTEST_FOR_MOCK_CONTEXT(TextBlobAbnormal, reporter, ctxInfo) { |
bsalomon | 8b7451a | 2016-05-11 06:33:06 -0700 | [diff] [blame] | 170 | text_blob_cache_inner(reporter, ctxInfo.grContext(), 256, 256, 10, false, false); |
joshualitt | 7f9c9eb | 2015-08-21 11:08:00 -0700 | [diff] [blame] | 171 | } |
| 172 | |
Brian Osman | 7c59774 | 2019-03-26 11:10:11 -0400 | [diff] [blame] | 173 | DEF_GPUTEST_FOR_MOCK_CONTEXT(TextBlobStressAbnormal, reporter, ctxInfo) { |
Herb Derby | 278b067 | 2018-10-05 13:46:51 -0400 | [diff] [blame] | 174 | text_blob_cache_inner(reporter, ctxInfo.grContext(), 256, 256, 10, false, true); |
joshualitt | 65e96b4 | 2015-07-31 11:45:22 -0700 | [diff] [blame] | 175 | } |
Herb Derby | 9830fc4 | 2019-09-12 10:58:26 -0400 | [diff] [blame] | 176 | |
| 177 | static const int kScreenDim = 160; |
| 178 | |
| 179 | static SkBitmap draw_blob(SkTextBlob* blob, SkSurface* surface, SkPoint offset) { |
| 180 | |
| 181 | SkPaint paint; |
| 182 | |
| 183 | SkCanvas* canvas = surface->getCanvas(); |
| 184 | canvas->save(); |
| 185 | canvas->drawColor(SK_ColorWHITE, SkBlendMode::kSrc); |
| 186 | canvas->translate(offset.fX, offset.fY); |
| 187 | canvas->drawTextBlob(blob, 0, 0, paint); |
| 188 | SkBitmap bitmap; |
| 189 | bitmap.allocN32Pixels(kScreenDim, kScreenDim); |
| 190 | surface->readPixels(bitmap, 0, 0); |
| 191 | canvas->restore(); |
| 192 | return bitmap; |
| 193 | } |
| 194 | |
| 195 | static bool compare_bitmaps(const SkBitmap& expected, const SkBitmap& actual) { |
| 196 | SkASSERT(expected.width() == actual.width()); |
| 197 | SkASSERT(expected.height() == actual.height()); |
| 198 | for (int i = 0; i < expected.width(); ++i) { |
| 199 | for (int j = 0; j < expected.height(); ++j) { |
| 200 | SkColor expectedColor = expected.getColor(i, j); |
| 201 | SkColor actualColor = actual.getColor(i, j); |
| 202 | if (expectedColor != actualColor) { |
| 203 | return false; |
| 204 | } |
| 205 | } |
| 206 | } |
| 207 | return true; |
| 208 | } |
| 209 | |
| 210 | static sk_sp<SkTextBlob> make_blob() { |
| 211 | auto tf = SkTypeface::MakeFromName("Roboto2-Regular", SkFontStyle()); |
| 212 | SkFont font; |
| 213 | font.setTypeface(tf); |
| 214 | font.setSubpixel(false); |
| 215 | font.setEdging(SkFont::Edging::kAlias); |
| 216 | font.setSize(24); |
| 217 | |
| 218 | static char text[] = "HekpqB"; |
| 219 | static const int maxGlyphLen = sizeof(text) * 4; |
| 220 | SkGlyphID glyphs[maxGlyphLen]; |
| 221 | int glyphCount = |
| 222 | font.textToGlyphs(text, sizeof(text), SkTextEncoding::kUTF8, glyphs, maxGlyphLen); |
| 223 | |
| 224 | SkTextBlobBuilder builder; |
| 225 | const auto& runBuffer = builder.allocRun(font, glyphCount, 0, 0); |
| 226 | for (int i = 0; i < glyphCount; i++) { |
| 227 | runBuffer.glyphs[i] = glyphs[i]; |
| 228 | } |
| 229 | return builder.make(); |
| 230 | } |
| 231 | |
| 232 | static const bool kDumpPngs = true; |
| 233 | // dump pngs needs a "good" and a "bad" directory to put the results in. This allows the use of the |
| 234 | // skdiff tool to visualize the differences. |
| 235 | |
| 236 | void write_png(const std::string& filename, const SkBitmap& bitmap) { |
| 237 | auto data = SkEncodeBitmap(bitmap, SkEncodedImageFormat::kPNG, 0); |
| 238 | SkFILEWStream w{filename.c_str()}; |
| 239 | w.write(data->data(), data->size()); |
| 240 | w.fsync(); |
| 241 | } |
| 242 | |
| 243 | DEF_GPUTEST_FOR_RENDERING_CONTEXTS(TextBlobJaggedGlyph, reporter, ctxInfo) { |
| 244 | auto grContext = ctxInfo.grContext(); |
| 245 | const SkImageInfo info = |
| 246 | SkImageInfo::Make(kScreenDim, kScreenDim, kN32_SkColorType, kPremul_SkAlphaType); |
| 247 | auto surface = SkSurface::MakeRenderTarget(grContext, SkBudgeted::kNo, info); |
| 248 | |
| 249 | auto blob = make_blob(); |
| 250 | |
| 251 | for (int y = 40; y < kScreenDim - 40; y++) { |
| 252 | SkBitmap base = draw_blob(blob.get(), surface.get(), {40, y + 0.0f}); |
| 253 | SkBitmap half = draw_blob(blob.get(), surface.get(), {40, y + 0.5f}); |
| 254 | SkBitmap unit = draw_blob(blob.get(), surface.get(), {40, y + 1.0f}); |
| 255 | bool isOk = compare_bitmaps(base, half) || compare_bitmaps(unit, half); |
| 256 | REPORTER_ASSERT(reporter, isOk); |
| 257 | if (!isOk) { |
| 258 | if (kDumpPngs) { |
| 259 | { |
| 260 | std::string filename = "bad/half-y" + std::to_string(y) + ".png"; |
| 261 | write_png(filename, half); |
| 262 | } |
| 263 | { |
| 264 | std::string filename = "good/half-y" + std::to_string(y) + ".png"; |
| 265 | write_png(filename, base); |
| 266 | } |
| 267 | } |
| 268 | break; |
| 269 | } |
| 270 | } |
| 271 | |
| 272 | // Testing the x direction across all platforms does not workout, because letter spacing can |
| 273 | // change based on non-integer advance widths, but this has been useful for diagnosing problems. |
| 274 | #if 0 |
| 275 | blob = make_blob(); |
| 276 | for (int x = 40; x < kScreenDim - 40; x++) { |
| 277 | SkBitmap base = draw_blob(blob.get(), surface.get(), {x + 0.0f, 40}); |
| 278 | SkBitmap half = draw_blob(blob.get(), surface.get(), {x + 0.5f, 40}); |
| 279 | SkBitmap unit = draw_blob(blob.get(), surface.get(), {x + 1.0f, 40}); |
| 280 | bool isOk = compare_bitmaps(base, half) || compare_bitmaps(unit, half); |
| 281 | REPORTER_ASSERT(reporter, isOk); |
| 282 | if (!isOk) { |
| 283 | if (kDumpPngs) { |
| 284 | { |
| 285 | std::string filename = "bad/half-x" + std::to_string(x) + ".png"; |
| 286 | write_png(filename, half); |
| 287 | } |
| 288 | { |
| 289 | std::string filename = "good/half-x" + std::to_string(x) + ".png"; |
| 290 | write_png(filename, base); |
| 291 | } |
| 292 | } |
| 293 | break; |
| 294 | } |
| 295 | } |
| 296 | #endif |
| 297 | } |
| 298 | |
| 299 | DEF_GPUTEST_FOR_RENDERING_CONTEXTS(TextBlobSmoothScroll, reporter, ctxInfo) { |
| 300 | auto grContext = ctxInfo.grContext(); |
| 301 | const SkImageInfo info = |
| 302 | SkImageInfo::Make(kScreenDim, kScreenDim, kN32_SkColorType, kPremul_SkAlphaType); |
| 303 | auto surface = SkSurface::MakeRenderTarget(grContext, SkBudgeted::kNo, info); |
| 304 | |
| 305 | auto movingBlob = make_blob(); |
| 306 | |
| 307 | for (SkScalar y = 40; y < 50; y += 1.0/8.0) { |
| 308 | auto expectedBlob = make_blob(); |
| 309 | auto expectedBitMap = draw_blob(expectedBlob.get(), surface.get(), {40, y}); |
| 310 | auto movingBitmap = draw_blob(movingBlob.get(), surface.get(), {40, y}); |
| 311 | bool isOk = compare_bitmaps(expectedBitMap, movingBitmap); |
| 312 | REPORTER_ASSERT(reporter, isOk); |
| 313 | if (!isOk) { |
| 314 | if (kDumpPngs) { |
| 315 | { |
| 316 | std::string filename = "bad/scroll-y" + std::to_string(y) + ".png"; |
| 317 | write_png(filename, movingBitmap); |
| 318 | } |
| 319 | { |
| 320 | std::string filename = "good/scroll-y" + std::to_string(y) + ".png"; |
| 321 | write_png(filename, expectedBitMap); |
| 322 | } |
| 323 | } |
| 324 | break; |
| 325 | } |
| 326 | } |
| 327 | } |