@shopify/react-native-skia 0.1.192 → 0.1.193

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

@@ -8,32 +8,25 @@
 #ifndef SkImageGenerator_DEFINED
 #define SkImageGenerator_DEFINED
 
-#include "include/core/SkBitmap.h"
-#include "include/core/SkColor.h"
-#include "include/core/SkImage.h"
+#include "include/core/SkData.h"
 #include "include/core/SkImageInfo.h"
-#include "include/core/SkSurfaceProps.h"
+#include "include/core/SkPixmap.h"
+#include "include/core/SkRefCnt.h"
 #include "include/core/SkYUVAPixmaps.h"
+#include "include/private/base/SkAPI.h"
 
+#if defined(SK_GRAPHITE)
+#include "include/core/SkImage.h"
+#include "include/gpu/graphite/Recorder.h"
+#endif
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
 #include <optional>
 
 class GrRecordingContext;
-class GrSurfaceProxyView;
-class GrSamplerState;
-class SkBitmap;
-class SkData;
-class SkMatrix;
-class SkPaint;
-class SkPicture;
-
-enum class GrImageTexGenPolicy : int;
-
-#if SK_GRAPHITE_ENABLED
-namespace skgpu::graphite {
-enum class Mipmapped : bool;
-class Recorder;
-}
-#endif
+enum SkAlphaType : int;
 
 class SK_API SkImageGenerator {
 public:
@@ -121,36 +114,12 @@ public:
      */
     bool getYUVAPlanes(const SkYUVAPixmaps& yuvaPixmaps);
 
-#if SK_SUPPORT_GPU
-    /**
-     *  If the generator can natively/efficiently return its pixels as a GPU image (backed by a
-     *  texture) this will return that image. If not, this will return NULL.
-     *
-     *  Regarding the GrRecordingContext parameter:
-     *
-     *  It must be non-NULL. The generator should only succeed if:
-     *  - its internal context is the same
-     *  - it can somehow convert its texture into one that is valid for the provided context.
-     *
-     *  If the mipmapped parameter is kYes, the generator should try to create a TextureProxy that
-     *  at least has the mip levels allocated and the base layer filled in. If this is not possible,
-     *  the generator is allowed to return a non mipped proxy, but this will have some additional
-     *  overhead in later allocating mips and copying of the base layer.
-     *
-     *  GrImageTexGenPolicy determines whether or not a new texture must be created (and its budget
-     *  status) or whether this may (but is not required to) return a pre-existing texture that is
-     *  retained by the generator (kDraw).
-     */
-    GrSurfaceProxyView generateTexture(GrRecordingContext*,
-                                       const SkImageInfo& info,
-                                       GrMipmapped mipmapped,
-                                       GrImageTexGenPolicy);
-#endif
+    virtual bool isTextureGenerator() const { return false; }
 
-#if SK_GRAPHITE_ENABLED
+#if defined(SK_GRAPHITE)
     sk_sp<SkImage> makeTextureImage(skgpu::graphite::Recorder*,
                                     const SkImageInfo&,
-                                    skgpu::graphite::Mipmapped);
+                                    skgpu::Mipmapped);
 #endif
 
     /**
@@ -164,17 +133,6 @@ public:
     static std::unique_ptr<SkImageGenerator> MakeFromEncoded(
             sk_sp<SkData>, std::optional<SkAlphaType> = std::nullopt);
 
-    /** Return a new image generator backed by the specified picture.  If the size is empty or
-     *  the picture is NULL, this returns NULL.
-     *  The optional matrix and paint arguments are passed to drawPicture() at rasterization
-     *  time.
-     */
-    static std::unique_ptr<SkImageGenerator> MakeFromPicture(const SkISize&, sk_sp<SkPicture>,
-                                                             const SkMatrix*, const SkPaint*,
-                                                             SkImage::BitDepth,
-                                                             sk_sp<SkColorSpace>,
-                                                             SkSurfaceProps props = {});
-
 protected:
     static constexpr int kNeedNewImageUniqueID = 0;
 
@@ -187,30 +145,17 @@ protected:
     virtual bool onQueryYUVAInfo(const SkYUVAPixmapInfo::SupportedDataTypes&,
                                  SkYUVAPixmapInfo*) const { return false; }
     virtual bool onGetYUVAPlanes(const SkYUVAPixmaps&) { return false; }
