diff --git a/src/core/SkGlyphRunPainter.cpp b/src/core/SkGlyphRunPainter.cpp
index 72a89f6..5a6da46 100644
--- a/src/core/SkGlyphRunPainter.cpp
+++ b/src/core/SkGlyphRunPainter.cpp
@@ -306,14 +306,12 @@
                 fStrikeCache->findOrCreateScopedStrike(
                         *ad.getDesc(), effects, *runFont.getTypefaceOrDefault());
 
-        size_t drawableGlyphCount = strike->glyphMetrics(fARGBGlyphsIDs.data(),
-                                                         fARGBPositions.data(),
-                                                         fARGBGlyphsIDs.size(),
-                                                         fGlyphPos);
+        SkSpan<const SkGlyphPos> glyphPosSpan = strike->glyphMetrics(fARGBGlyphsIDs.data(),
+                                                                     fARGBPositions.data(),
+                                                                     fARGBGlyphsIDs.size(),
+                                                                     fGlyphPos);
         if (process) {
-            process->processDeviceFallback(
-                    SkSpan<const SkGlyphPos>{fGlyphPos, drawableGlyphCount},
-                    strike.get());
+            process->processDeviceFallback(glyphPosSpan, strike.get());
         }
 
     } else {
@@ -352,11 +350,10 @@
                 fStrikeCache->findOrCreateScopedStrike(
                         *ad.getDesc(), effects, *fallbackFont.getTypefaceOrDefault());
 
-        SkPoint* posCursor = fARGBPositions.data();
         int glyphCount = 0;
         for (size_t i = 0; i < fARGBGlyphsIDs.size(); i++) {
             SkGlyphID glyphID = fARGBGlyphsIDs[i];
-            SkPoint pos = *posCursor++;
+            SkPoint pos = fARGBPositions[i];
             const SkGlyph& glyph = strike->getGlyphMetrics(glyphID, {0, 0});
             fGlyphPos[glyphCount++] = {i, &glyph, pos};
         }
@@ -555,12 +552,11 @@
             mapping.postTranslate(rounding.x(), rounding.y());
             mapping.mapPoints(fPositions, glyphRun.positions().data(), glyphRun.runSize());
 
-            size_t drawableGlyphCount = strike->glyphMetrics(
+            SkSpan<const SkGlyphPos> glyphPosSpan = strike->glyphMetrics(
                     glyphRun.glyphsIDs().data(), fPositions, glyphRun.runSize(), fGlyphPos);
 
             size_t glyphsWithMaskCount = 0;
-            for (size_t i = 0; i < drawableGlyphCount; i++) {
-                SkGlyphPos glyphPos = fGlyphPos[i];
+            for (const SkGlyphPos& glyphPos : glyphPosSpan) {
                 const SkGlyph& glyph = *glyphPos.glyph;
                 const SkPoint position = glyphPos.position;
                 if (!SkScalarsAreFinite(position.x(), position.y())) {
diff --git a/src/core/SkRemoteGlyphCache.cpp b/src/core/SkRemoteGlyphCache.cpp
index 381057d..5abb37c 100644
--- a/src/core/SkRemoteGlyphCache.cpp
+++ b/src/core/SkRemoteGlyphCache.cpp
@@ -610,13 +610,12 @@
 
 // This version of glyphMetrics only adds entries to result if their data need to be sent to the
 // GPU process.
-size_t SkStrikeServer::SkGlyphCacheState::glyphMetrics(
+SkSpan<const SkGlyphPos> SkStrikeServer::SkGlyphCacheState::glyphMetrics(
         const SkGlyphID glyphIDs[], const SkPoint positions[], size_t n, SkGlyphPos result[]) {
 
     size_t glyphsToSendCount = 0;
-    const SkPoint* posCursor = positions;
     for (size_t i = 0; i < n; i++) {
-        SkPoint glyphPos = *posCursor++;
+        SkPoint glyphPos = positions[i];
         SkGlyphID glyphID = glyphIDs[i];
         SkIPoint lookupPoint = SkStrikeCommon::SubpixelLookup(fAxisAlignmentForHText, glyphPos);
         SkPackedGlyphID packedGlyphID = fIsSubpixel ? SkPackedGlyphID{glyphID, lookupPoint}
@@ -642,7 +641,7 @@
         }
     }
 
-    return glyphsToSendCount;
+    return SkSpan<const SkGlyphPos>{result, glyphsToSendCount};
 }
 
 // SkStrikeClient -----------------------------------------
diff --git a/src/core/SkRemoteGlyphCacheImpl.h b/src/core/SkRemoteGlyphCacheImpl.h
index 0341f6a..c7f5acf 100644
--- a/src/core/SkRemoteGlyphCacheImpl.h
+++ b/src/core/SkRemoteGlyphCacheImpl.h
@@ -43,7 +43,8 @@
 
     const SkGlyph& getGlyphMetrics(SkGlyphID glyphID, SkPoint position) override;
 
-    size_t glyphMetrics(const SkGlyphID[], const SkPoint[], size_t n, SkGlyphPos result[]) override;
+    SkSpan<const SkGlyphPos> glyphMetrics(
+            const SkGlyphID[], const SkPoint[], size_t n, SkGlyphPos result[]) override;
 
     bool decideCouldDrawFromPath(const SkGlyph& glyph) override;
 
diff --git a/src/core/SkStrike.cpp b/src/core/SkStrike.cpp
index bc672f4..236d721 100644
--- a/src/core/SkStrike.cpp
+++ b/src/core/SkStrike.cpp
@@ -233,15 +233,13 @@
 
 // N.B. This glyphMetrics call culls all the glyphs which will not display based on a non-finite
 // position or that there are no mask pixels.
-size_t SkStrike::glyphMetrics(const SkGlyphID glyphIDs[],
-                              const SkPoint positions[],
-                              size_t n,
-                              SkGlyphPos result[]) {
-
+SkSpan<const SkGlyphPos> SkStrike::glyphMetrics(const SkGlyphID glyphIDs[],
+                                                const SkPoint positions[],
+                                                size_t n,
+                                                SkGlyphPos result[]) {
     size_t drawableGlyphCount = 0;
-    const SkPoint* posCursor = positions;
     for (size_t i = 0; i < n; i++) {
-        SkPoint glyphPos = *posCursor++;
+        SkPoint glyphPos = positions[i];
         if (SkScalarsAreFinite(glyphPos.x(), glyphPos.y())) {
             const SkGlyph& glyph = this->getGlyphMetrics(glyphIDs[i], glyphPos);
             if (!glyph.isEmpty()) {
@@ -250,7 +248,7 @@
         }
     }
 
-    return drawableGlyphCount;
+    return SkSpan<const SkGlyphPos>{result, drawableGlyphCount};
 }
 
 #include "../pathops/SkPathOpsCubic.h"
diff --git a/src/core/SkStrike.h b/src/core/SkStrike.h
index 1e9cac5..1f17b14 100644
--- a/src/core/SkStrike.h
+++ b/src/core/SkStrike.h
@@ -136,7 +136,8 @@
                             this->getScalerContext()->getEffects()};
     }
 
-    size_t glyphMetrics(const SkGlyphID[], const SkPoint[], size_t n, SkGlyphPos result[]) override;
+    SkSpan<const SkGlyphPos> glyphMetrics(
+            const SkGlyphID[], const SkPoint[], size_t n, SkGlyphPos result[]) override;
 
     void onAboutToExitScope() override;
 
diff --git a/src/core/SkStrikeCache.cpp b/src/core/SkStrikeCache.cpp
index b1da46a..f5da322 100644
--- a/src/core/SkStrikeCache.cpp
+++ b/src/core/SkStrikeCache.cpp
@@ -36,7 +36,7 @@
         return fStrike.getGlyphMetrics(glyphID, position);
     }
 
-    size_t glyphMetrics(
+    SkSpan<const SkGlyphPos> glyphMetrics(
             const SkGlyphID id[], const SkPoint point[], size_t n, SkGlyphPos result[]) override {
         return fStrike.glyphMetrics(id, point, n, result);
     }
diff --git a/src/core/SkStrikeInterface.h b/src/core/SkStrikeInterface.h
index 08ce683..0353b0a 100644
--- a/src/core/SkStrikeInterface.h
+++ b/src/core/SkStrikeInterface.h
@@ -71,7 +71,7 @@
     virtual SkStrikeSpec strikeSpec() const = 0;
 
     // glyphMetrics writes its results to result, but only returns a subspan of result.
-    virtual size_t glyphMetrics(
+    virtual SkSpan<const SkGlyphPos> glyphMetrics(
             const SkGlyphID[], const SkPoint[], size_t n, SkGlyphPos result[]) = 0;
     virtual const SkGlyph& getGlyphMetrics(SkGlyphID glyphID, SkPoint position) = 0;
     virtual bool decideCouldDrawFromPath(const SkGlyph& glyph) = 0;