SkRemoteGlyphCacheTest.cpp File Reference

#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 "include/gpu/ganesh/SkSurfaceGanesh.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/SkReadBuffer.h"
#include "src/core/SkStrikeSpec.h"
#include "src/core/SkTHash.h"
#include "src/core/SkTypeface_remote.h"
#include "src/core/SkWriteBuffer.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/FontToolUtils.h"
#include "tools/fonts/TestEmptyTypeface.h"
#include <cmath>
#include <cstdint>
#include <cstring>
#include <initializer_list>
#include <memory>
#include <optional>
#include <vector>

Go to the source code of this file.

Classes
class	DiscardableManager
class	SkRemoteGlyphCacheTest

Typedefs
using	Slug = sktext::gpu::Slug

Functions
sk_sp< SkTextBlob >	buildTextBlob (sk_sp< SkTypeface > tf, int glyphCount, int textSize=1)
static void	compare_blobs (const SkBitmap &expected, const SkBitmap &actual, skiatest::Reporter *reporter, int tolerance=0)
sk_sp< SkSurface >	MakeSurface (int width, int height, GrRecordingContext *rContext)
SkSurfaceProps	FindSurfaceProps (GrRecordingContext *rContext)
SkBitmap	RasterBlob (sk_sp< SkTextBlob > blob, int width, int height, const SkPaint &paint, GrRecordingContext *rContext, const SkMatrix *matrix=nullptr, SkScalar x=0)
SkBitmap	RasterBlobThroughSlug (sk_sp< SkTextBlob > blob, int width, int height, const SkPaint &paint, GrRecordingContext *rContext, const SkMatrix *matrix=nullptr, SkScalar x=0)
SkBitmap	RasterSlug (sk_sp< Slug > slug, int width, int height, const SkPaint &paint, GrRecordingContext *rContext, const SkMatrix *matrix=nullptr, SkScalar x=0)
	DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS (SkRemoteGlyphCache_StrikeSerialization, reporter, ctxInfo, CtsEnforcement::kNever)
static void	use_padding_options (GrContextOptions *options)
	DEF_GANESH_TEST_FOR_CONTEXTS (SkRemoteGlyphCache_StrikeSerializationSlug, skgpu::IsRenderingContext, reporter, ctxInfo, use_padding_options, CtsEnforcement::kNever)
	DEF_GANESH_TEST_FOR_CONTEXTS (SkRemoteGlyphCache_StrikeSerializationSlugForcePath, skgpu::IsRenderingContext, reporter, ctxInfo, use_padding_options, CtsEnforcement::kNever)
	DEF_GANESH_TEST_FOR_CONTEXTS (SkRemoteGlyphCache_SlugSerialization, skgpu::IsRenderingContext, reporter, ctxInfo, use_padding_options, CtsEnforcement::kNever)
	DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS (SkRemoteGlyphCache_ReleaseTypeFace, reporter, ctxInfo, CtsEnforcement::kNever)
	DEF_TEST (SkRemoteGlyphCache_StrikeLockingServer, reporter)
	DEF_TEST (SkRemoteGlyphCache_StrikeDeletionServer, reporter)
	DEF_TEST (SkRemoteGlyphCache_StrikePinningClient, reporter)
	DEF_TEST (SkRemoteGlyphCache_ClientMemoryAccounting, reporter)
	DEF_TEST (SkRemoteGlyphCache_PurgesServerEntries, reporter)
	DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS (SkRemoteGlyphCache_DrawTextAsPath, reporter, ctxInfo, CtsEnforcement::kNever)
