@shopify/react-native-skia 1.5.3 → 1.5.5

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

@@ -10,14 +10,12 @@
 
 #include "include/core/SkFlattenable.h"
 #include "include/core/SkRefCnt.h"
-#include "include/core/SkScalar.h"
 #include "include/private/base/SkAPI.h"
 
 // TODO(kjlubick) update clients and remove this unnecessary #include
 #include "include/core/SkPath.h"  // IWYU pragma: keep
 
 #include <cstddef>
-#include <cstdint>
 
 class SkMatrix;
 class SkStrokeRec;
@@ -55,27 +53,6 @@ public:
         return kSkPathEffect_Type;
     }
 
-    // move to base?
-
-    enum DashType {
-        kNone_DashType, //!< ignores the info parameter
-        kDash_DashType, //!< fills in all of the info parameter
-    };
-
-    struct DashInfo {
-        DashInfo() : fIntervals(nullptr), fCount(0), fPhase(0) {}
-        DashInfo(SkScalar* intervals, int32_t count, SkScalar phase)
-            : fIntervals(intervals), fCount(count), fPhase(phase) {}
-
-        SkScalar*   fIntervals;         //!< Length of on/off intervals for dashed lines
-                                        //   Even values represent ons, and odds offs
-        int32_t     fCount;             //!< Number of intervals in the dash. Should be even number
-        SkScalar    fPhase;             //!< Offset into the dashed interval pattern
-                                        //   mod the sum of all intervals
-    };
-
-    DashType asADash(DashInfo* info) const;
-
     /**
      *  Given a src path (input) and a stroke-rec (input and output), apply
      *  this effect to the src path, returning the new path in dst, and return

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

@@ -21,6 +21,7 @@
 #include <cstring>
 
 struct SkRect;
+class SkString;
 
 /** \struct SkIRect
     SkIRect holds four 32-bit integer coordinates describing the upper and
@@ -1347,6 +1348,7 @@ public:
         example: https://fiddle.skia.org/c/@Rect_dump
     */
     void dump(bool asHex) const;
