Remove SkExclusiveStrikePtr. Replace it with sk_sp<SkStrike>

herbderby · Skia Commit-Bot · commit a64f5b2439a0 · 2020-02-24T21:41:05.000Z
* Rename all the Exclusive things. Change-Id: If6b5fec5130bf58c396e0a472730efd2ae38c0d2 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/273057 Reviewed-by: Ben Wagner <bungeman@google.com> Commit-Queue: Herb Derby <herb@google.com>
diff --git a/bench/PathTextBench.cpp b/bench/PathTextBench.cpp
@@ -48,10 +48,10 @@ class PathTextBench : public Benchmark {
     void onDelayedSetup() override {
         SkFont defaultFont;
         SkStrikeSpec strikeSpec = SkStrikeSpec::MakeWithNoDevice(defaultFont);
-        auto cache = strikeSpec.findOrCreateExclusiveStrike();
+        auto strike = strikeSpec.findOrCreateStrike();
         for (int i = 0; i < kNumGlyphs; ++i) {
             SkPackedGlyphID id(defaultFont.unicharToGlyph(kGlyphs[i]));
-            sk_ignore_unused_variable(cache->getScalerContext()->getPath(id, &fGlyphs[i]));
+            sk_ignore_unused_variable(strike->getScalerContext()->getPath(id, &fGlyphs[i]));
             fGlyphs[i].setIsVolatile(fUncached);
         }
 
diff --git a/samplecode/SamplePathText.cpp b/samplecode/SamplePathText.cpp
@@ -34,13 +34,13 @@ class PathText : public Sample {
     void onOnceBeforeDraw() final {
         SkFont defaultFont;
         SkStrikeSpec strikeSpec = SkStrikeSpec::MakeWithNoDevice(defaultFont);
-        auto cache = strikeSpec.findOrCreateExclusiveStrike();
+        auto strike = strikeSpec.findOrCreateStrike();
         SkPath glyphPaths[52];
         for (int i = 0; i < 52; ++i) {
             // I and l are rects on OS X ...
             char c = "aQCDEFGH7JKLMNOPBRZTUVWXYSAbcdefghijk1mnopqrstuvwxyz"[i];
             SkPackedGlyphID id(defaultFont.unicharToGlyph(c));
-            sk_ignore_unused_variable(cache->getScalerContext()->getPath(id, &glyphPaths[i]));
+            sk_ignore_unused_variable(strike->getScalerContext()->getPath(id, &glyphPaths[i]));
         }
 
         for (int i = 0; i < kNumPaths; ++i) {
diff --git a/src/core/SkFont.cpp b/src/core/SkFont.cpp
@@ -352,7 +352,7 @@ SkScalar SkFont::getMetrics(SkFontMetrics* metrics) const {
         metrics = &storage;
     }
 
-    auto cache = strikeSpec.findOrCreateExclusiveStrike();
+    auto cache = strikeSpec.findOrCreateStrike();
     *metrics = cache->getFontMetrics();
 
     if (strikeSpec.strikeToSourceRatio() != 1) {
diff --git a/src/core/SkGlyphRunPainter.cpp b/src/core/SkGlyphRunPainter.cpp
@@ -104,7 +104,7 @@ void SkGlyphRunListPainter::drawForBitmapDevice(
             SkStrikeSpec strikeSpec = SkStrikeSpec::MakePath(
                     runFont, runPaint, props, fScalerContextFlags);
 
-            auto strike = strikeSpec.findOrCreateExclusiveStrike();
+            auto strike = strikeSpec.findOrCreateStrike();
 
             fDrawable.startSource(fRejects.source(), drawOrigin);
             strike->prepareForPathDrawing(&fDrawable, &fRejects);
@@ -121,7 +121,7 @@ void SkGlyphRunListPainter::drawForBitmapDevice(
             SkStrikeSpec strikeSpec = SkStrikeSpec::MakeMask(
                     runFont, runPaint, props, fScalerContextFlags, deviceMatrix);
 
-            auto strike = strikeSpec.findOrCreateExclusiveStrike();
+            auto strike = strikeSpec.findOrCreateStrike();
 
             fDrawable.startDevice(
                     fRejects.source(), drawOrigin, deviceMatrix, strike->roundingSpec());
diff --git a/src/core/SkRemoteGlyphCache.cpp b/src/core/SkRemoteGlyphCache.cpp
@@ -943,7 +943,7 @@ bool SkStrikeClient::readStrikeData(const volatile void* memory, size_t memorySi
         SkAutoDescriptor ad;
         auto* client_desc = auto_descriptor_from_desc(sourceAd.getDesc(), tf->uniqueID(), &ad);
 
-        auto strike = fStrikeCache->findStrikeExclusive(*client_desc);
+        auto strike = fStrikeCache->findStrike(*client_desc);
         // Metrics are only sent the first time. If the metrics are not initialized, there must
         // be an existing strike.
         if (fontMetricsInitialized && strike == nullptr) READ_FAILURE
@@ -953,7 +953,7 @@ bool SkStrikeClient::readStrikeData(const volatile void* memory, size_t memorySi
             // effects.
             SkScalerContextEffects effects;
             auto scaler = tf->createScalerContext(effects, client_desc);
-            strike = fStrikeCache->createStrikeExclusive(
+            strike = fStrikeCache->createStrike(
                     *client_desc, std::move(scaler), &fontMetrics,
                     std::make_unique<DiscardableStrikePinner>(
                             spec.discardableHandleId, fDiscardableHandleManager));
diff --git a/src/core/SkStrikeCache.cpp b/src/core/SkStrikeCache.cpp
@@ -31,58 +31,6 @@ SkStrikeCache* SkStrikeCache::GlobalStrikeCache() {
     return cache;
 }
 
-SkStrikeCache::ExclusiveStrikePtr::ExclusiveStrikePtr(sk_sp<Strike> strike)
-    : fStrike{std::move(strike)} {}
-
-SkStrikeCache::ExclusiveStrikePtr::ExclusiveStrikePtr()
-    : fStrike{nullptr} {}
-
-SkStrikeCache::ExclusiveStrikePtr::ExclusiveStrikePtr(ExclusiveStrikePtr&& o)
-    : fStrike{std::move(o.fStrike)} {
-    o.fStrike = nullptr;
-}
-
-SkStrikeCache::ExclusiveStrikePtr&
-SkStrikeCache::ExclusiveStrikePtr::operator = (ExclusiveStrikePtr&& that) {
-    fStrike = std::move(that.fStrike);
-    return *this;
-}
-
-SkStrike* SkStrikeCache::ExclusiveStrikePtr::get() const {
-    return fStrike.get();
-}
-
-SkStrike* SkStrikeCache::ExclusiveStrikePtr::operator -> () const {
-    return this->get();
-}
-
-SkStrike& SkStrikeCache::ExclusiveStrikePtr::operator *  () const {
-    return *this->get();
-}
-
-SkStrikeCache::ExclusiveStrikePtr::operator bool () const {
-    return fStrike != nullptr;
-}
-
-bool operator == (const SkStrikeCache::ExclusiveStrikePtr& lhs,
-                  const SkStrikeCache::ExclusiveStrikePtr& rhs) {
-    return lhs.fStrike == rhs.fStrike;
-}
-
-bool operator == (const SkStrikeCache::ExclusiveStrikePtr& lhs, decltype(nullptr)) {
-    return lhs.fStrike == nullptr;
-}
-
-bool operator == (decltype(nullptr), const SkStrikeCache::ExclusiveStrikePtr& rhs) {
-    return nullptr == rhs.fStrike;
-}
-
-SkExclusiveStrikePtr SkStrikeCache::findOrCreateStrikeExclusive(
-        const SkDescriptor& desc, const SkScalerContextEffects& effects, const SkTypeface& typeface)
-{
-    return SkExclusiveStrikePtr(this->findOrCreateStrike(desc, effects, typeface));
-}
-
 auto SkStrikeCache::findOrCreateStrike(const SkDescriptor& desc,
                                        const SkScalerContextEffects& effects,
                                        const SkTypeface& typeface) -> sk_sp<Strike> {
@@ -170,9 +118,9 @@ void SkStrikeCache::DumpMemoryStatistics(SkTraceMemoryDump* dump) {
     GlobalStrikeCache()->forEachStrike(visitor);
 }
 
-SkExclusiveStrikePtr SkStrikeCache::findStrikeExclusive(const SkDescriptor& desc) {
+sk_sp<SkStrike> SkStrikeCache::findStrike(const SkDescriptor& desc) {
     SkAutoSpinlock ac(fLock);
-    return SkExclusiveStrikePtr(this->internalFindStrikeOrNull(desc));
+    return this->internalFindStrikeOrNull(desc);
 }
 
 auto SkStrikeCache::internalFindStrikeOrNull(const SkDescriptor& desc) -> sk_sp<Strike> {
@@ -196,15 +144,13 @@ auto SkStrikeCache::internalFindStrikeOrNull(const SkDescriptor& desc) -> sk_sp<
     return sk_ref_sp(strikePtr);
 }
 
-SkExclusiveStrikePtr SkStrikeCache::createStrikeExclusive(
+sk_sp<SkStrike> SkStrikeCache::createStrike(
         const SkDescriptor& desc,
         std::unique_ptr<SkScalerContext> scaler,
         SkFontMetrics* maybeMetrics,
-        std::unique_ptr<SkStrikePinner> pinner)
-{
+        std::unique_ptr<SkStrikePinner> pinner) {
     SkAutoSpinlock ac(fLock);
-    return SkExclusiveStrikePtr(
-            this->internalCreateStrike(desc, std::move(scaler), maybeMetrics, std::move(pinner)));
+    return this->internalCreateStrike(desc, std::move(scaler), maybeMetrics, std::move(pinner));
 }
 
 auto SkStrikeCache::internalCreateStrike(
diff --git a/src/core/SkStrikeCache.h b/src/core/SkStrikeCache.h
@@ -145,38 +145,17 @@ class SkStrikeCache final : public SkStrikeForGPUCacheInterface {
         bool                            fRemoved{false};
     };  // Strike
 
-    class ExclusiveStrikePtr {
-    public:
-        explicit ExclusiveStrikePtr(sk_sp<Strike> strike);
-        ExclusiveStrikePtr();
-        ExclusiveStrikePtr(const ExclusiveStrikePtr&) = delete;
-        ExclusiveStrikePtr& operator = (const ExclusiveStrikePtr&) = delete;
-        ExclusiveStrikePtr(ExclusiveStrikePtr&&);
-        ExclusiveStrikePtr& operator = (ExclusiveStrikePtr&&);
-
-        Strike* get() const;
-        Strike* operator -> () const;
-        Strike& operator *  () const;
-        explicit operator bool () const;
-        friend bool operator == (const ExclusiveStrikePtr&, const ExclusiveStrikePtr&);
-        friend bool operator == (const ExclusiveStrikePtr&, decltype(nullptr));
-        friend bool operator == (decltype(nullptr), const ExclusiveStrikePtr&);
-
-    private:
-        sk_sp<Strike> fStrike;
-    };
-
     static SkStrikeCache* GlobalStrikeCache();
 
-    ExclusiveStrikePtr findStrikeExclusive(const SkDescriptor&) SK_EXCLUDES(fLock);
+    sk_sp<Strike> findStrike(const SkDescriptor& desc) SK_EXCLUDES(fLock);
 
-    ExclusiveStrikePtr createStrikeExclusive(
+    sk_sp<Strike> createStrike(
             const SkDescriptor& desc,
             std::unique_ptr<SkScalerContext> scaler,
             SkFontMetrics* maybeMetrics = nullptr,
             std::unique_ptr<SkStrikePinner> = nullptr) SK_EXCLUDES(fLock);
 
-    ExclusiveStrikePtr findOrCreateStrikeExclusive(
+    sk_sp<Strike> findOrCreateStrike(
             const SkDescriptor& desc,
             const SkScalerContextEffects& effects,
             const SkTypeface& typeface) SK_EXCLUDES(fLock);
@@ -213,10 +192,6 @@ class SkStrikeCache final : public SkStrikeForGPUCacheInterface {
             std::unique_ptr<SkScalerContext> scaler,
             SkFontMetrics* maybeMetrics = nullptr,
             std::unique_ptr<SkStrikePinner> = nullptr) SK_REQUIRES(fLock);
-    sk_sp<Strike> findOrCreateStrike(
-            const SkDescriptor& desc,
-            const SkScalerContextEffects& effects,
-            const SkTypeface& typeface) SK_EXCLUDES(fLock);
 
     // The following methods can only be called when mutex is already held.
     void internalRemoveStrike(Strike* strike) SK_REQUIRES(fLock);
@@ -252,7 +227,6 @@ class SkStrikeCache final : public SkStrikeForGPUCacheInterface {
     int32_t fPointSizeLimit{SK_DEFAULT_FONT_CACHE_POINT_SIZE_LIMIT};
 };
 
-using SkExclusiveStrikePtr = SkStrikeCache::ExclusiveStrikePtr;
 using SkStrike = SkStrikeCache::Strike;
 
 #endif  // SkStrikeCache_DEFINED
diff --git a/src/core/SkStrikeSpec.cpp b/src/core/SkStrikeSpec.cpp
@@ -231,13 +231,13 @@ SkScopedStrikeForGPU SkStrikeSpec::findOrCreateScopedStrike(SkStrikeForGPUCacheI
     return cache->findOrCreateScopedStrike(*fAutoDescriptor.getDesc(), effects, *fTypeface);
 }
 
-SkExclusiveStrikePtr SkStrikeSpec::findOrCreateExclusiveStrike(SkStrikeCache* cache) const {
+sk_sp<SkStrike> SkStrikeSpec::findOrCreateStrike(SkStrikeCache* cache) const {
     SkScalerContextEffects effects{fPathEffect.get(), fMaskFilter.get()};
-    return cache->findOrCreateStrikeExclusive(*fAutoDescriptor.getDesc(), effects, *fTypeface);
+    return cache->findOrCreateStrike(*fAutoDescriptor.getDesc(), effects, *fTypeface);
 }
 
 SkBulkGlyphMetrics::SkBulkGlyphMetrics(const SkStrikeSpec& spec)
-    : fStrike{spec.findOrCreateExclusiveStrike()} { }
+    : fStrike{spec.findOrCreateStrike()} { }
 
 SkSpan<const SkGlyph*> SkBulkGlyphMetrics::glyphs(SkSpan<const SkGlyphID> glyphIDs) {
     fGlyphs.reset(glyphIDs.size());
@@ -249,9 +249,9 @@ const SkGlyph* SkBulkGlyphMetrics::glyph(SkGlyphID glyphID) {
 }
 
 SkBulkGlyphMetricsAndPaths::SkBulkGlyphMetricsAndPaths(const SkStrikeSpec& spec)
-    : fStrike{spec.findOrCreateExclusiveStrike()} { }
+    : fStrike{spec.findOrCreateStrike()} { }
 
-SkBulkGlyphMetricsAndPaths::SkBulkGlyphMetricsAndPaths(SkExclusiveStrikePtr&& strike)
+SkBulkGlyphMetricsAndPaths::SkBulkGlyphMetricsAndPaths(sk_sp<SkStrike>&& strike)
         : fStrike{std::move(strike)} { }
 
 SkSpan<const SkGlyph*> SkBulkGlyphMetricsAndPaths::glyphs(SkSpan<const SkGlyphID> glyphIDs) {
@@ -272,9 +272,9 @@ void SkBulkGlyphMetricsAndPaths::findIntercepts(
 }
 
 SkBulkGlyphMetricsAndImages::SkBulkGlyphMetricsAndImages(const SkStrikeSpec& spec)
-        : fStrike{spec.findOrCreateExclusiveStrike()} { }
+        : fStrike{spec.findOrCreateStrike()} { }
 
-SkBulkGlyphMetricsAndImages::SkBulkGlyphMetricsAndImages(SkExclusiveStrikePtr&& strike)
+SkBulkGlyphMetricsAndImages::SkBulkGlyphMetricsAndImages(sk_sp<SkStrike>&& strike)
         : fStrike{std::move(strike)} { }
 
 SkSpan<const SkGlyph*> SkBulkGlyphMetricsAndImages::glyphs(SkSpan<const SkPackedGlyphID> glyphIDs) {
diff --git a/src/core/SkStrikeSpec.h b/src/core/SkStrikeSpec.h
@@ -74,7 +74,7 @@ class SkStrikeSpec {
 
     SkScopedStrikeForGPU findOrCreateScopedStrike(SkStrikeForGPUCacheInterface* cache) const;
 
-    SkExclusiveStrikePtr findOrCreateExclusiveStrike(
+    sk_sp<SkStrike> findOrCreateStrike(
             SkStrikeCache* cache = SkStrikeCache::GlobalStrikeCache()) const;
 
     SkScalar strikeToSourceRatio() const { return fStrikeToSourceRatio; }
@@ -106,13 +106,13 @@ class SkBulkGlyphMetrics {
 private:
     static constexpr int kTypicalGlyphCount = 20;
     SkAutoSTArray<kTypicalGlyphCount, const SkGlyph*> fGlyphs;
-    SkExclusiveStrikePtr fStrike;
+    sk_sp<SkStrike> fStrike;
 };
 
 class SkBulkGlyphMetricsAndPaths {
 public:
     explicit SkBulkGlyphMetricsAndPaths(const SkStrikeSpec& spec);
-    explicit SkBulkGlyphMetricsAndPaths(SkExclusiveStrikePtr&& strike);
+    explicit SkBulkGlyphMetricsAndPaths(sk_sp<SkStrike>&& strike);
     SkSpan<const SkGlyph*> glyphs(SkSpan<const SkGlyphID> glyphIDs);
     const SkGlyph* glyph(SkGlyphID glyphID);
     void findIntercepts(const SkScalar bounds[2], SkScalar scale, SkScalar xPos,
@@ -121,22 +121,21 @@ class SkBulkGlyphMetricsAndPaths {
 private:
     static constexpr int kTypicalGlyphCount = 20;
     SkAutoSTArray<kTypicalGlyphCount, const SkGlyph*> fGlyphs;
-    SkExclusiveStrikePtr fStrike;
+    sk_sp<SkStrike> fStrike;
 };
 
 class SkBulkGlyphMetricsAndImages {
 public:
     explicit SkBulkGlyphMetricsAndImages(const SkStrikeSpec& spec);
-    explicit SkBulkGlyphMetricsAndImages(SkExclusiveStrikePtr&& strike);
+    explicit SkBulkGlyphMetricsAndImages(sk_sp<SkStrike>&& strike);
     SkSpan<const SkGlyph*> glyphs(SkSpan<const SkPackedGlyphID> packedIDs);
     const SkGlyph* glyph(SkPackedGlyphID packedID);
     const SkDescriptor& descriptor() const;
 
-
 private:
     static constexpr int kTypicalGlyphCount = 64;
     SkAutoSTArray<kTypicalGlyphCount, const SkGlyph*> fGlyphs;
-    SkExclusiveStrikePtr fStrike;
+    sk_sp<SkStrike> fStrike;
 };
 
 #endif  // SkStrikeSpec_DEFINED
diff --git a/src/pdf/SkPDFFont.cpp b/src/pdf/SkPDFFont.cpp
@@ -539,11 +539,11 @@ static void emit_subset_type3(const SkPDFFont& pdfFont, SkPDFDocument* doc) {
     }
     int unitsPerEm;
     SkStrikeSpec strikeSpec = SkStrikeSpec::MakePDFVector(*typeface, &unitsPerEm);
-    auto cache = strikeSpec.findOrCreateExclusiveStrike();
-    SkASSERT(cache);
+    auto strike = strikeSpec.findOrCreateStrike();
+    SkASSERT(strike);
     SkScalar emSize = (SkScalar)unitsPerEm;
-    SkScalar xHeight = cache->getFontMetrics().fXHeight;
-    SkBulkGlyphMetricsAndPaths metricsAndPaths(std::move(cache));
+    SkScalar xHeight = strike->getFontMetrics().fXHeight;
+    SkBulkGlyphMetricsAndPaths metricsAndPaths(std::move(strike));
 
     SkStrikeSpec strikeSpecSmall = kBitmapFontSize > 0 ? make_small_strike(*typeface)
                                                        : strikeSpec;

Original file line number	Diff line number	Diff line change
`@@ -352,7 +352,7 @@ SkScalar SkFont::getMetrics(SkFontMetrics* metrics) const {`
`352`	`352`	`metrics = &storage;`
`353`	`353`	`}`
`354`	`354`
`355`		`- auto cache = strikeSpec.findOrCreateExclusiveStrike();`
	`355`	`+ auto cache = strikeSpec.findOrCreateStrike();`
`356`	`356`	`*metrics = cache->getFontMetrics();`
`357`	`357`
`358`	`358`	`if (strikeSpec.strikeToSourceRatio() != 1) {`