@shopify/react-native-skia 2.0.0-next.3 → 2.0.0-next.4

package/cpp/skia/include/codec/SkCodec.h

@@ -784,12 +784,46 @@ public:
      *
      *  As such, future decoding calls may require a rewind.
      *
-     *  For still (non-animated) image codecs, this will return 0.
+     *  `getRepetitionCount` will return `0` in two cases:
+     *  1. Still (non-animated) images.
+     *  2. Animated images that only play the animation once (i.e. that don't
+     *     repeat the animation)
+     *  `isAnimated` can be used to disambiguate between these two cases.
      */
     int getRepetitionCount() {
         return this->onGetRepetitionCount();
     }
 
+    /**
+     * `isAnimated` returns whether the full input is expected to contain an
+     * animated image (i.e. more than 1 image frame).  This can be used to
+     * disambiguate the meaning of `getRepetitionCount` returning `0` (see
+     * `getRepetitionCount`'s doc comment for more details).
+     *
+     * Note that in some codecs `getFrameCount()` only returns the number of
+     * frames for which all the metadata has been already successfully decoded.
+     * Therefore for a partial input `isAnimated()` may return "yes", even
+     * though `getFrameCount()` may temporarily return `1` until more of the
+     * input is available.
+     *
+     * When handling partial input, some codecs may not know until later (e.g.
+     * until encountering additional image frames) whether the given image has
+     * more than one frame.  Such codecs may initially return
+     * `IsAnimated::kUnknown` and only later give a definitive "yes" or "no"
+     * answer.  GIF format is one example where this may happen.
+     *
+     * Other codecs may be able to decode the information from the metadata
+     * present before the first image frame.  Such codecs should be able to give
+     * a definitive "yes" or "no" answer as soon as they are constructed.  PNG
+     * format is one example where this happens.
+     */
+    enum class IsAnimated {
+        kYes,
+        kNo,
+        kUnknown,
+    };
+    IsAnimated isAnimated() { return this->onIsAnimated(); }
+
     // Register a decoder at runtime by passing two function pointers:
     //    - peek() to return true if the span of bytes appears to be your encoded format;
     //    - make() to attempt to create an SkCodec from the given stream.
@@ -937,6 +971,10 @@ protected:
         return 0;
     }
 
+    virtual IsAnimated onIsAnimated() {
+        return IsAnimated::kNo;
+    }
+
 private:
     const SkEncodedInfo                fEncodedInfo;
     XformFormat                        fSrcXformFormat;

package/cpp/skia/include/config/SkUserConfig.h

@@ -80,16 +80,6 @@
 */
 //#define SK_CANVAS_SAVE_RESTORE_PREALLOC_COUNT 32
 
-/* Determines whether to build code that supports the Ganesh GPU backend. Some classes
-   that are not GPU-specific, such as SkShader subclasses, have optional code
-   that is used allows them to interact with this GPU backend. If you'd like to
-   include this code, include -DSK_GANESH in your cflags or uncomment below.
-   Defaults to not set (No Ganesh GPU backend).
-   This define affects the ABI of Skia, so make sure it matches the client which uses
-   the compiled version of Skia.
-*/
-//#define SK_GANESH
-
 /* Skia makes use of histogram logging macros to trace the frequency of
    events. By default, Skia provides no-op versions of these macros.
    Skia consumers can provide their own definitions of these macros to
@@ -99,6 +89,7 @@
 //#define SK_HISTOGRAM_ENUMERATION(name, sampleEnum, enumSize)
 //#define SK_HISTOGRAM_EXACT_LINEAR(name, sample, valueMax)
 //#define SK_HISTOGRAM_MEMORY_KB(name, sample)
+//#define SK_HISTOGRAM_CUSTOM_COUNTS(name, sample, countMin, countMax, bucketCount)
 //#define SK_HISTOGRAM_CUSTOM_MICROSECONDS_TIMES(name, sampleUSec, minUSec, maxUSec, bucketCount)
 
 /*

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

@@ -54,6 +54,7 @@ class GrRecordingContext;
 
 class SkBitmap;
 class SkBlender;
+class SkBlurMaskFilterImpl;
 class SkColorSpace;
 class SkData;
 class SkDevice;
@@ -2679,11 +2680,14 @@ private:
     // into the canvas' global space.
     SkRect computeDeviceClipBounds(bool outsetForAA=true) const;
 
-    // Attempt to draw a rrect with an analytic blur. If the paint does not contain a blur, or the
-    // geometry can't be drawn with an analytic blur by the device, a layer is returned for a
-    // regular draw. If the draw succeeds or predrawNotify fails, nullopt is returned indicating
-    // that nothing further should be drawn.
+    // Returns the paint's mask filter if it can be used to draw an rrect with an analytic blur, and
+    // returns null otherwise.
+    const SkBlurMaskFilterImpl* canAttemptBlurredRRectDraw(const SkPaint&) const;
+
+    // Attempt to draw a rrect with an analytic blur. If the draw succeeds or predrawNotify fails,
+    // nullopt is returned indicating that nothing further should be drawn.
     std::optional<AutoLayerForImageFilter> attemptBlurredRRectDraw(const SkRRect&,
+                                                                   const SkBlurMaskFilterImpl*,
                                                                    const SkPaint&,
                                                                    SkEnumBitMask<PredrawFlags>);
 

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

@@ -91,13 +91,13 @@ public:
             return *this;
         }
 
-        bool operator==(const ForwardVerbIterator& other) {
+        bool operator==(const ForwardVerbIterator& other) const {
             SkASSERT(fSegments.data() != other.fSegments.data() ||
                      fSegments.size() == other.fSegments.size());
             return fSegments.data() == other.fSegments.data();
         }
 
-        bool operator!=(const ForwardVerbIterator& other) {
+        bool operator!=(const ForwardVerbIterator& other) const {
             return !((*this) == other);
         }
 

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

@@ -5,5 +5,5 @@
  * found in the LICENSE file.
  */
 #ifndef SK_MILESTONE
