@shopify/react-native-skia 2.0.5 → 2.0.6

package/cpp/skia/include/core/SkCanvas.h

@@ -19,6 +19,7 @@
 #include "include/core/SkMatrix.h"
 #include "include/core/SkPaint.h"
 #include "include/core/SkPoint.h"
+#include "include/core/SkRSXform.h" // IWYU pragma: keep    (for unspanned apis)
 #include "include/core/SkRasterHandleAllocator.h"
 #include "include/core/SkRect.h"
 #include "include/core/SkRefCnt.h"
@@ -68,6 +69,7 @@ class SkPicture;
 class SkPixmap;
 class SkRRect;
 class SkRegion;
+class SkRecorder;
 class SkShader;
 class SkSpecialImage;
 class SkSurface;
@@ -75,7 +77,6 @@ class SkSurface_Base;
 class SkTextBlob;
 class SkVertices;
 struct SkDrawShadowRec;
-struct SkRSXform;
 
 template<typename E>
 class SkEnumBitMask;
@@ -327,13 +328,18 @@ public:
      */
     virtual GrRecordingContext* recordingContext() const;
 
-
     /** Returns Recorder for the GPU surface associated with SkCanvas.
 
         @return  Recorder, if available; nullptr otherwise
      */
     virtual skgpu::graphite::Recorder* recorder() const;
 
+    /** Returns Recorder for the surface associated with SkCanvas.
+
+        @return  Recorder, should be non-null
+     */
+    virtual SkRecorder* baseRecorder() const;
+
     /** Sometimes a canvas is owned by a surface. If it is, getSurface() will return a bare
      *  pointer to that surface, else this will return nullptr.
      */
@@ -1321,7 +1327,12 @@ public:
 
         example: https://fiddle.skia.org/c/@Canvas_drawPoints
     */
-    void drawPoints(PointMode mode, size_t count, const SkPoint pts[], const SkPaint& paint);
+    void drawPoints(PointMode mode, SkSpan<const SkPoint>, const SkPaint& paint);
+#ifdef SK_SUPPORT_UNSPANNED_APIS
+    void drawPoints(PointMode mode, size_t count, const SkPoint pts[], const SkPaint& paint) {
+        this->drawPoints(mode, {pts, count}, paint);
+    }
+#endif
 
     /** Draws point at (x, y) using clip, SkMatrix and SkPaint paint.
 
@@ -1893,19 +1904,28 @@ public:
        SkColorFilter, and SkImageFilter; apply to text. By
        default, draws filled black glyphs.
 
-       @param count           number of glyphs to draw
-       @param glyphs          the array of glyphIDs to draw
+       @param glyphs          the span of glyphIDs to draw
        @param positions       where to draw each glyph relative to origin
-       @param clusters        array of size count of cluster information
-       @param textByteCount   size of the utf8text
+       @param clusters        cluster information
        @param utf8text        utf8text supporting information for the glyphs
        @param origin          the origin of all the positions
        @param font            typeface, text size and so, used to describe the text
        @param paint           blend, color, and so on, used to draw
     */
+    void drawGlyphs(SkSpan<const SkGlyphID> glyphs, SkSpan<const SkPoint> positions,
+                    SkSpan<const uint32_t> clusters, SkSpan<const char> utf8text,
+                    SkPoint origin, const SkFont& font, const SkPaint& paint);
+#ifdef SK_SUPPORT_UNSPANNED_APIS
     void drawGlyphs(int count, const SkGlyphID glyphs[], const SkPoint positions[],
                     const uint32_t clusters[], int textByteCount, const char utf8text[],
-                    SkPoint origin, const SkFont& font, const SkPaint& paint);
+                    SkPoint origin, const SkFont& font, const SkPaint& paint) {
+        this->drawGlyphs({glyphs,    count},
+                         {positions, count},
+                         {clusters,  count},
+                         {utf8text,  textByteCount},
+                         origin, font, paint);
+    }
+#endif
 
     /** Draws count glyphs, at positions relative to origin styled with font and paint.
 
@@ -1925,8 +1945,14 @@ public:
         @param font        typeface, text size and so, used to describe the text
         @param paint       blend, color, and so on, used to draw
     */