-#if SK_SUPPORT_GPU
-    // returns nullptr
-    virtual GrSurfaceProxyView onGenerateTexture(GrRecordingContext*, const SkImageInfo&,
-                                                 GrMipmapped, GrImageTexGenPolicy);
-
-    // Most internal SkImageGenerators produce textures and views that use kTopLeft_GrSurfaceOrigin.
-    // If the generator may produce textures with different origins (e.g.
-    // GrAHardwareBufferImageGenerator) it should override this function to return the correct
-    // origin.
-    virtual GrSurfaceOrigin origin() const { return kTopLeft_GrSurfaceOrigin; }
-#endif
 
-#if SK_GRAPHITE_ENABLED
+#if defined(SK_GRAPHITE)
     virtual sk_sp<SkImage> onMakeTextureImage(skgpu::graphite::Recorder*,
                                               const SkImageInfo&,
-                                              skgpu::graphite::Mipmapped);
+                                              skgpu::Mipmapped);
 #endif
+    const SkImageInfo fInfo;
 
 private:
-    const SkImageInfo fInfo;
     const uint32_t fUniqueID;
 
-    friend class SkImage_Lazy;
-
     // This is our default impl, which may be different on different platforms.
     // It is called from NewFromEncoded() after it has checked for any runtime factory.
     // The SkData will never be NULL, as that will have been checked by NewFromEncoded.

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

@@ -10,16 +10,18 @@
 
 #include "include/core/SkAlphaType.h"
 #include "include/core/SkColorType.h"
-#include "include/core/SkMath.h"
 #include "include/core/SkRect.h"
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkSize.h"
+#include "include/private/base/SkAPI.h"
+#include "include/private/base/SkDebug.h"
+#include "include/private/base/SkMath.h"
+#include "include/private/base/SkTFitsIn.h"
 
-#include "include/private/SkTFitsIn.h"
-#include "include/private/SkTo.h"
+#include <cstddef>
+#include <cstdint>
+#include <utility>
 