-#define SK_MILESTONE 134
+#define SK_MILESTONE 136
 #endif

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

@@ -317,15 +317,18 @@ public:
     */
     SkScalar getStrokeMiter() const { return fMiterLimit; }
 
-    /** Sets the limit at which a sharp corner is drawn beveled.
-        Valid values are zero and greater.
-        Has no effect if miter is less than zero.
+    /** When stroking a small joinAngle with miter, the miterLength may be very long.
+        When miterLength > maxMiterLength (or joinAngle < minJoinAngle) the join will become bevel.
+        miterLimit = maxMiterLength / strokeWidth or miterLimit = 1 / sin(minJoinAngle / 2).
 
-        @param miter  zero and greater miter limit
+        This call has no effect if the miterLimit passed is less than zero.
+        Values less than one will be treated as bevel.
+
+        @param miterLimit  zero and greater miter limit
 
         example: https://fiddle.skia.org/c/@Paint_setStrokeMiter
     */
-    void setStrokeMiter(SkScalar miter);
+    void setStrokeMiter(SkScalar miterLimit);
 
     /** \enum SkPaint::Cap
         Cap draws at the beginning and end of an open path contour.

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

@@ -79,10 +79,12 @@ public:
     [[nodiscard]] bool readS8(int8_t*);
     [[nodiscard]] bool readS16(int16_t*);
     [[nodiscard]] bool readS32(int32_t*);
+    [[nodiscard]] bool readS64(int64_t*);
 
-    [[nodiscard]] bool readU8(uint8_t* i) { return this->readS8((int8_t*)i); }
+    [[nodiscard]] bool readU8(uint8_t* i)   { return this->readS8((int8_t*)i); }
     [[nodiscard]] bool readU16(uint16_t* i) { return this->readS16((int16_t*)i); }
     [[nodiscard]] bool readU32(uint32_t* i) { return this->readS32((int32_t*)i); }
+    [[nodiscard]] bool readU64(uint64_t* i) { return this->readS64((int64_t*)i); }
 
     [[nodiscard]] bool readBool(bool* b) {
         uint8_t i;
@@ -240,8 +242,11 @@ public:
         uint16_t v = SkToU16(value);
         return this->write(&v, 2);
     }
-    bool write32(uint32_t v) {
-        return this->write(&v, 4);
+    bool write32(uint32_t value) {
+        return this->write(&value, 4);
+    }
+    bool write64(uint64_t value) {
+        return this->write(&value, 8);
     }
 
     bool writeText(const char text[]) {

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

@@ -209,13 +209,13 @@ public:
     class SK_API Iter {
     public:
         struct Run {
-            SkTypeface*     fTypeface;
-            int             fGlyphCount;
-            const uint16_t* fGlyphIndices;
+            SkTypeface* fTypeface;
+            int fGlyphCount;
+            const SkGlyphID* fGlyphIndices;
 #ifdef SK_UNTIL_CRBUG_1187654_IS_FIXED
             const uint32_t* fClusterIndex_forTest;
-            int             fUtf8Size_forTest;
-            const char*     fUtf8_forTest;
+            int fUtf8Size_forTest;
+            const char* fUtf8_forTest;
 #endif
         };
 
@@ -229,10 +229,10 @@ public:
 
         // Experimental, DO NO USE, will change/go-away
         struct ExperimentalRun {
-            SkFont          font;
-            int             count;
-            const uint16_t* glyphs;
-            const SkPoint*  positions;
+            SkFont font;
+            int count;
+            const SkGlyphID* glyphs;
+            const SkPoint* positions;
         };
         bool experimentalNext(ExperimentalRun*);
 

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

@@ -366,12 +366,10 @@ protected:
     virtual bool onGetFixedPitch() const; // TODO: = 0;
 
     // Must return a valid scaler context. It can not return nullptr.
-    virtual std::unique_ptr<SkScalerContext> onCreateScalerContext(const SkScalerContextEffects&,
-                                                                   const SkDescriptor*) const = 0;
+    virtual std::unique_ptr<SkScalerContext> onCreateScalerContext(
+        const SkScalerContextEffects&, const SkDescriptor*) const = 0;
     virtual std::unique_ptr<SkScalerContext> onCreateScalerContextAsProxyTypeface
-                                                                  (const SkScalerContextEffects&,
-                                                                   const SkDescriptor*,
-                                                                   sk_sp<SkTypeface>) const;
+        (const SkScalerContextEffects&, const SkDescriptor*, SkTypeface* proxyTypeface) const;
     virtual void onFilterRec(SkScalerContextRec*) const = 0;
     friend class SkScalerContext;  // onFilterRec
 
@@ -442,8 +440,8 @@ private:
     friend class SkRandomTypeface;   // getAdvancedMetrics
     friend class SkPDFFont;          // getAdvancedMetrics
     friend class SkTypeface_proxy;
-
     friend class SkFontPriv;         // getGlyphToUnicodeMap
+    friend void TestSkTypefaceGlyphToUnicodeMap(SkTypeface&, SkUnichar*);
 
 private:
     SkTypefaceID        fUniqueID;

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

@@ -97,6 +97,7 @@
     defined(SK_HISTOGRAM_BOOLEAN)      || \
     defined(SK_HISTOGRAM_EXACT_LINEAR) || \
     defined(SK_HISTOGRAM_MEMORY_KB)    || \
+    defined(SK_HISTOGRAM_CUSTOM_COUNTS)|| \
     defined(SK_HISTOGRAM_CUSTOM_MICROSECONDS_TIMES)
 #  define SK_HISTOGRAMS_ENABLED 1
 #else
@@ -119,6 +120,10 @@
 #  define SK_HISTOGRAM_MEMORY_KB(name, sample)
 #endif
 
+#ifndef SK_HISTOGRAM_CUSTOM_COUNTS
+#  define SK_HISTOGRAM_CUSTOM_COUNTS(name, sample, countMin, countMax, bucketCount)
+#endif
+
 #ifndef SK_HISTOGRAM_CUSTOM_MICROSECONDS_TIMES
 #  define SK_HISTOGRAM_CUSTOM_MICROSECONDS_TIMES(name, sampleUSec, minUSec, maxUSec, bucketCount)
 #endif

package/cpp/skia/include/docs/SkPDFDocument.h

@@ -16,9 +16,12 @@
 #include <vector>
 
 class SkCanvas;
+class SkCodec;
+class SkData;
 class SkExecutor;
 class SkPDFArray;
 class SkPDFStructTree;
+class SkPixmap;
 class SkWStream;
 
 #define SKPDF_STRING(X) SKPDF_STRING_IMPL(X)
@@ -80,6 +83,9 @@ struct DateTime {
     void toISO8601(SkString* dst) const;
 };
 
+using DecodeJpegCallback = std::unique_ptr<SkCodec> (*)(sk_sp<SkData>);
+using EncodeJpegCallback = bool (*)(SkWStream* dst, const SkPixmap& src, int quality);
+
 /** Optional metadata to be passed into the PDF factory function.
 */
 struct Metadata {
@@ -157,6 +163,7 @@ struct Metadata {
     enum class Outline : int {
         None = 0,
         StructureElementHeaders = 1,
+        StructureElements = 2,
     } fOutline = Outline::None;
 
     /** Executor to handle threaded work within PDF Backend. If this is nullptr,
@@ -186,14 +193,50 @@ struct Metadata {
     enum Subsetter {
         kHarfbuzz_Subsetter,
     } fSubsetter = kHarfbuzz_Subsetter;
+
+    /** Clients can provide a way to decode jpeg. To use Skia's JPEG decoder, pass in
+        SkJpegDecoder::Decode. If not supplied, all images will need to be re-encoded
+        as jpegs or deflated images before embedding. If supplied, Skia may be able to
+        skip the re-encoding step.
+        Skia's JPEG decoder can be used here.
+    */
+    SkPDF::DecodeJpegCallback jpegDecoder = nullptr;
+
+    /** Clients can provide a way to encode jpeg. If not supplied, images will be embedded
+        as a deflated image, potentially making them much larger. If clients provide
+        their own implementation, JPEGs should be encoded to RGB (not YUV) otherwise they
+        will have the wrong surrounding metadata provided by Skia.
+        Skia's JPEG encoder can be used here.
+    */
+    SkPDF::EncodeJpegCallback jpegEncoder = nullptr;
+
+    // Skia's PDF support depends on having both a jpeg encoder and decoder for writing
+    // compact PDFs. It will technically work, but produce larger than optimal PDFs
+    // if either the decoder or encoder are left as nullptr. If clients will be creating
+    // PDFs that don't use images or otherwise want to incur this cost (with the upside
+    // of not having a jpeg library), they should set this to true to avoid an internal
+    // assert from firing.
+    bool allowNoJpegs = false;
 };
 
+namespace NodeID {
+static const constexpr int Nothing = 0;
+static const constexpr int OtherArtifact = -1;
+static const constexpr int PaginationArtifact = -2;
+static const constexpr int PaginationHeaderArtifact = -3;
+static const constexpr int PaginationFooterArtifact = -4;
+static const constexpr int PaginationWatermarkArtifact = -5;
+static const constexpr int LayoutArtifact = -6;
+static const constexpr int PageArtifact = -7;
+static const constexpr int BackgroundArtifact = -8;
+}  // namespace NodeID
+
 /** Associate a node ID with subsequent drawing commands in an
     SkCanvas.  The same node ID can appear in a StructureElementNode
     in order to associate a document's structure element tree with
     its content.
 
-    A node ID of zero indicates no node ID.
+    A node ID of zero indicates no node ID. Negative node IDs are reserved.
 
     @param canvas  The canvas used to draw to the PDF.
     @param nodeId  The node ID for subsequent drawing commands.
@@ -207,15 +250,17 @@ SK_API void SetNodeId(SkCanvas* dst, int nodeID);
     @param stream A PDF document will be written to this stream.  The document may write
            to the stream at anytime during its lifetime, until either close() is
            called or the document is deleted.
-    @param metadata a PDFmetadata object.  Any fields may be left empty.
+    @param metadata a PDFmetadata object. Some fields may be left empty.
 
     @returns NULL if there is an error, otherwise a newly created PDF-backed SkDocument.
 */
 SK_API sk_sp<SkDocument> MakeDocument(SkWStream* stream, const Metadata& metadata);
 
+#if !defined(SK_DISABLE_LEGACY_PDF_JPEG)
 static inline sk_sp<SkDocument> MakeDocument(SkWStream* stream) {
     return MakeDocument(stream, Metadata());
 }
+#endif
 
 }  // namespace SkPDF
 

