@shopify/react-native-skia 2.0.4 → 2.0.6

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

@@ -8,6 +8,10 @@
 #ifndef SkPathTypes_DEFINED
 #define SkPathTypes_DEFINED
 
+#include "include/core/SkTypes.h"
+
+#include <cstdint>
+
 enum class SkPathFillType {
     /** Specifies that "inside" is computed by a non-zero sum of signed edge crossings */
     kWinding,
@@ -45,7 +49,7 @@ enum SkPathSegmentMask {
     kCubic_SkPathSegmentMask  = 1 << 3,
 };
 
-enum class SkPathVerb {
+enum class SkPathVerb : uint8_t {
     kMove,   //!< SkPath::RawIter returns 1 point
     kLine,   //!< SkPath::RawIter returns 2 points
     kQuad,   //!< SkPath::RawIter returns 3 points

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

@@ -27,7 +27,7 @@ class SkCanvas;
 class SkDrawable;
 class SkPicture;
 class SkRecord;
-class SkRecorder;
+class SkRecordCanvas;
 
 class SK_API SkPictureRecorder {
 public:
@@ -102,11 +102,11 @@ private:
     friend class SkPictureRecorderReplayTester; // for unit testing
     void partialReplay(SkCanvas* canvas) const;
 
-    bool                        fActivelyRecording;
-    SkRect                      fCullRect;
-    sk_sp<SkBBoxHierarchy>      fBBH;
-    std::unique_ptr<SkRecorder> fRecorder;
-    sk_sp<SkRecord>             fRecord;
+    sk_sp<SkBBoxHierarchy> fBBH;
+    std::unique_ptr<SkRecordCanvas> fRecorder;
+    sk_sp<SkRecord> fRecord;
+    SkRect fCullRect;
+    bool fActivelyRecording;
 
     SkPictureRecorder(SkPictureRecorder&&) = delete;
     SkPictureRecorder& operator=(SkPictureRecorder&&) = delete;

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

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2025 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#ifndef SkRecorder_DEFINED
+#define SkRecorder_DEFINED
+
+#include "include/private/base/SkAPI.h"
+
+namespace skcpu {
+class Recorder;
+}
+
+class SK_API SkRecorder {
+public:
+    SkRecorder() = default;
+    virtual ~SkRecorder() = default;
+    SkRecorder(const SkRecorder&) = delete;
+    SkRecorder(SkRecorder&&) = delete;
+    SkRecorder& operator=(const SkRecorder&) = delete;
+
+    enum class Type {
+        kCPU,
+        kGanesh,
+        kGraphite,
+    };
+
+    virtual Type type() const = 0;
+
+    virtual skcpu::Recorder* cpuRecorder() = 0;
+};
+
+#endif

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

@@ -10,6 +10,7 @@
 
 #include "include/core/SkPoint.h"
 #include "include/core/SkSize.h"
+#include "include/core/SkSpan.h"
 #include "include/core/SkTypes.h"
 #include "include/private/base/SkFloatingPoint.h"
 #include "include/private/base/SkSafe32.h"
@@ -19,6 +20,7 @@
 #include <cmath>
 #include <cstdint>
 #include <cstring>
+#include <optional>
 
 struct SkRect;
 class SkString;
@@ -571,6 +573,13 @@ struct SK_API SkIRect {
         return MakeLTRB(std::min(fLeft, fRight), std::min(fTop, fBottom),
                         std::max(fLeft, fRight), std::max(fTop, fBottom));
     }
+
+    /** Returns pointer to first int32 in SkIRect, to treat it as an array with four
+        entries.
+
+        @return  pointer to fLeft
+    */
+    const int32_t* asInt32s() const { return &fLeft; }
 };
 
 /** \struct SkRect
@@ -870,43 +879,64 @@ struct SK_API SkRect {
         fBottom = bottom;
     }
 
-    /** Sets to bounds of SkPoint array with count entries. If count is zero or smaller,
-        or if SkPoint array contains an infinity or NaN, sets to (0, 0, 0, 0).
-
-        Result is either empty or sorted: fLeft is less than or equal to fRight, and
-        fTop is less than or equal to fBottom.
+    /**
+     * Compute the bounds of the span of points.
+     * If the span is empty, returns the empty-rect {0, 0, 0, 0.
+     * If the span contains non-finite values (inf or nan), returns {}
+     */
+    static std::optional<SkRect> Bounds(SkSpan<const SkPoint> pts);
 
-        @param pts    SkPoint array
-        @param count  entries in array
-    */
-    void setBounds(const SkPoint pts[], int count) {
-        (void)this->setBoundsCheck(pts, count);
+    static SkRect BoundsOrEmpty(SkSpan<const SkPoint> pts) {
+        if (auto bounds = Bounds(pts)) {
+            return bounds.value();
+        } else {
+            return MakeEmpty();
+        }
     }
 
-    /** Sets to bounds of SkPoint array with count entries. Returns false if count is
-        zero or smaller, or if SkPoint array contains an infinity or NaN; in these cases
-        sets SkRect to (0, 0, 0, 0).
+    /** Sets to bounds of SkPoint array with count entries. If count is zero or smaller,
+        or if SkPoint array contains an infinity or NaN, sets to (0, 0, 0, 0).
 
         Result is either empty or sorted: fLeft is less than or equal to fRight, and
         fTop is less than or equal to fBottom.
 
-        @param pts    SkPoint array
-        @param count  entries in array
-        @return       true if all SkPoint values are finite
-
-        example: https://fiddle.skia.org/c/@Rect_setBoundsCheck
+        @param pts    SkPoint span
     */
-    bool setBoundsCheck(const SkPoint pts[], int count);
-
-    /** Sets to bounds of SkPoint pts array with count entries. If any SkPoint in pts
-        contains infinity or NaN, all SkRect dimensions are set to NaN.
+    void setBounds(SkSpan<const SkPoint> pts) {
+        (void)this->setBoundsCheck(pts);
+    }
 
-        @param pts    SkPoint array
-        @param count  entries in array
+    /** Sets to bounds of the span of points, and return true (if all point values were finite).
+     *
+     * If the span is empty, set the rect to empty() and return true.
+     * If any point contains an infinity or NaN, set the rect to empty and return false.
+     *
+     * @param pts    SkPoint span
+     * example: https://fiddle.skia.org/c/@Rect_setBoundsCheck
+     */
+    bool setBoundsCheck(SkSpan<const SkPoint> pts);
+
+    /** Sets to bounds of the span of points.
+     *
+     * If the span is empty, set the rect to empty().
+     * If any point contains an infinity or NaN, set the rect to NaN.
+     *
+     * @param pts    SkPoint span
+     * example: https://fiddle.skia.org/c/@Rect_setBoundsNoCheck
+     */
+    void setBoundsNoCheck(SkSpan<const SkPoint> pts);
 
-        example: https://fiddle.skia.org/c/@Rect_setBoundsNoCheck
-    */
-    void setBoundsNoCheck(const SkPoint pts[], int count);
+#ifdef SK_SUPPORT_UNSPANNED_APIS
+    void setBounds(const SkPoint pts[], int count) {
+        this->setBounds({pts, count});
+    }
+    void setBoundsNoCheck(const SkPoint pts[], int count) {
+        this->setBoundsNoCheck({pts, count});
+    }
+    bool setBoundsCheck(const SkPoint pts[], int count) {
+        return this->setBoundsCheck({pts, count});
+    }
+#endif
 
     /** Sets bounds to the smallest SkRect enclosing SkPoint p0 and p1. The result is
         sorted and may be empty. Does not check to see if values are finite.

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

@@ -626,7 +626,7 @@ private:
     struct RunHead;
 
     static RunHead* emptyRunHeadPtr() { return (SkRegion::RunHead*) -1; }
-    static constexpr RunHead* kRectRunHeadPtr = nullptr;
+    static constexpr const RunHead* const kRectRunHeadPtr = nullptr;
 
     // allocate space for count runs
     void allocateRuns(int count);

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

@@ -25,13 +25,14 @@ class GrBackendSemaphore;
 class GrBackendTexture;
 class GrRecordingContext;
 class GrSurfaceCharacterization;
-enum GrSurfaceOrigin : int;
 class SkBitmap;
 class SkCanvas;
 class SkCapabilities;
 class SkColorSpace;
 class SkPaint;
+class SkRecorder;
 class SkSurface;
+enum GrSurfaceOrigin : int;
 struct SkIRect;
 struct SkISize;
 
@@ -226,6 +227,12 @@ public:
      */
     skgpu::graphite::Recorder* recorder() const;
 
+    /** Returns the base SkRecorder being used by the SkSurface.
+
+        @return the recorder; should be non-null for drawable surfaces
+    */
+    SkRecorder* baseRecorder() const;
+
     enum class BackendHandleAccess {
         kFlushRead,     //!< back-end object is readable
         kFlushWrite,    //!< back-end object is writable

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

@@ -10,9 +10,12 @@
 
 #include "include/core/SkFont.h"
 #include "include/core/SkFontTypes.h"
+#include "include/core/SkPoint.h"
+#include "include/core/SkRSXform.h"
 #include "include/core/SkRect.h"
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkScalar.h"
+#include "include/core/SkSpan.h"
 #include "include/core/SkTypes.h"
 #include "include/private/base/SkDebug.h"
 #include "include/private/base/SkTemplates.h"
@@ -25,8 +28,6 @@ class SkData;
 class SkPaint;
 class SkTypeface;
 struct SkDeserialProcs;
-struct SkPoint;
-struct SkRSXform;
 struct SkSerialProcs;
 
 namespace sktext {
@@ -133,8 +134,9 @@ public:
         @return        new textblob or nullptr
      */
     static sk_sp<SkTextBlob> MakeFromPosTextH(const void* text, size_t byteLength,
-                                      const SkScalar xpos[], SkScalar constY, const SkFont& font,
-                                      SkTextEncoding encoding = SkTextEncoding::kUTF8);
+                                              SkSpan<const SkScalar> xpos, SkScalar constY,
+                                              const SkFont& font,
+                                              SkTextEncoding encoding = SkTextEncoding::kUTF8);
 
     /** Returns a textblob built from a single run of text with positions.
         This is equivalent to using SkTextBlobBuilder and calling allocRunPos().
@@ -148,13 +150,33 @@ public:
         @return        new textblob or nullptr
      */
     static sk_sp<SkTextBlob> MakeFromPosText(const void* text, size_t byteLength,
-                                             const SkPoint pos[], const SkFont& font,
+                                             SkSpan<const SkPoint> pos, const SkFont& font,
                                              SkTextEncoding encoding = SkTextEncoding::kUTF8);
 
     static sk_sp<SkTextBlob> MakeFromRSXform(const void* text, size_t byteLength,
-                                             const SkRSXform xform[], const SkFont& font,
+                                             SkSpan<const SkRSXform> xform, const SkFont& font,
                                              SkTextEncoding encoding = SkTextEncoding::kUTF8);
 
+    // Helpers for glyphs
+
+    static sk_sp<SkTextBlob> MakeFromPosHGlyphs(SkSpan<const SkGlyphID> glyphs,
+                                                SkSpan<const SkScalar> xpos, SkScalar constY,
+                                                const SkFont& font) {
+        return MakeFromPosTextH(glyphs.data(), glyphs.size() * sizeof(SkGlyphID), xpos, constY,
+                                font, SkTextEncoding::kGlyphID);
+    }
+    static sk_sp<SkTextBlob> MakeFromPosGlyphs(SkSpan<const SkGlyphID> glyphs,
+                                               SkSpan<const SkPoint> pos, const SkFont& font) {
+        return MakeFromPosText(glyphs.data(), glyphs.size() * sizeof(SkGlyphID), pos, font,
+                               SkTextEncoding::kGlyphID);
+    }
+    static sk_sp<SkTextBlob> MakeFromRSXformGlyphs(SkSpan<const SkGlyphID> glyphs,
+                                                   SkSpan<const SkRSXform> xform,
+                                                   const SkFont& font) {
+        return MakeFromRSXform(glyphs.data(), glyphs.size() * sizeof(SkGlyphID), xform, font,
+                               SkTextEncoding::kGlyphID);
+    }
+
     /** Writes data to allow later reconstruction of SkTextBlob. memory points to storage
         to receive the encoded data, and memory_size describes the size of storage.
         Returns bytes used if provided storage is large enough to hold all data;
@@ -240,6 +262,28 @@ public:
         const RunRecord* fRunRecord;
     };
 
+#ifdef SK_SUPPORT_UNSPANNED_APIS
+    static sk_sp<SkTextBlob> MakeFromPosTextH(const void* text, size_t byteLength,
+                                              const SkScalar xpos[], SkScalar constY,
+                                              const SkFont& font,
+                                              SkTextEncoding encoding = SkTextEncoding::kUTF8) {
+        const size_t worstCaseCount = byteLength;
+        return MakeFromPosTextH(text, byteLength, {xpos, worstCaseCount}, constY, font, encoding);
+    }
+    static sk_sp<SkTextBlob> MakeFromPosText(const void* text, size_t byteLength,
+                                             const SkPoint pos[], const SkFont& font,
+                                             SkTextEncoding encoding = SkTextEncoding::kUTF8) {
+        const size_t worstCaseCount = byteLength;
+        return MakeFromPosText(text, byteLength, {pos, worstCaseCount}, font, encoding);
+    }
+    static sk_sp<SkTextBlob> MakeFromRSXform(const void* text, size_t byteLength,
+                                              const SkRSXform xform[], const SkFont& font,
+                                              SkTextEncoding encoding = SkTextEncoding::kUTF8) {
+        const size_t worstCaseCount = byteLength;
+        return MakeFromRSXform(text, byteLength, {xform, worstCaseCount}, font, encoding);
+    }
+#endif
+
 private:
     friend class SkNVRefCnt<SkTextBlob>;
 

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

@@ -104,6 +104,13 @@ public:
      */
     virtual void dumpBudgetedState(const char* /*dumpName*/, bool /*isBudgeted*/) {}
 
+    /**
+     * Returns true if we should dump sizeless non-texture objects (e.g. Samplers, pipelines, etc).
+     * Memoryless textures are always dumped. This call is only used when dumping Graphite memory
+     * statistics.
+     */
+    virtual bool shouldDumpSizelessObjects() const { return false; }
+
 protected:
     virtual ~SkTraceMemoryDump() = default;
     SkTraceMemoryDump() = default;

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

@@ -14,6 +14,7 @@
 #include "include/core/SkFourByteTag.h"
 #include "include/core/SkRect.h"
 #include "include/core/SkRefCnt.h"
+#include "include/core/SkSpan.h"
 #include "include/core/SkString.h"
 #include "include/core/SkTypes.h"
 #include "include/private/SkWeakRefCnt.h"
@@ -68,31 +69,28 @@ public:
 
     /** Copy into 'coordinates' (allocated by the caller) the design variation coordinates.
      *
-     *  @param coordinates the buffer into which to write the design variation coordinates.
-     *  @param coordinateCount the number of entries available through 'coordinates'.
+     *  @param coordinates the span into which to write the design variation coordinates.
      *
      *  @return The number of axes, or -1 if there is an error.
-     *  If 'coordinates != nullptr' and 'coordinateCount >= numAxes' then 'coordinates' will be
+     *  If 'coordinates.size() >= numAxes' then 'coordinates' will be
      *  filled with the variation coordinates describing the position of this typeface in design
      *  variation space. It is possible the number of axes can be retrieved but actual position
      *  cannot.
      */
-    int getVariationDesignPosition(SkFontArguments::VariationPosition::Coordinate coordinates[],
-                                   int coordinateCount) const;
+    int getVariationDesignPosition(
+                       SkSpan<SkFontArguments::VariationPosition::Coordinate> coordinates) const;
 
     /** Copy into 'parameters' (allocated by the caller) the design variation parameters.
      *
-     *  @param parameters the buffer into which to write the design variation parameters.
-     *  @param coordinateCount the number of entries available through 'parameters'.
+     *  @param parameters the span into which to write the design variation parameters.
      *
      *  @return The number of axes, or -1 if there is an error.
-     *  If 'parameters != nullptr' and 'parameterCount >= numAxes' then 'parameters' will be
+     *  If 'parameters.size() >= numAxes' then 'parameters' will be
      *  filled with the variation parameters describing the position of this typeface in design
      *  variation space. It is possible the number of axes can be retrieved but actual parameters
      *  cannot.
      */
-    int getVariationDesignParameters(SkFontParameters::Variation::Axis parameters[],
-                                     int parameterCount) const;
+    int getVariationDesignParameters(SkSpan<SkFontParameters::Variation::Axis> parameters) const;
 
     /** Return a 32bit value for this typeface, unique for the underlying font
         data. Will never return 0.
@@ -149,14 +147,13 @@ public:
     /**
      *  Given an array of UTF32 character codes, return their corresponding glyph IDs.
      *
-     *  @param chars pointer to the array of UTF32 chars
-     *  @param number of chars and glyphs
+     *  @param unis span of UTF32 chars
      *  @param glyphs returns the corresponding glyph IDs for each character.
      */
-    void unicharsToGlyphs(const SkUnichar uni[], int count, SkGlyphID glyphs[]) const;
+    void unicharsToGlyphs(SkSpan<const SkUnichar> unis, SkSpan<SkGlyphID> glyphs) const;
 
-    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;
 
     /**
      *  Return the glyphID that corresponds to the specified unicode code-point
@@ -179,10 +176,10 @@ public:
 
     /** Copy into tags[] (allocated by the caller) the list of table tags in
      *  the font, and return the number. This will be the same as CountTables()
-     *  or 0 if an error occured. If tags == NULL, this only returns the count
+     *  or 0 if an error occured. If tags is empty, this only returns the count
      *  (the same as calling countTables()).
      */
-    int getTableTags(SkFontTableTag tags[]) const;
+    int readTableTags(SkSpan<SkFontTableTag> tags) const;
 
     /** Given a table tag, return the size of its contents, or 0 if not present
      */
@@ -232,22 +229,22 @@ public:
      *  typeface's units per em (see getUnitsPerEm).
      *
      *  Some typefaces are known to never support kerning. Calling this method
-     *  with all zeros (e.g. getKerningPairAdustments(NULL, 0, NULL)) returns
+     *  with empty spans (e.g. getKerningPairAdustments({}, {})) returns
      *  a boolean indicating if the typeface might support kerning. If it
      *  returns false, then it will always return false (no kerning) for all
      *  possible glyph runs. If it returns true, then it *may* return true for
-     *  somne glyph runs.
+     *  some glyph runs.
      *
-     *  If count is non-zero, then the glyphs parameter must point to at least
-     *  [count] valid glyph IDs, and the adjustments parameter must be
-     *  sized to at least [count - 1] entries. If the method returns true, then
-     *  [count-1] entries in the adjustments array will be set. If the method
-     *  returns false, then no kerning should be applied, and the adjustments
+     *  If the method returns true, and there are 1 or more glyphs in the span, then
+     *  this will return in adjustments N values,
+     *  where N = min(glyphs.size() - 1, adjustments.size()).
+
+     *  If the method returns false, then no kerning should be applied, and the adjustments
      *  array will be in an undefined state (possibly some values may have been
      *  written, but none of them should be interpreted as valid values).
      */
-    bool getKerningPairAdjustments(const SkGlyphID glyphs[], int count,
-                                   int32_t adjustments[]) const;
+    bool getKerningPairAdjustments(SkSpan<const SkGlyphID> glyphs,
+                                   SkSpan<int32_t> adjustments) const;
 
     struct LocalizedString {
         SkString fString;
@@ -350,7 +347,37 @@ public:
             FactoryId id,
             sk_sp<SkTypeface> (*make)(std::unique_ptr<SkStreamAsset>, const SkFontArguments&));
 
+#ifdef SK_SUPPORT_UNSPANNED_APIS
+public:
+    int getVariationDesignPosition(SkFontArguments::VariationPosition::Coordinate coordinates[],
+                                   int count) const {
+        return this->getVariationDesignPosition({coordinates, count});
+    }
+    int getVariationDesignParameters(SkFontParameters::Variation::Axis parameters[],
+                                     int count) const {
+        return this->getVariationDesignParameters({parameters, count});
+    }
+    void unicharsToGlyphs(const SkUnichar unis[], int count, SkGlyphID glyphs[]) const {
+        this->unicharsToGlyphs({unis, count}, {glyphs, count});
+    }
+    int textToGlyphs(const void* text, size_t byteLength, SkTextEncoding encoding,
+                     SkGlyphID glyphs[], int maxGlyphCount) const {
+        return (int)this->textToGlyphs(text, byteLength, encoding, {glyphs, maxGlyphCount});
+    }
+    int getTableTags(SkFontTableTag tags[]) const {
+        const size_t count = tags ? MAX_REASONABLE_TABLE_COUNT : 0;
+        return this->readTableTags({tags, count});
+    }
+    bool getKerningPairAdjustments(const SkGlyphID glyphs[], int count,
+                                   int32_t adjustments[]) const {
+        return this->getKerningPairAdjustments({glyphs, count}, {adjustments, count});
+    }
+#endif
+
 protected:
+    // needed until onGetTableTags() is updated to take a span
+    enum { MAX_REASONABLE_TABLE_COUNT = (1 << 16) - 1 };
+
     explicit SkTypeface(const SkFontStyle& style, bool isFixedPitch = false);
     ~SkTypeface() override;
 

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

@@ -96,6 +96,7 @@
 #if defined(SK_HISTOGRAM_ENUMERATION)  || \
     defined(SK_HISTOGRAM_BOOLEAN)      || \
     defined(SK_HISTOGRAM_EXACT_LINEAR) || \
+    defined(SK_HISTOGRAM_CUSTOM_EXACT_LINEAR) || \
     defined(SK_HISTOGRAM_MEMORY_KB)    || \
     defined(SK_HISTOGRAM_CUSTOM_COUNTS)|| \
     defined(SK_HISTOGRAM_CUSTOM_MICROSECONDS_TIMES)
@@ -116,6 +117,11 @@
 #  define SK_HISTOGRAM_EXACT_LINEAR(name, sample, valueMax)
 #endif
 
+#ifndef SK_HISTOGRAM_CUSTOM_EXACT_LINEAR
+#  define SK_HISTOGRAM_CUSTOM_EXACT_LINEAR(name, sample, value_min, \
+                                           value_max, bucket_count)
+#endif
+
 #ifndef SK_HISTOGRAM_MEMORY_KB
 #  define SK_HISTOGRAM_MEMORY_KB(name, sample)
 #endif

package/cpp/skia/include/effects/SkDashPathEffect.h

@@ -8,12 +8,12 @@
 #ifndef SkDashPathEffect_DEFINED
 #define SkDashPathEffect_DEFINED
 
+#include "include/core/SkPathEffect.h"  // IWYU pragma: keep    (for unspanned apis)
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkScalar.h"
+#include "include/core/SkSpan.h"
 #include "include/core/SkTypes.h"
 
-class SkPathEffect;
-
 class SK_API SkDashPathEffect {
 public:
     /** intervals: array containing an even number of entries (>=2), with
@@ -37,7 +37,13 @@ public:
 
         Note: only affects stroked paths.
     */
-    static sk_sp<SkPathEffect> Make(const SkScalar intervals[], int count, SkScalar phase);
+    static sk_sp<SkPathEffect> Make(SkSpan<const SkScalar> intervals, SkScalar phase);
+
+#ifdef SK_SUPPORT_UNSPANNED_APIS
+    static sk_sp<SkPathEffect> Make(const SkScalar intervals[], int count, SkScalar phase) {
+        return intervals ? Make({intervals, count}, phase) : nullptr;
+    }
+#endif
 };
 
 #endif

package/cpp/skia/include/effects/SkRuntimeEffect.h

@@ -139,7 +139,7 @@ public:
         // When not 0, this field allows Skia to assign a stable key to a known runtime effect
         uint32_t fStableKey = 0;
 
-        // TODO(skia:11209) - Replace this with a promised SkCapabilities?
+        // TODO(skbug.com/40042585) - Replace this with a promised SkCapabilities?
         // This flag lifts the ES2 restrictions on Runtime Effects that are gated by the
         // `strictES2Mode` check. Be aware that the software renderer and pipeline-stage effect are
         // still largely ES3-unaware and can still fail or crash if post-ES2 features are used.

package/cpp/skia/include/encode/SkEncoder.h

@@ -22,7 +22,7 @@ public:
      * A single frame to be encoded into an animated image.
      *
      * If a frame does not fit in the canvas size, this is an error.
-     * TODO(skia:13705): Add offsets when we have support for an encoder that supports using
+     * TODO(skbug.com/40044793): Add offsets when we have support for an encoder that supports using
      * offsets.
      */
     struct SK_API Frame {

package/cpp/skia/include/encode/SkICC.h

@@ -26,7 +26,7 @@ SK_API sk_sp<SkData> SkWriteICCProfile(const skcms_ICCProfile*, const char* desc
 // Utility function for populating the grid_16 member of skcms_A2B and skcms_B2A
 // structures. This converts a point in XYZD50 to its representation in grid_16_lab.
 // It will write 6 bytes. The behavior of this function matches how skcms will decode
-// values, but might not match the specification, see https://crbug.com/skia/13807.
+// values, but might not match the specification, see skbug.com/40044907.
 SK_API void SkICCFloatXYZD50ToGrid16Lab(const float* float_xyz, uint8_t* grid16_lab);
 
 // Utility function for popluating the table_16 member of skcms_Curve structure.

package/cpp/skia/include/gpu/ganesh/GrDirectContext.h

@@ -515,7 +515,30 @@ public:
 
     bool supportsDistanceFieldText() const;
 
+    /**
+     * Returns true if the underlying Vulkan implementation can accurately detect when the data in
+     * the pipeline cache changes. Returns false on non-Vulkan implementations.
+     *
+     * When this is false, the return value of `hasNewVkPipelineCacheData` will occasionally issue a
+     * false positive.
+     */
+    bool canDetectNewVkPipelineCacheData() const;
+    /**
+     * For Vulkan implementations, returns true if the data in the pipeline cache could have changed
+     * since the last call to `storeVkPipelineCacheData`. Always returns true on non-Vulkan
+     * implementations.
+     *
+     * Pipeline cache changes are detected when creating new pipelines, however this will
+     * occasionally result in a false positive. When VK_EXT_pipeline_creation_cache_control is
+     * enabled, we additionally know when a pipeline creation does not change the cache, thus
+     * eliminating false-positives.
+     *
+     * Check `canDetectNewVkPipelineCacheData` to see whether VK_EXT_pipeline_creation_cache_control
+     * is available and enabled.
+     */
+    bool hasNewVkPipelineCacheData() const;
     void storeVkPipelineCacheData();
+    void storeVkPipelineCacheData(size_t maxSize);
 
     /**
      * Retrieve the default GrBackendFormat for a given SkColorType and renderability.

package/cpp/skia/include/gpu/ganesh/GrRecordingContext.h

@@ -33,6 +33,13 @@ class GrThreadSafeCache;
 class SkArenaAlloc;
 class SkCapabilities;
 class SkJSONWriter;
+class SkGaneshRecorder;
+class SkRecorder;
+
+namespace skcpu {
+class ContextImpl;
+class Recorder;
+}  // namespace skcpu
 
 namespace sktext::gpu {
 class SubRunAllocator;
@@ -99,6 +106,9 @@ public:
 
     SK_API sk_sp<const SkCapabilities> skCapabilities() const;
 
+    SK_API SkRecorder* asRecorder();
+    SK_API std::unique_ptr<skcpu::Recorder> makeCPURecorder();
+
     // Provides access to functions that aren't part of the public API.
     GrRecordingContextPriv priv();
     const GrRecordingContextPriv priv() const;  // NOLINT(readability-const-return-type)
@@ -269,6 +279,8 @@ private:
 
     std::unique_ptr<GrDrawingManager> fDrawingManager;
     std::unique_ptr<GrProxyProvider>  fProxyProvider;
+    std::unique_ptr<const skcpu::ContextImpl> fCPUContext;
+    std::unique_ptr<SkGaneshRecorder> fRecorder;
 
 #if defined(GPU_TEST_UTILS)
     int fSuppressWarningMessages = 0;