blob: 0814f9aa1a0a3d8b6712016b35fe58bdc9f7e7a7 [file] [log] [blame]
/*
* Copyright 2018 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "include/core/SkAlphaType.h"
#include "include/core/SkBitmap.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkColor.h"
#include "include/core/SkColorSpace.h"
#include "include/core/SkColorType.h"
#include "include/core/SkData.h"
#include "include/core/SkFont.h"
#include "include/core/SkFontStyle.h"
#include "include/core/SkFontTypes.h"
#include "include/core/SkGraphics.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkPaint.h"
#include "include/core/SkRect.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkScalar.h"
#include "include/core/SkSerialProcs.h"
#include "include/core/SkSurface.h"
#include "include/core/SkSurfaceProps.h"
#include "include/core/SkTextBlob.h"
#include "include/core/SkTypeface.h"
#include "include/core/SkTypes.h"
#include "include/gpu/GpuTypes.h"
#include "include/gpu/GrContextOptions.h"
#include "include/gpu/GrDirectContext.h"
#include "include/gpu/GrRecordingContext.h"
#include "src/core/SkTHash.h"
#include "include/private/base/SkMalloc.h"
#include "include/private/base/SkMutex.h"
#include "include/private/chromium/SkChromeRemoteGlyphCache.h"
#include "include/private/chromium/Slug.h"
#include "src/core/SkFontPriv.h"
#include "src/core/SkGlyph.h"
#include "src/core/SkStrikeSpec.h"
#include "src/core/SkTypeface_remote.h"
#include "src/gpu/ganesh/GrCaps.h"
#include "src/gpu/ganesh/GrDirectContextPriv.h"
#include "src/gpu/ganesh/GrRecordingContextPriv.h"
#include "src/gpu/ganesh/GrShaderCaps.h"
#include "src/text/gpu/SDFTControl.h"
#include "tests/CtsEnforcement.h"
#include "tests/Test.h"
#include "tools/Resources.h"
#include "tools/ToolUtils.h"
#include "tools/fonts/TestEmptyTypeface.h"
#include <cmath>
#include <cstdint>
#include <cstring>
#include <initializer_list>
#include <memory>
#include <vector>
// Since SkRemoteGlyphCache is not re-entrant, we can't use it while drawing slugs to simulate
// text blobs in the GPU stack.
#if !defined(SK_EXPERIMENTAL_SIMULATE_DRAWGLYPHRUNLIST_WITH_SLUG_STRIKE_SERIALIZE)
using Slug = sktext::gpu::Slug;
class DiscardableManager : public SkStrikeServer::DiscardableHandleManager,
public SkStrikeClient::DiscardableHandleManager {
public:
DiscardableManager() { sk_bzero(&fCacheMissCount, sizeof(fCacheMissCount)); }
~DiscardableManager() override = default;
// Server implementation.
SkDiscardableHandleId createHandle() override {
SkAutoMutexExclusive l(fMutex);
// Handles starts as locked.
fLockedHandles.add(++fNextHandleId);
return fNextHandleId;
}
bool lockHandle(SkDiscardableHandleId id) override {
SkAutoMutexExclusive l(fMutex);
if (id <= fLastDeletedHandleId) return false;
fLockedHandles.add(id);
return true;
}
// Client implementation.
bool deleteHandle(SkDiscardableHandleId id) override {
SkAutoMutexExclusive l(fMutex);
return id <= fLastDeletedHandleId;
}
void notifyCacheMiss(SkStrikeClient::CacheMissType type, int fontSize) override {
SkAutoMutexExclusive l(fMutex);
fCacheMissCount[type]++;
}
bool isHandleDeleted(SkDiscardableHandleId id) override {
SkAutoMutexExclusive l(fMutex);
return id <= fLastDeletedHandleId;
}
void unlockAll() {
SkAutoMutexExclusive l(fMutex);
fLockedHandles.reset();
}
void unlockAndDeleteAll() {
SkAutoMutexExclusive l(fMutex);
fLockedHandles.reset();
fLastDeletedHandleId = fNextHandleId;
}
const SkTHashSet<SkDiscardableHandleId>& lockedHandles() const {
SkAutoMutexExclusive l(fMutex);
return fLockedHandles;
}
SkDiscardableHandleId handleCount() {
SkAutoMutexExclusive l(fMutex);
return fNextHandleId;
}
int cacheMissCount(uint32_t type) {
SkAutoMutexExclusive l(fMutex);
return fCacheMissCount[type];
}
bool hasCacheMiss() const {
SkAutoMutexExclusive l(fMutex);
for (uint32_t i = 0; i <= SkStrikeClient::CacheMissType::kLast; ++i) {
if (fCacheMissCount[i] > 0) { return true; }
}
return false;
}
void resetCacheMissCounts() {
SkAutoMutexExclusive l(fMutex);
sk_bzero(&fCacheMissCount, sizeof(fCacheMissCount));
}
private:
// The tests below run in parallel on multiple threads and use the same
// process global SkStrikeCache. So the implementation needs to be
// thread-safe.
mutable SkMutex fMutex;
SkDiscardableHandleId fNextHandleId = 0u;
SkDiscardableHandleId fLastDeletedHandleId = 0u;
SkTHashSet<SkDiscardableHandleId> fLockedHandles;
int fCacheMissCount[SkStrikeClient::CacheMissType::kLast + 1u];
};
sk_sp<SkTextBlob> buildTextBlob(sk_sp<SkTypeface> tf, int glyphCount, int textSize = 1) {
SkFont font;
font.setTypeface(tf);
font.setHinting(SkFontHinting::kNormal);
font.setSize(textSize);
font.setEdging(SkFont::Edging::kAntiAlias);
font.setSubpixel(true);
SkTextBlobBuilder builder;
SkRect bounds = SkRect::MakeWH(10, 10);
const auto& runBuffer = builder.allocRunPosH(font, glyphCount, 0, &bounds);
SkASSERT(runBuffer.utf8text == nullptr);
SkASSERT(runBuffer.clusters == nullptr);
for (int i = 0; i < glyphCount; i++) {
runBuffer.glyphs[i] = static_cast<SkGlyphID>(i);
runBuffer.pos[i] = SkIntToScalar(i);
}
return builder.make();
}
static void compare_blobs(const SkBitmap& expected, const SkBitmap& actual,
skiatest::Reporter* reporter, int tolerance = 0) {
SkASSERT(expected.width() == actual.width());
SkASSERT(expected.height() == actual.height());
for (int i = 0; i < expected.width(); ++i) {
for (int j = 0; j < expected.height(); ++j) {
SkColor expectedColor = expected.getColor(i, j);
SkColor actualColor = actual.getColor(i, j);
if (0 == tolerance) {
REPORTER_ASSERT(reporter, expectedColor == actualColor);
} else {
for (int k = 0; k < 4; ++k) {
int expectedChannel = (expectedColor >> (k*8)) & 0xff;
int actualChannel = (actualColor >> (k*8)) & 0xff;
REPORTER_ASSERT(reporter, abs(expectedChannel - actualChannel) <= tolerance);
}
}
}
}
}
sk_sp<SkSurface> MakeSurface(int width, int height, GrRecordingContext* rContext) {
const SkImageInfo info =
SkImageInfo::Make(width, height, kN32_SkColorType, kPremul_SkAlphaType);
return SkSurface::MakeRenderTarget(rContext, skgpu::Budgeted::kNo, info);
}
SkSurfaceProps FindSurfaceProps(GrRecordingContext* rContext) {
auto surface = MakeSurface(1, 1, rContext);
return surface->props();
}
SkBitmap RasterBlob(sk_sp<SkTextBlob> blob, int width, int height, const SkPaint& paint,
GrRecordingContext* rContext, const SkMatrix* matrix = nullptr,
SkScalar x = 0) {
auto surface = MakeSurface(width, height, rContext);
if (matrix) {
surface->getCanvas()->concat(*matrix);
}
surface->getCanvas()->drawTextBlob(blob.get(), x, height/2, paint);
SkBitmap bitmap;
bitmap.allocN32Pixels(width, height);
surface->readPixels(bitmap, 0, 0);
return bitmap;
}
SkBitmap RasterBlobThroughSlug(sk_sp<SkTextBlob> blob, int width, int height, const SkPaint& paint,
GrRecordingContext* rContext, const SkMatrix* matrix = nullptr,
SkScalar x = 0) {
auto surface = MakeSurface(width, height, rContext);
if (matrix) {
surface->getCanvas()->concat(*matrix);
}
auto canvas = surface->getCanvas();
auto slug = Slug::ConvertBlob(canvas, *blob, {x, height/2.0f}, paint);
slug->draw(canvas);
SkBitmap bitmap;
bitmap.allocN32Pixels(width, height);
surface->readPixels(bitmap, 0, 0);
return bitmap;
}
SkBitmap RasterSlug(sk_sp<Slug> slug, int width, int height, const SkPaint& paint,
GrRecordingContext* rContext, const SkMatrix* matrix = nullptr,
SkScalar x = 0) {
auto surface = MakeSurface(width, height, rContext);
auto canvas = surface->getCanvas();
if (matrix) {
canvas->concat(*matrix);
}
slug->draw(canvas);
SkBitmap bitmap;
bitmap.allocN32Pixels(width, height);
surface->readPixels(bitmap, 0, 0);
return bitmap;
}
DEF_TEST(SkRemoteGlyphCache_TypefaceSerialization, reporter) {
sk_sp<DiscardableManager> discardableManager = sk_make_sp<DiscardableManager>();
SkStrikeServer server(discardableManager.get());
SkStrikeClient client(discardableManager, false);
auto server_tf = SkTypeface::MakeDefault();
auto tf_data = server.serializeTypeface(server_tf.get());
auto client_tf = client.deserializeTypeface(tf_data->data(), tf_data->size());
REPORTER_ASSERT(reporter, client_tf);
REPORTER_ASSERT(reporter, static_cast<SkTypefaceProxy*>(client_tf.get())->remoteTypefaceID() ==
server_tf->uniqueID());
// Must unlock everything on termination, otherwise valgrind complains about memory leaks.
discardableManager->unlockAndDeleteAll();
}
DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS(SkRemoteGlyphCache_StrikeSerialization,
reporter,
ctxInfo,
CtsEnforcement::kNever) {
auto dContext = ctxInfo.directContext();
sk_sp<DiscardableManager> discardableManager = sk_make_sp<DiscardableManager>();
SkStrikeServer server(discardableManager.get());
SkStrikeClient client(discardableManager, false);
const SkPaint paint;
// Server.
auto serverTf = SkTypeface::MakeFromName("monospace", SkFontStyle());
auto serverTfData = server.serializeTypeface(serverTf.get());
int glyphCount = 10;
auto serverBlob = buildTextBlob(serverTf, glyphCount);
auto props = FindSurfaceProps(dContext);
std::unique_ptr<SkCanvas> cache_diff_canvas = server.makeAnalysisCanvas(
10, 10, props, nullptr, dContext->supportsDistanceFieldText(),
!dContext->priv().caps()->disablePerspectiveSDFText());
cache_diff_canvas->drawTextBlob(serverBlob.get(), 0, 0, paint);
std::vector<uint8_t> serverStrikeData;
server.writeStrikeData(&serverStrikeData);
// Client.
auto clientTf = client.deserializeTypeface(serverTfData->data(), serverTfData->size());
REPORTER_ASSERT(reporter,
client.readStrikeData(serverStrikeData.data(), serverStrikeData.size()));
auto clientBlob = buildTextBlob(clientTf, glyphCount);
SkBitmap expected = RasterBlob(serverBlob, 10, 10, paint, dContext);
SkBitmap actual = RasterBlob(clientBlob, 10, 10, paint, dContext);
compare_blobs(expected, actual, reporter);
REPORTER_ASSERT(reporter, !discardableManager->hasCacheMiss());
// Must unlock everything on termination, otherwise valgrind complains about memory leaks.
discardableManager->unlockAndDeleteAll();
}
static void use_padding_options(GrContextOptions* options) {
options->fSupportBilerpFromGlyphAtlas = true;
}
DEF_GANESH_TEST_FOR_CONTEXTS(SkRemoteGlyphCache_StrikeSerializationSlug,
sk_gpu_test::GrContextFactory::IsRenderingContext,
reporter,
ctxInfo,
use_padding_options,
CtsEnforcement::kNever) {
auto dContext = ctxInfo.directContext();
sk_sp<DiscardableManager> discardableManager = sk_make_sp<DiscardableManager>();
SkStrikeServer server(discardableManager.get());
SkStrikeClient client(discardableManager, false);
const SkPaint paint;
// Server.
auto serverTf = SkTypeface::MakeFromName("monospace", SkFontStyle());
auto serverTfData = server.serializeTypeface(serverTf.get());
int glyphCount = 10;
auto serverBlob = buildTextBlob(serverTf, glyphCount);
auto props = FindSurfaceProps(dContext);
std::unique_ptr<SkCanvas> analysisCanvas = server.makeAnalysisCanvas(
10, 10, props, nullptr, dContext->supportsDistanceFieldText(),
!dContext->priv().caps()->disablePerspectiveSDFText());
// Generate strike updates.
(void)Slug::ConvertBlob(analysisCanvas.get(), *serverBlob, {0, 0}, paint);
std::vector<uint8_t> serverStrikeData;
server.writeStrikeData(&serverStrikeData);
// Client.
auto clientTf = client.deserializeTypeface(serverTfData->data(), serverTfData->size());
REPORTER_ASSERT(reporter,
client.readStrikeData(serverStrikeData.data(), serverStrikeData.size()));
auto clientBlob = buildTextBlob(clientTf, glyphCount);
SkBitmap expected = RasterBlobThroughSlug(serverBlob, 10, 10, paint, dContext);
SkBitmap actual = RasterBlobThroughSlug(clientBlob, 10, 10, paint, dContext);
compare_blobs(expected, actual, reporter);
REPORTER_ASSERT(reporter, !discardableManager->hasCacheMiss());
// Must unlock everything on termination, otherwise valgrind complains about memory leaks.
discardableManager->unlockAndDeleteAll();
}
DEF_GANESH_TEST_FOR_CONTEXTS(SkRemoteGlyphCache_StrikeSerializationSlugForcePath,
sk_gpu_test::GrContextFactory::IsRenderingContext,
reporter,
ctxInfo,
use_padding_options,
CtsEnforcement::kNever) {
auto dContext = ctxInfo.directContext();
sk_sp<DiscardableManager> discardableManager = sk_make_sp<DiscardableManager>();
SkStrikeServer server(discardableManager.get());
SkStrikeClient client(discardableManager, false);
const SkPaint paint;
// Server.
auto serverTf = SkTypeface::MakeFromName("monospace", SkFontStyle());
auto serverTfData = server.serializeTypeface(serverTf.get());
int glyphCount = 10;
auto serverBlob = buildTextBlob(serverTf, glyphCount, 360);
auto props = FindSurfaceProps(dContext);
std::unique_ptr<SkCanvas> analysisCanvas = server.makeAnalysisCanvas(
10, 10, props, nullptr, dContext->supportsDistanceFieldText(),
!dContext->priv().caps()->disablePerspectiveSDFText());
// Generate strike updates.
(void)Slug::ConvertBlob(analysisCanvas.get(), *serverBlob, {0, 0}, paint);
std::vector<uint8_t> serverStrikeData;
server.writeStrikeData(&serverStrikeData);
// Client.
auto clientTf = client.deserializeTypeface(serverTfData->data(), serverTfData->size());
REPORTER_ASSERT(reporter,
client.readStrikeData(serverStrikeData.data(), serverStrikeData.size()));
auto clientBlob = buildTextBlob(clientTf, glyphCount, 360);
SkBitmap expected = RasterBlobThroughSlug(serverBlob, 10, 10, paint, dContext);
SkBitmap actual = RasterBlobThroughSlug(clientBlob, 10, 10, paint, dContext);
compare_blobs(expected, actual, reporter);
REPORTER_ASSERT(reporter, !discardableManager->hasCacheMiss());
// Must unlock everything on termination, otherwise valgrind complains about memory leaks.
discardableManager->unlockAndDeleteAll();
}
DEF_GANESH_TEST_FOR_CONTEXTS(SkRemoteGlyphCache_SlugSerialization,
sk_gpu_test::GrContextFactory::IsRenderingContext,
reporter,
ctxInfo,
use_padding_options,
CtsEnforcement::kNever) {
auto dContext = ctxInfo.directContext();
sk_sp<DiscardableManager> discardableManager = sk_make_sp<DiscardableManager>();
SkStrikeServer server(discardableManager.get());
SkStrikeClient client(discardableManager, false);
const SkPaint paint;
// Server.
auto serverTf = SkTypeface::MakeFromName("monospace", SkFontStyle());
auto serverTfData = server.serializeTypeface(serverTf.get());
int glyphCount = 10;
auto serverBlob = buildTextBlob(serverTf, glyphCount);
auto props = FindSurfaceProps(dContext);
std::unique_ptr<SkCanvas> analysisCanvas = server.makeAnalysisCanvas(
10, 10, props, nullptr, dContext->supportsDistanceFieldText(),
!dContext->priv().caps()->disablePerspectiveSDFText());
// Generate strike updates.
auto srcSlug = Slug::ConvertBlob(analysisCanvas.get(), *serverBlob, {0.3f, 0}, paint);
auto dstSlugData = srcSlug->serialize();
std::vector<uint8_t> serverStrikeData;
server.writeStrikeData(&serverStrikeData);
// Client.
REPORTER_ASSERT(reporter,
client.readStrikeData(serverStrikeData.data(), serverStrikeData.size()));
SkBitmap expected = RasterSlug(srcSlug, 10, 10, paint, dContext);
auto dstSlug = client.deserializeSlug(dstSlugData->data(), dstSlugData->size());
REPORTER_ASSERT(reporter, dstSlug != nullptr);
SkBitmap actual = RasterSlug(dstSlug, 10, 10, paint, dContext);
compare_blobs(expected, actual, reporter);
REPORTER_ASSERT(reporter, !discardableManager->hasCacheMiss());
// Must unlock everything on termination, otherwise valgrind complains about memory leaks.
discardableManager->unlockAndDeleteAll();
}
DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS(SkRemoteGlyphCache_ReleaseTypeFace,
reporter,
ctxInfo,
CtsEnforcement::kNever) {
sk_sp<DiscardableManager> discardableManager = sk_make_sp<DiscardableManager>();
SkStrikeServer server(discardableManager.get());
SkStrikeClient client(discardableManager, false);
// Server.
auto serverTf = TestEmptyTypeface::Make();
auto serverTfData = server.serializeTypeface(serverTf.get());
REPORTER_ASSERT(reporter, serverTf->unique());
{
const SkPaint paint;
int glyphCount = 10;
auto serverBlob = buildTextBlob(serverTf, glyphCount);
const SkSurfaceProps props;
std::unique_ptr<SkCanvas> cache_diff_canvas = server.makeAnalysisCanvas(
10, 10, props, nullptr, ctxInfo.directContext()->supportsDistanceFieldText(),
!ctxInfo.directContext()->priv().caps()->disablePerspectiveSDFText());
cache_diff_canvas->drawTextBlob(serverBlob.get(), 0, 0, paint);
REPORTER_ASSERT(reporter, !serverTf->unique());
std::vector<uint8_t> serverStrikeData;
server.writeStrikeData(&serverStrikeData);
}
REPORTER_ASSERT(reporter, serverTf->unique());
// Must unlock everything on termination, otherwise valgrind complains about memory leaks.
discardableManager->unlockAndDeleteAll();
}
DEF_TEST(SkRemoteGlyphCache_StrikeLockingServer, reporter) {
sk_sp<DiscardableManager> discardableManager = sk_make_sp<DiscardableManager>();
SkStrikeServer server(discardableManager.get());
SkStrikeClient client(discardableManager, false);
auto serverTf = SkTypeface::MakeFromName("monospace", SkFontStyle());
server.serializeTypeface(serverTf.get());
int glyphCount = 10;
auto serverBlob = buildTextBlob(serverTf, glyphCount);
const SkSurfaceProps props;
std::unique_ptr<SkCanvas> cache_diff_canvas =
server.makeAnalysisCanvas(10, 10, props, nullptr, true, true);
SkPaint paint;
cache_diff_canvas->drawTextBlob(serverBlob.get(), 0, 0, paint);
// The strike from the blob should be locked after it has been drawn on the canvas.
REPORTER_ASSERT(reporter, discardableManager->handleCount() == 1u);
REPORTER_ASSERT(reporter, discardableManager->lockedHandles().count() == 1u);
// Write the strike data and unlock everything. Re-analyzing the blob should lock the handle
// again.
std::vector<uint8_t> fontData;
server.writeStrikeData(&fontData);
discardableManager->unlockAll();
REPORTER_ASSERT(reporter, discardableManager->lockedHandles().count() == 0u);
cache_diff_canvas->drawTextBlob(serverBlob.get(), 0, 0, paint);
REPORTER_ASSERT(reporter, discardableManager->handleCount() == 1u);
REPORTER_ASSERT(reporter, discardableManager->lockedHandles().count() == 1u);
// Must unlock everything on termination, otherwise valgrind complains about memory leaks.
discardableManager->unlockAndDeleteAll();
}
DEF_TEST(SkRemoteGlyphCache_StrikeDeletionServer, reporter) {
sk_sp<DiscardableManager> discardableManager = sk_make_sp<DiscardableManager>();
SkStrikeServer server(discardableManager.get());
SkStrikeClient client(discardableManager, false);
auto serverTf = SkTypeface::MakeFromName("monospace", SkFontStyle());
server.serializeTypeface(serverTf.get());
int glyphCount = 10;
auto serverBlob = buildTextBlob(serverTf, glyphCount);
const SkSurfaceProps props;
std::unique_ptr<SkCanvas> cache_diff_canvas =
server.makeAnalysisCanvas(10, 10, props, nullptr, true, true);
SkPaint paint;
cache_diff_canvas->drawTextBlob(serverBlob.get(), 0, 0, paint);
REPORTER_ASSERT(reporter, discardableManager->handleCount() == 1u);
// Write the strike data and delete all the handles. Re-analyzing the blob should create new
// handles.
std::vector<uint8_t> fontData;
server.writeStrikeData(&fontData);
// Another analysis pass, to ensure that deleting handles after a complete cache hit still
// works. This is a regression test for crbug.com/999682.
cache_diff_canvas->drawTextBlob(serverBlob.get(), 0, 0, paint);
server.writeStrikeData(&fontData);
REPORTER_ASSERT(reporter, discardableManager->handleCount() == 1u);
discardableManager->unlockAndDeleteAll();
cache_diff_canvas->drawTextBlob(serverBlob.get(), 0, 0, paint);
REPORTER_ASSERT(reporter, discardableManager->handleCount() == 2u);
// Must unlock everything on termination, otherwise valgrind complains about memory leaks.
discardableManager->unlockAndDeleteAll();
}
DEF_TEST(SkRemoteGlyphCache_StrikePinningClient, reporter) {
sk_sp<DiscardableManager> discardableManager = sk_make_sp<DiscardableManager>();
SkStrikeServer server(discardableManager.get());
SkStrikeClient client(discardableManager, false);
// Server.
auto serverTf = SkTypeface::MakeFromName("monospace", SkFontStyle());
auto serverTfData = server.serializeTypeface(serverTf.get());
int glyphCount = 10;
auto serverBlob = buildTextBlob(serverTf, glyphCount);
const SkSurfaceProps props;
std::unique_ptr<SkCanvas> cache_diff_canvas =
server.makeAnalysisCanvas(10, 10, props, nullptr, true, true);
SkPaint paint;
cache_diff_canvas->drawTextBlob(serverBlob.get(), 0, 0, paint);
std::vector<uint8_t> serverStrikeData;
server.writeStrikeData(&serverStrikeData);
// Client.
REPORTER_ASSERT(reporter,
client.readStrikeData(serverStrikeData.data(), serverStrikeData.size()));
auto* clientTf = client.deserializeTypeface(serverTfData->data(), serverTfData->size()).get();
// The cache remains alive until it is pinned in the discardable manager.
SkGraphics::PurgeFontCache();
REPORTER_ASSERT(reporter, !clientTf->unique());
// Once the strike is unpinned and purged, SkStrikeClient should be the only owner of the
// clientTf.
discardableManager->unlockAndDeleteAll();
SkGraphics::PurgeFontCache();
REPORTER_ASSERT(reporter, clientTf->unique());
// Must unlock everything on termination, otherwise valgrind complains about memory leaks.
discardableManager->unlockAndDeleteAll();
}
DEF_TEST(SkRemoteGlyphCache_ClientMemoryAccounting, reporter) {
sk_sp<DiscardableManager> discardableManager = sk_make_sp<DiscardableManager>();
SkStrikeServer server(discardableManager.get());
SkStrikeClient client(discardableManager, false);
// Server.
auto serverTf = SkTypeface::MakeFromName("monospace", SkFontStyle());
auto serverTfData = server.serializeTypeface(serverTf.get());
int glyphCount = 10;
auto serverBlob = buildTextBlob(serverTf, glyphCount);
const SkSurfaceProps props;
std::unique_ptr<SkCanvas> cache_diff_canvas =
server.makeAnalysisCanvas(10, 10, props, nullptr, true, true);
SkPaint paint;
cache_diff_canvas->drawTextBlob(serverBlob.get(), 0, 0, paint);
std::vector<uint8_t> serverStrikeData;
server.writeStrikeData(&serverStrikeData);
// Client.
REPORTER_ASSERT(reporter,
client.readStrikeData(serverStrikeData.data(), serverStrikeData.size()));
// Must unlock everything on termination, otherwise valgrind complains about memory leaks.
discardableManager->unlockAndDeleteAll();
}
DEF_TEST(SkRemoteGlyphCache_PurgesServerEntries, reporter) {
sk_sp<DiscardableManager> discardableManager = sk_make_sp<DiscardableManager>();
SkStrikeServer server(discardableManager.get());
server.setMaxEntriesInDescriptorMapForTesting(1u);
SkStrikeClient client(discardableManager, false);
{
auto serverTf = SkTypeface::MakeFromName("monospace", SkFontStyle());
int glyphCount = 10;
auto serverBlob = buildTextBlob(serverTf, glyphCount);
const SkSurfaceProps props;
std::unique_ptr<SkCanvas> cache_diff_canvas =
server.makeAnalysisCanvas(10, 10, props, nullptr, true, true);
SkPaint paint;
REPORTER_ASSERT(reporter, server.remoteStrikeMapSizeForTesting() == 0u);
cache_diff_canvas->drawTextBlob(serverBlob.get(), 0, 0, paint);
REPORTER_ASSERT(reporter, server.remoteStrikeMapSizeForTesting() == 1u);
}
// Serialize to release the lock from the strike server and delete all current
// handles.
std::vector<uint8_t> fontData;
server.writeStrikeData(&fontData);
discardableManager->unlockAndDeleteAll();
// Use a different typeface. Creating a new strike should evict the previous
// one.
{
auto serverTf = SkTypeface::MakeFromName("Georgia", SkFontStyle());
int glyphCount = 10;
auto serverBlob = buildTextBlob(serverTf, glyphCount);
const SkSurfaceProps props;
std::unique_ptr<SkCanvas> cache_diff_canvas =
server.makeAnalysisCanvas(10, 10, props, nullptr, true, true);
SkPaint paint;
REPORTER_ASSERT(reporter, server.remoteStrikeMapSizeForTesting() == 1u);
cache_diff_canvas->drawTextBlob(serverBlob.get(), 0, 0, paint);
REPORTER_ASSERT(reporter, server.remoteStrikeMapSizeForTesting() == 1u);
}
// Must unlock everything on termination, otherwise valgrind complains about memory leaks.
discardableManager->unlockAndDeleteAll();
}
DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS(SkRemoteGlyphCache_DrawTextAsPath,
reporter,
ctxInfo,
CtsEnforcement::kNever) {
auto direct = ctxInfo.directContext();
sk_sp<DiscardableManager> discardableManager = sk_make_sp<DiscardableManager>();
SkStrikeServer server(discardableManager.get());
SkStrikeClient client(discardableManager, false);
SkPaint paint;
paint.setStyle(SkPaint::kStroke_Style);
paint.setStrokeWidth(0);
REPORTER_ASSERT(reporter,
SkStrikeSpec::ShouldDrawAsPath(paint, SkFont(), SkMatrix::I()));
// Server.
auto serverTf = SkTypeface::MakeFromName("monospace", SkFontStyle());
auto serverTfData = server.serializeTypeface(serverTf.get());
int glyphCount = 10;
auto serverBlob = buildTextBlob(serverTf, glyphCount);
auto props = FindSurfaceProps(direct);
std::unique_ptr<SkCanvas> cache_diff_canvas = server.makeAnalysisCanvas(
10, 10, props, nullptr, direct->supportsDistanceFieldText(),
!direct->priv().caps()->disablePerspectiveSDFText());
cache_diff_canvas->drawTextBlob(serverBlob.get(), 0, 0, paint);
std::vector<uint8_t> serverStrikeData;
server.writeStrikeData(&serverStrikeData);
// Client.
auto clientTf = client.deserializeTypeface(serverTfData->data(), serverTfData->size());
REPORTER_ASSERT(reporter,
client.readStrikeData(serverStrikeData.data(), serverStrikeData.size()));
auto clientBlob = buildTextBlob(clientTf, glyphCount);
SkBitmap expected = RasterBlob(serverBlob, 10, 10, paint, direct);
SkBitmap actual = RasterBlob(clientBlob, 10, 10, paint, direct);
compare_blobs(expected, actual, reporter, 1);
REPORTER_ASSERT(reporter, !discardableManager->hasCacheMiss());
// Must unlock everything on termination, otherwise valgrind complains about memory leaks.
discardableManager->unlockAndDeleteAll();
}
sk_sp<SkTextBlob> make_blob_causing_fallback(
sk_sp<SkTypeface> targetTf, const SkTypeface* glyphTf, skiatest::Reporter* reporter) {
SkFont font;
font.setSubpixel(true);
font.setSize(96);
font.setHinting(SkFontHinting::kNormal);
font.setTypeface(targetTf);
REPORTER_ASSERT(reporter,
!SkStrikeSpec::ShouldDrawAsPath(SkPaint(), font, SkMatrix::I()));
char s[] = "Skia";
int runSize = strlen(s);
SkTextBlobBuilder builder;
SkRect bounds = SkRect::MakeIWH(100, 100);
const auto& runBuffer = builder.allocRunPosH(font, runSize, 10, &bounds);
SkASSERT(runBuffer.utf8text == nullptr);
SkASSERT(runBuffer.clusters == nullptr);
SkFont(sk_ref_sp(glyphTf)).textToGlyphs(s, strlen(s), SkTextEncoding::kUTF8,
runBuffer.glyphs, runSize);
SkRect glyphBounds;
font.getWidths(runBuffer.glyphs, 1, nullptr, &glyphBounds);
REPORTER_ASSERT(reporter, glyphBounds.width() > SkGlyphDigest::kSkSideTooBigForAtlas);
for (int i = 0; i < runSize; i++) {
runBuffer.pos[i] = i * 10;
}
return builder.make();
}
DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS(SkRemoteGlyphCache_DrawTextAsMaskWithPathFallback,
reporter,
ctxInfo,
CtsEnforcement::kNever) {
auto direct = ctxInfo.directContext();
sk_sp<DiscardableManager> discardableManager = sk_make_sp<DiscardableManager>();
SkStrikeServer server(discardableManager.get());
SkStrikeClient client(discardableManager, false);
SkPaint paint;
auto serverTf = MakeResourceAsTypeface("fonts/HangingS.ttf");
// TODO: when the cq bots can handle this font remove the check.
if (serverTf == nullptr) {
return;
}
auto serverTfData = server.serializeTypeface(serverTf.get());
auto serverBlob = make_blob_causing_fallback(serverTf, serverTf.get(), reporter);
auto props = FindSurfaceProps(direct);
std::unique_ptr<SkCanvas> cache_diff_canvas = server.makeAnalysisCanvas(
10, 10, props, nullptr, direct->supportsDistanceFieldText(),
!direct->priv().caps()->disablePerspectiveSDFText());
cache_diff_canvas->drawTextBlob(serverBlob.get(), 0, 0, paint);
std::vector<uint8_t> serverStrikeData;
server.writeStrikeData(&serverStrikeData);
// Client.
auto clientTf = client.deserializeTypeface(serverTfData->data(), serverTfData->size());
REPORTER_ASSERT(reporter,
client.readStrikeData(serverStrikeData.data(), serverStrikeData.size()));
auto clientBlob = make_blob_causing_fallback(clientTf, serverTf.get(), reporter);
SkBitmap expected = RasterBlob(serverBlob, 10, 10, paint, direct);
SkBitmap actual = RasterBlob(clientBlob, 10, 10, paint, direct);
compare_blobs(expected, actual, reporter);
REPORTER_ASSERT(reporter, !discardableManager->hasCacheMiss());
// Must unlock everything on termination, otherwise valgrind complains about memory leaks.
discardableManager->unlockAndDeleteAll();
}
#if 0
// TODO: turn this one when I figure out how to deal with the pixel variance from linear
// interpolation from GPU to GPU.
DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS(SkRemoteGlyphCache_DrawTextAsSDFTWithAllARGBFallback,
reporter, ctxInfo, CtsEnforcement::kNever) {
sk_sp<DiscardableManager> discardableManager = sk_make_sp<DiscardableManager>();
SkStrikeServer server(discardableManager.get());
SkStrikeClient client(discardableManager, false);
SkPaint paint;
auto serverTf = ToolUtils::planet_typeface();
// TODO: when the cq bots can handle this font remove the check.
if (serverTf == nullptr) {
return;
}
auto serverTfData = server.serializeTypeface(serverTf.get());
auto makeBlob = [&reporter](sk_sp<SkTypeface> typeface) {
SkFont font;
font.setSubpixel(true);
font.setSize(96);
font.setHinting(SkFontHinting::kNormal);
font.setTypeface(typeface);
REPORTER_ASSERT(reporter, !SkDraw::ShouldDrawTextAsPaths(font, SkPaint(), SkMatrix::I()));
// Mercury to Uranus.
SkGlyphID glyphs[] = {1, 2, 3, 4, 5, 6, 7, 8};
SkTextBlobBuilder builder;
SkRect bounds = SkRect::MakeIWH(100, 100);
const auto& runBuffer = builder.allocRunPosH(font, std::size(glyphs), 100, &bounds);
SkASSERT(runBuffer.utf8text == nullptr);
SkASSERT(runBuffer.clusters == nullptr);
std::copy(std::begin(glyphs), std::end(glyphs), runBuffer.glyphs);
for (size_t i = 0; i < std::size(glyphs); i++) {
runBuffer.pos[i] = i * 100;
}
return builder.make();
};
auto serverBlob = makeBlob(serverTf);
auto props = FindSurfaceProps(ctxInfo.grContext());
std::unique_ptr<SkCanvas> cache_diff_canvas = server.makeAnalysisCanvas(
10, 10, props, nullptr, ctxInfo.directContext()->supportsDistanceFieldText());
cache_diff_canvas->drawTextBlob(serverBlob.get(), 0, 400, paint);
std::vector<uint8_t> serverStrikeData;
server.writeStrikeData(&serverStrikeData);
// Client.
auto clientTf = client.deserializeTypeface(serverTfData->data(), serverTfData->size());
REPORTER_ASSERT(reporter,
client.readStrikeData(serverStrikeData.data(), serverStrikeData.size()));
auto clientBlob = makeBlob(clientTf);
SkBitmap expected = RasterBlob(serverBlob, 800, 800, paint, ctxInfo.grContext());
SkBitmap actual = RasterBlob(clientBlob, 800, 800, paint, ctxInfo.grContext());
// Pixel variance can be high because of the atlas placement, and large scaling in the linear
// interpolation.
compare_blobs(expected, actual, reporter, 36);
REPORTER_ASSERT(reporter, !discardableManager->hasCacheMiss());
// Must unlock everything on termination, otherwise valgrind complains about memory leaks.
discardableManager->unlockAndDeleteAll();
}
#endif
DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS(SkRemoteGlyphCache_DrawTextXY,
reporter,
ctxInfo,
CtsEnforcement::kNever) {
auto direct = ctxInfo.directContext();
sk_sp<DiscardableManager> discardableManager = sk_make_sp<DiscardableManager>();
SkStrikeServer server(discardableManager.get());
SkStrikeClient client(discardableManager, false);
SkPaint paint;
paint.setAntiAlias(true);
// Server.
auto serverTf = SkTypeface::MakeFromName("monospace", SkFontStyle());
auto serverTfData = server.serializeTypeface(serverTf.get());
int glyphCount = 10;
auto serverBlob = buildTextBlob(serverTf, glyphCount);
auto props = FindSurfaceProps(direct);
std::unique_ptr<SkCanvas> cache_diff_canvas = server.makeAnalysisCanvas(
10, 10, props, nullptr, direct->supportsDistanceFieldText(),
!direct->priv().caps()->disablePerspectiveSDFText());
cache_diff_canvas->drawTextBlob(serverBlob.get(), 0.5, 0, paint);
std::vector<uint8_t> serverStrikeData;
server.writeStrikeData(&serverStrikeData);
// Client.
auto clientTf = client.deserializeTypeface(serverTfData->data(), serverTfData->size());
REPORTER_ASSERT(reporter,
client.readStrikeData(serverStrikeData.data(), serverStrikeData.size()));
auto clientBlob = buildTextBlob(clientTf, glyphCount);
SkBitmap expected = RasterBlob(serverBlob, 10, 10, paint, direct, nullptr, 0.5);
SkBitmap actual = RasterBlob(clientBlob, 10, 10, paint, direct, nullptr, 0.5);
compare_blobs(expected, actual, reporter);
REPORTER_ASSERT(reporter, !discardableManager->hasCacheMiss());
// Must unlock everything on termination, otherwise valgrind complains about memory leaks.
discardableManager->unlockAndDeleteAll();
}
#if !defined(SK_DISABLE_SDF_TEXT)
DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS(SkRemoteGlyphCache_DrawTextAsDFT,
reporter,
ctxInfo,
CtsEnforcement::kNever) {
auto direct = ctxInfo.directContext();
if (!direct->priv().caps()->shaderCaps()->supportsDistanceFieldText()) {
return;
}
sk_sp<DiscardableManager> discardableManager = sk_make_sp<DiscardableManager>();
SkStrikeServer server(discardableManager.get());
SkStrikeClient client(discardableManager, false);
SkPaint paint;
SkFont font;
// A scale transform forces fallback to dft.
SkMatrix matrix = SkMatrix::Scale(16, 16);
sktext::gpu::SDFTControl control =
direct->priv().asRecordingContext()->priv().getSDFTControl(true);
SkScalar approximateDeviceTextSize = SkFontPriv::ApproximateTransformedTextSize(font, matrix,
{0, 0});
REPORTER_ASSERT(reporter, control.isSDFT(approximateDeviceTextSize, paint, matrix));
// Server.
auto serverTf = SkTypeface::MakeFromName("monospace", SkFontStyle());
auto serverTfData = server.serializeTypeface(serverTf.get());
int glyphCount = 10;
auto serverBlob = buildTextBlob(serverTf, glyphCount);
const SkSurfaceProps props;
std::unique_ptr<SkCanvas> cache_diff_canvas = server.makeAnalysisCanvas(
10, 10, props, nullptr, direct->supportsDistanceFieldText(),
!direct->priv().caps()->disablePerspectiveSDFText());
cache_diff_canvas->concat(matrix);
cache_diff_canvas->drawTextBlob(serverBlob.get(), 0, 0, paint);
std::vector<uint8_t> serverStrikeData;
server.writeStrikeData(&serverStrikeData);
// Client.
auto clientTf = client.deserializeTypeface(serverTfData->data(), serverTfData->size());
REPORTER_ASSERT(reporter,
client.readStrikeData(serverStrikeData.data(), serverStrikeData.size()));
auto clientBlob = buildTextBlob(clientTf, glyphCount);
SkBitmap expected = RasterBlob(serverBlob, 10, 10, paint, direct, &matrix);
SkBitmap actual = RasterBlob(clientBlob, 10, 10, paint, direct, &matrix);
compare_blobs(expected, actual, reporter);
REPORTER_ASSERT(reporter, !discardableManager->hasCacheMiss());
// Must unlock everything on termination, otherwise valgrind complains about memory leaks.
discardableManager->unlockAndDeleteAll();
}
#endif // !defined(SK_DISABLE_SDF_TEXT)
DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS(SkRemoteGlyphCache_CacheMissReporting,
reporter,
ctxInfo,
CtsEnforcement::kNever) {
sk_sp<DiscardableManager> discardableManager = sk_make_sp<DiscardableManager>();
SkStrikeServer server(discardableManager.get());
SkStrikeClient client(discardableManager, false);
auto serverTf = SkTypeface::MakeFromName("monospace", SkFontStyle());
auto tfData = server.serializeTypeface(serverTf.get());
auto clientTf = client.deserializeTypeface(tfData->data(), tfData->size());
REPORTER_ASSERT(reporter, clientTf);
int glyphCount = 10;
auto clientBlob = buildTextBlob(clientTf, glyphCount);
// Raster the client-side blob without the glyph data, we should get cache miss notifications.
SkPaint paint;
SkMatrix matrix = SkMatrix::I();
RasterBlob(clientBlob, 10, 10, paint, ctxInfo.directContext(), &matrix);
REPORTER_ASSERT(reporter,
discardableManager->cacheMissCount(SkStrikeClient::kFontMetrics) == 1);
REPORTER_ASSERT(reporter,
discardableManager->cacheMissCount(SkStrikeClient::kGlyphMetrics) == 10);
// There shouldn't be any image or path requests, since we mark the glyph as empty on a cache
// miss.
REPORTER_ASSERT(reporter, discardableManager->cacheMissCount(SkStrikeClient::kGlyphImage) == 0);
REPORTER_ASSERT(reporter, discardableManager->cacheMissCount(SkStrikeClient::kGlyphPath) == 0);
// Must unlock everything on termination, otherwise valgrind complains about memory leaks.
discardableManager->unlockAndDeleteAll();
}
sk_sp<SkTextBlob> MakeEmojiBlob(sk_sp<SkTypeface> serverTf, SkScalar textSize,
sk_sp<SkTypeface> clientTf = nullptr) {
SkFont font;
font.setTypeface(serverTf);
font.setSize(textSize);
const char* text = ToolUtils::emoji_sample_text();
auto blob = SkTextBlob::MakeFromText(text, strlen(text), font);
if (clientTf == nullptr) return blob;
SkSerialProcs s_procs;
s_procs.fTypefaceProc = [](SkTypeface*, void* ctx) -> sk_sp<SkData> {
return SkData::MakeUninitialized(1u);
};
auto serialized = blob->serialize(s_procs);
SkDeserialProcs d_procs;
d_procs.fTypefaceCtx = &clientTf;
d_procs.fTypefaceProc = [](const void* data, size_t length, void* ctx) -> sk_sp<SkTypeface> {
return *(static_cast<sk_sp<SkTypeface>*>(ctx));
};
return SkTextBlob::Deserialize(serialized->data(), serialized->size(), d_procs);
}
DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS(SkRemoteGlyphCache_TypefaceWithNoPaths,
reporter,
ctxInfo,
CtsEnforcement::kNever) {
auto direct = ctxInfo.directContext();
sk_sp<DiscardableManager> discardableManager = sk_make_sp<DiscardableManager>();
SkStrikeServer server(discardableManager.get());
SkStrikeClient client(discardableManager, false);
auto serverTf = ToolUtils::emoji_typeface();
auto serverTfData = server.serializeTypeface(serverTf.get());
auto clientTf = client.deserializeTypeface(serverTfData->data(), serverTfData->size());
auto props = FindSurfaceProps(direct);
std::unique_ptr<SkCanvas> cache_diff_canvas = server.makeAnalysisCanvas(
500, 500, props, nullptr, direct->supportsDistanceFieldText(),
!direct->priv().caps()->disablePerspectiveSDFText());
for (SkScalar textSize : { 70, 180, 270, 340}) {
auto serverBlob = MakeEmojiBlob(serverTf, textSize);
SkPaint paint;
cache_diff_canvas->drawTextBlob(serverBlob.get(), 100, 100, paint);
std::vector<uint8_t> serverStrikeData;
server.writeStrikeData(&serverStrikeData);
if (!serverStrikeData.empty()) {
REPORTER_ASSERT(reporter,
client.readStrikeData(serverStrikeData.data(),
serverStrikeData.size()));
}
auto clientBlob = MakeEmojiBlob(serverTf, textSize, clientTf);
REPORTER_ASSERT(reporter, clientBlob);
RasterBlob(clientBlob, 500, 500, paint, direct);
REPORTER_ASSERT(reporter, !discardableManager->hasCacheMiss());
discardableManager->resetCacheMissCounts();
}
// Must unlock everything on termination, otherwise valgrind complains about memory leaks.
discardableManager->unlockAndDeleteAll();
}
class SkRemoteGlyphCacheTest {
public:
static sk_sp<SkTextBlob> MakeNormalBlob(SkPaint* paint,
sk_sp<SkTypeface> serverTf, bool asPaths, SkScalar textSize,
sk_sp<SkTypeface> clientTf = nullptr) {
SkFont font;
font.setTypeface(serverTf);
font.setSize(textSize);
const char* text = "Hel lo";
if (asPaths) {
font.setupForAsPaths(paint);
} else {
SkFont font2(font);
font2.setupForAsPaths(paint);
}
auto blob = SkTextBlob::MakeFromText(text, strlen(text), font);
if (clientTf == nullptr) return blob;
SkSerialProcs s_procs;
s_procs.fTypefaceProc = [](SkTypeface*, void* ctx) -> sk_sp<SkData> {
return SkData::MakeUninitialized(1u);
};
auto serialized = blob->serialize(s_procs);
SkDeserialProcs d_procs;
d_procs.fTypefaceCtx = &clientTf;
d_procs.fTypefaceProc = [](const void* data, size_t length, void* ctx) -> sk_sp<SkTypeface> {
return *(static_cast<sk_sp<SkTypeface>*>(ctx));
};
return SkTextBlob::Deserialize(serialized->data(), serialized->size(), d_procs);
}
};
DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS(SkRemoteGlyphCache_TypefaceWithPaths_MaskThenPath,
reporter,
ctxInfo,
CtsEnforcement::kNever) {
auto direct = ctxInfo.directContext();
sk_sp<DiscardableManager> discardableManager = sk_make_sp<DiscardableManager>();
SkStrikeServer server(discardableManager.get());
SkStrikeClient client(discardableManager, true);
auto serverTf = ToolUtils::create_portable_typeface();
auto serverTfData = server.serializeTypeface(serverTf.get());
auto clientTf = client.deserializeTypeface(serverTfData->data(), serverTfData->size());
auto props = FindSurfaceProps(direct);
std::unique_ptr<SkCanvas> cache_diff_canvas = server.makeAnalysisCanvas(
500, 500, props, nullptr, direct->supportsDistanceFieldText(),
!direct->priv().caps()->disablePerspectiveSDFText());
SkPaint paint;
using Rgct = SkRemoteGlyphCacheTest;
// Draw from mask out of the strike which provides paths.
{
auto serverBlob = Rgct::MakeNormalBlob(&paint, serverTf, true, 64);
cache_diff_canvas->drawTextBlob(serverBlob.get(), 100, 100, paint);
}
// Draw from path out of the strike which provides paths.
{
auto serverBlob = Rgct::MakeNormalBlob(&paint, serverTf, false, 440);
cache_diff_canvas->drawTextBlob(serverBlob.get(), 100, 100, paint);
}
std::vector<uint8_t> serverStrikeData;
server.writeStrikeData(&serverStrikeData);
if (!serverStrikeData.empty()) {
REPORTER_ASSERT(reporter,
client.readStrikeData(serverStrikeData.data(),
serverStrikeData.size()));
}
{
auto clientBlob = Rgct::MakeNormalBlob(&paint, serverTf, true, 64, clientTf);
REPORTER_ASSERT(reporter, clientBlob);
RasterBlob(clientBlob, 100, 100, paint, direct);
REPORTER_ASSERT(reporter, !discardableManager->hasCacheMiss());
discardableManager->resetCacheMissCounts();
}
{
auto clientBlob = Rgct::MakeNormalBlob(&paint, serverTf, false, 440, clientTf);
REPORTER_ASSERT(reporter, clientBlob);
RasterBlob(clientBlob, 100, 100, paint, direct);
REPORTER_ASSERT(reporter, !discardableManager->hasCacheMiss());
discardableManager->resetCacheMissCounts();
}
// Must unlock everything on termination, otherwise valgrind complains about memory leaks.
discardableManager->unlockAndDeleteAll();
}
DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS(SkRemoteGlyphCache_TypefaceWithPaths_PathThenMask,
reporter,
ctxInfo,
CtsEnforcement::kNever) {
auto direct = ctxInfo.directContext();
sk_sp<DiscardableManager> discardableManager = sk_make_sp<DiscardableManager>();
SkStrikeServer server(discardableManager.get());
SkStrikeClient client(discardableManager, true);
auto serverTf = ToolUtils::create_portable_typeface();
auto serverTfData = server.serializeTypeface(serverTf.get());
auto clientTf = client.deserializeTypeface(serverTfData->data(), serverTfData->size());
auto props = FindSurfaceProps(direct);
std::unique_ptr<SkCanvas> cache_diff_canvas = server.makeAnalysisCanvas(
500, 500, props, nullptr, direct->supportsDistanceFieldText(),
!direct->priv().caps()->disablePerspectiveSDFText());
SkPaint paint;
using Rgct = SkRemoteGlyphCacheTest;
// Draw from path out of the strike which provides paths.
{
auto serverBlob = Rgct::MakeNormalBlob(&paint, serverTf, false, 440);
cache_diff_canvas->drawTextBlob(serverBlob.get(), 100, 100, paint);
}
// Draw from mask out of the strike which provides paths.
{
auto serverBlob = Rgct::MakeNormalBlob(&paint, serverTf, true, 64);
cache_diff_canvas->drawTextBlob(serverBlob.get(), 100, 100, paint);
}
std::vector<uint8_t> serverStrikeData;
server.writeStrikeData(&serverStrikeData);
if (!serverStrikeData.empty()) {
REPORTER_ASSERT(reporter,
client.readStrikeData(serverStrikeData.data(),
serverStrikeData.size()));
}
{
auto clientBlob = Rgct::MakeNormalBlob(&paint, serverTf, true, 64, clientTf);
REPORTER_ASSERT(reporter, clientBlob);
RasterBlob(clientBlob, 100, 100, paint, direct);
REPORTER_ASSERT(reporter, !discardableManager->hasCacheMiss());
discardableManager->resetCacheMissCounts();
}
{
auto clientBlob = Rgct::MakeNormalBlob(&paint, serverTf, false, 440, clientTf);
REPORTER_ASSERT(reporter, clientBlob);
RasterBlob(clientBlob, 100, 100, paint, direct);
REPORTER_ASSERT(reporter, !discardableManager->hasCacheMiss());
discardableManager->resetCacheMissCounts();
}
// Must unlock everything on termination, otherwise valgrind complains about memory leaks.
discardableManager->unlockAndDeleteAll();
}
#endif