package/cpp/skia/include/docs/SkPDFJpegHelpers.h

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#ifndef SkPDFJPEGHelpers_DEFINED
+#define SkPDFJPEGHelpers_DEFINED
+
+#include "include/codec/SkJpegDecoder.h"
+#include "include/core/SkData.h"
+#include "include/core/SkRefCnt.h"
+#include "include/docs/SkPDFDocument.h"
+#include "include/encode/SkJpegEncoder.h"
+
+class SkPixmap;
+class SkWStream;
+
+#include <memory>
+
+namespace SkPDF::JPEG {
+inline std::unique_ptr<SkCodec> Decode(sk_sp<SkData> data) {
+    return SkJpegDecoder::Decode(data, nullptr, nullptr);
+}
+
+inline bool Encode(SkWStream* dst, const SkPixmap& src, int quality) {
+    SkJpegEncoder::Options jOpts;
+    jOpts.fQuality = quality;
+    return SkJpegEncoder::Encode(dst, src, jOpts);
+}
+
+inline SkPDF::Metadata MetadataWithCallbacks() {
+    SkPDF::Metadata m;
+    m.jpegDecoder = SkPDF::JPEG::Decode;
+    m.jpegEncoder = SkPDF::JPEG::Encode;
+    return m;
+}
+
+}  // namespace SkPDF::JPEG
+
+#endif

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

