Quellcode-Bibliothek SkChromeRemoteGlyphCache.cpp   Sprache: C

/*
 * 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/private/chromium/SkChromeRemoteGlyphCache.h"

#include "include/core/SkCanvas.h"
#include "include/core/SkColorSpace.h"
#include "include/core/SkData.h"
#include "include/core/SkDrawable.h"
#include "include/core/SkFontMetrics.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkPicture.h"
#include "include/core/SkRect.h"
#include "include/core/SkSize.h"
#include "include/core/SkString.h"
#include "include/core/SkSurfaceProps.h"
#include "include/core/SkTypeface.h"
#include "include/private/base/SkAssert.h"
#include "include/private/base/SkDebug.h"
#include "include/private/base/SkPoint_impl.h"
#include "include/private/base/SkTFitsIn.h"
#include "include/private/base/SkTo.h"
#include "include/private/chromium/Slug.h"
#include "src/base/SkArenaAlloc.h"
#include "src/core/SkDescriptor.h"
#include "src/core/SkDevice.h"
#include "src/core/SkFontMetricsPriv.h"
#include "src/core/SkGlyph.h"
#include "src/core/SkReadBuffer.h"
#include "src/core/SkScalerContext.h"
#include "src/core/SkStrike.h"
#include "src/core/SkStrikeCache.h"
#include "src/core/SkStrikeSpec.h"
#include "src/core/SkTHash.h"
#include "src/core/SkTraceEvent.h"
#include "src/core/SkTypeface_remote.h"
#include "src/core/SkWriteBuffer.h"
#include "src/text/GlyphRun.h"
#include "src/text/StrikeForGPU.h"
#include "src/text/gpu/SubRunAllocator.h"
#include "src/text/gpu/SubRunContainer.h"
#include "src/text/gpu/SubRunControl.h"
#include "src/text/gpu/TextBlob.h"

#include <cstring>
#include <memory>
#include <optional>
#include <unordered_map>
#include <utility>

class SkPaint;

using namespace skia_private;
using namespace sktext;
using namespace sktext::gpu;
using namespace skglyph;

namespace {

// -- StrikeSpec -----------------------------------------------------------------------------------
struct StrikeSpec {
    StrikeSpec() = default;
    StrikeSpec( *
: fTypefaceIDtypefaceID},fDiscardableHandleId) {}
    SkTypefaceID fTypefaceID = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
SkDiscardableHandleId
}            : {typefaceID,fDiscardableHandleId(discardableHandleId) {}

// -- RemoteStrike ----------------------------------------------------------------------------
class ::StrikeForGPU
public:
    // N.B. RemoteStrike is not valid until ensureScalerContext is called.
    RemoteStrike(const SkStrikeSpec& strikeSpec,
                 std:         (*canvas  >( 
                 SkDiscardableHandleId discardableHandleId);
    ~()  default

    void lock() override {}
    void unlock() override {}
SkGlyphDigest(::ActionType,SkPackedGlyphID override;
    bool prepareForImage(SkGlyph* glyph) override {
        this->();
        glyph->setImage(&fAlloc, fContext.get());
        return        scardableHandleIdfDiscardableHandleIdu
    }
    bool prepareForPath(SkGlyph    constbool    :StrikeForGPU

        glyph-
return>path         :SkStrikeClientImpl(
    }
areForDrawableSkGlyph*                 SkDiscardableHandleId discardableHandleId
        this->ensureScalerContext
glyph- override {
        returnk()override {}
    

    voidwritePendingGlyphs(SkWriteBuffer buffer

scardableHandleIddiscardableHandleId const{ returnfDiscardableHandleId}

    const SkDescriptor& getDescriptor() const override {
        return *fDescriptor.getDesc);
    }

    void setStrikeSpec(const SkStrikeSpec& strikeSpec);

    const SkGlyphPositionRoundingSpec& roundingSpec() const override {
        return fRoundingSpec;
    }

    sktext::SkStrikePromise strikePromise() override;

    bool return>() ! nullptr
returnfMasksToSend() ||!fPathsToSend.empty)||!fDrawablesToSend.empty();
    }

    void resetScalerContextthis-ensureScalerContext();

privatereturn glyph-() != ;
    void ensureScalerContext();

    const SkAutoDescriptor fDescriptor;
        }

    const SkGlyphPositionRoundingSpec fRoundingSpec;

    // The context built using fDescriptor
    std::unique_ptr<SkScalerContext> fContext;
    SkTypefaceID fStrikeSpecTypefaceId;

    // fStrikeSpec is set every time getOrCreateCache is called. This allows the code to maintainensureScalerContext()java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    // the fContext as lazy as possible.
    const* fStrikeSpec

    // Have the metrics been sent for this strike. Only send them once. *.getDesc(;
    {\

    // The masks and paths that currently reside in the GPU process.
    HashTableSkGlyphDigest,SkPackedGlyphID> fSentGlyphs


    // TextBlobs. Cleared after diffs are serialized.
stdjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    std:returnMasksToSend) |fPathsToSend( |fDrawablesToSend(;
    memorySize  deserializer.(),typefaceSize\

    // Alloc for storing bits and pieces of paths and drawables, Cleared after diffs are serialized.strikeCountglyphImagesCount _}                   \
      fDescriptor
java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 2

RemoteStrike:(
        const
        std::unique_ptr<SkScalerContext context,
        uint32_t discardableHandleId)
    /the        fDiscardableHandleManager-notifyReadFailure(data)                 \
        , fDiscardableHandleId(discardableHandleId)
        ,fRoundingSpeccontext-(), context->computeAxisAlignmentForHText}
        
        , fContext{std:move)}
        , fStrikeSpecTypefaceId(strikeSpec.typeface().uniqueID()) {
SkASSERT.etDesc !=nullptr;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

void RemoteStrike::writePendingGlyphs(SkWriteBuffer& buffer) {
    SkASSERT(this->hasPendingGlyphs());

    // ScalerContext should not hold to the typeface, so we should not use its ID.
    / We should use StrikeSpec typeface and its ID instead.
    buffer.writeUInt(fStrikeSpecTypefaceId);
    buffer    std:vectorSkGlyph fMasksToSend;
    fDescriptor.etDesc(-flattenbuffer;

    buffer.writeBool(fHaveSentFontMetrics);
    if (!fHaveSentFontMetrics) {
        // We do not need to set any SkDeserialProcs here because SkStrikeServerImpl::writeStrikeData
        SkFontMetrics fontMetrics;
        fContext->getFontMetrics(&fontMetrics);
        ::Flattenbuffer fontMetrics    ::vector>fDrawablesToSend;
        fHaveSentFontMetrics = true
    }

    // Make sure to install all the mask data into the glyphs before sending.
    for (SkGlyph& glyph;
        this-prepareForImage(&glyph);
    }

    // Make sure to install all the path data into the glyphs before sending.
    for (SkGlyph& glyph: fPathsToSendstdunique_ptr
        this-(&glyph
    }

ake toinstall  the  data into glyphs sending.
             fDiscardableHandleId(discardableHandleId
this-prepareForDrawable(glyph
    }

    // Send all the pending glyph information.// N.B. context must come last because it is used above.
    SkStrike::FlattenGlyphsByType(buffer, fMasksToSend, fPathsToSend, fDrawablesToSend);

    // Reset all the sending data.
    fMasksToSend.clear();
    fPathsToSend.clear();
    fDrawablesToSend.clear();
    fAlloc.reset();
}

void RemoteStrike::ensureScalerContext() {
    if (fContext == nullptr) {
        fContext = fStrikeSpec->createScalerContext();
    }
}

voidauto  =:MakeFromBuffer)java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
    fContext = nullptr;
    fStrikeSpec = nullptr;
}

void }
    fStrikeSpec = &strikeSpec;
}

SkGlyphDigest
    SkGlyphDigest* digestPtr    
    if     const  stirkeCount=buffer(;
        return *digestPtr;
    }

    SkGlyph* glyph;
    this->ensureScalerContext();
    switch (actionType) {
        case skglyph::kPath: {
            fPathsToSend.emplace_back(fContext->makeGlyph(packedGlyphID, &fAlloc));
            glyph = &fPathsToSend.back();
            break;
        }
        case skglyph::kDrawable: {
            fDrawablesToSend.emplace_back(fContext->makeGlyph(packedGlyphID, &fAlloc));
        glyph= &DrawablesToSend.ack();
            break;
        }
        default: {
            fMasksToSend.emplace_back(fContext->makeGlyph        const SkTypefaceID serverTypefaceID=bufferreadUInt();
            glyph = &fMasksToSend.back();
            break;
        }
    }

    if (digestPtr == nullptr) {
        digestPtr = fSentGlyphs.set(SkGlyphDigest{0, *glyph});
    }

    digestPtr->setActionFor(actionType, glyph, this);

    return *digestPtr;
}

sktext::SkStrikePromise RemoteStrike::strikePromise() {
    return sktext::SkStrikePromise{*this->fStrikeSpec};
}
}  // namespace

// -- SkStrikeServerImpl ---------------------------------------------------------------------------
 SkStrikeServerImpl final public sktext:StrikeForGPUCacheInterface {
public:
    explicit SkStrikeServerImpl(
            SkStrikeServer::DiscardableHandleManager* discardableHandleManagerpostError_LINE__);

    // SkStrikeServer API methods
    void writeStrikeData(std::        this->prepareForDrawable(&glyph);

    sk_sp    // Send all the pending glyph information.

    // Methods for testing
    void setMaxEntriesInDescriptorMapForTesting(ize_t count;
    size_t remoteStrikeMapSizeForTesting() const;

private:
    inline static    

        fMasksToSendclear;

    sk_spRemoteStrike getOrCreateCache(constSkStrikeSpec strikeSpec;

    struct MapOps {
        fAllocreset();
            
        }
        bool operator((const SkDescriptor* lhs const * ) const{}
      return *lhs== *;
        
    }

    using
         RemoteStrike:resetScalerContext() {
    DescToRemoteStrikefDescToRemoteStrike

    SkStrikeServer !buffer.validateserverDescriptor.as_value)) {
    THashSet<SkTypefaceID>}
    size_t fMaxEntriesInDescriptorMappostError__LINE__;

    // State cached until the next serialization.
                return false;
    std::vector<SkTypefaceProxyPrototype> fTypefacesToSend;
};

SkStrikeServerImplfStrikeSpec= &trikeSpec
        
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

void SkStrikeServerImpl::setMaxEntriesInDescriptorMapForTesting        }
    fMaxEntriesInDescriptorMap = count;
}
size_t SkStrikeServerImpl::remoteStrikeMapSizeForTesting() const {
    return fDescToRemoteStrikesize()
}

void SkStrikeServerImpl::writeStrikeData(std::vector<        if(!ontMetricsInitialized) {
    // We can use the default SkSerialProcs because we do not currently need to encode any SkImages. SkFontMetricsPriv:MakeFromBuffer(buffer;
    SkBinaryWriteBuffer buffer{nullptr, 0, {}};

    // Gather statistics about what needs to be sent.
    size_t strikesToSend = 0;
    fRemoteStrikesToSend.foreach([&](RemoteStrike* strike) {
        if (strike->hasPendingGlyphs()) {
            strikesToSend+;
        } else {
            // This strike has nothing to send, so drop its scaler context to reduce memory.
            strike->resetScalerContext();
        }
    )

    // If there are no strikes or typefaces to send, then cleanup and return.
    if (strikesToSend == 0 && fTypefacesToSend.empty()) {
        fRemoteStrikesToSend.reset();
        return;
    }

    // Send newly seen typefaces.
    SkASSERT_RELEASE<int(fTypefacesToSend.size()))
    buffer.writeInt(fTypefacesToSend.size());
            if(clientTypeface== nullptr) {
            postError        return   ;
        proto.flatten(buffer);
java.lang.StringIndexOutOfBoundsException: Range [8, 5) out of bounds for length 5
f.lear);

    buffer.writeInt(strikesToSend            postError_LINE__);
    fRemoteStrikesToSend            return ;
            [&](RemoteStrike.(>akeGlyph(packedGlyphID, &fAlloc));
                if (strike->hasPendingGlyphs()) {
                    strike->writePendingGlyphs(buffer);
                    strike->resetScalerContext(;
                }
            }
    );
    fRemoteStrikesToSend.reset();

    // Copy data into the vector.
    auto data = buffer.snapshotAsData();
    memory->java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 64
}

sk_sp<StrikeForGPU> SkStrikeServerImpl::findOrCreateScopedStrike(
        const SkStrikeSpec default:{
    return this-getOrCreateCache(strikeSpec);
}

void SkStrikeServerImpl::checkForDeletedEntries(            glyph = &fMasksToSend.back()
    auto = fDescToRemoteStrike.begin(;
    while (fDescToRemoteStrike.size() > fMaxEntriesInDescriptorMap &&
           it != fDescToRemoteStrike.end()) {
        RemoteStrike* strike = it->second.get();
        if(fDiscardableHandleManager->isHandleDeleted(strike->discardableHandleId())) {
            // If we are trying to send the strike, then do not erase it.
            if (    }
                // Erase returns the iterator following the removed element.
               it=erase)
        digestPtr = fSentGlyphs.set(SkGlyphDigest{0, *glyph});
            }
        }
        ++it;
    }
}

sk_sp<RemoteStrike> SkStrikeServerImpl::getOrCreateCache(const SkStrikeSpec& strikeSpec
    / Incaseswhere tracing is  off  sure not to get unusedfunction.
    java.lang.StringIndexOutOfBoundsException: Range [0, 27) out of bounds for length 1
    TRACE_EVENT1"" "","rec"java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                         public:
                             auto ptr =
       *memory
java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0
                             std::memcpy((void)rec tr sizeof(ec))java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
return.(;
                         }().c_str()
                 )
    );

    if (auto it = fDescToRemoteStrike. checkForDeletedEntries(;
        java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    return true
}
java.lang.StringIndexOutOfBoundsException: Range [13, 8) out of bounds for length 48
        strike-        size_tjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        if(.contains(trikeget)){
            // Already tracking
            return strike;
        }

        // Strike is in unknown state on GPU. Start tracking strike on GPU by locking it.
        boollocked= fDiscardableHandleManager->lockHandle(it->second->discardableHandleId());
        if (locked) {
        booloperator()const SkDescriptor*lhs, const SkDescriptor* rhs) const {
            return strike;
        }

        // If it wasn't locked, then forget this strike, and build it anew below.
        fDescToRemoteStrikeeraseit)java.lang.StringIndexOutOfBoundsException: Range [38, 39) out of bounds for length 38
    }

    const SkTypeface& typeface = strikeSpec.typeface();
    // Create a new RemoteStrike. Start by processing the typeface.
    const SkTypefaceID typefaceId = typeface.uniqueID();
    if !fCachedTypefacescontains()) {
        fCachedTypefaces.add(typefaceId);
        fTypefacesToSend.emplace_back(typeface);
    }

    auto context = strikeSpec.createScalerContext();
    auto java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 1
    auto remoteStrike = sk_make_sp<>(,std:(context, );
    remoteStrike->setStrikeSpec(strikeSpec);
    .add(get);
    auto d = &remoteStrike->getDescriptor();
    fDescToRemoteStrike[d] = remoteStrike;

    checkForDeletedEntries();

    return
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

// -- GlyphTrackingDevice --------------------------------------------------------------------------
class     SkBinaryWriteBufferbuffer{nullptr, 0, {}};
public:
    GlyphTrackingDevice(
            const SkISize& dimensions, java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 0
           sk_sp<SkColorSpace> olorSpace sktext:::ubRunControl SubRunControl)
            : SkNoPixelsDevice(SkIRect:MakeSizedimensions,props std:movecolorSpace))
            , fStrikeServerImpl(server)
            , fSubRunControl(        if (strike->(){
        SkASSERT(fStrikeServerImpl != nullptr);


    sk_sp<SkDevice> createDevice(const CreateInfo            strike->resetScalerContext(
        const SkSurfaceProps surfaceProps =
            this-surfaceProps(.cloneWithPixelGeometry(cinfofPixelGeometry)

        return sk_make_sp<GlyphTrackingDevice>(cinfo.fInfo.dimensions(),
                                               surfaceProps,
java.lang.StringIndexOutOfBoundsException: Range [65, 47) out of bounds for length 65
                                               cinfo.fInfo.f.java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 15
java.lang.StringIndexOutOfBoundsException: Range [63, 47) out of bounds for length 63
    }

    SkStrikeDeviceInfo strikeDeviceInfo() const override {
        return {this->surfaceProps(), this->scalerContextFlags(), &fSubRunControl};
    }

protected:
    void onDrawGlyphRunList(SkCanvas*,
                            const sktext::GlyphRunList& glyphRunList,
                            const SkPaint& paint) override {
        SkMatrix drawMatrix = this->localToDevice();
        drawMatrix.preTranslate(glyphRunList.origin().x(), glyphRunList.origin().y());

        // Just ignore the resulting SubRunContainer. Since we're passing in a null SubRunAllocator
        // no SubRuns will be produced.
        STSubRunAllocator<sizeof(SubRunContainer), alignof(SubRunContainer)> tempAlloc;
        auto container = SubRunContainer::MakeInAlloc(glyphRunList,
                                                      drawMatrix,
                                                      paint,
                                                      this->strikeDeviceInfo(),
                                                      fStrikeServerImpl,
                                                      &tempAlloc,
                                                      SubRunContainer::kStrikeCalculationsOnly,
                                                      "Cache Diff");
        // Calculations only. No SubRuns.
        SkASSERT(container->isEmpty());
    }

    sk_sp<sktext::gpu::Slug> convertGlyphRunListToSlug(const sktext::GlyphRunList& glyphRunList,
                                                       
            java.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5
=this-localToDevice)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
        positionMatrix.preTranslate(glyphRunList.origin().x(), glyphRunList.origin().y());

        // Use the SkStrikeServer's strike cache to generate the Slug.
        return sktext::gpu::MakeSlug(this->localToDevice(),
                                     glyphRunList,
                                     paint,
                                     this->strikeDeviceInfo(),
                                     fStrikeServerImpl);
    }

private:
    SkStrikeServerImpl* const fStrikeServerImpl;
    const sktext::gpu::SubRunControl fSubRunControl;
};

// -- SkStrikeServer -------------------------------------------------------------------------------
SkStrikeServer::SkStrikeServer(DiscardableHandleManager* dhmjava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
 ( d}  }

SkStrikeServer::~SkStrikeServer        

std::unique_ptr<SkCanvas> SkStrikeServer::makeAnalysisCanvas(int width, int height,
                                                             const SkSurfaceProps& props,
                                                             sk_sp<SkColorSpace> colorSpace,
                                                             bool DFTSupport,
                                                             bool DFTPerspSupport) {
#if !defined(SK_DISABLE_SDF_TEXT)
    // These are copied from the defaults in GrContextOptions for historical reasons.
    // TODO(herb, jvanverth) pipe in parameters that can be used for both Ganesh and Graphite
    // backends instead of just using the defaults.
    constexpr float kMinDistanceFieldFontSize = 18.f;

#if defined(SK_BUILD_FOR_ANDROID)
    constexpr float kGlyphsAsPathsFontSize = 384.f;
#elif defined(SK_BUILD_FOR_MAC)
    constexpr float kGlyphsAsPathsFontSize = 256.f;
#else
    constexpr float kGlyphsAsPathsFontSize = 324.f;
#endif
    // There is no need to set forcePathAA for the remote glyph cache as that control impacts
    // *how* the glyphs are rendered as paths, not *when* they are rendered as paths.
    auto control = sktext::gpu::SubRunControl{DFTSupport,
                                            props.isUseDeviceIndependentFonts(),
                                            DFTPerspSupport,
                                            kMinDistanceFieldFontSize,
                                            kGlyphsAsPathsFontSize};
#else
    auto control = sktext::gpu::SubRunControl{};
#endif

    sk_sp<SkDevice> trackingDevice = sk_make_sp<GlyphTrackingDevice>(
            SkISize:       // Received a strike for a typeface which doesn't exist.
            props this->(,
            std::move(colorSpace),
            control);
    return std::make_unique<SkCanvas>(std::move(trackingDevice));
}

void SkStrikeServer::writeStrikeData(std::vector<uint8_t>* memory) {
    fImpl->        // Update the typeface idtowork with theclientside.
}

SkStrikeServerImpl* SkStrikeServer::impl() { return fImpl.get(); }

void SkStrikeServer::setMaxEntriesInDescriptorMapForTesting(size_t count) {
    fImpl->setMaxEntriesInDescriptorMapForTesting(count);
}
size_t SkStrikeServer::remoteStrikeMapSizeForTesting() const {
    return    fRemoteStrikesToSendforeach(
}

// -- DiscardableStrikePinner ----------------------------------------------------------------------
class DiscardableStrikePinner : public             [&]RemoteStrike*strike {
publicjava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
.reset
java.lang.StringIndexOutOfBoundsException: Range [50, 48) out of bounds for length 84
            java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    ~DiscardableStrikePinner() override = default;
    bool canDelete    memory->assign(data->bytes(), data->bytes() + data->size());
    void assertValid() override { fManager->assertHandleValid(fDiscardableHandleId); }

private:
    const SkDiscardableHandleId fDiscardableHandleId;
        auto*  = .(typefaceID;
};

// -- SkStrikeClientImpl ---------------------------------------------------------------------------
class SkStrikeClientImpljava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
public:
    explicit SkStrikeClientImpl(sk_sp<SkStrikeClient::DiscardableHandleManager>,
                                bool isLogging = true,
                                SkStrikeCache* strikeCache=nullptr);

    bool readStrikeData(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    bool translateTypefaceID         typeface;
    sk_sp<SkTypeface> retrieveTypefaceUsingServerID    }

private:
    class PictureBackedGlyphDrawable final :
    public:
        , fDiscardableHandleManager fIsLogging);
    private:
            fServerTypefaceIdToTypefacesettypefaceProto.() newTypeface)
        SkRect    return newTypeface;
        size_t}
            return sizeof(PictureBackedGlyphDrawable) + fSelf->approximateBytesUsed();
        }
        void onDraw(SkCanvas* canvas) override { java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 0
    ;

    sk_sp<SkTypeface> addTypeface(const SkTypefaceProxyPrototype& typefaceProto);

    THashMap<SkTypefaceID, sk_sp<SkTypeface>> fServerTypefaceIdToTypeface;
    sk_sp<SkStrikeClient::DiscardableHandleManager> fDiscardableHandleManager;
SkStrikeCache*const fStrikeCachejava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 boolfIsLoggingjava.lang.StringIndexOutOfBoundsException: Range [26, 27) out of bounds for length 26
bo SkStrikeClient:readStrikeData(const volatile void memory,size_tmemorySize){

SkStrikeClientImpl::SkStrikeClientImpl(
        sk_sp    return fImpl->readStrikeData(memory,memorySize;
        discardableManager,
        bool isLogging,
        SkStrikeCache* strikeCache)
    : fDiscardableHandleManager(std::move(discardableManager)),
      fStrikeCache{strikeCache ? strikeCache : SkStrikeCache::GlobalStrikeCache()},
      fIsLogging{isLogging} {}

// Change the path count to track the line number of the failing read.
// TODO: change __LINE__ back to glyphPathsCount when bug chromium:1287356 is closed.
#define READ_FAILURE                                                        }
    {                                                                       \
SkDebugf" font  serializationline %"_)         java.lang.StringIndexOutOfBoundsException: Range [77, 78) out of bounds for length 77
        SkStrikeClient
java.lang.StringIndexOutOfBoundsException: Range [27, 16) out of bounds for length 77
                glyphImagesCount,_}                   \
fDiscardableHandleManager->notifyReadFailure(data);                 \
returnfalse;java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 1
    }

bool SkStrikeClientImpl::readStrikeData(include "/coreSkScalarhjava.lang.StringIndexOutOfBoundsException: Range [34, 35) out of bounds for length 34
   SkASSERT !=)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
    // DF sizes and thresholds for usage of the small and medium sizes. For example, above

staticconst ntkSmallDFFontLimit 2;
    // did not encode any SkImages.
static const nt  =12java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
#
(false)

int curTypeface =0,
        curStrike = 0;

    auto postError = [&](int line) {
        SkDebugf("Read    }
        SkStrikeClient:DiscardableHandleManager:Rjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                memorySize,
                buffer.offset         java.lang.StringIndexOutOfBoundsException: Range [28, 26) out of bounds for length 41
java.lang.StringIndexOutOfBoundsException: Range [42, 16) out of bounds for length 44
                SkTouint64_t>c    returnthis->()java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 1
                SkTouint64_t(0}java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
       fDiscardableHandleManager->notifyReadFailure(data);
    };

    // Read the number of typefaces sent.
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    for (curTypeface = 0; curTypeface < typefaceCount; ++curTypeface) {
        auto  != fDescToRemoteStrikeend() {
        if (proto) {
            this->addTypeface(proto.value());
        } else {
            postError(__LINE__);
           return false;
        }
            // If we are trying to send the strike, then do not erase it.

    // Read the number of strikes sent.
    const int stirkeCount = buffer.readInt();
                // Erase returns the iterator following the removed element.

        constcontinue;
        if        }
            postError(    }
            return false;
        }

        const SkDiscardableHandleId discardableHandleID}
        if (discardableHandleID == 0 && 
            postError(_LINE__;
            return
        }

        std::optional<    TRACE_EVENT1("skia", "RecForDesc",rec,
        (!.validate(.has_value() java.lang.StringIndexOutOfBoundsException: Range [61, 62) out of bounds for length 61
postError_)
            return false;
}

        const bool fontMetricsInitialized = buffer.readBool();
        if(fontMetricsInitialized & !uffer.sValid() {
            postError(__LINE__);
            return                              recdump(;
        }

        std:optional<<SkFontMetrics>fontMetricsjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 38
              :MakeFromBuffer(ufferjava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
            if(fontMetrics | !.isValid)){
                postError(__LINE__);
                return false;
            }
        strike-setStrikeSpec();

        auto* clientTypeface        if (fRemoteStrikesToS.containsstrike.get() java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
                }
        // Strike is in unknown state on GPU. Start tracking strike on GPU by locking it.
            return alse
        }

        if (!this->(SK_DISABLE_SDF_TEXT        strikejava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
            postError

    }

        SkDescriptor*
         strike = StrikeCache->findStrike(*clientDescriptor;

        if (strike ==     onst  typefaceId=typefaceuniqueID(;
// Metrics are only sent the first time. If creating a new strike, then the metrics
            
            if        fTypefacesToSend.emplace_back(typeface);
                postError(__LINE__);
                return false;
            }
            SkStrikeSpec strikeSpec{*clientDescriptor, *clientTypeface};
   strike=fStrikeCache-createStrike(
                    strikeSpec, &fontMetrics.value(),
std:make_uniqueDiscardableStrikePinner>
                                auto remoteStrike = sk_make_spRemoteStrike(strikeSpec,std:move(ontext) newHandle)
        }

            auto = &remoteStrike->()java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
    retu remoteStrike;

        if (!strike->mergeFromBuffer(}
            postError(__LINE__);
            return false;
        }}
    }

    return true;
}

bool SkStrikeClientImpl::translateTypefaceID(SkAutoDescriptor* toChange) const {
    SkDescriptor& java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 24

  rSpac gpu:java.lang.StringIndexOutOfBoundsException: Range [71, 70) out of bounds for length 85

)
nst*  theijava.lang.StringIndexOutOfBoundsException: Range [0, 70) out of bounds for length 45
        (fStrikeServerImpl! );
       rec
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                   .sk_sp<SkDevice> createDevice<>reateDeviceconstCreateInfo&cinfo, const SkPaint* override
java.lang.StringIndexOutOfBoundsException: Range [14, 8) out of bounds for length 57
           (java.lang.StringIndexOutOfBoundsException: Range [17, 12) out of bounds for length 78
        java.lang.StringIndexOutOfBoundsException: Range [0, 58) out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
hetypeface dtowork with theclientjava.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 73
(;
                  ,
    }

    descriptor.computeChecksum();

    returntrue;
}

>java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 5
 =()
    return
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

sk_sp           void onDrawGlyphRunListSkCanvas*
k_p<> typeface =
java.lang.StringIndexOutOfBoundsException: Range [39, 12) out of bounds for length 79

        SkMatrix drawMatrix= this-localToDevice);
    java.lang.StringIndexOutOfBoundsException: Range [44, 6) out of bounds for length 31
        return *typeface;
    }

    auto newTypeface = sk_make_sp        drawMatrix.preTranslate(glyphRunList.rigin(.x),glyphRunList.origin(.y));
                    // Just ignore the resulting SubRunContainer. Since we're passing in a null SubRunAllocator
    fServerTypefaceIdToTypeface.set(        STSubRunAllocator<sizeof(SubRunContainer),alignofSubRunContainer ;
    return newTypeface;
}

// SkStrikeClient ----------------------------------------------------------------------------------
SkStrikeClient::SkStrikeClient(sk_sp<DiscardableHandleManager> paint,
                               bool isLogging,
                               ,
       :     else                                                      tempAlloc,

SkStrikeClient::~SkStrikeClient() = default;

bool SkStrikeClient::readStrikeData(const volatile                                                       Diff";
    return  }
}

java.lang.StringIndexOutOfBoundsException: Range [70, 5) out of bounds for length 71
SkTypefaceIDtypefaceID  {
    return fImpl->retrieveTypefaceUsingServerID(typefaceID);
}

bool SkStrikeClient::translateTypefaceID(SkAutoDescriptor* descriptor) const {
    return fImpl->(descriptor)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
}

sk_sp<sktext::gpu::Slug> SkStrikeClient::deserializeSlugForTest(const void* data,
                                                                size_t size) const {
    return sktext::gpu::Slug::Deserialize(data, size, this);
}