sk_sp< SkTextBlob >	make_blob_causing_fallback (sk_sp< SkTypeface > targetTf, const SkTypeface *glyphTf, skiatest::Reporter *reporter)
	DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS (SkRemoteGlyphCache_DrawTextAsMaskWithPathFallback, reporter, ctxInfo, CtsEnforcement::kNever)
	DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS (SkRemoteGlyphCache_DrawTextXY, reporter, ctxInfo, CtsEnforcement::kNever)
	DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS (SkRemoteGlyphCache_DrawTextAsDFT, reporter, ctxInfo, CtsEnforcement::kNever)
	DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS (SkRemoteGlyphCache_CacheMissReporting, reporter, ctxInfo, CtsEnforcement::kNever)
sk_sp< SkTextBlob >	MakeEmojiBlob (sk_sp< SkTypeface > serverTf, SkScalar textSize, sk_sp< SkTypeface > clientTf=nullptr)
	DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS (SkRemoteGlyphCache_TypefaceWithNoPaths, reporter, ctxInfo, CtsEnforcement::kNever)
	DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS (SkRemoteGlyphCache_TypefaceWithPaths_MaskThenPath, reporter, ctxInfo, CtsEnforcement::kNever)
	DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS (SkRemoteGlyphCache_TypefaceWithPaths_PathThenMask, reporter, ctxInfo, CtsEnforcement::kNever)
	DEF_TEST (SkTypefaceProxy_Basic_Serial, reporter)
	DEF_TEST (SkGraphics_Limits, reporter)

Typedef Documentation

Slug

using Slug = sktext::gpu::Slug

Definition at line 68 of file SkRemoteGlyphCacheTest.cpp.

Function Documentation

buildTextBlob()

sk_sp< SkTextBlob > buildTextBlob	(	sk_sp< SkTypeface >	tf,
		int	glyphCount,
		int	textSize = 1
	)

Definition at line 161 of file SkRemoteGlyphCacheTest.cpp.

                                                                                        {
    SkFont font;
    SkASSERT(tf);
    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();
}

compare_blobs()

static void compare_blobs ( const SkBitmap &  expected, const SkBitmap &  actual, skiatest::Reporter *  reporter, int  tolerance = 0  )

static

Definition at line 183 of file SkRemoteGlyphCacheTest.cpp.

                                                                         {
    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);
                }
            }
        }
    }
}

DEF_GANESH_TEST_FOR_CONTEXTS() [1/3]

DEF_GANESH_TEST_FOR_CONTEXTS	(	SkRemoteGlyphCache_SlugSerialization	,
		skgpu::IsRenderingContext	,
		reporter	,
		ctxInfo	,
		use_padding_options	,
		CtsEnforcement::kNever
	)