-    void drawGlyphs(int count, const SkGlyphID glyphs[], const SkPoint positions[],
+    void drawGlyphs(SkSpan<const SkGlyphID> glyphs, SkSpan<const SkPoint> positions,
                     SkPoint origin, const SkFont& font, const SkPaint& paint);
+#ifdef SK_SUPPORT_UNSPANNED_APIS
+    void drawGlyphs(int count, const SkGlyphID glyphs[], const SkPoint positions[],
+                    SkPoint origin, const SkFont& font, const SkPaint& paint) {
+        this->drawGlyphs({glyphs, count}, {positions, count}, origin, font, paint);
+    }
+#endif
 
     /** Draws count glyphs, at positions relative to origin styled with font and paint.
 
@@ -1947,8 +1973,14 @@ public:
         @param font     typeface, text size and so, used to describe the text
         @param paint    blend, color, and so on, used to draw
     */
+    void drawGlyphsRSXform(SkSpan<const SkGlyphID> glyphs, SkSpan<const SkRSXform> xforms,
+                           SkPoint origin, const SkFont& font, const SkPaint& paint);
+#ifdef SK_SUPPORT_UNSPANNED_APIS
     void drawGlyphs(int count, const SkGlyphID glyphs[], const SkRSXform xforms[],
-                    SkPoint origin, const SkFont& font, const SkPaint& paint);
+                    SkPoint origin, const SkFont& font, const SkPaint& paint) {
+        this->drawGlyphsRSXform({glyphs, count}, {xforms, count}, origin, font, paint);
+    }
+#endif
 
     /** Draws SkTextBlob blob at (x, y), using clip, SkMatrix, and SkPaint paint.
 
@@ -2155,7 +2187,9 @@ public:
 
         SkMaskFilter and SkPathEffect on paint are ignored.
 
-        xform, tex, and colors if present, must contain count entries.
+        For non-empty spans, the number of draws will be the min of
+        xform.size(), tex.size(), and (if not empty) colors.size().
+
         Optional colors are applied for each sprite using SkBlendMode mode, treating
         sprite as source and colors as destination.
         Optional cullRect is a conservative bounds of all transformed sprites.
@@ -2167,15 +2201,25 @@ public:
         @param xform     SkRSXform mappings for sprites in atlas
         @param tex       SkRect locations of sprites in atlas
         @param colors    one per sprite, blended with sprite using SkBlendMode; may be nullptr
-        @param count     number of sprites to draw
         @param mode      SkBlendMode combining colors and sprites
         @param sampling  SkSamplingOptions used when sampling from the atlas image
         @param cullRect  bounds of transformed sprites for efficient clipping; may be nullptr
         @param paint     SkColorFilter, SkImageFilter, SkBlendMode, and so on; may be nullptr
     */