@@ -126,6 +126,8 @@ public:
         // don't run the inliner directly, but they still get an inlining pass once they are
         // painted.)
         bool forceUnoptimized = false;
+        // When possible this name will be used to identify the created runtime effect.
+        std::string_view fName;
 
     private:
         friend class SkRuntimeEffect;
@@ -317,7 +319,9 @@ private:
     friend class SkRuntimeEffectPriv;
 
     uint32_t fHash;
-    uint32_t fStableKey;
+    // When not 0, this field holds a StableKey value or a user-defined stable key
+    uint32_t fStableKey = 0;
+    SkString fName;
 
     std::unique_ptr<SkSL::Program> fBaseProgram;
     std::unique_ptr<SkSL::RP::Program> fRPProgram;

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

@@ -38,6 +38,10 @@ public:
     static SkMaskFilter* CreateClip(uint8_t min, uint8_t max);
 
     SkTableMaskFilter() = delete;
+
+private:
+    static void RegisterFlattenables();
+    friend class SkFlattenable;
 };
 
 #endif

package/cpp/skia/include/gpu/graphite/BackendTexture.h

@@ -17,7 +17,6 @@
 namespace skgpu::graphite {
 
 class BackendTextureData;
-struct VulkanTextureInfo;
 
 class SK_API BackendTexture {
 public:
@@ -61,4 +60,3 @@ private:
 } // namespace skgpu::graphite
 
 #endif // skgpu_graphite_BackendTexture_DEFINED
-

package/cpp/skia/include/gpu/graphite/ContextOptions.h

@@ -9,12 +9,14 @@
 #define skgpu_graphite_ContextOptions_DEFINED
 
 #include "include/core/SkRefCnt.h"
+#include "include/core/SkSpan.h"
 #include "include/private/base/SkAPI.h"
 #include "include/private/base/SkMath.h"
 
 #include <optional>
 
 class SkData;
+class SkRuntimeEffect;
 namespace skgpu { class ShaderErrorHandler; }
 
 namespace skgpu::graphite {
@@ -136,6 +138,21 @@ struct SK_API ContextOptions {
     PipelineCallbackContext fPipelineCallbackContext = nullptr;
     PipelineCallback fPipelineCallback = nullptr;
 
+    /**
+     * The runtime effects provided here will be registered as user-defined *known* runtime
+     * effects and will be given a stable key. Such runtime effects can then be used in
+     * serialized pipeline keys (c.f. PrecompileContext::precompile).
+     *
+     * Graphite will take a ref on the provided runtime effects and they will persist for as long
+     * as the Context exists. Rather than recreating new SkRuntimeEffects using the same SkSL,
+     * clients should use the existing SkRuntimeEffects provided here.
+     *
+     * Warning: Registering runtime effects here does obligate users to clear out their caches
+     * of serialized pipeline keys if the provided runtime effects ever change in a meaningful way.
+     * This includes adding, removing or reordering the effects provided here.
+     */
+    SkSpan<sk_sp<SkRuntimeEffect>> fUserDefinedKnownRuntimeEffects;
+
     /**
      * Private options that are only meant for testing within Skia's tools.
      */

package/cpp/skia/include/gpu/graphite/GraphiteTypes.h

@@ -140,44 +140,47 @@ enum class DepthStencilFlags : int {
  */
 enum DrawTypeFlags : uint16_t {
 
-    kNone             = 0b000000000,
+    kNone             = 0,
 
     // kBitmapText_Mask should be used for the BitmapTextRenderStep[mask] RenderStep
-    kBitmapText_Mask  = 0b00000001,
+    kBitmapText_Mask  = 1 << 0,
     // kBitmapText_LCD should be used for the BitmapTextRenderStep[LCD] RenderStep
-    kBitmapText_LCD   = 0b00000010,
+    kBitmapText_LCD   = 1 << 1,
     // kBitmapText_Color should be used for the BitmapTextRenderStep[color] RenderStep
-    kBitmapText_Color = 0b00000100,
+    kBitmapText_Color = 1 << 2,
     // kSDFText should be used for the SDFTextRenderStep RenderStep
-    kSDFText          = 0b00001000,
+    kSDFText          = 1 << 3,
     // kSDFText_LCD should be used for the SDFTextLCDRenderStep RenderStep
-    kSDFText_LCD      = 0b00010000,
+    kSDFText_LCD      = 1 << 4,
 
     // kDrawVertices should be used to generate Pipelines that use the following RenderSteps:
     //    VerticesRenderStep[*] for:
-    //        [tris], [tris-texCoords], [tris-color], [tris-color-texCoords],
-    //        [tristrips], [tristrips-texCoords], [tristrips-color], [tristrips-color-texCoords]
-    kDrawVertices     = 0b00100000,
+    //        [Tris], [TrisTexCoords], [TrisColor], [TrisColorTexCoords],
+    //        [Tristrips], [TristripsTexCoords], [TristripsColor], [TristripsColorTexCoords]
+    kDrawVertices     = 1 << 5,
+
+    // kCircularArc renders filled circular arcs, with or without the center included, and
+    // stroked circular arcs with butt or round caps that don't include the center point.
+    // It corresponds to the CircularArcRenderStep.
+    kCircularArc      = 1 << 6,
 
     // kSimpleShape should be used to generate Pipelines that use the following RenderSteps:
-    //    AnalyticBlurRenderStep
     //    AnalyticRRectRenderStep
     //    PerEdgeAAQuadRenderStep
-    //    CoverBoundsRenderStep[non-aa-fill]
-    kSimpleShape      = 0b01000000,
+    //    CoverBoundsRenderStep[NonAAFill]
+    kSimpleShape      = 1 << 7,
 
     // kNonSimpleShape should be used to generate Pipelines that use the following RenderSteps:
     //    CoverageMaskRenderStep
-    //    CoverBoundsRenderStep[*] for [inverse-cover], [regular-cover]
+    //    CoverBoundsRenderStep[*] for [InverseCover], [RegularCover]
     //    TessellateStrokeRenderStep
-    //    TessellateWedgesRenderStep[*] for [convex], [evenodd], [winding]
-    //    TessellateCurvesRenderStep[*] for [even-odd], [winding]
-    //    MiddleOutFanRenderStep[*] for [even-odd], [winding]
-    kNonSimpleShape   = 0b10000000,
+    //    TessellateWedgesRenderStep[*] for [Convex], [EvenOdd], [Winding]
+    //    TessellateCurvesRenderStep[*] for [EvenOdd], [Winding]
+    //    MiddleOutFanRenderStep[*] for [EvenOdd], [Winding]
+    kNonSimpleShape   = 1 << 8,
 
     kLast = kNonSimpleShape,
 };
-static constexpr int kDrawTypeFlagsCnt = static_cast<int>(DrawTypeFlags::kLast) + 1;
 
 } // namespace skgpu::graphite
 

package/cpp/skia/include/gpu/graphite/PrecompileContext.h

@@ -14,6 +14,8 @@
 #include <chrono>
 #include <memory>
 
+class SkData;
+
 namespace skgpu::graphite {
 
 class SharedContext;
@@ -32,6 +34,28 @@ public:
      */
     void purgePipelinesNotUsedInMs(std::chrono::milliseconds msNotUsed);
 
+    /**
+     * Emit histograms (using the SK_HISTOGRAM* macros) for Skia's Pipeline usage.
+     */
+    void reportPipelineStats();
+
+    /**
+     * Precompile one specific Pipeline that has been previously serialized. Serialized pipeline
+     * keys can be acquired via the ContextOptions::PipelineCallback.
+     *
+     * @param serializedPipelineKey   serialized Pipeline key.
+     * @return                        true if a Pipeline was created from the key; false otherwise
+     */
+    bool precompile(sk_sp<SkData> serializedPipelineKey);
+
+    /**
+     * Get a human-readable version of a serialized pipeline key.
+     *
+     * @param serializedPipelineKey   serialized Pipeline key.
+     * @return                        A human-readable version of the provided key; "" on failure.
+     */
+    std::string getPipelineLabel(sk_sp<SkData> serializedPipelineKey);
+
     // Provides access to functions that aren't part of the public API.
     PrecompileContextPriv priv();
     const PrecompileContextPriv priv() const;  // NOLINT(readability-const-return-type)