Definition at line 398 of file SkRemoteGlyphCacheTest.cpp.

                                                   {
    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 serverTypeface = ToolUtils::CreateTestTypeface("monospace", SkFontStyle());
 
    int glyphCount = 10;
    auto serverBlob = buildTextBlob(serverTypeface, 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.deserializeSlugForTest(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_CONTEXTS() [2/3]

DEF_GANESH_TEST_FOR_CONTEXTS	(	SkRemoteGlyphCache_StrikeSerializationSlug	,
		skgpu::IsRenderingContext	,
		reporter	,
		ctxInfo	,
		use_padding_options	,
		CtsEnforcement::kNever
	)

Definition at line 310 of file SkRemoteGlyphCacheTest.cpp.

                                                   {
    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 serverTypeface = ToolUtils::CreateTestTypeface("monospace", SkFontStyle());
    const SkTypefaceID serverTypefaceID = serverTypeface->uniqueID();
 
    int glyphCount = 10;
    auto serverBlob = buildTextBlob(serverTypeface, 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.
    REPORTER_ASSERT(reporter,
                    client.readStrikeData(serverStrikeData.data(), serverStrikeData.size()));
    auto clientTypeface = client.retrieveTypefaceUsingServerIDForTest(serverTypefaceID);
    auto clientBlob = buildTextBlob(clientTypeface, 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() [3/3]

DEF_GANESH_TEST_FOR_CONTEXTS	(	SkRemoteGlyphCache_StrikeSerializationSlugForcePath	,
		skgpu::IsRenderingContext	,
		reporter	,
		ctxInfo	,
		use_padding_options	,
		CtsEnforcement::kNever
	)

Definition at line 354 of file SkRemoteGlyphCacheTest.cpp.

                                                   {
    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 serverTypeface = ToolUtils::CreateTestTypeface("monospace", SkFontStyle());
    const SkTypefaceID serverTypefaceID = serverTypeface->uniqueID();
 
    int glyphCount = 10;
    auto serverBlob = buildTextBlob(serverTypeface, 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.
    REPORTER_ASSERT(reporter,
                    client.readStrikeData(serverStrikeData.data(), serverStrikeData.size()));
    auto clientTypeface = client.retrieveTypefaceUsingServerIDForTest(serverTypefaceID);
    auto clientBlob = buildTextBlob(clientTypeface, 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_RENDERING_CONTEXTS() [1/10]

DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS	(	SkRemoteGlyphCache_CacheMissReporting	,
		reporter	,
		ctxInfo	,
		CtsEnforcement::kNever
	)

Definition at line 877 of file SkRemoteGlyphCacheTest.cpp.

                                                             {
    sk_sp<DiscardableManager> discardableManager = sk_make_sp<DiscardableManager>();
    SkStrikeServer server(discardableManager.get());
    SkStrikeClient client(discardableManager, false);
 
    auto serverTypeface = ToolUtils::CreateTestTypeface("monospace", SkFontStyle());
    REPORTER_ASSERT(reporter, serverTypeface);
 
    // Create the clientTypeface proxy directly from the serverTypeface.
    auto clientTypeface = sk_make_sp<SkTypefaceProxy>(
            serverTypeface->uniqueID(),
            serverTypeface->countGlyphs(),
            serverTypeface->fontStyle(),
            serverTypeface->isFixedPitch(),
            /*glyphMaskNeedsCurrentColor=*/ false,
            discardableManager,
            /*isLogging=*/ false);
 
    REPORTER_ASSERT(reporter, clientTypeface);
    int glyphCount = 10;
    auto clientBlob = buildTextBlob(clientTypeface, 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();
}

DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS() [2/10]

DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS	(	SkRemoteGlyphCache_DrawTextAsDFT	,
		reporter	,
		ctxInfo	,
		CtsEnforcement::kNever
	)

Definition at line 823 of file SkRemoteGlyphCacheTest.cpp.

                                                             {
    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 = ToolUtils::DefaultFont();
 
    // 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 serverTypeface = ToolUtils::CreateTestTypeface("monospace", SkFontStyle());
    const SkTypefaceID serverTypefaceID = serverTypeface->uniqueID();
 
    int glyphCount = 10;
    auto serverBlob = buildTextBlob(serverTypeface, 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.
    REPORTER_ASSERT(reporter,
                    client.readStrikeData(serverStrikeData.data(), serverStrikeData.size()));
    auto clientTypeface = client.retrieveTypefaceUsingServerIDForTest(serverTypefaceID);
    auto clientBlob = buildTextBlob(clientTypeface, 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();
}

DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS() [3/10]

DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS	(	SkRemoteGlyphCache_DrawTextAsMaskWithPathFallback	,
		reporter	,
		ctxInfo	,
		CtsEnforcement::kNever
	)

Definition at line 737 of file SkRemoteGlyphCacheTest.cpp.

                                                             {
    auto direct = ctxInfo.directContext();
    sk_sp<DiscardableManager> discardableManager = sk_make_sp<DiscardableManager>();
    SkStrikeServer server(discardableManager.get());
    SkStrikeClient client(discardableManager, false);
 
    SkPaint paint;
 
    auto serverTypeface = ToolUtils::CreateTypefaceFromResource("fonts/HangingS.ttf");
    // TODO: when the cq bots can handle this font remove the check.
    if (serverTypeface == nullptr) {
        return;
    }
    const SkTypefaceID serverTypefaceID = serverTypeface->uniqueID();
 
    auto serverBlob = make_blob_causing_fallback(serverTypeface, serverTypeface.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.
    REPORTER_ASSERT(reporter,
                    client.readStrikeData(serverStrikeData.data(), serverStrikeData.size()));
    auto clientTypeface = client.retrieveTypefaceUsingServerIDForTest(serverTypefaceID);
    auto clientBlob = make_blob_causing_fallback(clientTypeface, serverTypeface.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();
}

DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS() [4/10]

DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS	(	SkRemoteGlyphCache_DrawTextAsPath	,
		reporter	,
		ctxInfo	,
		CtsEnforcement::kNever
	)

Definition at line 657 of file SkRemoteGlyphCacheTest.cpp.

                                                             {
    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);
    SkFont font = ToolUtils::DefaultFont();
    REPORTER_ASSERT(reporter,
            SkStrikeSpec::ShouldDrawAsPath(paint, font, SkMatrix::I()));
 
    // Server.
    auto serverTypeface = ToolUtils::CreateTestTypeface("monospace", SkFontStyle());
    const SkTypefaceID serverTypefaceID = serverTypeface->uniqueID();
 
    int glyphCount = 10;
    auto serverBlob = buildTextBlob(serverTypeface, 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.
    REPORTER_ASSERT(reporter,
                    client.readStrikeData(serverStrikeData.data(), serverStrikeData.size()));
    auto clientTypeface = client.retrieveTypefaceUsingServerIDForTest(serverTypefaceID);
    auto clientBlob = buildTextBlob(clientTypeface, 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();
}

DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS() [5/10]

DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS	(	SkRemoteGlyphCache_DrawTextXY	,
		reporter	,
		ctxInfo	,
		CtsEnforcement::kNever
	)

Definition at line 781 of file SkRemoteGlyphCacheTest.cpp.

                                                             {
    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 serverTypeface = ToolUtils::CreateTestTypeface("monospace", SkFontStyle());
    const SkTypefaceID serverTypefaceID = serverTypeface->uniqueID();
 
    int glyphCount = 10;
    auto serverBlob = buildTextBlob(serverTypeface, 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.
    REPORTER_ASSERT(reporter,
                    client.readStrikeData(serverStrikeData.data(), serverStrikeData.size()));
    auto clientTypeface = client.retrieveTypefaceUsingServerIDForTest(serverTypefaceID);
    auto clientBlob = buildTextBlob(clientTypeface, 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();
}

DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS() [6/10]

DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS	(	SkRemoteGlyphCache_ReleaseTypeFace	,
		reporter	,
		ctxInfo	,
		CtsEnforcement::kNever
	)

Definition at line 442 of file SkRemoteGlyphCacheTest.cpp.

                                                             {
    sk_sp<DiscardableManager> discardableManager = sk_make_sp<DiscardableManager>();
    SkStrikeServer server(discardableManager.get());
    SkStrikeClient client(discardableManager, false);
 
    // Server.
    auto serverTypeface = TestEmptyTypeface::Make();
    REPORTER_ASSERT(reporter, serverTypeface->unique());
 
    {
        const SkPaint paint;
        int glyphCount = 10;
        auto serverBlob = buildTextBlob(serverTypeface, 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, !serverTypeface->unique());
 
        std::vector<uint8_t> serverStrikeData;
        server.writeStrikeData(&serverStrikeData);
    }
    REPORTER_ASSERT(reporter, serverTypeface->unique());
 
    // Must unlock everything on termination, otherwise valgrind complains about memory leaks.
    discardableManager->unlockAndDeleteAll();
}

DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS() [7/10]

DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS	(	SkRemoteGlyphCache_StrikeSerialization	,
		reporter	,
		ctxInfo	,
		CtsEnforcement::kNever
	)

Definition at line 260 of file SkRemoteGlyphCacheTest.cpp.

                                                             {
    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 serverTypeface = ToolUtils::CreateTestTypeface("monospace", SkFontStyle());
    const SkTypefaceID serverTypefaceID = serverTypeface->uniqueID();
 
    int glyphCount = 10;
    auto serverBlob = buildTextBlob(serverTypeface, glyphCount);
    auto props = FindSurfaceProps(dContext);
    std::unique_ptr<SkCanvas> analysisCanvas = server.makeAnalysisCanvas(
            10, 10, props, nullptr, dContext->supportsDistanceFieldText(),
            !dContext->priv().caps()->disablePerspectiveSDFText());
    analysisCanvas->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 clientTypeface = client.retrieveTypefaceUsingServerIDForTest(serverTypefaceID);
 
    // Ensure typeface serialization/deserialization worked.
    REPORTER_ASSERT(reporter,
                    static_cast<SkTypefaceProxy*>(clientTypeface.get())->remoteTypefaceID() ==
                        serverTypefaceID);
 
    auto clientBlob = buildTextBlob(clientTypeface, 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();
}

DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS() [8/10]

DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS	(	SkRemoteGlyphCache_TypefaceWithNoPaths	,
		reporter	,
		ctxInfo	,
		CtsEnforcement::kNever
	)

Definition at line 944 of file SkRemoteGlyphCacheTest.cpp.

                                                             {
    auto direct = ctxInfo.directContext();
    sk_sp<DiscardableManager> discardableManager = sk_make_sp<DiscardableManager>();
    SkStrikeServer server(discardableManager.get());
    SkStrikeClient client(discardableManager, false);
 
    auto serverTypeface = ToolUtils::EmojiSample().typeface;
    const SkTypefaceID serverTypefaceID = serverTypeface->uniqueID();
 
    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(serverTypeface, 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 clientTypeface = client.retrieveTypefaceUsingServerIDForTest(serverTypefaceID);
        auto clientBlob = MakeEmojiBlob(serverTypeface, textSize, clientTypeface);
        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();
}

DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS() [9/10]

DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS	(	SkRemoteGlyphCache_TypefaceWithPaths_MaskThenPath	,
		reporter	,
		ctxInfo	,
		CtsEnforcement::kNever
	)

Definition at line 1019 of file SkRemoteGlyphCacheTest.cpp.

                                                             {
    auto direct = ctxInfo.directContext();
    sk_sp<DiscardableManager> discardableManager = sk_make_sp<DiscardableManager>();
    SkStrikeServer server(discardableManager.get());
    SkStrikeClient client(discardableManager, true);
 
    auto serverTypeface = ToolUtils::DefaultPortableTypeface();
    const SkTypefaceID serverTypefaceID = serverTypeface->uniqueID();
 
    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, serverTypeface, 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, serverTypeface, 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 clientTypeface = client.retrieveTypefaceUsingServerIDForTest(serverTypefaceID);
 
    {
        auto clientBlob = Rgct::MakeNormalBlob(&paint, serverTypeface, true, 64, clientTypeface);
        REPORTER_ASSERT(reporter, clientBlob);
 
        RasterBlob(clientBlob, 100, 100, paint, direct);
        REPORTER_ASSERT(reporter, !discardableManager->hasCacheMiss());
        discardableManager->resetCacheMissCounts();
    }
    {
        auto clientBlob = Rgct::MakeNormalBlob(&paint, serverTypeface, false, 440, clientTypeface);
        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() [10/10]

DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS	(	SkRemoteGlyphCache_TypefaceWithPaths_PathThenMask	,
		reporter	,
		ctxInfo	,
		CtsEnforcement::kNever
	)

Definition at line 1078 of file SkRemoteGlyphCacheTest.cpp.

                                                             {
    auto direct = ctxInfo.directContext();
    sk_sp<DiscardableManager> discardableManager = sk_make_sp<DiscardableManager>();
    SkStrikeServer server(discardableManager.get());
    SkStrikeClient client(discardableManager, true);
 
    auto serverTypeface = ToolUtils::DefaultPortableTypeface();
    const SkTypefaceID serverTypefaceID = serverTypeface->uniqueID();
 
    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, serverTypeface, 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, serverTypeface, 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 clientTypeface = client.retrieveTypefaceUsingServerIDForTest(serverTypefaceID);
 
    {
        auto clientBlob = Rgct::MakeNormalBlob(&paint, serverTypeface, true, 64, clientTypeface);
        REPORTER_ASSERT(reporter, clientBlob);
 
        RasterBlob(clientBlob, 100, 100, paint, direct);
        REPORTER_ASSERT(reporter, !discardableManager->hasCacheMiss());
        discardableManager->resetCacheMissCounts();
    }
    {
        auto clientBlob = Rgct::MakeNormalBlob(&paint, serverTypeface, false, 440, clientTypeface);
        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_TEST() [1/7]

DEF_TEST	(	SkGraphics_Limits	,
		reporter
	)

Definition at line 1165 of file SkRemoteGlyphCacheTest.cpp.

                                      {
    const auto prev1 = SkGraphics::GetTypefaceCacheCountLimit();
 
    auto prev2 = SkGraphics::SetTypefaceCacheCountLimit(prev1 + 1);
    REPORTER_ASSERT(reporter, prev1 == prev2);
    prev2 = SkGraphics::GetTypefaceCacheCountLimit();
    REPORTER_ASSERT(reporter, prev2 == prev1 + 1);
 
    SkGraphics::SetTypefaceCacheCountLimit(prev1);  // restore orig
}

DEF_TEST() [2/7]

DEF_TEST	(	SkRemoteGlyphCache_ClientMemoryAccounting	,
		reporter
	)

Definition at line 583 of file SkRemoteGlyphCacheTest.cpp.

                                                              {
    sk_sp<DiscardableManager> discardableManager = sk_make_sp<DiscardableManager>();
    SkStrikeServer server(discardableManager.get());
    SkStrikeClient client(discardableManager, false);
 
    // Server.
    auto serverTypeface = ToolUtils::CreateTestTypeface("monospace", SkFontStyle());
 
    int glyphCount = 10;
    auto serverBlob = buildTextBlob(serverTypeface, 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() [3/7]

DEF_TEST	(	SkRemoteGlyphCache_PurgesServerEntries	,
		reporter
	)

Definition at line 611 of file SkRemoteGlyphCacheTest.cpp.

                                                           {
    sk_sp<DiscardableManager> discardableManager = sk_make_sp<DiscardableManager>();
    SkStrikeServer server(discardableManager.get());
    server.setMaxEntriesInDescriptorMapForTesting(1u);
    SkStrikeClient client(discardableManager, false);
 
    {
        auto serverTypeface = ToolUtils::CreateTestTypeface("monospace", SkFontStyle());
        int glyphCount = 10;
        auto serverBlob = buildTextBlob(serverTypeface, 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 serverTypeface = ToolUtils::CreateTestTypeface("Georgia", SkFontStyle());
        int glyphCount = 10;
        auto serverBlob = buildTextBlob(serverTypeface, 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_TEST() [4/7]

DEF_TEST	(	SkRemoteGlyphCache_StrikeDeletionServer	,
		reporter
	)

Definition at line 508 of file SkRemoteGlyphCacheTest.cpp.

                                                            {
    sk_sp<DiscardableManager> discardableManager = sk_make_sp<DiscardableManager>();
    SkStrikeServer server(discardableManager.get());
    SkStrikeClient client(discardableManager, false);
 
    auto serverTypeface = ToolUtils::CreateTestTypeface("monospace", SkFontStyle());
    int glyphCount = 10;
    auto serverBlob = buildTextBlob(serverTypeface, 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() [5/7]

DEF_TEST	(	SkRemoteGlyphCache_StrikeLockingServer	,
		reporter
	)

Definition at line 474 of file SkRemoteGlyphCacheTest.cpp.

                                                           {
    sk_sp<DiscardableManager> discardableManager = sk_make_sp<DiscardableManager>();
    SkStrikeServer server(discardableManager.get());
    SkStrikeClient client(discardableManager, false);
 
    auto serverTypeface = ToolUtils::CreateTestTypeface("monospace", SkFontStyle());
    int glyphCount = 10;
    auto serverBlob = buildTextBlob(serverTypeface, 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() [6/7]

DEF_TEST	(	SkRemoteGlyphCache_StrikePinningClient	,
		reporter
	)

Definition at line 543 of file SkRemoteGlyphCacheTest.cpp.

                                                           {
    sk_sp<DiscardableManager> discardableManager = sk_make_sp<DiscardableManager>();
    SkStrikeServer server(discardableManager.get());
    SkStrikeClient client(discardableManager, false);
 
    // Server.
    auto serverTypeface = ToolUtils::CreateTestTypeface("monospace", SkFontStyle());
    const SkTypefaceID serverTypefaceID = serverTypeface->uniqueID();
 
    int glyphCount = 10;
    auto serverBlob = buildTextBlob(serverTypeface, 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* clientTypeface = client.retrieveTypefaceUsingServerIDForTest(serverTypefaceID).get();
 
    // The cache remains alive until it is pinned in the discardable manager.
    SkGraphics::PurgeFontCache();
    REPORTER_ASSERT(reporter, !clientTypeface->unique());
 
    // Once the strike is unpinned and purged, SkStrikeClient should be the only owner of the
    // clientTf.
    discardableManager->unlockAndDeleteAll();
    SkGraphics::PurgeFontCache();
    REPORTER_ASSERT(reporter, clientTypeface->unique());
 
    // Must unlock everything on termination, otherwise valgrind complains about memory leaks.
    discardableManager->unlockAndDeleteAll();
}

DEF_TEST() [7/7]

DEF_TEST	(	SkTypefaceProxy_Basic_Serial	,
		reporter
	)

Definition at line 1137 of file SkRemoteGlyphCacheTest.cpp.

                                                 {
    auto typeface = ToolUtils::CreateTestTypeface("monospace", SkFontStyle());
    sk_sp<DiscardableManager> discardableManager = sk_make_sp<DiscardableManager>();
    SkTypefaceProxyPrototype srcProto{*typeface};
 
    SkBinaryWriteBuffer writeBuffer({});
    srcProto.flatten(writeBuffer);
 
    auto data = writeBuffer.snapshotAsData();
    SkReadBuffer readBuffer{data->data(), data->size()};
    std::optional<SkTypefaceProxyPrototype> dstProto =
            SkTypefaceProxyPrototype::MakeFromBuffer(readBuffer);
    REPORTER_ASSERT(reporter, dstProto.has_value());
    auto proxy = sk_make_sp<SkTypefaceProxy>(dstProto.value(), discardableManager, false);
    REPORTER_ASSERT(reporter, typeface->uniqueID() == proxy->remoteTypefaceID());
    REPORTER_ASSERT(reporter, typeface->uniqueID() != proxy->uniqueID());
    REPORTER_ASSERT(reporter, typeface->countGlyphs() == proxy->countGlyphs());
    REPORTER_ASSERT(reporter, typeface->fontStyle() == proxy->fontStyle());
    REPORTER_ASSERT(reporter, typeface->isFixedPitch() == proxy->isFixedPitch());
 
    // Must be multiple of 4 bytes or the buffer will be invalid.
    uint8_t brokenBytes[] = {1, 2, 3, 4, 5, 6, 7, 8};
    SkReadBuffer brokenBuffer{std::data(brokenBytes), std::size(brokenBytes)};
    std::optional<SkTypefaceProxyPrototype> brokenProto =
            SkTypefaceProxyPrototype::MakeFromBuffer(brokenBuffer);
    REPORTER_ASSERT(reporter, !brokenProto.has_value());
}

FindSurfaceProps()

SkSurfaceProps FindSurfaceProps

(

GrRecordingContext *

rContext

)

Definition at line 210 of file SkRemoteGlyphCacheTest.cpp.

                                                              {
    auto surface = MakeSurface(1, 1, rContext);
    return surface->props();
}

make_blob_causing_fallback()

sk_sp< SkTextBlob > make_blob_causing_fallback	(	sk_sp< SkTypeface >	targetTf,
		const SkTypeface *	glyphTf,
		skiatest::Reporter *	reporter
	)

Definition at line 702 of file SkRemoteGlyphCacheTest.cpp.

                                                                                           {
    SkFont font = ToolUtils::DefaultFont();
    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();
}

MakeEmojiBlob()

sk_sp< SkTextBlob > MakeEmojiBlob	(	sk_sp< SkTypeface >	serverTf,
		SkScalar	textSize,
		sk_sp< SkTypeface >	clientTf = nullptr
	)

Definition at line 920 of file SkRemoteGlyphCacheTest.cpp.

                                                                      {
    SkFont font = ToolUtils::DefaultFont();
    font.setTypeface(serverTf);
    font.setSize(textSize);
 
    const char* text = ToolUtils::EmojiSample().sampleText;
    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);
}

MakeSurface()

sk_sp< SkSurface > MakeSurface	(	int	width,
		int	height,
		GrRecordingContext *	rContext
	)

Definition at line 204 of file SkRemoteGlyphCacheTest.cpp.

                                                                                  {
    const SkImageInfo info =
            SkImageInfo::Make(width, height, kN32_SkColorType, kPremul_SkAlphaType);
    return SkSurfaces::RenderTarget(rContext, skgpu::Budgeted::kNo, info);
}

RasterBlob()

SkBitmap RasterBlob	(	sk_sp< SkTextBlob >	blob,
		int	width,
		int	height,
		const SkPaint &	paint,
		GrRecordingContext *	rContext,
		const SkMatrix *	matrix = nullptr,
		SkScalar	x = 0
	)

Definition at line 215 of file SkRemoteGlyphCacheTest.cpp.

                                    {
    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;
}

RasterBlobThroughSlug()

SkBitmap RasterBlobThroughSlug	(	sk_sp< SkTextBlob >	blob,
		int	width,
		int	height,
		const SkPaint &	paint,
		GrRecordingContext *	rContext,
		const SkMatrix *	matrix = nullptr,
		SkScalar	x = 0
	)

Definition at line 229 of file SkRemoteGlyphCacheTest.cpp.

                                               {
    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, paint);
    SkBitmap bitmap;
    bitmap.allocN32Pixels(width, height);
    surface->readPixels(bitmap, 0, 0);
    return bitmap;
}

RasterSlug()

SkBitmap RasterSlug	(	sk_sp< Slug >	slug,
		int	width,
		int	height,
		const SkPaint &	paint,
		GrRecordingContext *	rContext,
		const SkMatrix *	matrix = nullptr,
		SkScalar	x = 0
	)

Definition at line 245 of file SkRemoteGlyphCacheTest.cpp.

                                    {
    auto surface = MakeSurface(width, height, rContext);
    auto canvas = surface->getCanvas();
    if (matrix) {
        canvas->concat(*matrix);
    }
    slug->draw(canvas, paint);
    SkBitmap bitmap;
    bitmap.allocN32Pixels(width, height);
    surface->readPixels(bitmap, 0, 0);
    return bitmap;
}

use_padding_options()

static void use_padding_options ( GrContextOptions *  options )

static

Definition at line 306 of file SkRemoteGlyphCacheTest.cpp.

                                                           {
    options->fSupportBilerpFromGlyphAtlas = true;
}