+    SkString dumpToString(bool asHex) const;
 
     /** Writes text representation of SkRect to standard output. The representation may be
         directly compiled as C++ code. Floating point values are written

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

@@ -132,6 +132,8 @@ public:
     const char* data() const { return fRec->data(); }
     const char* c_str() const { return fRec->data(); }
     char operator[](size_t n) const { return this->c_str()[n]; }
+    const char* begin() const { return data(); }
+    const char* end() const { return data() + size(); }
 
     bool equals(const SkString&) const;
     bool equals(const char text[]) const;
@@ -177,6 +179,8 @@ public:
 
     char* data();
     char& operator[](size_t n) { return this->data()[n]; }
+    char* begin() { return data(); }
+    char* end() { return data() + size(); }
 
     void reset();
     /** String contents are preserved on resize. (For destructive resize, `set(nullptr, length)`.)

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

@@ -352,6 +352,10 @@ protected:
     // 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> onCreateScalerContextAsProxyTypeface
+                                                                  (const SkScalerContextEffects&,
+                                                                   const SkDescriptor*,
+                                                                   sk_sp<SkTypeface>) const;
     virtual void onFilterRec(SkScalerContextRec*) const = 0;
     friend class SkScalerContext;  // onFilterRec
 
@@ -420,6 +424,7 @@ private:
     std::unique_ptr<SkAdvancedTypefaceMetrics> getAdvancedMetrics() const;
     friend class SkRandomTypeface;   // getAdvancedMetrics
     friend class SkPDFFont;          // getAdvancedMetrics
+    friend class SkTypeface_fontconfig;
 
     friend class SkFontPriv;         // getGlyphToUnicodeMap
 

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

@@ -96,7 +96,8 @@
 #if defined(SK_HISTOGRAM_ENUMERATION)  || \
     defined(SK_HISTOGRAM_BOOLEAN)      || \
     defined(SK_HISTOGRAM_EXACT_LINEAR) || \
-    defined(SK_HISTOGRAM_MEMORY_KB)
+    defined(SK_HISTOGRAM_MEMORY_KB)    || \
+    defined(SK_HISTOGRAM_CUSTOM_MICROSECONDS_TIMES)
 #  define SK_HISTOGRAMS_ENABLED 1
 #else
 #  define SK_HISTOGRAMS_ENABLED 0
@@ -107,17 +108,21 @@
 #endif
 
 #ifndef SK_HISTOGRAM_ENUMERATION
-#  define SK_HISTOGRAM_ENUMERATION(name, sample, enum_size)
+#  define SK_HISTOGRAM_ENUMERATION(name, sampleEnum, enumSize)
 #endif
 
 #ifndef SK_HISTOGRAM_EXACT_LINEAR
-#  define SK_HISTOGRAM_EXACT_LINEAR(name, sample, value_max)
+#  define SK_HISTOGRAM_EXACT_LINEAR(name, sample, valueMax)
 #endif
 
 #ifndef SK_HISTOGRAM_MEMORY_KB
 #  define SK_HISTOGRAM_MEMORY_KB(name, sample)
 #endif
 
+#ifndef SK_HISTOGRAM_CUSTOM_MICROSECONDS_TIMES
+#  define SK_HISTOGRAM_CUSTOM_MICROSECONDS_TIMES(name, sampleUSec, minUSec, maxUSec, bucketCount)
+#endif
+
 #define SK_HISTOGRAM_PERCENTAGE(name, percent_as_int) \
     SK_HISTOGRAM_EXACT_LINEAR(name, percent_as_int, 101)
 

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

@@ -18,7 +18,7 @@
 class SkCanvas;
 class SkExecutor;
 class SkPDFArray;
-class SkPDFTagTree;
+class SkPDFStructTree;
 class SkWStream;
 
 #define SKPDF_STRING(X) SKPDF_STRING_IMPL(X)
@@ -46,9 +46,10 @@ public:
                            const std::vector<int>& nodeIds);
 
 private:
-    friend class ::SkPDFTagTree;
+    friend class ::SkPDFStructTree;
 
     std::unique_ptr<SkPDFArray> fAttrs;
+    std::vector<int> fElemIds; // element identifiers referenced by fAttrs
 };
 
 /** A node in a PDF structure tree, giving a semantic representation
@@ -60,7 +61,6 @@ struct StructureElementNode {
     SkString fTypeString;
     std::vector<std::unique_ptr<StructureElementNode>> fChildVector;
     int fNodeId = 0;
-    std::vector<int> fAdditionalNodeIds;
     AttributeList fAttributes;
     SkString fAlt;
     SkString fLang;

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

@@ -21,6 +21,7 @@ class SkColorFilter;
  *  ...
  *  5 (or larger) -> colors[5]
  *
+ *  https://fiddle.skia.org/c/@overdrawcolorfilter_grid
  */
 class SK_API SkOverdrawColorFilter {
 public:

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

@@ -162,6 +162,7 @@ public:
 
     // Color filter SkSL requires an entry point that looks like:
     //     vec4 main(vec4 inColor) { ... }
+    //     https://fiddle.skia.org/c/@runtimeeffect_colorfilter_grid
     static Result MakeForColorFilter(SkString sksl, const Options&);
     static Result MakeForColorFilter(SkString sksl) {
         return MakeForColorFilter(std::move(sksl), Options{});
@@ -352,7 +353,7 @@ private:
  * Note that SkRuntimeEffectBuilder is built entirely on the public API of SkRuntimeEffect,
  * so can be used as-is or serve as inspiration for other interfaces or binding techniques.
  */
-class SkRuntimeEffectBuilder {
+class SK_API SkRuntimeEffectBuilder {
 public:
     explicit SkRuntimeEffectBuilder(sk_sp<SkRuntimeEffect> effect)
             : fEffect(std::move(effect))

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

@@ -8,10 +8,12 @@
 #ifndef SkJpegEncoder_DEFINED
 #define SkJpegEncoder_DEFINED
 
+#include "include/codec/SkEncodedOrigin.h"
 #include "include/core/SkRefCnt.h"
 #include "include/private/base/SkAPI.h"
 
 #include <memory>
+#include <optional>
 
 class SkColorSpace;
 class SkData;
@@ -86,6 +88,8 @@ struct Options {
      */
     const skcms_ICCProfile* fICCProfile = nullptr;
     const char* fICCProfileDescription = nullptr;
+
+    std::optional<SkEncodedOrigin> fOrigin;
 };
 
 /**

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

@@ -11,9 +11,9 @@
 #include "include/core/SkData.h"
 #include "include/core/SkString.h"
 #include "include/core/SkTypes.h"
+#include "include/gpu/ShaderErrorHandler.h"
 #include "include/gpu/ganesh/GrDriverBugWorkarounds.h"
 #include "include/gpu/ganesh/GrTypes.h"
-#include "include/gpu/ShaderErrorHandler.h"
 #include "include/private/gpu/ganesh/GrTypesPriv.h"
 
 #include <optional>
@@ -176,6 +176,13 @@ struct SK_API GrContextOptions {
      */
     bool fAvoidStencilBuffers = false;
 
+    /**
+     * If true, texture fetches from mip-mapped textures will be biased to read larger MIP levels.
+     * This has the effect of sharpening those textures, at the cost of some aliasing, and possible
+     * performance impact.
+     */
+    bool fSharpenMipmappedTextures = true;
+
     /**
      * Enables driver workaround to use draws instead of HW clears, e.g. glClear on the GL backend.
      */

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

@@ -479,10 +479,25 @@ public:
      * If it returns false, then those same semaphores will not have been submitted and we will not
      * try to submit them again. The caller is free to delete the semaphores at any time.
      *
-     * If sync flag is GrSyncCpu::kYes, this function will return once the gpu has finished with all
-     * submitted work.
+     * If GrSubmitInfo::fSync flag is GrSyncCpu::kYes, this function will return once the gpu has
+     * finished with all submitted work.
+     *
+     * If GrSubmitInfo::fMarkBoundary flag is GrMarkFrameBoundary::kYes and the GPU supports a way
+     * to be notified about frame boundaries, then we will notify the GPU during/after the
+     * submission of work to the GPU. GrSubmitInfo::fFrameID is a frame ID that is passed to the
+     * GPU when marking a boundary. Ideally this value should be unique for each frame. Currently
+     * marking frame boundaries is only supported with the Vulkan backend and only if the
+     * VK_EXT_frame_boudnary extenstion is available.
      */
-    bool submit(GrSyncCpu sync = GrSyncCpu::kNo);
+    bool submit(const GrSubmitInfo&);
+
+    bool submit(GrSyncCpu sync = GrSyncCpu::kNo) {
+        GrSubmitInfo info;
+        info.fSync = sync;
+
+        return this->submit(info);
+    }
+
 
     /**
      * Checks whether any asynchronous work is complete and if so calls related callbacks.

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

@@ -174,4 +174,15 @@ enum class GrSyncCpu : bool {
     kYes = true,
 };
 
+enum class GrMarkFrameBoundary : bool {
+    kNo = false,
+    kYes = true,
+};
+
+struct GrSubmitInfo {
+    GrSyncCpu fSync = GrSyncCpu::kNo;
+    GrMarkFrameBoundary fMarkBoundary = GrMarkFrameBoundary::kNo;
+    uint64_t fFrameID = 0;
+};
+
 #endif

package/cpp/skia/include/gpu/ganesh/gl/GrGLFunctions.h

@@ -104,7 +104,6 @@ using GrGLGetProgramInfoLogFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint program, G
 using GrGLGetProgramivFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint program, GrGLenum pname, GrGLint* params);
 using GrGLGetQueryivFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum GLtarget, GrGLenum pname, GrGLint* params);
 using GrGLGetQueryObjecti64vFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint id, GrGLenum pname, GrGLint64* params);
-using GrGLGetQueryObjectivFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint id, GrGLenum pname, GrGLint* params);
 using GrGLGetQueryObjectui64vFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint id, GrGLenum pname, GrGLuint64* params);
 using GrGLGetQueryObjectuivFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint id, GrGLenum pname, GrGLuint* params);
 using GrGLGetRenderbufferParameterivFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLenum pname, GrGLint* params);
@@ -219,8 +218,13 @@ using GrGLMultiDrawElementsInstancedBaseVertexBaseInstanceFn = GrGLvoid GR_GL_FU
 /* ARB_sync */
 using GrGLFenceSyncFn = GrGLsync GR_GL_FUNCTION_TYPE(GrGLenum condition, GrGLbitfield flags);
 using GrGLIsSyncFn = GrGLboolean GR_GL_FUNCTION_TYPE(GrGLsync sync);
+#if defined(__EMSCRIPTEN__)
+using GrGLClientWaitSyncFn = GrGLenum GR_GL_FUNCTION_TYPE(GrGLsync sync, GrGLbitfield flags, GrGLint timeoutLo, GrGLint timeoutHi);
+using GrGLWaitSyncFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLsync sync, GrGLbitfield flags, GrGLuint timeoutLo, GrGLuint timeoutHi);
+#else
 using GrGLClientWaitSyncFn = GrGLenum GR_GL_FUNCTION_TYPE(GrGLsync sync, GrGLbitfield flags, GrGLuint64 timeout);
 using GrGLWaitSyncFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLsync sync, GrGLbitfield flags, GrGLuint64 timeout);
+#endif
 using GrGLDeleteSyncFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLsync sync);
 
 /* ARB_internalformat_query */

package/cpp/skia/include/gpu/ganesh/gl/GrGLInterface.h

@@ -174,7 +174,6 @@ public:
         GrGLFunction<GrGLGetProgramInfoLogFn> fGetProgramInfoLog;
         GrGLFunction<GrGLGetProgramivFn> fGetProgramiv;
         GrGLFunction<GrGLGetQueryObjecti64vFn> fGetQueryObjecti64v;
-        GrGLFunction<GrGLGetQueryObjectivFn> fGetQueryObjectiv;
         GrGLFunction<GrGLGetQueryObjectui64vFn> fGetQueryObjectui64v;
         GrGLFunction<GrGLGetQueryObjectuivFn> fGetQueryObjectuiv;
         GrGLFunction<GrGLGetQueryivFn> fGetQueryiv;

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

@@ -9,6 +9,7 @@
 #define skgpu_graphite_GraphiteTypes_DEFINED
 
 #include "include/core/SkPoint.h"
+#include "include/core/SkRect.h"
 #include "include/core/SkTypes.h"
 #include "include/gpu/GpuTypes.h"
 
@@ -44,6 +45,9 @@ using GpuFinishedProc = void (*)(GpuFinishedContext finishedContext, CallbackRes
  *
  * fTargetTranslation is an additional translation applied to draws targeting fTargetSurface.
  *
+ * fTargetClip is an additional clip applied to draws targeting fTargetSurface. It is defined in the
+ * local replay space, that is, with fTargetTranslation applied. An empty clip will not be applied.
+ *
  * The client may pass in two arrays of initialized BackendSemaphores to be included in the
  * command stream. At some time before issuing commands in the Recording, the fWaitSemaphores will
  * be waited on by the gpu. We only guarantee these wait semaphores block transfer and fragment
@@ -62,6 +66,7 @@ struct InsertRecordingInfo {
 
     SkSurface* fTargetSurface = nullptr;
     SkIVector fTargetTranslation = {0, 0};
+    SkIRect fTargetClip = {0, 0, 0, 0};
     MutableTextureState* fTargetTextureState = nullptr;
 
     size_t fNumWaitSemaphores = 0;
@@ -150,7 +155,10 @@ enum DrawTypeFlags : uint16_t {
     //    TessellateCurvesRenderStep[*] for [even-odd], [winding]
     //    MiddleOutFanRenderStep[*] for [even-odd], [winding]
     kNonSimpleShape   = 0b10000000,
+
+    kLast = kNonSimpleShape,
 };
+static constexpr int kDrawTypeFlagsCnt = static_cast<int>(DrawTypeFlags::kLast) + 1;
 
 } // namespace skgpu::graphite
 

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

@@ -58,7 +58,6 @@ class UploadBufferManager;
 class UploadList;
 
 template<typename T> class PipelineDataCache;
-using UniformDataCache = PipelineDataCache<UniformDataBlock>;
 using TextureDataCache = PipelineDataCache<TextureDataBlock>;
 
 struct SK_API RecorderOptions final {
@@ -262,7 +261,6 @@ private:
     // Aggregated one-time uploads that preceed all tasks in the root task list.
     std::unique_ptr<UploadList> fRootUploads;
 
-    std::unique_ptr<UniformDataCache> fUniformDataCache;
     std::unique_ptr<TextureDataCache> fTextureDataCache;
     std::unique_ptr<DrawBufferManager> fDrawBufferManager;
     std::unique_ptr<UploadBufferManager> fUploadBufferManager;

package/cpp/skia/include/gpu/graphite/precompile/PaintOptions.h

@@ -32,6 +32,7 @@ class KeyContext;
 class PaintOptionsPriv;
 class PaintParamsKeyBuilder;
 class PipelineDataGatherer;
+struct RenderPassDesc;
 class UniquePaintParamsID;
 
 /** \class PaintOptions
@@ -171,14 +172,16 @@ private:
     typedef std::function<void(UniquePaintParamsID id,
                                DrawTypeFlags,
                                bool withPrimitiveBlender,
-                               Coverage)> ProcessCombination;
+                               Coverage,
+                               const RenderPassDesc&)> ProcessCombination;
 
     void buildCombinations(const KeyContext&,
                            PipelineDataGatherer*,
-                           DrawTypeFlags drawTypes,
+                           DrawTypeFlags,
                            bool addPrimitiveBlender,
-                           Coverage coverage,
-                           const ProcessCombination& processCombination) const;
+                           Coverage,
+                           const RenderPassDesc&,
+                           const ProcessCombination&) const;
 
     skia_private::TArray<sk_sp<PrecompileShader>> fShaderOptions;
     skia_private::TArray<sk_sp<PrecompileColorFilter>> fColorFilterOptions;

package/cpp/skia/include/gpu/graphite/precompile/PrecompileImageFilter.h

@@ -61,10 +61,12 @@ private:
 
     virtual void onCreatePipelines(const KeyContext&,
                                    PipelineDataGatherer*,
+                                   const RenderPassDesc&,
                                    const PaintOptions::ProcessCombination&) const = 0;
 
     void createPipelines(const KeyContext&,
                          PipelineDataGatherer*,
+                         const RenderPassDesc&,
                          const PaintOptions::ProcessCombination&);
 
     skia_private::AutoSTArray<2, sk_sp<PrecompileImageFilter>> fInputs;

package/cpp/skia/include/gpu/graphite/precompile/PrecompileMaskFilter.h

@@ -31,6 +31,8 @@ protected:
 
     virtual void createPipelines(const KeyContext&,
                                  PipelineDataGatherer*,
+                                 const PaintOptions&,
+                                 const RenderPassDesc&,
                                  const PaintOptions::ProcessCombination&) const = 0;
 };
 

package/cpp/skia/include/ports/SkFontMgr_android_ndk.h

@@ -0,0 +1,25 @@
+/*
+ * 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 SkFontMgr_android_ndk_DEFINED
+#define SkFontMgr_android_ndk_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypes.h"
+
+#include <memory>
+
+class SkFontMgr;
+class SkFontScanner;
+
+/** Create a font manager for Android NDK. May return nullptr if unavailable (API < 29). */
+SK_API sk_sp<SkFontMgr> SkFontMgr_New_AndroidNDK(bool cacheFontFiles);
+
+SK_API sk_sp<SkFontMgr> SkFontMgr_New_AndroidNDK(bool cacheFontFiles,
+                                                 std::unique_ptr<SkFontScanner> scanner);
+
+#endif // SkFontMgr_android_ndk_DEFINED

package/cpp/skia/include/ports/SkFontMgr_fontconfig.h

@@ -8,8 +8,9 @@
 #ifndef SkFontMgr_fontconfig_DEFINED
 #define SkFontMgr_fontconfig_DEFINED
 
-#include "include/core/SkRefCnt.h"
 #include <fontconfig/fontconfig.h>
+#include "include/core/SkRefCnt.h"
+#include <memory>
 
 class SkFontMgr;
 
@@ -17,6 +18,7 @@ class SkFontMgr;
  *  If 'fc' is NULL, will use a new default config.
  *  Takes ownership of 'fc' and will call FcConfigDestroy on it.
  */
+class SkFontScanner;
+SK_API sk_sp<SkFontMgr> SkFontMgr_New_FontConfig(FcConfig* fc, std::unique_ptr<SkFontScanner> scanner);
 SK_API sk_sp<SkFontMgr> SkFontMgr_New_FontConfig(FcConfig* fc);
-
 #endif // #ifndef SkFontMgr_fontconfig_DEFINED

package/cpp/skia/include/ports/SkFontScanner_Fontations.h

@@ -0,0 +1,15 @@
+/*
+* Copyright 2024 Google Inc.
+*
+* Use of this source code is governed by a BSD-style license that can be
+* found in the LICENSE file.
+*/
+
+#ifndef SKFONTSCANNER_FONTATIONS_H_
+#define SKFONTSCANNER_FONTATIONS_H_
+
+#include "include/core/SkFontScanner.h"
+
+SK_API std::unique_ptr<SkFontScanner> SkFontScanner_Make_Fontations();
+
+#endif // SKFONTSCANNER_FONTATIONS_H_

package/cpp/skia/include/ports/SkFontScanner_FreeType.h

@@ -0,0 +1,15 @@
+/*
+* Copyright 2024 Google Inc.
+*
+* Use of this source code is governed by a BSD-style license that can be
+* found in the LICENSE file.
+*/
+
+#ifndef SKFONTSCANNER_FREETYPE_H_
+#define SKFONTSCANNER_FREETYPE_H_
+
+#include "include/core/SkFontScanner.h"
+
+SK_API std::unique_ptr<SkFontScanner> SkFontScanner_Make_FreeType();
+
+#endif // SKFONTSCANNER_FREETYPE_H_

package/cpp/skia/include/private/SkExif.h

@@ -9,6 +9,7 @@
 #define SkExif_DEFINED
 
 #include "include/codec/SkEncodedOrigin.h"
+#include "include/core/SkRefCnt.h"
 #include "include/private/base/SkAPI.h"
 
 #include <cstdint>
@@ -50,6 +51,19 @@ struct Metadata {
  */
 void SK_API Parse(Metadata& metadata, const SkData* data);
 
+/*
+ * Write exif data that includes the values in |metadata| and returns it as SkData
+ * untruncated. Return nullptr if a write to the data stream fails or if
+ * |metadata.fHdrHeadroom| has value.
+ * This function cannot write an IFD entry based on the HdrHeadroom value because
+ * the information of maker33 and maker48 are lost in decoding.
+ * For metadata that belongs in a subIFD the function will write it to one and
+ * store it after the root IFD.
+ * Data that does not fit within kSizeEntry, is appended to the end of the data,
+ * after the subIFD if it exists.
+ */
+sk_sp<SkData> WriteExif(Metadata& metadata);
+
 }  // namespace SkExif
 
 #endif

package/cpp/skia/include/private/SkPathRef.h

@@ -8,6 +8,7 @@
 #ifndef SkPathRef_DEFINED
 #define SkPathRef_DEFINED
 
+#include "include/core/SkArc.h"
 #include "include/core/SkPoint.h"
 #include "include/core/SkRect.h"
 #include "include/core/SkRefCnt.h"
@@ -63,6 +64,7 @@ public:
         kGeneral,
         kOval,
         kRRect,
+        kArc,
     };
 
     SkPathRef(SkSpan<const SkPoint> points, SkSpan<const uint8_t> verbs,
@@ -78,6 +80,9 @@ public:
         // The next two values don't matter unless fType is kOval or kRRect
         fRRectOrOvalIsCCW = false;
         fRRectOrOvalStartIdx = 0xAC;
+        fArcOval.setEmpty();
+        fArcStartAngle = fArcSweepAngle = 0.0f;
+        fArcType = SkArc::Type::kArc;
         SkDEBUGCODE(fEditorsAttached.store(0);)
 
         this->computeBounds();  // do this now, before we worry about multiple owners/threads
@@ -160,6 +165,10 @@ public:
             fPathRef->setIsRRect(isCCW, start);
         }
 
+        void setIsArc(const SkArc& arc) {
+            fPathRef->setIsArc(arc);
+        }
+
         void setBounds(const SkRect& rect) { fPathRef->setBounds(rect); }
 
     private:
@@ -249,6 +258,16 @@ public:
 
     bool isRRect(SkRRect* rrect, bool* isCCW, unsigned* start) const;
 
+    bool isArc(SkArc* arc) const {
+        if (fType == PathType::kArc) {
+            if (arc) {
+                *arc = SkArc::Make(fArcOval, fArcStartAngle, fArcSweepAngle, fArcType);
+            }
+        }
+
+        return fType == PathType::kArc;
+    }
+
     bool hasComputedBounds() const {
         return !fBoundsIsDirty;
     }
@@ -365,6 +384,9 @@ private:
         // The next two values don't matter unless fType is kOval or kRRect
         fRRectOrOvalIsCCW = false;
         fRRectOrOvalStartIdx = 0xAC;
+        fArcOval.setEmpty();
+        fArcStartAngle = fArcSweepAngle = 0.0f;
+        fArcType = SkArc::Type::kArc;
         if (numPoints > 0) {
             fPoints.reserve_exact(numPoints);
         }
@@ -497,6 +519,14 @@ private:
         fRRectOrOvalStartIdx = SkToU8(start);
     }
 
+    void setIsArc(const SkArc& arc) {
+        fType = PathType::kArc;
+        fArcOval = arc.fOval;
+        fArcStartAngle = arc.fStartAngle;
+        fArcSweepAngle = arc.fSweepAngle;
+        fArcType = arc.fType;
+    }
+
     // called only by the editor. Note that this is not a const function.
     SkPoint* getWritablePoints() {
         SkDEBUGCODE(this->validate();)
@@ -534,6 +564,12 @@ private:
     bool     fRRectOrOvalIsCCW;
     uint8_t  fRRectOrOvalStartIdx;
     uint8_t  fSegmentMask;
+    // If the path is an arc, these four variables store that information.
+    // We should just store an SkArc, but alignment would cost us 8 more bytes.
+    SkArc::Type fArcType;
+    SkRect      fArcOval;
+    SkScalar    fArcStartAngle;
+    SkScalar    fArcSweepAngle;
 
     friend class PathRefTest_Private;
     friend class ForceIsRRect_Private; // unit test isRRect

package/cpp/skia/include/private/base/SkFeatures.h

@@ -69,6 +69,10 @@
   #define SK_CPU_LOONGARCH 1
 #endif
 
+#if defined(__powerpc__) || defined (__powerpc64__)
+  #define SK_CPU_PPC 1
+#endif
+
 /**
  *  SK_CPU_SSE_LEVEL
  *

package/cpp/skia/include/private/base/SkSpan_impl.h

@@ -69,7 +69,7 @@ public:
     template <typename Integer, std::enable_if_t<std::is_integral_v<Integer>, bool> = true>
     constexpr SkSpan(T* ptr, Integer size) : fPtr{ptr}, fSize{SkToSizeT(size)} {
         SkASSERT(ptr || fSize == 0);  // disallow nullptr + a nonzero size
-        SkASSERT(fSize < kMaxSize);
+        SkASSERT(fSize < (std::numeric_limits<size_t>::max() / sizeof(T)));
     }
     template <typename U, typename = std::enable_if_t<std::is_same_v<const U, T>>>
     constexpr SkSpan(const SkSpan<U>& that) : fPtr(std::data(that)), fSize(std::size(that)) {}
@@ -118,8 +118,6 @@ public:
     }
 
 private:
-    static constexpr size_t kMaxSize = std::numeric_limits<size_t>::max() / sizeof(T);
-
     T* fPtr;
     size_t fSize;
 };