diff --git a/bench/PathTextBench.cpp b/bench/PathTextBench.cpp
index 846f049..43f43d7 100644
--- a/bench/PathTextBench.cpp
+++ b/bench/PathTextBench.cpp
@@ -10,7 +10,7 @@
 #include "include/core/SkPaint.h"
 #include "include/core/SkPath.h"
 #include "include/utils/SkRandom.h"
-#include "src/core/SkStrike.h"
+#include "src/core/SkScalerCache.h"
 #include "src/core/SkStrikeCache.h"
 #include "src/core/SkStrikeSpec.h"
 #include "tools/ToolUtils.h"
diff --git a/bench/SkGlyphCacheBench.cpp b/bench/SkGlyphCacheBench.cpp
index 725cedc..5704a74 100644
--- a/bench/SkGlyphCacheBench.cpp
+++ b/bench/SkGlyphCacheBench.cpp
@@ -5,7 +5,7 @@
  * found in the LICENSE file.
  */
 
-#include "src/core/SkStrike.h"
+#include "src/core/SkScalerCache.h"
 
 #include "bench/Benchmark.h"
 #include "include/core/SkCanvas.h"
diff --git a/gn/core.gni b/gn/core.gni
index c3a4471..743ea25 100644
--- a/gn/core.gni
+++ b/gn/core.gni
@@ -323,6 +323,8 @@
   "$_src/core/SkRuntimeEffect.cpp",
   "$_src/core/SkRWBuffer.cpp",
   "$_src/core/SkScalar.cpp",
+  "$_src/core/SkScalerCache.cpp",
+  "$_src/core/SkScalerCache.h",
   "$_src/core/SkScalerContext.cpp",
   "$_src/core/SkScalerContext.h",
   "$_src/core/SkScaleToSides.h",
@@ -349,8 +351,6 @@
   "$_src/core/SkSpriteBlitter.h",
   "$_src/core/SkStream.cpp",
   "$_src/core/SkStreamPriv.h",
-  "$_src/core/SkStrike.cpp",
-  "$_src/core/SkStrike.h",
   "$_src/core/SkStrikeCache.cpp",
   "$_src/core/SkStrikeCache.h",
   "$_src/core/SkStrikeForGPU.h",
diff --git a/gn/tests.gni b/gn/tests.gni
index c681a15..3c35994 100644
--- a/gn/tests.gni
+++ b/gn/tests.gni
@@ -253,7 +253,7 @@
   "$_tests/SkSLSPIRVTest.cpp",
   "$_tests/SkShaperJSONWriterTest.cpp",
   "$_tests/SkSharedMutexTest.cpp",
-  "$_tests/SkStrikeTest.cpp",
+  "$_tests/SkScalerCacheTest.cpp",
   "$_tests/SkUTFTest.cpp",
   "$_tests/SkVMTest.cpp",
   "$_tests/SkVxTest.cpp",
diff --git a/samplecode/SamplePathText.cpp b/samplecode/SamplePathText.cpp
index 54f49b3..c9504ae 100644
--- a/samplecode/SamplePathText.cpp
+++ b/samplecode/SamplePathText.cpp
@@ -10,7 +10,7 @@
 #include "include/core/SkPath.h"
 #include "include/utils/SkRandom.h"
 #include "samplecode/Sample.h"
-#include "src/core/SkStrike.h"
+#include "src/core/SkScalerCache.h"
 #include "src/core/SkStrikeCache.h"
 #include "src/core/SkStrikeSpec.h"
 #include "src/core/SkTaskGroup.h"
diff --git a/src/core/SkDraw_text.cpp b/src/core/SkDraw_text.cpp
index d192952..73e2722 100644
--- a/src/core/SkDraw_text.cpp
+++ b/src/core/SkDraw_text.cpp
@@ -9,8 +9,8 @@
 #include "src/core/SkFontPriv.h"
 #include "src/core/SkPaintPriv.h"
 #include "src/core/SkRasterClip.h"
+#include "src/core/SkScalerCache.h"
 #include "src/core/SkScalerContext.h"
-#include "src/core/SkStrike.h"
 #include "src/core/SkUtils.h"
 #include <climits>
 
diff --git a/src/core/SkFont.cpp b/src/core/SkFont.cpp
index b0de674..8f09ac1 100644
--- a/src/core/SkFont.cpp
+++ b/src/core/SkFont.cpp
@@ -13,8 +13,8 @@
 #include "src/core/SkDraw.h"
 #include "src/core/SkFontPriv.h"
 #include "src/core/SkPaintDefaults.h"
+#include "src/core/SkScalerCache.h"
 #include "src/core/SkScalerContext.h"
-#include "src/core/SkStrike.h"
 #include "src/core/SkStrikeCache.h"
 #include "src/core/SkStrikeSpec.h"
 #include "src/core/SkTLazy.h"
diff --git a/src/core/SkGlyph.h b/src/core/SkGlyph.h
index 048c953..773dad6 100644
--- a/src/core/SkGlyph.h
+++ b/src/core/SkGlyph.h
@@ -17,7 +17,6 @@
 #include "src/core/SkMask.h"
 
 class SkArenaAlloc;
-class SkStrike;
 class SkScalerContext;
 
 // needs to be != to any valid SkMask::Format
diff --git a/src/core/SkGlyphRun.cpp b/src/core/SkGlyphRun.cpp
index e85fb37..7a6a427 100644
--- a/src/core/SkGlyphRun.cpp
+++ b/src/core/SkGlyphRun.cpp
@@ -13,7 +13,7 @@
 #include "include/private/SkTo.h"
 #include "src/core/SkDevice.h"
 #include "src/core/SkFontPriv.h"
-#include "src/core/SkStrike.h"
+#include "src/core/SkScalerCache.h"
 #include "src/core/SkStrikeCache.h"
 #include "src/core/SkStrikeSpec.h"
 #include "src/core/SkTextBlobPriv.h"
diff --git a/src/core/SkGlyphRunPainter.cpp b/src/core/SkGlyphRunPainter.cpp
index f9f361f..29c986f 100644
--- a/src/core/SkGlyphRunPainter.cpp
+++ b/src/core/SkGlyphRunPainter.cpp
@@ -29,7 +29,7 @@
 #include "src/core/SkEnumerate.h"
 #include "src/core/SkFontPriv.h"
 #include "src/core/SkRasterClip.h"
-#include "src/core/SkStrike.h"
+#include "src/core/SkScalerCache.h"
 #include "src/core/SkStrikeCache.h"
 #include "src/core/SkStrikeForGPU.h"
 #include "src/core/SkStrikeSpec.h"