-class SkReadBuffer;
-class SkWriteBuffer;
 class SkColorSpace;
 
 /** Returns the number of bytes required to store a pixel, including unused padding.

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

@@ -99,6 +99,11 @@ struct SK_API SkV4 {
     }
     bool operator!=(const SkV4& v) const { return !(*this == v); }
 
+    static SkScalar Dot(const SkV4& a, const SkV4& b) {
+        return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w;
+    }
+    static SkV4 Normalize(const SkV4& v) { return v * (1.0f / v.length()); }
+
     SkV4 operator-() const { return {-x, -y, -z, -w}; }
     SkV4 operator+(const SkV4& v) const { return { x + v.x, y + v.y, z + v.z, w + v.w }; }
     SkV4 operator-(const SkV4& v) const { return { x - v.x, y - v.y, z - v.z, w - v.w }; }
@@ -111,6 +116,12 @@ struct SK_API SkV4 {
     }
     friend SkV4 operator*(SkScalar s, const SkV4& v) { return v*s; }
 
+    SkScalar lengthSquared() const { return Dot(*this, *this); }
+    SkScalar length() const { return SkScalarSqrt(Dot(*this, *this)); }
+
+    SkScalar dot(const SkV4& v) const { return Dot(*this, v); }
+    SkV4 normalize()            const { return Normalize(*this); }
+
     const float* ptr() const { return &x; }
     float* ptr() { return &x; }
 

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

@@ -8,12 +8,15 @@
 #ifndef SkMaskFilter_DEFINED
 #define SkMaskFilter_DEFINED
 
-#include "include/core/SkBlurTypes.h"
-#include "include/core/SkCoverageMode.h"
 #include "include/core/SkFlattenable.h"
+#include "include/core/SkRefCnt.h"
 #include "include/core/SkScalar.h"
+#include "include/core/SkTypes.h"
 
-class SkMatrix;
+#include <cstddef>
+
+enum SkBlurStyle : int;
+struct SkDeserialProcs;
 struct SkRect;
 
 /** \class SkMaskFilter

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

@@ -8,12 +8,19 @@
 #ifndef SkMatrix_DEFINED
 #define SkMatrix_DEFINED
 
+#include "include/core/SkPoint.h"
 #include "include/core/SkRect.h"
-#include "include/private/SkMacros.h"
-#include "include/private/SkTo.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkTypes.h"
+#include "include/private/base/SkMacros.h"
+#include "include/private/base/SkTo.h"
+
+#include <cstdint>
+#include <cstring>
 
-struct SkRSXform;
 struct SkPoint3;
+struct SkRSXform;
+struct SkSize;
 
 // Remove when clients are updated to live without this
 #define SK_SUPPORT_LEGACY_MATRIX_RECTTORECT
@@ -1812,7 +1819,10 @@ public:
         if (tx != 0.0f || ty != 0.0f) {
             mask |= kTranslate_Mask;
         }
-        this->setTypeMask(mask | kRectStaysRect_Mask);
+        if (sx != 0 && sy != 0) {
+            mask |= kRectStaysRect_Mask;
+        }
+        this->setTypeMask(mask);
     }
 
     /** Returns true if all elements of the matrix are finite. Returns false if any

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

@@ -19,6 +19,7 @@
 #include "include/effects/SkRuntimeEffect.h"
 
 #include <memory>
+#include <tuple>
 #include <vector>
 
 class GrDirectContext;
@@ -29,22 +30,31 @@ namespace SkSL { struct Program; }
 
 /**
  * A specification for custom meshes. Specifies the vertex buffer attributes and stride, the
- * vertex program that produces a user-defined set of varyings, a fragment program that ingests
- * the interpolated varyings and produces local coordinates and optionally a color.
+ * vertex program that produces a user-defined set of varyings, and a fragment program that ingests
+ * the interpolated varyings and produces local coordinates for shading and optionally a color.
+ *
+ * The varyings must include a float2 named "position". If the passed varyings does not
+ * contain such a varying then one is implicitly added to the final specification and the SkSL
+ * Varyings struct described below. It is an error to have a varying named "position" that has a
+ * type other than float2.
+ *
+ * The provided attributes and varyings are used to create Attributes and Varyings structs in SkSL
+ * that are used by the shaders. Each attribute from the Attribute span becomes a member of the
+ * SkSL Attributes struct and likewise for the varyings.
  *
  * The signature of the vertex program must be:
- *   float2 main(Attributes, out Varyings)
- * where the return value is a local position that will be transformed by SkCanvas's matrix.
+ *   Varyings main(const Attributes).
  *
  * The signature of the fragment program must be either:
- *   (float2|void) main(Varyings)
+ *   float2 main(const Varyings)
  * or
- *   (float2|void) main(Varyings, out (half4|float4) color)
+ *   float2 main(const Varyings, out (half4|float4) color)
  *
  * where the return value is the local coordinates that will be used to access SkShader. If the
- * return type is void then the interpolated position from vertex shader return is used as the local
- * coordinate. If the color variant is used it will be blended with SkShader (or SkPaint color in
- * absence of a shader) using the SkBlender provided to the SkCanvas draw call.
+ * color variant is used, the returned color will be blended with SkPaint's SkShader (or SkPaint
+ * color in absence of a SkShader) using the SkBlender passed to SkCanvas drawMesh(). To use
+ * interpolated local space positions as the shader coordinates, equivalent to how SkPaths are
+ * shaded, return the position field from the Varying struct as the coordinates.
  *
  * The vertex and fragment programs may both contain uniforms. Uniforms with the same name are
  * assumed to be shared between stages. It is an error to specify uniforms in the vertex and
@@ -187,11 +197,12 @@ private:
     SkMeshSpecification(SkSpan<const Attribute>,
                         size_t,
                         SkSpan<const Varying>,
+                        int passthroughLocalCoordsVaryingIndex,
+                        uint32_t deadVaryingMask,
                         std::vector<Uniform> uniforms,
                         std::unique_ptr<const SkSL::Program>,
                         std::unique_ptr<const SkSL::Program>,
                         ColorType,
-                        bool hasLocalCoords,
                         sk_sp<SkColorSpace>,
                         SkAlphaType);
 
@@ -208,8 +219,9 @@ private:
     const std::unique_ptr<const SkSL::Program> fFS;
     const size_t                               fStride;
           uint32_t                             fHash;
+    const int                                  fPassthroughLocalCoordsVaryingIndex;
+    const uint32_t                             fDeadVaryingMask;
     const ColorType                            fColorType;
-    const bool                                 fHasLocalCoords;
     const sk_sp<SkColorSpace>                  fColorSpace;
     const SkAlphaType                          fAlphaType;
 };
@@ -295,8 +307,11 @@ public:
      */
     static sk_sp<IndexBuffer> MakeIndexBuffer(GrDirectContext*, const void* data, size_t size);
 
