chromium/third_party/skia/src/core/SkStrikeCache.cpp

/*
 * 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 "src/core/SkStrikeCache.h"

#include "include/core/SkGraphics.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkTraceMemoryDump.h"
#include "include/private/base/SkAssert.h"
#include "include/private/base/SkDebug.h"
#include "include/private/base/SkMutex.h"
#include "src/core/SkDescriptor.h"
#include "src/core/SkStrike.h"
#include "src/core/SkStrikeSpec.h"

#include <algorithm>
#include <utility>

class SkScalerContext;
struct SkFontMetrics;

usingnamespacesktext;

bool gSkUseThreadLocalStrikeCaches_IAcknowledgeThisIsIncrediblyExperimental = …;

SkStrikeCache* SkStrikeCache::GlobalStrikeCache() { … }

auto SkStrikeCache::findOrCreateStrike(const SkStrikeSpec& strikeSpec) -> sk_sp<SkStrike> { … }

sk_sp<StrikeForGPU> SkStrikeCache::findOrCreateScopedStrike(const SkStrikeSpec& strikeSpec) { … }

void SkStrikeCache::PurgeAll() { … }

void SkStrikeCache::Dump() { … }

void SkStrikeCache::DumpMemoryStatistics(SkTraceMemoryDump* dump) { … }

sk_sp<SkStrike> SkStrikeCache::findStrike(const SkDescriptor& desc) { … }

auto SkStrikeCache::internalFindStrikeOrNull(const SkDescriptor& desc) -> sk_sp<SkStrike> { … }

sk_sp<SkStrike> SkStrikeCache::createStrike(
        const SkStrikeSpec& strikeSpec,
        SkFontMetrics* maybeMetrics,
        std::unique_ptr<SkStrikePinner> pinner) { … }

auto SkStrikeCache::internalCreateStrike(
        const SkStrikeSpec& strikeSpec,
        SkFontMetrics* maybeMetrics,
        std::unique_ptr<SkStrikePinner> pinner) -> sk_sp<SkStrike> { … }

void SkStrikeCache::purgePinned(size_t minBytesNeeded) { … }

void SkStrikeCache::purgeAll() { … }

size_t SkStrikeCache::getTotalMemoryUsed() const { … }

int SkStrikeCache::getCacheCountUsed() const { … }

int SkStrikeCache::getCacheCountLimit() const { … }

size_t SkStrikeCache::setCacheSizeLimit(size_t newLimit) { … }

size_t  SkStrikeCache::getCacheSizeLimit() const { … }

int SkStrikeCache::setCacheCountLimit(int newCount) { … }

void SkStrikeCache::forEachStrike(std::function<void(const SkStrike&)> visitor) const { … }

size_t SkStrikeCache::internalPurge(size_t minBytesNeeded, bool checkPinners) { … }

void SkStrikeCache::internalAttachToHead(sk_sp<SkStrike> strike) { … }

void SkStrikeCache::internalRemoveStrike(SkStrike* strike) { … }

void SkStrikeCache::validate() const { … }

const SkDescriptor& SkStrikeCache::StrikeTraits::GetKey(const sk_sp<SkStrike>& strike) { … }

uint32_t SkStrikeCache::StrikeTraits::Hash(const SkDescriptor& descriptor) { … }