+    void drawAtlas(const SkImage* atlas, SkSpan<const SkRSXform> xform,
+                   SkSpan<const SkRect> tex, SkSpan<const SkColor> colors, SkBlendMode mode,
+                   const SkSamplingOptions& sampling, const SkRect* cullRect, const SkPaint* paint);
+#ifdef SK_SUPPORT_UNSPANNED_APIS
     void drawAtlas(const SkImage* atlas, const SkRSXform xform[], const SkRect tex[],
                    const SkColor colors[], int count, SkBlendMode mode,
-                   const SkSamplingOptions& sampling, const SkRect* cullRect, const SkPaint* paint);
+                   const SkSamplingOptions& samp, const SkRect* cullRect, const SkPaint* paint) {
+        this->drawAtlas(atlas,
+                        {xform, count},
+                        {tex, tex ? count : 0},
+                        {colors, colors ? count : 0},
+                        mode, samp, cullRect, paint);
+    }
+#endif
 
     /** Draws SkDrawable drawable using clip and SkMatrix, concatenated with
         optional matrix.

package/cpp/skia/include/core/SkContourMeasure.h

@@ -8,6 +8,7 @@
 #ifndef SkContourMeasure_DEFINED
 #define SkContourMeasure_DEFINED
 
+#include "include/core/SkPathTypes.h" // IWYU pragma: keep
 #include "include/core/SkPoint.h"
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkScalar.h"
@@ -21,7 +22,6 @@
 
 class SkMatrix;
 class SkPath;
-enum class SkPathVerb;
 
 class SK_API SkContourMeasure : public SkRefCnt {
 public:

package/cpp/skia/include/core/SkData.h

@@ -9,68 +9,83 @@
 #define SkData_DEFINED
 
 #include "include/core/SkRefCnt.h"
+#include "include/core/SkSpan.h"
 #include "include/private/base/SkAPI.h"
-#include "include/private/base/SkAssert.h"
 
+#include <cstddef>
 #include <cstdint>
 #include <cstdio>
 
 class SkStream;
 
 /**
- *  SkData holds an immutable data buffer. Not only is the data immutable,
- *  but the actual ptr that is returned (by data() or bytes()) is guaranteed
- *  to always be the same for the life of this instance.
+ *  SkData holds a data buffer. It can be created to allocate its own buffer
+ *  for the contents, or to share a pointer to the client's buffer. The size and
+ *  address of the contents never change for the lifetime of the data object.
  */
 class SK_API SkData final : public SkNVRefCnt<SkData> {
 public:
     /**
-     *  Returns the number of bytes stored.
+     *  Returns true if this and rhs are the same size, and contain the same contents.
+     *  All empty objects compare as equal.
      */
-    size_t size() const { return fSize; }
+    bool operator==(const SkData& rhs) const;
+    bool operator!=(const SkData& rhs) const { return !(*this == rhs); }
 
-    bool isEmpty() const { return 0 == fSize; }
+    /**
+     * Calls == operator, but first checks if other is null (in which case it returns false)
+     */
+    bool equals(const SkData* other) const {
+        return (other != nullptr) && *this == *other;
+    }
 
     /**
-     *  Returns the ptr to the data.
+     *  Returns the number of bytes stored.
      */
-    const void* data() const { return fPtr; }
+    size_t size() const { return fSpan.size(); }
 
     /**
-     *  Like data(), returns a read-only ptr into the data, but in this case
-     *  it is cast to uint8_t*, to make it easy to add an offset to it.
+     *  Returns the ptr to the data.
      */
-    const uint8_t* bytes() const {
-        return reinterpret_cast<const uint8_t*>(fPtr);
-    }
+    const void* data() const { return fSpan.data(); }
+
+    bool empty() const { return fSpan.empty(); }
+
+    const uint8_t* bytes() const { return reinterpret_cast<const uint8_t*>(this->data()); }
+
+    SkSpan<const uint8_t> byteSpan() const { return {this->bytes(), this->size()}; }
 
     /**
      *  USE WITH CAUTION.
-     *  This call will assert that the refcnt is 1, as a precaution against modifying the
-     *  contents when another client/thread has access to the data.
+     *  Be sure other 'owners' of this object are not accessing it in aother thread.
      */
     void* writable_data() {
-        if (fSize) {
-            // only assert we're unique if we're not empty
-            SkASSERT(this->unique());
-        }
-        return const_cast<void*>(fPtr);
+        return fSpan.data();
     }
 
+    /** Attempt to create a deep copy of the original data, using the default allocator.
+     *
+     *  If  offset+length > this->size(), then this returns nullptr.
+     */
+    sk_sp<SkData> copySubset(size_t offset, size_t length) const;
+
+    /** Attempt to return a data that is a reference to a subset of the original data,
+     *  This will never make a deep copy of the contents, but will retain a reference
+     *  to the original data object.
+     *
+     *  If  offset+length > this->size(), then this returns nullptr.
+     */
+    sk_sp<SkData> shareSubset(size_t offset, size_t length);
+    sk_sp<const SkData> shareSubset(size_t offset, size_t length) const;
+
     /**
      *  Helper to copy a range of the data into a caller-provided buffer.
      *  Returns the actual number of bytes copied, after clamping offset and
-     *  length to the size of the data. If buffer is NULL, it is ignored, and
+     *  length to the size of this data. If buffer is NULL, it is ignored, and
      *  only the computed number of bytes is returned.
      */
     size_t copyRange(size_t offset, size_t length, void* buffer) const;
 
-    /**
-     *  Returns true if these two objects have the same length and contents,
-     *  effectively returning 0 == memcmp(...)
-     */
-    bool equals(const SkData* other) const;
-
     /**
      *  Function that, if provided, will be called when the SkData goes out
      *  of scope, allowing for custom allocation/freeing of the data's contents.
@@ -111,7 +126,7 @@ public:
 
     /**
      *  Call this when the data parameter is already const and will outlive the lifetime of the
-     *  SkData. Suitable for with const globals.
+     *  SkData. Suitable for globals.
      */
     static sk_sp<SkData> MakeWithoutCopy(const void* data, size_t length) {
         return MakeWithProc(data, length, NoopReleaseProc, nullptr);
@@ -155,10 +170,17 @@ public:
     static sk_sp<SkData> MakeFromStream(SkStream*, size_t size);
 
     /**
-     *  Create a new dataref using a subset of the data in the specified
-     *  src dataref.
+     *  DEPRECATED variant of src->shareSubset(offset, length)
+     *
+     *  This variant checks if shaerSubset() returned null (because offset or length were out-of-range)
+     *  and returns an empty SkData, rather than returning null.
      */
-    static sk_sp<SkData> MakeSubset(const SkData* src, size_t offset, size_t length);
+    static sk_sp<SkData> MakeSubset(const SkData* src, size_t offset, size_t length) {
+        if (sk_sp<SkData> dst = const_cast<SkData*>(src)->shareSubset(offset, length)) {
+            return dst;
+        }
+        return SkData::MakeEmpty();
+    }
 
     /**
      *  Returns a new empty dataref (or a reference to a shared empty dataref).
@@ -166,14 +188,18 @@ public:
      */
     static sk_sp<SkData> MakeEmpty();
 
+    /**
+     *  DEPRECATED -- use empty()
+     */
+    bool isEmpty() const { return fSpan.empty(); }
+
 private:
     friend class SkNVRefCnt<SkData>;
-    ReleaseProc fReleaseProc;
-    void*       fReleaseProcContext;
-    const void* fPtr;
-    size_t      fSize;
+    ReleaseProc         fReleaseProc;
+    void*               fReleaseProcContext;
+    SkSpan<std::byte>   fSpan;
 
-    SkData(const void* ptr, size_t size, ReleaseProc, void* context);
+    SkData(SkSpan<std::byte>, ReleaseProc, void* context);
     explicit SkData(size_t size);   // inplace new/delete
     ~SkData();
 

package/cpp/skia/include/core/SkFont.h

@@ -8,9 +8,11 @@
 #ifndef SkFont_DEFINED
 #define SkFont_DEFINED
 
+#include "include/core/SkPoint.h" // IWYU pragma: keep    (for unspanned apis)
 #include "include/core/SkRect.h"
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkScalar.h"
+#include "include/core/SkSpan.h"
 #include "include/core/SkTypeface.h"
 #include "include/core/SkTypes.h"
 #include "include/private/base/SkTo.h"
@@ -18,7 +20,6 @@
 
 #include <cstddef>
 #include <cstdint>
-#include <type_traits>
 #include <vector>
 
 class SkMatrix;
@@ -27,7 +28,6 @@ class SkPath;
 enum class SkFontHinting;
 enum class SkTextEncoding;
 struct SkFontMetrics;
-struct SkPoint;
 
 /** \class SkFont
     SkFont controls options applied when drawing and measuring text.
@@ -271,7 +271,7 @@ public:
     /** Converts text into glyph indices.
         Returns the number of glyph indices represented by text.
         SkTextEncoding specifies how text represents characters or glyphs.
-        glyphs may be nullptr, to compute the glyph count.
+        glyphs may be empty, to compute the glyph count.
 
         Does not check text for valid character codes or valid glyph indices.
 
@@ -287,17 +287,16 @@ public:
         mapping from the SkTypeface and maps characters not found in the
         SkTypeface to zero.
 
-        If maxGlyphCount is not sufficient to store all the glyphs, no glyphs are copied.
+        If glyphs.size() is not sufficient to store all the glyphs, no glyphs are copied.
         The total glyph count is returned for subsequent buffer reallocation.
 
         @param text          character storage encoded with SkTextEncoding
         @param byteLength    length of character storage in bytes
-        @param glyphs        storage for glyph indices; may be nullptr
-        @param maxGlyphCount storage capacity
-        @return              number of glyphs represented by text of length byteLength
+        @param glyphs        storage for glyph indices; may be empty
+        @return number of glyphs represented by text of length byteLength
     */
-    int textToGlyphs(const void* text, size_t byteLength, SkTextEncoding encoding,
-                     SkGlyphID glyphs[], int maxGlyphCount) const;
+    size_t textToGlyphs(const void* text, size_t byteLength, SkTextEncoding encoding,
+                        SkSpan<SkGlyphID> glyphs) const;
 
     /** Returns glyph index for Unicode character.
 
@@ -308,7 +307,7 @@ public:
     */
     SkGlyphID unicharToGlyph(SkUnichar uni) const;
 
-    void unicharsToGlyphs(const SkUnichar uni[], int count, SkGlyphID glyphs[]) const;
+    void unicharsToGlyphs(SkSpan<const SkUnichar> src, SkSpan<SkGlyphID> dst) const;
 
     /** Returns number of glyphs represented by text.
 
@@ -320,8 +319,8 @@ public:
         @param byteLength    length of character storage in bytes
         @return              number of glyphs represented by text of length byteLength
     */
-    int countText(const void* text, size_t byteLength, SkTextEncoding encoding) const {
-        return this->textToGlyphs(text, byteLength, encoding, nullptr, 0);
+    size_t countText(const void* text, size_t byteLength, SkTextEncoding encoding) const {
+        return this->textToGlyphs(text, byteLength, encoding, {});
     }
 
     /** Returns the advance width of text.
@@ -352,99 +351,80 @@ public:
     SkScalar measureText(const void* text, size_t byteLength, SkTextEncoding encoding,
                          SkRect* bounds, const SkPaint* paint) const;
 
-    /** DEPRECATED
-        Retrieves the advance and bounds for each glyph in glyphs.
-        Both widths and bounds may be nullptr.
-        If widths is not nullptr, widths must be an array of count entries.
-        if bounds is not nullptr, bounds must be an array of count entries.
-
-        @param glyphs      array of glyph indices to be measured
-        @param count       number of glyphs
-        @param widths      returns text advances for each glyph; may be nullptr
-        @param bounds      returns bounds for each glyph relative to (0, 0); may be nullptr
-    */
-    void getWidths(const SkGlyphID glyphs[], int count, SkScalar widths[], SkRect bounds[]) const {
-        this->getWidthsBounds(glyphs, count, widths, bounds, nullptr);
-    }
-
-    // DEPRECATED
-    void getWidths(const SkGlyphID glyphs[], int count, SkScalar widths[], std::nullptr_t) const {
-        this->getWidths(glyphs, count, widths);
-    }
-
     /** Retrieves the advance and bounds for each glyph in glyphs.
-        Both widths and bounds may be nullptr.
-        If widths is not nullptr, widths must be an array of count entries.
-        if bounds is not nullptr, bounds must be an array of count entries.
+        widths receives min(widths.size(), glyphs.size()) values.
+        bounds receives min(bounds.size(), glyphs.size()) values.
 
         @param glyphs      array of glyph indices to be measured
-        @param count       number of glyphs
         @param widths      returns text advances for each glyph
+        @param bounds      returns bounds for each glyph relative to (0, 0)
+        @param paint       optional, specifies stroking, SkPathEffect and SkMaskFilter
      */
-    void getWidths(const SkGlyphID glyphs[], int count, SkScalar widths[]) const {
-        this->getWidthsBounds(glyphs, count, widths, nullptr, nullptr);
-    }
+    void getWidthsBounds(SkSpan<const SkGlyphID> glyphs, SkSpan<SkScalar> widths, SkSpan<SkRect> bounds,
+                         const SkPaint* paint) const;
 
     /** Retrieves the advance and bounds for each glyph in glyphs.
-        Both widths and bounds may be nullptr.
-        If widths is not nullptr, widths must be an array of count entries.
-        if bounds is not nullptr, bounds must be an array of count entries.
+        widths receives min(widths.size(), glyphs.size()) values.
 
         @param glyphs      array of glyph indices to be measured
-        @param count       number of glyphs
-        @param widths      returns text advances for each glyph; may be nullptr
-        @param bounds      returns bounds for each glyph relative to (0, 0); may be nullptr
-        @param paint       optional, specifies stroking, SkPathEffect and SkMaskFilter
+        @param widths      returns text advances for each glyph
      */
-    void getWidthsBounds(const SkGlyphID glyphs[], int count, SkScalar widths[], SkRect bounds[],
-                         const SkPaint* paint) const;
-
+    void getWidths(SkSpan<const SkGlyphID> glyphs, SkSpan<SkScalar> widths) const {
+        this->getWidthsBounds(glyphs, widths, {}, nullptr);
+    }
+    SkScalar getWidth(SkGlyphID glyph) const {
+        SkScalar width;
+        this->getWidthsBounds({&glyph, 1}, {&width, 1}, {}, nullptr);
+        return width;
+    }
 
     /** Retrieves the bounds for each glyph in glyphs.
-        bounds must be an array of count entries.
+        bounds receives min(bounds.size(), glyphs.size()) values.
         If paint is not nullptr, its stroking, SkPathEffect, and SkMaskFilter fields are respected.
 
         @param glyphs      array of glyph indices to be measured
-        @param count       number of glyphs
         @param bounds      returns bounds for each glyph relative to (0, 0); may be nullptr
         @param paint       optional, specifies stroking, SkPathEffect, and SkMaskFilter
      */
-    void getBounds(const SkGlyphID glyphs[], int count, SkRect bounds[],
+    void getBounds(SkSpan<const SkGlyphID> glyphs, SkSpan<SkRect> bounds,
                    const SkPaint* paint) const {
-        this->getWidthsBounds(glyphs, count, nullptr, bounds, paint);
+        this->getWidthsBounds(glyphs, {}, bounds, paint);
+    }
+    SkRect getBounds(SkGlyphID glyph, const SkPaint* paint) const {
+        SkRect bounds;
+        this->getBounds({&glyph, 1}, {&bounds, 1}, paint);
+        return bounds;
     }
 
-    /** Retrieves the positions for each glyph, beginning at the specified origin. The caller
-        must allocated at least count number of elements in the pos[] array.
+    /** Retrieves the positions for each glyph, beginning at the specified origin.
+        pos receives min(pos.size(), glyphs.size()) values.
 
         @param glyphs   array of glyph indices to be positioned
-        @param count    number of glyphs
         @param pos      returns glyphs positions
         @param origin   location of the first glyph. Defaults to {0, 0}.
      */
-    void getPos(const SkGlyphID glyphs[], int count, SkPoint pos[], SkPoint origin = {0, 0}) const;
+    void getPos(SkSpan<const SkGlyphID> glyphs, SkSpan<SkPoint> pos, SkPoint origin = {0, 0}) const;
 
-    /** Retrieves the x-positions for each glyph, beginning at the specified origin. The caller
-        must allocated at least count number of elements in the xpos[] array.
+    /** Retrieves the x-positions for each glyph, beginning at the specified origin.
+        xpos receives min(xpos.size(), glyphs.size()) values.
 
         @param glyphs   array of glyph indices to be positioned
-        @param count    number of glyphs
         @param xpos     returns glyphs x-positions
         @param origin   x-position of the first glyph. Defaults to 0.
      */
-    void getXPos(const SkGlyphID glyphs[], int count, SkScalar xpos[], SkScalar origin = 0) const;
+    void getXPos(SkSpan<const SkGlyphID> glyphs, SkSpan<SkScalar> xpos, SkScalar origin = 0) const;
 
     /** Returns intervals [start, end] describing lines parallel to the advance that intersect
      *  with the glyphs.
      *
      *  @param glyphs   the glyphs to intersect
-     *  @param count    the number of glyphs and positions
      *  @param pos      the position of each glyph
      *  @param top      the top of the line intersecting
      *  @param bottom   the bottom of the line intersecting
         @return         array of pairs of x values [start, end]. May be empty.
      */
-    std::vector<SkScalar> getIntercepts(const SkGlyphID glyphs[], int count, const SkPoint pos[],
+    std::vector<SkScalar> getIntercepts(SkSpan<const SkGlyphID> glyphs,
+                                        SkSpan<const SkPoint> pos,
                                         SkScalar top, SkScalar bottom,
                                         const SkPaint* = nullptr) const;
 
@@ -462,11 +442,10 @@ public:
     /** Returns path corresponding to glyph array.
 
         @param glyphIDs      array of glyph indices
-        @param count         number of glyphs
         @param glyphPathProc function returning one glyph description as path
         @param ctx           function context
    */
-    void getPaths(const SkGlyphID glyphIDs[], int count,
+    void getPaths(SkSpan<const SkGlyphID> glyphIDs,
                   void (*glyphPathProc)(const SkPath* pathOrNull, const SkMatrix& mx, void* ctx),
                   void* ctx) const;
 
@@ -500,6 +479,56 @@ public:
 
     using sk_is_trivially_relocatable = std::true_type;
 
+#ifdef SK_SUPPORT_UNSPANNED_APIS
+    int textToGlyphs(const void* text, size_t byteLength, SkTextEncoding encoding,
+                     SkGlyphID glyphs[], int maxGlyphCount) const {
+        return (int)this->textToGlyphs(text, byteLength, encoding, {glyphs, maxGlyphCount});
+    }
+    void unicharsToGlyphs(const SkUnichar uni[], int count, SkGlyphID glyphs[]) const {
+        this->unicharsToGlyphs({uni, count}, {glyphs, count});
+    }
+
+    void getPos(const SkGlyphID glyphs[], int count, SkPoint pos[], SkPoint origin = {0, 0}) const {
+        this->getPos({glyphs, count}, {pos, count}, origin);
+    }
+    void getXPos(const SkGlyphID glyphs[], int count, SkScalar xpos[], SkScalar origin = 0) const {
+        this->getXPos({glyphs, count}, {xpos, count}, origin);
+    }
+    void getPaths(const SkGlyphID glyphIDs[], int count,
+                  void (*glyphPathProc)(const SkPath* pathOrNull, const SkMatrix& mx, void* ctx),
+                  void* ctx) const {
+        this->getPaths({glyphIDs, count}, glyphPathProc, ctx);
+    }
+    void getWidthsBounds(const SkGlyphID glyphs[], int count, SkScalar widths[], SkRect bounds[],
+                         const SkPaint* paint) const {
+        const auto nw = widths ? count : 0;
+        const auto nb = bounds ? count : 0;
+        this->getWidthsBounds({glyphs, count}, {widths, nw}, {bounds, nb}, paint);
+    }
+    void getWidths(const SkGlyphID glyphs[], int count, SkScalar widths[], SkRect bounds[]) const {
+        const auto nw = widths ? count : 0;
+        const auto nb = bounds ? count : 0;
+        this->getWidthsBounds({glyphs, count}, {widths, nw}, {bounds, nb}, nullptr);
+    }
+    void getWidths(const SkGlyphID glyphs[], int count, SkScalar widths[], std::nullptr_t) const {
+        this->getWidthsBounds({glyphs, count}, {widths, count}, {}, nullptr);
+    }
+    void getWidths(const SkGlyphID glyphs[], int count, SkScalar widths[]) const {
+        this->getWidthsBounds({glyphs, count}, {widths, count}, {}, nullptr);
+    }
+    void getBounds(const SkGlyphID glyphs[], int count, SkRect bounds[],
+                   const SkPaint* paint) const {
+        this->getWidthsBounds({glyphs, count}, {}, {bounds, count}, paint);
+    }
+
+    std::vector<SkScalar> getIntercepts(const SkGlyphID glyphs[], int count, const SkPoint pos[],
+                                        SkScalar top, SkScalar bottom,
+                                        const SkPaint* paint = nullptr) const {
+        return this->getIntercepts({glyphs, count}, {pos, count}, top, bottom, paint);
+    }
+#endif
+
+
 private:
     enum PrivFlags {
         kForceAutoHinting_PrivFlag      = 1 << 0,