SkStrikeClientImpl Class Reference

Public Member Functions
	SkStrikeClientImpl (sk_sp< SkStrikeClient::DiscardableHandleManager >, bool isLogging=true, SkStrikeCache *strikeCache=nullptr)
bool	readStrikeData (const volatile void *memory, size_t memorySize)
bool	translateTypefaceID (SkAutoDescriptor *descriptor) const
sk_sp< SkTypeface >	retrieveTypefaceUsingServerID (SkTypefaceID) const

Detailed Description

Definition at line 585 of file SkChromeRemoteGlyphCache.cpp.

Constructor & Destructor Documentation

SkStrikeClientImpl()

SkStrikeClientImpl::SkStrikeClientImpl ( sk_sp< SkStrikeClient::DiscardableHandleManager >  discardableManager, bool  isLogging = true, SkStrikeCache *  strikeCache = nullptr  )

explicit

Definition at line 616 of file SkChromeRemoteGlyphCache.cpp.

    : fDiscardableHandleManager(std::move(discardableManager)),
      fStrikeCache{strikeCache ? strikeCache : SkStrikeCache::GlobalStrikeCache()},
      fIsLogging{isLogging} {}

Member Function Documentation

readStrikeData()

bool SkStrikeClientImpl::readStrikeData	(	const volatile void *	memory,
		size_t	memorySize
	)

Definition at line 637 of file SkChromeRemoteGlyphCache.cpp.

                                                                                      {
    SkASSERT(memorySize != 0);
    SkASSERT(memory != nullptr);
 
    // We do not need to set any SkDeserialProcs here because SkStrikeServerImpl::writeStrikeData
    // did not encode any SkImages.
    SkReadBuffer buffer{const_cast<const void*>(memory), memorySize};
    // Limit the kinds of effects that appear in a glyph's drawable (crbug.com/1442140):
    buffer.setAllowSkSL(false);
 
    int curTypeface = 0,
        curStrike = 0;
 
    auto postError = [&](int line) {
        SkDebugf("Read Error Posted %s : %d", __FILE__, line);
        SkStrikeClient::DiscardableHandleManager::ReadFailureData data{
                memorySize,
                buffer.offset(),
                SkTo<uint64_t>(curTypeface),
                SkTo<uint64_t>(curStrike),
                SkTo<uint64_t>(0),
                SkTo<uint64_t>(0)};
        fDiscardableHandleManager->notifyReadFailure(data);
    };
 
    // Read the number of typefaces sent.
    const int typefaceCount = buffer.readInt();
    for (curTypeface = 0; curTypeface < typefaceCount; ++curTypeface) {
        auto proto = SkTypefaceProxyPrototype::MakeFromBuffer(buffer);
        if (proto) {
            this->addTypeface(proto.value());
        } else {
            postError(__LINE__);
            return false;
        }
    }
 
    // Read the number of strikes sent.
    const int stirkeCount = buffer.readInt();
    for (curStrike = 0; curStrike < stirkeCount; ++curStrike) {
 
        const SkTypefaceID serverTypefaceID = buffer.readUInt();
        if (serverTypefaceID == 0 && !buffer.isValid()) {
            postError(__LINE__);
            return false;
        }
 
        const SkDiscardableHandleId discardableHandleID = buffer.readUInt();
        if (discardableHandleID == 0 && !buffer.isValid()) {
            postError(__LINE__);
            return false;
        }
 
        std::optional<SkAutoDescriptor> serverDescriptor = SkAutoDescriptor::MakeFromBuffer(buffer);
        if (!buffer.validate(serverDescriptor.has_value())) {
            postError(__LINE__);
            return false;
        }
 
        const bool fontMetricsInitialized = buffer.readBool();
        if (!fontMetricsInitialized && !buffer.isValid()) {
            postError(__LINE__);
            return false;
        }
 
        std::optional<SkFontMetrics> fontMetrics;
        if (!fontMetricsInitialized) {
            fontMetrics = SkFontMetricsPriv::MakeFromBuffer(buffer);
            if (!fontMetrics || !buffer.isValid()) {
                postError(__LINE__);
                return false;
            }
        }
 
        auto* clientTypeface = fServerTypefaceIdToTypeface.find(serverTypefaceID);
        if (clientTypeface == nullptr) {
            postError(__LINE__);
            return false;
        }
 
        if (!this->translateTypefaceID(&serverDescriptor.value())) {
            postError(__LINE__);
            return false;
        }
 
        SkDescriptor* clientDescriptor = serverDescriptor->getDesc();
        auto strike = fStrikeCache->findStrike(*clientDescriptor);
 
        if (strike == nullptr) {
            // Metrics are only sent the first time. If creating a new strike, then the metrics
            // are not initialized.
            if (fontMetricsInitialized) {
                postError(__LINE__);
                return false;
            }
            SkStrikeSpec strikeSpec{*clientDescriptor, *clientTypeface};
            strike = fStrikeCache->createStrike(
                    strikeSpec, &fontMetrics.value(),
                    std::make_unique<DiscardableStrikePinner>(
                            discardableHandleID, fDiscardableHandleManager));
        }
 
        // Make sure this strike is pinned on the GPU side.
        strike->verifyPinnedStrike();
 
        if (!strike->mergeFromBuffer(buffer)) {
            postError(__LINE__);
            return false;
        }
    }
 
    return true;
}

retrieveTypefaceUsingServerID()

sk_sp< SkTypeface > SkStrikeClientImpl::retrieveTypefaceUsingServerID

(

SkTypefaceID

typefaceID

)

const

Definition at line 776 of file SkChromeRemoteGlyphCache.cpp.

                                                                                                 {
    auto* tfPtr = fServerTypefaceIdToTypeface.find(typefaceID);
    return tfPtr != nullptr ? *tfPtr : nullptr;
}

translateTypefaceID()

bool SkStrikeClientImpl::translateTypefaceID

(

SkAutoDescriptor *

descriptor

)

const

Definition at line 751 of file SkChromeRemoteGlyphCache.cpp.

                                                                             {
    SkDescriptor& descriptor = *toChange->getDesc();
 
    // Rewrite the typefaceID in the rec.
    {
        uint32_t size;
        // findEntry returns a const void*, remove the const in order to update in place.
        void* ptr = const_cast<void *>(descriptor.findEntry(kRec_SkDescriptorTag, &size));
        SkScalerContextRec rec;
        if (!ptr || size != sizeof(rec)) { return false; }
        std::memcpy((void*)&rec, ptr, size);
        // Get the local typeface from remote typefaceID.
        auto* tfPtr = fServerTypefaceIdToTypeface.find(rec.fTypefaceID);
        // Received a strike for a typeface which doesn't exist.
        if (!tfPtr) { return false; }
        // Update the typeface id to work with the client side.
        rec.fTypefaceID = tfPtr->get()->uniqueID();
        std::memcpy(ptr, &rec, size);
    }
 
    descriptor.computeChecksum();
 
    return true;
}

---

The documentation for this class was generated from the following file:

• third_party/skia/src/text/gpu/SkChromeRemoteGlyphCache.cpp