diff --git a/src/core/SkRemoteGlyphCache.cpp b/src/core/SkRemoteGlyphCache.cpp
index 46f09b1..211344e 100644
--- a/src/core/SkRemoteGlyphCache.cpp
+++ b/src/core/SkRemoteGlyphCache.cpp
@@ -19,8 +19,8 @@
 #include "src/core/SkDraw.h"
 #include "src/core/SkEnumerate.h"
 #include "src/core/SkGlyphRun.h"
+#include "src/core/SkScalerCache.h"
 #include "src/core/SkSpan.h"
-#include "src/core/SkStrike.h"
 #include "src/core/SkStrikeCache.h"
 #include "src/core/SkTLazy.h"
 #include "src/core/SkTraceEvent.h"
diff --git a/src/core/SkRemoteGlyphCache.h b/src/core/SkRemoteGlyphCache.h
index 4a3bd36..3155b87 100644
--- a/src/core/SkRemoteGlyphCache.h
+++ b/src/core/SkRemoteGlyphCache.h
@@ -35,7 +35,6 @@
 enum SkAxisAlignment : uint32_t;
 class SkDescriptor;
 class SkAutoDescriptor;
-class SkStrike;
 struct SkPackedGlyphID;
 enum SkScalerContextFlags : uint32_t;
 class SkStrikeCache;
diff --git a/src/core/SkStrike.cpp b/src/core/SkScalerCache.cpp
similarity index 82%
rename from src/core/SkStrike.cpp
rename to src/core/SkScalerCache.cpp
index 2435993..d994485 100644
--- a/src/core/SkStrike.cpp
+++ b/src/core/SkScalerCache.cpp
@@ -5,7 +5,7 @@
  * found in the LICENSE file.
  */
 
-#include "src/core/SkStrike.h"
+#include "src/core/SkScalerCache.h"
 
 #include "include/core/SkGraphics.h"
 #include "include/core/SkPath.h"
@@ -27,7 +27,7 @@
     return answer;
 }
 