-    /** Deprecated in favor of const void* and size_t version above. */
-    static sk_sp<IndexBuffer> MakeIndexBuffer(GrDirectContext*, sk_sp<const SkData>);
+    /**
+     * Makes a copy of an index buffer. The implementation currently only supports a CPU-backed
+     * source buffer.
+     */
+    static sk_sp<IndexBuffer> CopyIndexBuffer(GrDirectContext*, sk_sp<IndexBuffer>);
 
     /**
      * Makes a vertex buffer to be used with SkMeshes. The buffer may be CPU- or GPU-backed
@@ -313,12 +328,23 @@ public:
      */
     static sk_sp<VertexBuffer> MakeVertexBuffer(GrDirectContext*, const void*, size_t size);
 
-    /** Deprecated in favor of const void* and size_t version above. */
-    static sk_sp<VertexBuffer> MakeVertexBuffer(GrDirectContext*, sk_sp<const SkData>);
+    /**
+     * Makes a copy of a vertex buffer. The implementation currently only supports a CPU-backed
+     * source buffer.
+     */
+    static sk_sp<VertexBuffer> CopyVertexBuffer(GrDirectContext*, sk_sp<VertexBuffer>);
 
     enum class Mode { kTriangles, kTriangleStrip };
 
-    static SkMesh Make(sk_sp<SkMeshSpecification>,
+    struct Result;
+
+    /**
+     * Creates a non-indexed SkMesh. The returned SkMesh can be tested for validity using
+     * SkMesh::isValid(). An invalid mesh simply fails to draws if passed to SkCanvas::drawMesh().
+     * If the mesh is invalid the returned string give contain the reason for the failure (e.g. the
+     * vertex buffer was null or uniform data too small).
+     */
+    static Result Make(sk_sp<SkMeshSpecification>,
                        Mode,
                        sk_sp<VertexBuffer>,
                        size_t vertexCount,
@@ -326,7 +352,13 @@ public:
                        sk_sp<const SkData> uniforms,
                        const SkRect& bounds);
 
-    static SkMesh MakeIndexed(sk_sp<SkMeshSpecification>,
+    /**
+     * Creates an indexed SkMesh. The returned SkMesh can be tested for validity using
+     * SkMesh::isValid(). A invalid mesh simply fails to draw if passed to SkCanvas::drawMesh().
+     * If the mesh is invalid the returned string give contain the reason for the failure (e.g. the
+     * index buffer was null or uniform data too small).
+     */
+    static Result MakeIndexed(sk_sp<SkMeshSpecification>,
                               Mode,
                               sk_sp<VertexBuffer>,
                               size_t vertexCount,
@@ -364,7 +396,7 @@ public:
 private:
     friend struct SkMeshPriv;
 
-    bool validate() const;
+    std::tuple<bool, SkString> validate() const;
 
     sk_sp<SkMeshSpecification> fSpec;
 
@@ -384,6 +416,8 @@ private:
     SkRect fBounds = SkRect::MakeEmpty();
 };
 
+struct SkMesh::Result { SkMesh mesh; SkString error; };
+
 #endif  // SK_ENABLE_SKSL
 
 #endif

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

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

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

@@ -8,23 +8,28 @@
 #ifndef SkPaint_DEFINED
 #define SkPaint_DEFINED
 
-#include "include/core/SkBlendMode.h"
 #include "include/core/SkColor.h"
 #include "include/core/SkRefCnt.h"
-#include "include/private/SkTo.h"
-
+#include "include/core/SkScalar.h"
+#include "include/core/SkTypes.h"
+#include "include/private/base/SkCPUTypes.h"
+#include "include/private/base/SkFloatingPoint.h"
+#include "include/private/base/SkTo.h"
+#include "include/private/base/SkTypeTraits.h"
+
+#include <cstdint>
 #include <optional>
+#include <type_traits>
 
 class SkBlender;
 class SkColorFilter;
 class SkColorSpace;
-struct SkRect;
 class SkImageFilter;
 class SkMaskFilter;
-class SkMatrix;
-class SkPath;
 class SkPathEffect;
 class SkShader;
+enum class SkBlendMode;
+struct SkRect;
 
 /** \class SkPaint
     SkPaint controls options applied when drawing. SkPaint collects all
@@ -383,34 +388,6 @@ public:
     */
     void setStrokeJoin(Join join);
 
-    /** Returns the filled equivalent of the stroked path.
-
-        @param src       SkPath read to create a filled version
-        @param dst       resulting SkPath; may be the same as src, but may not be nullptr
-        @param cullRect  optional limit passed to SkPathEffect
-        @param resScale  if > 1, increase precision, else if (0 < resScale < 1) reduce precision
-                         to favor speed and size
-        @return          true if the path represents style fill, or false if it represents hairline
-    */
-    bool getFillPath(const SkPath& src, SkPath* dst, const SkRect* cullRect,
-                     SkScalar resScale = 1) const;
-
-    bool getFillPath(const SkPath& src, SkPath* dst, const SkRect* cullRect,
-                     const SkMatrix& ctm) const;
-
-    /** Returns the filled equivalent of the stroked path.
-
-        Replaces dst with the src path modified by SkPathEffect and style stroke.
-        SkPathEffect, if any, is not culled. stroke width is created with default precision.
-
-        @param src  SkPath read to create a filled version
-        @param dst  resulting SkPath dst may be the same as src, but may not be nullptr
-        @return     true if the path represents style fill, or false if it represents hairline
-    */
-    bool getFillPath(const SkPath& src, SkPath* dst) const {
-        return this->getFillPath(src, dst, nullptr, 1);
-    }
-
     /** Returns optional colors used when filling a path, such as a gradient.
 
         Does not alter SkShader SkRefCnt.

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

@@ -10,20 +10,29 @@
 
 #include "include/core/SkMatrix.h"
 #include "include/core/SkPathTypes.h"
+#include "include/core/SkPoint.h"
+#include "include/core/SkRect.h"
 #include "include/core/SkRefCnt.h"
-#include "include/private/SkTo.h"
-
+#include "include/core/SkScalar.h"
+#include "include/core/SkTypes.h"
+#include "include/private/base/SkDebug.h"
+#include "include/private/base/SkTo.h"
+#include "include/private/base/SkTypeTraits.h"
+
+#include <atomic>
+#include <cstddef>
+#include <cstdint>
 #include <initializer_list>
 #include <tuple>
+#include <type_traits>
 
-class SkAutoPathBoundsUpdate;
 class SkData;
 class SkPathRef;
 class SkRRect;
 class SkWStream;
-
 enum class SkPathConvexity;
 enum class SkPathFirstDirection;
+struct SkPathVerbAnalysis;
 
 // WIP -- define this locally, and fix call-sites to use SkPathBuilder (skbug.com/9000)
 //#define SK_HIDE_PATH_EDIT_METHODS
@@ -1866,6 +1875,16 @@ private:
      */
     void shrinkToFit();
 
+    // Creates a new Path after the supplied arguments have been validated by
+    // sk_path_analyze_verbs().
+    static SkPath MakeInternal(const SkPathVerbAnalysis& analsis,
+                               const SkPoint points[],
+                               const uint8_t verbs[],
+                               int verbCount,
+                               const SkScalar conics[],
+                               SkPathFillType fillType,
+                               bool isVolatile);
+
     friend class SkAutoPathBoundsUpdate;
     friend class SkAutoDisableOvalCheck;
     friend class SkAutoDisableDirectionCheck;

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

@@ -8,11 +8,19 @@
 #ifndef SkPathBuilder_DEFINED
 #define SkPathBuilder_DEFINED
 
-#include "include/core/SkMatrix.h"
 #include "include/core/SkPath.h"
 #include "include/core/SkPathTypes.h"
+#include "include/core/SkPoint.h"
+#include "include/core/SkRect.h"
 #include "include/core/SkRefCnt.h"
-#include "include/private/SkTDArray.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkTypes.h"
+#include "include/private/SkPathRef.h"
+#include "include/private/base/SkTo.h"
+
+#include <initializer_list>
+
+class SkRRect;
 
 class SK_API SkPathBuilder {
 public:
@@ -220,9 +228,9 @@ public:
     }
 
 private:
-    SkTDArray<SkPoint>  fPts;
-    SkTDArray<uint8_t>  fVerbs;
-    SkTDArray<SkScalar> fConicWeights;
+    SkPathRef::PointsArray fPts;
+    SkPathRef::VerbsArray fVerbs;
+    SkPathRef::ConicWeightsArray fConicWeights;
 
     SkPathFillType      fFillType;
     bool                fIsVolatile;

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

@@ -10,7 +10,7 @@
 
 #include "include/core/SkContourMeasure.h"
 #include "include/core/SkPath.h"
-#include "include/private/SkTDArray.h"
+#include "include/private/base/SkTDArray.h"
 
 class SK_API SkPathMeasure {
 public:

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

@@ -8,8 +8,6 @@
 #ifndef SkPathTypes_DEFINED
 #define SkPathTypes_DEFINED
 
-#include "include/core/SkTypes.h"
-
 enum class SkPathFillType {
     /** Specifies that "inside" is computed by a non-zero sum of signed edge crossings */
     kWinding,

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

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2022 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#ifndef SkPathUtils_DEFINED
+#define SkPathUtils_DEFINED
+
+#include "include/core/SkScalar.h"
+#include "include/core/SkTypes.h"
+
+class SkMatrix;
+class SkPaint;
+class SkPath;
+struct SkRect;
+
+namespace skpathutils {
+
+/** Returns the filled equivalent of the stroked path.
+
+    @param src       SkPath read to create a filled version
+    @param paint     SkPaint, from which attributes such as stroke cap, width, miter, and join,
+                     as well as pathEffect will be used.
+    @param dst       resulting SkPath; may be the same as src, but may not be nullptr
+    @param cullRect  optional limit passed to SkPathEffect
+    @param resScale  if > 1, increase precision, else if (0 < resScale < 1) reduce precision
+                     to favor speed and size
+    @return          true if the dst path was updated, false if it was not (e.g. if the path
+                     represents hairline and cannot be filled).
+*/
+SK_API bool FillPathWithPaint(const SkPath &src, const SkPaint &paint, SkPath *dst,
+                              const SkRect *cullRect, SkScalar resScale = 1);
+
+SK_API bool FillPathWithPaint(const SkPath &src, const SkPaint &paint, SkPath *dst,
+                              const SkRect *cullRect, const SkMatrix &ctm);
+
+SK_API bool FillPathWithPaint(const SkPath &src, const SkPaint &paint, SkPath *dst);
+
+}
+
+#endif

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

@@ -243,8 +243,9 @@ private:
 
     void serialize(SkWStream*, const SkSerialProcs*, class SkRefCntSet* typefaces,
         bool textBlobsOnly=false) const;
-    static sk_sp<SkPicture> MakeFromStream(SkStream*, const SkDeserialProcs*,
-                                           class SkTypefacePlayback*);
+    static sk_sp<SkPicture> MakeFromStreamPriv(SkStream*, const SkDeserialProcs*,
+                                               class SkTypefacePlayback*,
+                                               int recursionLimit);
     friend class SkPictureData;
 
     /** Return true if the SkStream/Buffer represents a serialized picture, and

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

@@ -12,6 +12,8 @@
 #include "include/core/SkPicture.h"
 #include "include/core/SkRefCnt.h"
 
+#include <memory>
+
 #ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
 namespace android {
     class Picture;

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

@@ -8,20 +8,16 @@
 #ifndef SkPixelRef_DEFINED
 #define SkPixelRef_DEFINED
 
-#include "include/core/SkBitmap.h"
-#include "include/core/SkImageInfo.h"
-#include "include/core/SkPixmap.h"
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkSize.h"
 #include "include/private/SkIDChangeListener.h"
-#include "include/private/SkMutex.h"
-#include "include/private/SkTDArray.h"
+#include "include/private/base/SkAPI.h"
+#include "include/private/base/SkTo.h"
 
 #include <atomic>
+#include <cstddef>
+#include <cstdint>
 
-struct SkIRect;
-
-class GrTexture;
 class SkDiscardableMemory;
 
 /** \class SkPixelRef