-SkStrike::SkStrike(
+SkScalerCache::SkScalerCache(
     const SkDescriptor& desc,
     std::unique_ptr<SkScalerContext> scaler,
     const SkFontMetrics* fontMetrics)
@@ -46,14 +46,14 @@
 #endif
 
 // -- glyph creation -------------------------------------------------------------------------------
-SkGlyph* SkStrike::makeGlyph(SkPackedGlyphID packedGlyphID) {
+SkGlyph* SkScalerCache::makeGlyph(SkPackedGlyphID packedGlyphID) {
     fMemoryUsed += sizeof(SkGlyph);
     SkGlyph* glyph = fAlloc.make<SkGlyph>(packedGlyphID);
     fGlyphMap.set(glyph);
     return glyph;
 }
 
-SkGlyph* SkStrike::glyph(SkPackedGlyphID packedGlyphID) {
+SkGlyph* SkScalerCache::glyph(SkPackedGlyphID packedGlyphID) {
     VALIDATE();
     SkGlyph* glyph = fGlyphMap.findOrNull(packedGlyphID);
     if (glyph == nullptr) {
@@ -63,14 +63,14 @@
     return glyph;
 }
 
-const SkPath* SkStrike::preparePath(SkGlyph* glyph) {
+const SkPath* SkScalerCache::preparePath(SkGlyph* glyph) {
     if (glyph->setPath(&fAlloc, fScalerContext.get())) {
         fMemoryUsed += glyph->path()->approximateBytesUsed();
     }
     return glyph->path();
 }
 
-const SkPath* SkStrike::preparePath(SkGlyph* glyph, const SkPath* path) {
+const SkPath* SkScalerCache::preparePath(SkGlyph* glyph, const SkPath* path) {
     SkAutoMutexExclusive lock{fMu};
     if (glyph->setPath(&fAlloc, path)) {
         fMemoryUsed += glyph->path()->approximateBytesUsed();
@@ -78,20 +78,20 @@
     return glyph->path();
 }
 
-const SkDescriptor& SkStrike::getDescriptor() const {
+const SkDescriptor& SkScalerCache::getDescriptor() const {
     return *fDesc.getDesc();
 }
 
-int SkStrike::countCachedGlyphs() const {
+int SkScalerCache::countCachedGlyphs() const {
     SkAutoMutexExclusive lock(fMu);
     return fGlyphMap.count();
 }
 
-SkGlyph* SkStrike::internalGlyphOrNull(SkPackedGlyphID id) const {
+SkGlyph* SkScalerCache::internalGlyphOrNull(SkPackedGlyphID id) const {
     return fGlyphMap.findOrNull(id);
 }
 
-SkSpan<const SkGlyph*> SkStrike::internalPrepare(
+SkSpan<const SkGlyph*> SkScalerCache::internalPrepare(
         SkSpan<const SkGlyphID> glyphIDs, PathDetail pathDetail, const SkGlyph** results) {
     const SkGlyph** cursor = results;
     for (auto glyphID : glyphIDs) {
@@ -105,14 +105,14 @@
     return {results, glyphIDs.size()};
 }
 
-const void* SkStrike::prepareImage(SkGlyph* glyph) {
+const void* SkScalerCache::prepareImage(SkGlyph* glyph) {
     if (glyph->setImage(&fAlloc, fScalerContext.get())) {
         fMemoryUsed += glyph->imageSize();
     }
     return glyph->image();
 }
 
-SkGlyph* SkStrike::mergeGlyphAndImage(SkPackedGlyphID toID, const SkGlyph& from) {
+SkGlyph* SkScalerCache::mergeGlyphAndImage(SkPackedGlyphID toID, const SkGlyph& from) {
     SkAutoMutexExclusive lock{fMu};
     SkGlyph* glyph = fGlyphMap.findOrNull(toID);
     if (glyph == nullptr) {
@@ -124,20 +124,20 @@
     return glyph;
 }
 
-SkSpan<const SkGlyph*> SkStrike::metrics(SkSpan<const SkGlyphID> glyphIDs,
+SkSpan<const SkGlyph*> SkScalerCache::metrics(SkSpan<const SkGlyphID> glyphIDs,
                                          const SkGlyph* results[]) {
     SkAutoMutexExclusive lock{fMu};
     return this->internalPrepare(glyphIDs, kMetricsOnly, results);
 }
 
-SkSpan<const SkGlyph*> SkStrike::preparePaths(SkSpan<const SkGlyphID> glyphIDs,
+SkSpan<const SkGlyph*> SkScalerCache::preparePaths(SkSpan<const SkGlyphID> glyphIDs,
                                               const SkGlyph* results[]) {
     SkAutoMutexExclusive lock{fMu};
     return this->internalPrepare(glyphIDs, kMetricsAndPath, results);
 }
 
 SkSpan<const SkGlyph*>
-SkStrike::prepareImages(SkSpan<const SkPackedGlyphID> glyphIDs, const SkGlyph* results[]) {
+SkScalerCache::prepareImages(SkSpan<const SkPackedGlyphID> glyphIDs, const SkGlyph* results[]) {
     const SkGlyph** cursor = results;
     SkAutoMutexExclusive lock{fMu};
     for (auto glyphID : glyphIDs) {
@@ -150,7 +150,7 @@
 }
 
 template <typename Fn>
-void SkStrike::commonFilterLoop(SkDrawableGlyphBuffer* drawables, Fn&& fn) {
+void SkScalerCache::commonFilterLoop(SkDrawableGlyphBuffer* drawables, Fn&& fn) {
     for (auto [i, packedID, pos] : SkMakeEnumerate(drawables->input())) {
         if (SkScalarsAreFinite(pos.x(), pos.y())) {
             SkGlyph* glyph = this->glyph(packedID);
@@ -161,7 +161,7 @@
     }
 }
 
-void SkStrike::prepareForDrawingMasksCPU(SkDrawableGlyphBuffer* drawables) {
+void SkScalerCache::prepareForDrawingMasksCPU(SkDrawableGlyphBuffer* drawables) {
     SkAutoMutexExclusive lock{fMu};
     this->commonFilterLoop(drawables,
         [&](size_t i, SkGlyph* glyph, SkPoint pos) SK_REQUIRES(fMu) {
@@ -173,12 +173,12 @@
 }
 
 // Note: this does not actually fill out the image. That happens at atlas building time.
-void SkStrike::prepareForMaskDrawing(
+void SkScalerCache::prepareForMaskDrawing(
         SkDrawableGlyphBuffer* drawables, SkSourceGlyphBuffer* rejects) {
     SkAutoMutexExclusive lock{fMu};
     this->commonFilterLoop(drawables,
         [&](size_t i, SkGlyph* glyph, SkPoint pos) {
-            if (CanDrawAsMask(*glyph)) {
+            if (SkStrikeForGPU::CanDrawAsMask(*glyph)) {
                 drawables->push_back(glyph, i);
             } else {
                 rejects->reject(i);
@@ -186,12 +186,12 @@
         });
 }
 
-void SkStrike::prepareForSDFTDrawing(
+void SkScalerCache::prepareForSDFTDrawing(
         SkDrawableGlyphBuffer* drawables, SkSourceGlyphBuffer* rejects) {
     SkAutoMutexExclusive lock{fMu};
     this->commonFilterLoop(drawables,
         [&](size_t i, SkGlyph* glyph, SkPoint pos) {
-            if (CanDrawAsSDFT(*glyph)) {
+            if (SkStrikeForGPU::CanDrawAsSDFT(*glyph)) {
                 drawables->push_back(glyph, i);
             } else {
                 rejects->reject(i);
@@ -199,7 +199,7 @@
         });
 }
 
-void SkStrike::prepareForPathDrawing(
+void SkScalerCache::prepareForPathDrawing(
         SkDrawableGlyphBuffer* drawables, SkSourceGlyphBuffer* rejects) {
     SkAutoMutexExclusive lock{fMu};
     this->commonFilterLoop(drawables,
@@ -220,12 +220,12 @@
         });
 }
 
-void SkStrike::findIntercepts(const SkScalar bounds[2], SkScalar scale, SkScalar xPos,
+void SkScalerCache::findIntercepts(const SkScalar bounds[2], SkScalar scale, SkScalar xPos,
         SkGlyph* glyph, SkScalar* array, int* count) {
     glyph->ensureIntercepts(bounds, scale, xPos, array, count, &fAlloc);
 }
 
-void SkStrike::dump() const {
+void SkScalerCache::dump() const {
     SkAutoMutexExclusive lock{fMu};
     const SkTypeface* face = fScalerContext->getTypeface();
     const SkScalerContextRec& rec = fScalerContext->getRec();
@@ -243,10 +243,8 @@
     SkDebugf("%s\n", msg.c_str());
 }
 
-void SkStrike::onAboutToExitScope() { }
-
 #ifdef SK_DEBUG
-void SkStrike::forceValidate() const {
+void SkScalerCache::forceValidate() const {
     SkAutoMutexExclusive lock{fMu};
     size_t memoryUsed = sizeof(*this);
     fGlyphMap.foreach ([&memoryUsed](const SkGlyph* glyphPtr) {
@@ -261,7 +259,7 @@
     SkASSERT(fMemoryUsed == memoryUsed);
 }
 
-void SkStrike::validate() const {
+void SkScalerCache::validate() const {
 #ifdef SK_DEBUG_GLYPH_CACHE
     forceValidate();
 #endif
diff --git a/src/core/SkStrike.h b/src/core/SkScalerCache.h
similarity index 90%
rename from src/core/SkStrike.h
rename to src/core/SkScalerCache.h
index e468ff2..f211532 100644
--- a/src/core/SkStrike.h
+++ b/src/core/SkScalerCache.h
@@ -23,11 +23,11 @@
 // This class represents a strike: a specific combination of typeface, size, matrix, etc., and
 // holds the glyphs for that strike.
 
-class SkStrike final : public SkStrikeForGPU {
+class SkScalerCache {
 public:
-    SkStrike(const SkDescriptor& desc,
-             std::unique_ptr<SkScalerContext> scaler,
-             const SkFontMetrics* metrics = nullptr);
+    SkScalerCache(const SkDescriptor& desc,
+                  std::unique_ptr<SkScalerContext> scaler,
+                  const SkFontMetrics* metrics = nullptr);
 
     // Lookup (or create if needed) the toGlyph using toID. If that glyph is not initialized with
     // an image, then use the information in from to initialize the width, height top, left,
@@ -51,11 +51,6 @@
         return fFontMetrics;
     }
 
-    const SkGlyphPositionRoundingSpec& roundingSpec() const override {
-        return fRoundingSpec;
-    }
-
-    const SkDescriptor& getDescriptor() const override;
 
     SkSpan<const SkGlyph*> metrics(SkSpan<const SkGlyphID> glyphIDs,
                                    const SkGlyph* results[]) SK_EXCLUDES(fMu);
@@ -68,16 +63,21 @@
 
     void prepareForDrawingMasksCPU(SkDrawableGlyphBuffer* drawables) SK_EXCLUDES(fMu);
 
+    // SkStrikeForGPU APIs
+    const SkGlyphPositionRoundingSpec& roundingSpec() const {
+        return fRoundingSpec;
+    }
+
+    const SkDescriptor& getDescriptor() const;
+
     void prepareForMaskDrawing(
-            SkDrawableGlyphBuffer* drawables, SkSourceGlyphBuffer* rejects) override SK_EXCLUDES(fMu);
+            SkDrawableGlyphBuffer* drawables, SkSourceGlyphBuffer* rejects) SK_EXCLUDES(fMu);
 
     void prepareForSDFTDrawing(
-            SkDrawableGlyphBuffer* drawables, SkSourceGlyphBuffer* rejects) override SK_EXCLUDES(fMu);
+            SkDrawableGlyphBuffer* drawables, SkSourceGlyphBuffer* rejects) SK_EXCLUDES(fMu);
 
     void prepareForPathDrawing(
-            SkDrawableGlyphBuffer* drawables, SkSourceGlyphBuffer* rejects) override SK_EXCLUDES(fMu);
-
-    void onAboutToExitScope() override;
+            SkDrawableGlyphBuffer* drawables, SkSourceGlyphBuffer* rejects) SK_EXCLUDES(fMu);
 
     /** Return the approx RAM usage for this cache. */
     size_t getMemoryUsed() const SK_EXCLUDES(fMu) {
@@ -98,7 +98,7 @@
 
     class AutoValidate : SkNoncopyable {
     public:
-        AutoValidate(const SkStrike* cache) : fCache(cache) {
+        AutoValidate(const SkScalerCache* cache) : fCache(cache) {
             if (fCache) {
                 fCache->validate();
             }
@@ -112,7 +112,7 @@
             fCache = nullptr;
         }
     private:
-        const SkStrike* fCache;
+        const SkScalerCache* fCache;
     };
 
 private:
@@ -173,7 +173,7 @@
     SkArenaAlloc            fAlloc SK_GUARDED_BY(fMu) {kMinAllocAmount};
 
     // Tracks (approx) how much ram is tied-up in this strike.
-    size_t                  fMemoryUsed SK_GUARDED_BY(fMu) {sizeof(SkStrike)};
+    size_t                  fMemoryUsed SK_GUARDED_BY(fMu) {sizeof(SkScalerCache)};
 };
 
 #endif  // SkStrike_DEFINED
diff --git a/src/core/SkStrikeCache.cpp b/src/core/SkStrikeCache.cpp
index 986e7a1..7c793fb 100644
--- a/src/core/SkStrikeCache.cpp
+++ b/src/core/SkStrikeCache.cpp
@@ -16,52 +16,7 @@
 #include "include/private/SkMutex.h"
 #include "include/private/SkTemplates.h"
 #include "src/core/SkGlyphRunPainter.h"
-#include "src/core/SkStrike.h"
-
-class SkStrikeCache::Node final : public SkRefCnt, public SkStrikeForGPU {
-public:
-    Node(SkStrikeCache* strikeCache,
-         const SkDescriptor& desc,
-         std::unique_ptr<SkScalerContext> scaler,
-         const SkFontMetrics* metrics,
-         std::unique_ptr<SkStrikePinner> pinner)
-            : fStrikeCache{strikeCache}
-            , fStrike{desc, std::move(scaler), metrics}
-            , fPinner{std::move(pinner)} {}
-
-    const SkGlyphPositionRoundingSpec& roundingSpec() const override {
-        return fStrike.roundingSpec();
-    }
-
-    const SkDescriptor& getDescriptor() const override {
-        return fStrike.getDescriptor();
-    }
-
-    void prepareForMaskDrawing(
-            SkDrawableGlyphBuffer* drawbles, SkSourceGlyphBuffer* rejects) override {
-        fStrike.prepareForMaskDrawing(drawbles, rejects);
-    }
-
-    void prepareForSDFTDrawing(
-            SkDrawableGlyphBuffer* drawbles, SkSourceGlyphBuffer* rejects) override {
-        fStrike.prepareForSDFTDrawing(drawbles, rejects);
-    }
-
-    void prepareForPathDrawing(
-            SkDrawableGlyphBuffer* drawbles, SkSourceGlyphBuffer* rejects) override {
-        fStrike.prepareForPathDrawing(drawbles, rejects);
-    }
-
-    void onAboutToExitScope() override {
-        fStrikeCache->attachNode(this);
-    }
-
-    SkStrikeCache* const            fStrikeCache;
-    Node*                           fNext{nullptr};
-    Node*                           fPrev{nullptr};
-    SkStrike                        fStrike;
-    std::unique_ptr<SkStrikePinner> fPinner;
-};
+#include "src/core/SkScalerCache.h"
 
 bool gSkUseThreadLocalStrikeCaches_IAcknowledgeThisIsIncrediblyExperimental = false;
 
@@ -76,35 +31,35 @@
     return cache;
 }
 
-SkStrikeCache::ExclusiveStrikePtr::ExclusiveStrikePtr(SkStrikeCache::Node* node)
-    : fNode{node} {}
+SkStrikeCache::ExclusiveStrikePtr::ExclusiveStrikePtr(SkStrikeCache::Strike* strike)
+    : fStrike{strike} {}
 
 SkStrikeCache::ExclusiveStrikePtr::ExclusiveStrikePtr()
-    : fNode{nullptr} {}
+    : fStrike{nullptr} {}
 
 SkStrikeCache::ExclusiveStrikePtr::ExclusiveStrikePtr(ExclusiveStrikePtr&& o)
-    : fNode{o.fNode} {
-    o.fNode = nullptr;
+    : fStrike{o.fStrike} {
+    o.fStrike = nullptr;
 }
 
 SkStrikeCache::ExclusiveStrikePtr&
 SkStrikeCache::ExclusiveStrikePtr::operator = (ExclusiveStrikePtr&& o) {
-    if (fNode != nullptr) {
-        fNode->fStrikeCache->attachNode(fNode);
+    if (fStrike != nullptr) {
+        fStrike->fStrikeCache->attachStrike(fStrike);
     }
-    fNode = o.fNode;
-    o.fNode = nullptr;
+    fStrike = o.fStrike;
+    o.fStrike = nullptr;
     return *this;
 }
 
 SkStrikeCache::ExclusiveStrikePtr::~ExclusiveStrikePtr() {
-    if (fNode != nullptr) {
-        fNode->fStrikeCache->attachNode(fNode);
+    if (fStrike != nullptr) {
+        fStrike->fStrikeCache->attachStrike(fStrike);
     }
 }
 
 SkStrike* SkStrikeCache::ExclusiveStrikePtr::get() const {
-    return &fNode->fStrike;
+    return fStrike;
 }
 
 SkStrike* SkStrikeCache::ExclusiveStrikePtr::operator -> () const {
@@ -116,28 +71,28 @@
 }
 
 SkStrikeCache::ExclusiveStrikePtr::operator bool () const {
-    return fNode != nullptr;
+    return fStrike != nullptr;
 }
 
 bool operator == (const SkStrikeCache::ExclusiveStrikePtr& lhs,
                   const SkStrikeCache::ExclusiveStrikePtr& rhs) {
-    return lhs.fNode == rhs.fNode;
+    return lhs.fStrike == rhs.fStrike;
 }
 
 bool operator == (const SkStrikeCache::ExclusiveStrikePtr& lhs, decltype(nullptr)) {
-    return lhs.fNode == nullptr;
+    return lhs.fStrike == nullptr;
 }
 
 bool operator == (decltype(nullptr), const SkStrikeCache::ExclusiveStrikePtr& rhs) {
-    return nullptr == rhs.fNode;
+    return nullptr == rhs.fStrike;
 }
 
 SkStrikeCache::~SkStrikeCache() {
-    Node* node = fHead;
-    while (node) {
-        Node* next = node->fNext;
-        node->unref();
-        node = next;
+    Strike* strike = fHead;
+    while (strike) {
+        Strike* next = strike->fNext;
+        strike->unref();
+        strike = next;
     }
 }
 
@@ -149,13 +104,13 @@
 
 auto SkStrikeCache::findOrCreateStrike(const SkDescriptor& desc,
                                        const SkScalerContextEffects& effects,
-                                       const SkTypeface& typeface) -> Node* {
-    Node* node = this->findAndDetachStrike(desc);
-    if (node == nullptr) {
+                                       const SkTypeface& typeface) -> Strike* {
+    Strike* strike = this->findAndDetachStrike(desc);
+    if (strike == nullptr) {
         auto scaler = typeface.createScalerContext(effects, &desc);
-        node = this->createStrike(desc, std::move(scaler));
+        strike = this->createStrike(desc, std::move(scaler));
     }
-    return node;
+    return strike;
 }
 
 SkScopedStrikeForGPU SkStrikeCache::findOrCreateScopedStrike(const SkDescriptor& desc,
@@ -177,8 +132,8 @@
 
     int counter = 0;
 
-    auto visitor = [&counter](const SkStrike& cache) {
-        const SkScalerContextRec& rec = cache.getScalerContext()->getRec();
+    auto visitor = [&counter](const Strike& strike) {
+        const SkScalerContextRec& rec = strike.fScalerCache.getScalerContext()->getRec();
 
         SkDebugf("index %d\n", counter);
         SkDebugf("%s", rec.dump().c_str());
@@ -206,9 +161,9 @@
         return;
     }
 
-    auto visitor = [&dump](const SkStrike& cache) {
-        const SkTypeface* face = cache.getScalerContext()->getTypeface();
-        const SkScalerContextRec& rec = cache.getScalerContext()->getRec();
+    auto visitor = [&dump](const Strike& strike) {
+        const SkTypeface* face = strike.fScalerCache.getScalerContext()->getTypeface();
+        const SkScalerContextRec& rec = strike.fScalerCache.getScalerContext()->getRec();
 
         SkString fontName;
         face->getFamilyName(&fontName);
@@ -220,12 +175,13 @@
         }
 
         SkString dumpName = SkStringPrintf(
-                "%s/%s_%d/%p", gGlyphCacheDumpName, fontName.c_str(), rec.fFontID, &cache);
+                "%s/%s_%d/%p", gGlyphCacheDumpName, fontName.c_str(), rec.fFontID, &strike);
 
         dump->dumpNumericValue(dumpName.c_str(),
-                               "size", "bytes", cache.getMemoryUsed());
+                               "size", "bytes", strike.fScalerCache.getMemoryUsed());
         dump->dumpNumericValue(dumpName.c_str(),
-                               "glyph_count", "objects", cache.countCachedGlyphs());
+                               "glyph_count", "objects",
+                               strike.fScalerCache.countCachedGlyphs());
         dump->setMemoryBacking(dumpName.c_str(), "malloc", nullptr);
     };
 
@@ -233,16 +189,16 @@
 }
 
 
-void SkStrikeCache::attachNode(Node* node) {
-    if (node == nullptr) {
+void SkStrikeCache::attachStrike(Strike* strike) {
+    if (strike == nullptr) {
         return;
     }
     SkAutoSpinlock ac(fLock);
 
     this->validate();
-    node->fStrike.validate();
+    strike->fScalerCache.validate();
 
-    this->internalAttachToHead(node);
+    this->internalAttachToHead(strike);
     this->internalPurge();
 }
 
@@ -250,13 +206,13 @@
     return SkExclusiveStrikePtr(this->findAndDetachStrike(desc));
 }
 
-auto SkStrikeCache::findAndDetachStrike(const SkDescriptor& desc) -> Node* {
+auto SkStrikeCache::findAndDetachStrike(const SkDescriptor& desc) -> Strike* {
     SkAutoSpinlock ac(fLock);
 
-    for (Node* node = fHead; node != nullptr; node = node->fNext) {
-        if (node->fStrike.getDescriptor() == desc) {
-            this->internalDetachCache(node);
-            return node;
+    for (Strike* strike = fHead; strike != nullptr; strike = strike->fNext) {
+        if (strike->fScalerCache.getDescriptor() == desc) {
+            this->internalDetachStrike(strike);
+            return strike;
         }
     }
 
@@ -277,8 +233,8 @@
         const SkDescriptor& desc,
         std::unique_ptr<SkScalerContext> scaler,
         SkFontMetrics* maybeMetrics,
-        std::unique_ptr<SkStrikePinner> pinner) -> Node* {
-    return new Node{this, desc, std::move(scaler), maybeMetrics, std::move(pinner)};
+        std::unique_ptr<SkStrikePinner> pinner) -> Strike* {
+    return new Strike{this, desc, std::move(scaler), maybeMetrics, std::move(pinner)};
 }
 
 void SkStrikeCache::purgeAll() {
@@ -350,13 +306,13 @@
     return prevLimit;
 }
 
-void SkStrikeCache::forEachStrike(std::function<void(const SkStrike&)> visitor) const {
+void SkStrikeCache::forEachStrike(std::function<void(const Strike&)> visitor) const {
     SkAutoSpinlock ac(fLock);
 
     this->validate();
 
-    for (Node* node = fHead; node != nullptr; node = node->fNext) {
-        visitor(node->fStrike);
+    for (Strike* strike = fHead; strike != nullptr; strike = strike->fNext) {
+        visitor(*strike);
     }
 }
 
@@ -390,18 +346,18 @@
 
     // Start at the tail and proceed backwards deleting; the list is in LRU
     // order, with unimportant entries at the tail.
-    Node* node = fTail;
-    while (node != nullptr && (bytesFreed < bytesNeeded || countFreed < countNeeded)) {
-        Node* prev = node->fPrev;
+    Strike* strike = fTail;
+    while (strike != nullptr && (bytesFreed < bytesNeeded || countFreed < countNeeded)) {
+        Strike* prev = strike->fPrev;
 
         // Only delete if the strike is not pinned.
-        if (node->fPinner == nullptr || node->fPinner->canDelete()) {
-            bytesFreed += node->fStrike.getMemoryUsed();
+        if (strike->fPinner == nullptr || strike->fPinner->canDelete()) {
+            bytesFreed += strike->fScalerCache.getMemoryUsed();
             countFreed += 1;
-            this->internalDetachCache(node);
-            node->unref();
+            this->internalDetachStrike(strike);
+            strike->unref();
         }
-        node = prev;
+        strike = prev;
     }
 
     this->validate();
@@ -416,38 +372,38 @@
     return bytesFreed;
 }
 
-void SkStrikeCache::internalAttachToHead(Node* node) {
-    SkASSERT(nullptr == node->fPrev && nullptr == node->fNext);
+void SkStrikeCache::internalAttachToHead(Strike* strike) {
+    SkASSERT(nullptr == strike->fPrev && nullptr == strike->fNext);
     if (fHead) {
-        fHead->fPrev = node;
-        node->fNext = fHead;
+        fHead->fPrev = strike;
+        strike->fNext = fHead;
     }
-    fHead = node;
+    fHead = strike;
 
     if (fTail == nullptr) {
-        fTail = node;
+        fTail = strike;
     }
 
     fCacheCount += 1;
-    fTotalMemoryUsed += node->fStrike.getMemoryUsed();
+    fTotalMemoryUsed += strike->fScalerCache.getMemoryUsed();
 }
 
-void SkStrikeCache::internalDetachCache(Node* node) {
+void SkStrikeCache::internalDetachStrike(Strike* strike) {
     SkASSERT(fCacheCount > 0);
     fCacheCount -= 1;
-    fTotalMemoryUsed -= node->fStrike.getMemoryUsed();
+    fTotalMemoryUsed -= strike->fScalerCache.getMemoryUsed();
 
-    if (node->fPrev) {
-        node->fPrev->fNext = node->fNext;
+    if (strike->fPrev) {
+        strike->fPrev->fNext = strike->fNext;
     } else {
-        fHead = node->fNext;
+        fHead = strike->fNext;
     }
-    if (node->fNext) {
-        node->fNext->fPrev = node->fPrev;
+    if (strike->fNext) {
+        strike->fNext->fPrev = strike->fPrev;
     } else {
-        fTail = node->fPrev;
+        fTail = strike->fPrev;
     }
-    node->fPrev = node->fNext = nullptr;
+    strike->fPrev = strike->fNext = nullptr;
 }
 
 void SkStrikeCache::ValidateGlyphCacheDataSize() {
@@ -459,7 +415,7 @@
 #ifdef SK_DEBUG
 void SkStrikeCache::validateGlyphCacheDataSize() const {
     this->forEachStrike(
-            [](const SkStrike& cache) { cache.forceValidate();
+            [](const Strike& strike) { strike.fScalerCache.forceValidate();
     });
 }
 #endif
@@ -469,11 +425,11 @@
     size_t computedBytes = 0;
     int computedCount = 0;
 
-    const Node* node = fHead;
-    while (node != nullptr) {
-        computedBytes += node->fStrike.getMemoryUsed();
+    const Strike* strike = fHead;
+    while (strike != nullptr) {
+        computedBytes += strike->fScalerCache.getMemoryUsed();
         computedCount += 1;
-        node = node->fNext;
+        strike = strike->fNext;
     }
 
     // Can't use SkASSERTF because it looses thread annotations.
diff --git a/src/core/SkStrikeCache.h b/src/core/SkStrikeCache.h
index 89035bd..e589d00 100644
--- a/src/core/SkStrikeCache.h
+++ b/src/core/SkStrikeCache.h
@@ -14,7 +14,7 @@
 #include "include/private/SkSpinlock.h"
 #include "include/private/SkTemplates.h"
 #include "src/core/SkDescriptor.h"
-#include "src/core/SkStrike.h"
+#include "src/core/SkScalerCache.h"
 
 class SkTraceMemoryDump;
 
@@ -39,15 +39,102 @@
 };
 
 class SkStrikeCache final : public SkStrikeForGPUCacheInterface {
-    class Node;
-
 public:
     SkStrikeCache() = default;
     ~SkStrikeCache() override;
 
+    class Strike final : public SkRefCnt, public SkStrikeForGPU {
+    public:
+        Strike(SkStrikeCache* strikeCache,
+               const SkDescriptor& desc,
+               std::unique_ptr<SkScalerContext> scaler,
+               const SkFontMetrics* metrics,
+               std::unique_ptr<SkStrikePinner> pinner)
+                : fStrikeCache{strikeCache}
+                , fScalerCache{desc, std::move(scaler), metrics}
+                , fPinner{std::move(pinner)} {}
+
+        SkGlyph* mergeGlyphAndImage(SkPackedGlyphID toID, const SkGlyph& from) {
+            return fScalerCache.mergeGlyphAndImage(toID, from);
+        }
+
+        const SkPath* preparePath(SkGlyph* glyph, const SkPath* path) {
+            return fScalerCache.preparePath(glyph, path);
+        }
+
+        SkScalerContext* getScalerContext() const {
+            return fScalerCache.getScalerContext();
+        }
+
+        int countCachedGlyphs() {
+            return fScalerCache.countCachedGlyphs();
+        }
+
+        void findIntercepts(const SkScalar bounds[2], SkScalar scale, SkScalar xPos,
+                            SkGlyph* glyph, SkScalar* array, int* count) {
+            fScalerCache.findIntercepts(bounds, scale, xPos, glyph, array, count);
+        }
+
+        const SkFontMetrics& getFontMetrics() const {
+            return fScalerCache.getFontMetrics();
+        }
+
+        SkSpan<const SkGlyph*> metrics(SkSpan<const SkGlyphID> glyphIDs,
+                                       const SkGlyph* results[]) {
+            return fScalerCache.metrics(glyphIDs, results);
+        }
+
+        SkSpan<const SkGlyph*> preparePaths(SkSpan<const SkGlyphID> glyphIDs,
+                                            const SkGlyph* results[]) {
+            return fScalerCache.preparePaths(glyphIDs, results);
+        }
+
+        SkSpan<const SkGlyph*> prepareImages(SkSpan<const SkPackedGlyphID> glyphIDs,
+                                             const SkGlyph* results[]) {
+            return fScalerCache.prepareImages(glyphIDs, results);
+        }
+
+        void prepareForDrawingMasksCPU(SkDrawableGlyphBuffer* drawables) {
+            return fScalerCache.prepareForDrawingMasksCPU(drawables);
+        }
+
+        const SkGlyphPositionRoundingSpec& roundingSpec() const override {
+            return fScalerCache.roundingSpec();
+        }
+
+        const SkDescriptor& getDescriptor() const override {
+            return fScalerCache.getDescriptor();
+        }
+
+        void prepareForMaskDrawing(
+                SkDrawableGlyphBuffer* drawbles, SkSourceGlyphBuffer* rejects) override {
+            fScalerCache.prepareForMaskDrawing(drawbles, rejects);
+        }
+
+        void prepareForSDFTDrawing(
+                SkDrawableGlyphBuffer* drawbles, SkSourceGlyphBuffer* rejects) override {
+            fScalerCache.prepareForSDFTDrawing(drawbles, rejects);
+        }
+
+        void prepareForPathDrawing(
+                SkDrawableGlyphBuffer* drawbles, SkSourceGlyphBuffer* rejects) override {
+            fScalerCache.prepareForPathDrawing(drawbles, rejects);
+        }
+
+        void onAboutToExitScope() override {
+            fStrikeCache->attachStrike(this);
+        }
+
+        SkStrikeCache* const            fStrikeCache;
+        Strike*                         fNext{nullptr};
+        Strike*                         fPrev{nullptr};
+        SkScalerCache                   fScalerCache;
+        std::unique_ptr<SkStrikePinner> fPinner;
+    };  // Strike
+
     class ExclusiveStrikePtr {
     public:
-        explicit ExclusiveStrikePtr(Node*);
+        explicit ExclusiveStrikePtr(Strike*);
         ExclusiveStrikePtr();
         ExclusiveStrikePtr(const ExclusiveStrikePtr&) = delete;
         ExclusiveStrikePtr& operator = (const ExclusiveStrikePtr&) = delete;
@@ -55,16 +142,16 @@
         ExclusiveStrikePtr& operator = (ExclusiveStrikePtr&&);
         ~ExclusiveStrikePtr();
 
-        SkStrike* get() const;
-        SkStrike* operator -> () const;
-        SkStrike& operator *  () const;
+        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:
-        Node* fNode;
+        Strike* fStrike;
     };
 
     static SkStrikeCache* GlobalStrikeCache();
@@ -121,39 +208,40 @@
     void validate() const {}
 #endif
 
-    Node* findAndDetachStrike(const SkDescriptor&) SK_EXCLUDES(fLock);
-    Node* createStrike(
+    Strike* findAndDetachStrike(const SkDescriptor&) SK_EXCLUDES(fLock);
+    Strike* createStrike(
             const SkDescriptor& desc,
             std::unique_ptr<SkScalerContext> scaler,
             SkFontMetrics* maybeMetrics = nullptr,
             std::unique_ptr<SkStrikePinner> = nullptr);
-    Node* findOrCreateStrike(
+    Strike* findOrCreateStrike(
             const SkDescriptor& desc,
             const SkScalerContextEffects& effects,
             const SkTypeface& typeface) SK_EXCLUDES(fLock);
-    void attachNode(Node* node) SK_EXCLUDES(fLock);
+    void attachStrike(Strike* strike) SK_EXCLUDES(fLock);
 
     // The following methods can only be called when mutex is already held.
-    void internalDetachCache(Node*) SK_REQUIRES(fLock);
-    void internalAttachToHead(Node*) SK_REQUIRES(fLock);
+    void internalDetachStrike(Strike* strike) SK_REQUIRES(fLock);
+    void internalAttachToHead(Strike* strike) SK_REQUIRES(fLock);
 
     // Checkout budgets, modulated by the specified min-bytes-needed-to-purge,
     // and attempt to purge caches to match.
     // Returns number of bytes freed.
     size_t internalPurge(size_t minBytesNeeded = 0) SK_REQUIRES(fLock);
 
-    void forEachStrike(std::function<void(const SkStrike&)> visitor) const;
+    void forEachStrike(std::function<void(const Strike&)> visitor) const;
 
     mutable SkSpinlock fLock;
-    Node*              fHead SK_GUARDED_BY(fLock) {nullptr};
-    Node*              fTail SK_GUARDED_BY(fLock) {nullptr};
-    size_t             fCacheSizeLimit{SK_DEFAULT_FONT_CACHE_LIMIT};
-    size_t             fTotalMemoryUsed SK_GUARDED_BY(fLock) {0};
-    int32_t            fCacheCountLimit{SK_DEFAULT_FONT_CACHE_COUNT_LIMIT};
-    int32_t            fCacheCount SK_GUARDED_BY(fLock) {0};
-    int32_t            fPointSizeLimit{SK_DEFAULT_FONT_CACHE_POINT_SIZE_LIMIT};
+    Strike* fHead SK_GUARDED_BY(fLock) {nullptr};
+    Strike* fTail SK_GUARDED_BY(fLock) {nullptr};
+    size_t  fCacheSizeLimit{SK_DEFAULT_FONT_CACHE_LIMIT};
+    size_t  fTotalMemoryUsed SK_GUARDED_BY(fLock) {0};
+    int32_t fCacheCountLimit{SK_DEFAULT_FONT_CACHE_COUNT_LIMIT};
+    int32_t fCacheCount SK_GUARDED_BY(fLock) {0};
+    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/SkTypeface_remote.cpp b/src/core/SkTypeface_remote.cpp
index 7ae809a..21a4fc8 100644
--- a/src/core/SkTypeface_remote.cpp
+++ b/src/core/SkTypeface_remote.cpp
@@ -7,7 +7,7 @@
 
 #include "include/core/SkPaint.h"
 #include "src/core/SkRemoteGlyphCache.h"
-#include "src/core/SkStrike.h"
+#include "src/core/SkScalerCache.h"
 #include "src/core/SkStrikeCache.h"
 #include "src/core/SkTraceEvent.h"
 #include "src/core/SkTypeface_remote.h"
diff --git a/src/pdf/SkPDFDevice.cpp b/src/pdf/SkPDFDevice.cpp
index bb7554e..880dd43 100644
--- a/src/pdf/SkPDFDevice.cpp
+++ b/src/pdf/SkPDFDevice.cpp
@@ -32,8 +32,8 @@
 #include "src/core/SkImageFilter_Base.h"
 #include "src/core/SkMaskFilterBase.h"
 #include "src/core/SkRasterClip.h"
+#include "src/core/SkScalerCache.h"
 #include "src/core/SkScopeExit.h"
-#include "src/core/SkStrike.h"
 #include "src/core/SkStrikeSpec.h"
 #include "src/core/SkTextFormatParams.h"
 #include "src/core/SkXfermodeInterpretation.h"
diff --git a/src/pdf/SkPDFFont.cpp b/src/pdf/SkPDFFont.cpp
index 4fa981b..9869591 100644
--- a/src/pdf/SkPDFFont.cpp
+++ b/src/pdf/SkPDFFont.cpp
@@ -30,8 +30,8 @@
 #include "src/core/SkGlyph.h"
 #include "src/core/SkImagePriv.h"
 #include "src/core/SkMask.h"
+#include "src/core/SkScalerCache.h"
 #include "src/core/SkScalerContext.h"
-#include "src/core/SkStrike.h"
 #include "src/core/SkStrikeSpec.h"
 #include "src/pdf/SkPDFBitmap.h"
 #include "src/pdf/SkPDFDocumentPriv.h"
diff --git a/src/pdf/SkPDFFont.h b/src/pdf/SkPDFFont.h
index f047aa1..2c3c858 100644
--- a/src/pdf/SkPDFFont.h
+++ b/src/pdf/SkPDFFont.h
@@ -18,7 +18,6 @@
 #include <vector>
 
 class SkPDFDocument;
-class SkStrike;
 class SkString;
 
 /** \class SkPDFFont
diff --git a/src/pdf/SkPDFMakeCIDGlyphWidthsArray.cpp b/src/pdf/SkPDFMakeCIDGlyphWidthsArray.cpp
index 210202d..fdda294 100644
--- a/src/pdf/SkPDFMakeCIDGlyphWidthsArray.cpp
+++ b/src/pdf/SkPDFMakeCIDGlyphWidthsArray.cpp
@@ -9,7 +9,7 @@
 
 #include "include/core/SkPaint.h"
 #include "include/private/SkTo.h"
-#include "src/core/SkStrike.h"
+#include "src/core/SkScalerCache.h"
 #include "src/core/SkStrikeSpec.h"
 #include "src/pdf/SkPDFGlyphUse.h"
 
diff --git a/src/pdf/SkPDFMakeCIDGlyphWidthsArray.h b/src/pdf/SkPDFMakeCIDGlyphWidthsArray.h
index 041fe28..fd541c2 100644
--- a/src/pdf/SkPDFMakeCIDGlyphWidthsArray.h
+++ b/src/pdf/SkPDFMakeCIDGlyphWidthsArray.h
@@ -9,7 +9,6 @@
 
 #include "src/pdf/SkPDFTypes.h"
 
-class SkStrike;
 class SkPDFGlyphUse;
 class SkTypeface;
 
diff --git a/tests/SkRemoteGlyphCacheTest.cpp b/tests/SkRemoteGlyphCacheTest.cpp
index 64cc8b3..96f94d7 100644
--- a/tests/SkRemoteGlyphCacheTest.cpp
+++ b/tests/SkRemoteGlyphCacheTest.cpp
@@ -11,7 +11,7 @@
 #include "include/private/SkMutex.h"
 #include "src/core/SkDraw.h"
 #include "src/core/SkRemoteGlyphCache.h"
-#include "src/core/SkStrike.h"
+#include "src/core/SkScalerCache.h"
 #include "src/core/SkStrikeCache.h"
 #include "src/core/SkStrikeSpec.h"
 #include "src/core/SkSurfacePriv.h"
diff --git a/tests/SkStrikeTest.cpp b/tests/SkScalerCacheTest.cpp
similarity index 89%
rename from tests/SkStrikeTest.cpp
rename to tests/SkScalerCacheTest.cpp
index f7876e0..20480f4 100644
--- a/tests/SkStrikeTest.cpp
+++ b/tests/SkScalerCacheTest.cpp
@@ -7,7 +7,7 @@
 
 #include "include/core/SkFont.h"
 #include "include/core/SkTypeface.h"
-#include "src/core/SkStrike.h"
+#include "src/core/SkScalerCache.h"
 #include "src/core/SkStrikeSpec.h"
 #include "src/core/SkTaskGroup.h"
 #include "tests/Test.h"
@@ -27,7 +27,7 @@
     std::atomic<int> fThreadCount;
 };
 
-DEF_TEST(SkStrikeMultiThread, Reporter) {
+DEF_TEST(SkScalerCacheMultiThread, Reporter) {
     sk_sp<SkTypeface> typeface =
             ToolUtils::create_portable_typeface("serif", SkFontStyle::Italic());
     static constexpr int kThreadCount = 4;
@@ -59,7 +59,7 @@
         SkScalerContextEffects effects;
         std::unique_ptr<SkScalerContext> ctx{
                 typeface->createScalerContext(effects, &strikeSpec.descriptor())};
-        SkStrike strike{strikeSpec.descriptor(), std::move(ctx)};
+        SkScalerCache scalerCache{strikeSpec.descriptor(), std::move(ctx)};
 
         auto perThread = [&](int threadIndex) {
             barrier.waitForAll();
@@ -73,8 +73,8 @@
                 rejects.setSource(local);
 
                 drawable.startDevice(rejects.source(), {0, 0}, SkMatrix::I(),
-                                     strike.roundingSpec());
-                strike.prepareForMaskDrawing(&drawable, &rejects);
+                                     scalerCache.roundingSpec());
+                scalerCache.prepareForMaskDrawing(&drawable, &rejects);
                 rejects.flipRejectsToSource();
                 drawable.reset();
             }