@shopify/react-native-skia 0.1.192 → 0.1.193

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

@@ -9,11 +9,21 @@
 #define SkPixmap_DEFINED
 
 #include "include/core/SkColor.h"
+#include "include/core/SkColorType.h"
 #include "include/core/SkImageInfo.h"
+#include "include/core/SkRect.h"
+#include "include/core/SkRefCnt.h"
 #include "include/core/SkSamplingOptions.h"
+#include "include/core/SkSize.h"
+#include "include/private/base/SkAPI.h"
+#include "include/private/base/SkAssert.h"
+#include "include/private/base/SkAttributes.h"
+
+#include <cstddef>
+#include <cstdint>
 
 class SkColorSpace;
-class SkData;
+enum SkAlphaType : int;
 struct SkMask;
 
 /** \class SkPixmap
@@ -702,39 +712,21 @@ public:
     */
     bool erase(SkColor color) const { return this->erase(color, this->bounds()); }
 
-    /** Writes color to pixels bounded by subset; returns true on success.
-        if subset is nullptr, writes colors pixels inside bounds(). Returns false if
-        colorType() is kUnknown_SkColorType, if subset is not nullptr and does
-        not intersect bounds(), or if subset is nullptr and bounds() is empty.
-
-        @param color   sRGB unpremultiplied color to write
-        @param subset  bounding integer SkRect of pixels to write; may be nullptr
-        @return        true if pixels are changed
-
-        example: https://fiddle.skia.org/c/@Pixmap_erase_3
-    */
-    bool erase(const SkColor4f& color, const SkIRect* subset = nullptr) const {
-        return this->erase(color, nullptr, subset);
-    }
-
     /** Writes color to pixels bounded by subset; returns true on success.
         if subset is nullptr, writes colors pixels inside bounds(). Returns false if
         colorType() is kUnknown_SkColorType, if subset is not nullptr and does
         not intersect bounds(), or if subset is nullptr and bounds() is empty.
 
         @param color   unpremultiplied color to write
-        @param cs      SkColorSpace of color
         @param subset  bounding integer SkRect of pixels to write; may be nullptr
         @return        true if pixels are changed
     */
-    bool erase(const SkColor4f& color, SkColorSpace* cs, const SkIRect* subset = nullptr) const;
+    bool erase(const SkColor4f& color, const SkIRect* subset = nullptr) const;
 
 private:
     const void*     fPixels;
     size_t          fRowBytes;
     SkImageInfo     fInfo;
-
-    friend class SkPixmapPriv;
 };
 
 #endif

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

@@ -8,9 +8,11 @@
 #ifndef SkPoint_DEFINED
 #define SkPoint_DEFINED
 
-#include "include/core/SkMath.h"
 #include "include/core/SkScalar.h"
-#include "include/private/SkSafe32.h"
+#include "include/core/SkTypes.h"
+#include "include/private/base/SkSafe32.h"
+
+#include <cstdint>
 
 struct SkIPoint;
 

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

@@ -10,7 +10,7 @@
 
 #include "include/core/SkTypes.h"
 
-#if SK_SUPPORT_GPU
+#if defined(SK_GANESH)
 #include "include/core/SkRefCnt.h"
 #include "include/gpu/GrBackendSurface.h"
 /**
@@ -41,6 +41,6 @@ private:
 
     GrBackendTexture fBackendTexture;
 };
-#endif // SK_SUPPORT_GPU
+#endif // defined(SK_GANESH)
 
 #endif // SkPromiseImageTexture_DEFINED

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

@@ -10,8 +10,12 @@
 
 #include "include/core/SkPoint.h"
 #include "include/core/SkRect.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkTypes.h"
+
+#include <cstdint>
+#include <cstring>
 
-class SkPath;
 class SkMatrix;
 class SkString;
 

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

@@ -9,12 +9,15 @@
 #define SkRect_DEFINED
 
 #include "include/core/SkPoint.h"
+#include "include/core/SkScalar.h"
 #include "include/core/SkSize.h"
-#include "include/private/SkSafe32.h"
-#include "include/private/SkTFitsIn.h"
+#include "include/core/SkTypes.h"
+#include "include/private/base/SkSafe32.h"
+#include "include/private/base/SkTFitsIn.h"
 
+#include <string>
 #include <algorithm>
-#include <utility>
+#include <cstdint>
 
 struct SkRect;
 

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

@@ -9,14 +9,14 @@
 #define SkRefCnt_DEFINED
 
 #include "include/core/SkTypes.h"
-#include "include/private/SkTemplates.h"
+#include "include/private/base/SkDebug.h"
 
-#include <atomic>       // std::atomic, std::memory_order_*
-#include <cstddef>      // std::nullptr_t
-#include <iosfwd>       // std::basic_ostream
-#include <memory>       // TODO: unused
-#include <type_traits>  // std::enable_if, std::is_convertible
-#include <utility>      // std::forward, std::swap
+#include <atomic>
+#include <cstddef>
+#include <cstdint>
+#include <iosfwd>
+#include <type_traits>
+#include <utility>
 
 /** \class SkRefCntBase
 
@@ -174,7 +174,7 @@ public:
 
     bool unique() const { return 1 == fRefCnt.load(std::memory_order_acquire); }
     void ref() const { (void)fRefCnt.fetch_add(+1, std::memory_order_relaxed); }
-    void  unref() const {
+    void unref() const {
         if (1 == fRefCnt.fetch_add(-1, std::memory_order_acq_rel)) {
             // restore the 1 for our destructor's assert
             SkDEBUGCODE(fRefCnt.store(1, std::memory_order_relaxed));
@@ -217,12 +217,7 @@ private:
  *  may be considered as trivially relocatable by the compiler so that destroying-move operations
  *  i.e. move constructor followed by destructor can be optimized to memcpy.
  */
-#if defined(__clang__) && defined(__has_cpp_attribute) && __has_cpp_attribute(clang::trivial_abi)
-#define SK_SP_TRIVIAL_ABI [[clang::trivial_abi]]
-#else
-#define SK_SP_TRIVIAL_ABI
-#endif
-template <typename T> class SK_SP_TRIVIAL_ABI sk_sp {
+template <typename T> class SK_TRIVIAL_ABI sk_sp {
 public:
     using element_type = T;
 

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

@@ -9,7 +9,7 @@
 #define SkRegion_DEFINED
 
 #include "include/core/SkRect.h"
-#include "include/private/SkTemplates.h"
+#include "include/private/base/SkTypeTraits.h"
 
 class SkPath;
 class SkRgnBuilder;

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

@@ -8,10 +8,8 @@
 #ifndef SkScalar_DEFINED
 #define SkScalar_DEFINED
 
-#include "include/private/SkFloatingPoint.h"
-
-#undef SK_SCALAR_IS_FLOAT
-#define SK_SCALAR_IS_FLOAT  1
+#include "include/private/base/SkAssert.h"
+#include "include/private/base/SkFloatingPoint.h"
 
 typedef float SkScalar;
 

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

@@ -8,9 +8,15 @@
 #ifndef SkSerialProcs_DEFINED
 #define SkSerialProcs_DEFINED
 
-#include "include/core/SkImage.h"
-#include "include/core/SkPicture.h"
-#include "include/core/SkTypeface.h"
+#include "include/core/SkRefCnt.h"
+#include "include/private/base/SkAPI.h"
+
+#include <cstddef>
+
+class SkData;
+class SkImage;
+class SkPicture;
+class SkTypeface;
 
 /**
  *  A serial-proc is asked to serialize the specified object (e.g. picture or image).
@@ -22,30 +28,32 @@
  *  The default action for typefaces is to use Skia's internal format.
  */
 
-typedef sk_sp<SkData> (*SkSerialPictureProc)(SkPicture*, void* ctx);
-typedef sk_sp<SkData> (*SkSerialImageProc)(SkImage*, void* ctx);
-typedef sk_sp<SkData> (*SkSerialTypefaceProc)(SkTypeface*, void* ctx);
+using SkSerialPictureProc = sk_sp<SkData> (*)(SkPicture*, void* ctx);
+using SkSerialImageProc = sk_sp<SkData> (*)(SkImage*, void* ctx);
+using SkSerialTypefaceProc = sk_sp<SkData> (*)(SkTypeface*, void* ctx);
 
 /**
  *  Called with the encoded form of a picture (previously written with a custom
  *  SkSerialPictureProc proc). Return a picture object, or nullptr indicating failure.
  */
-typedef sk_sp<SkPicture> (*SkDeserialPictureProc)(const void* data, size_t length, void* ctx);
+using SkDeserialPictureProc = sk_sp<SkPicture> (*)(const void* data, size_t length, void* ctx);
 
 /**
- *  Called with the encoded from of an image. The proc can return an image object, or if it
+ *  Called with the encoded form of an image. The proc can return an image object, or if it
  *  returns nullptr, then Skia will take its default action to try to create an image from the data.
  *
+ *  This will also be used to decode the internal mipmap layers that are saved on some images.
+ *
  *  Note that unlike SkDeserialPictureProc and SkDeserialTypefaceProc, return nullptr from this
  *  does not indicate failure, but is a signal for Skia to take its default action.
  */
-typedef sk_sp<SkImage> (*SkDeserialImageProc)(const void* data, size_t length, void* ctx);
+using SkDeserialImageProc = sk_sp<SkImage> (*)(const void* data, size_t length, void* ctx);
 
 /**
  *  Called with the encoded form of a typeface (previously written with a custom
  *  SkSerialTypefaceProc proc). Return a typeface object, or nullptr indicating failure.
  */
-typedef sk_sp<SkTypeface> (*SkDeserialTypefaceProc)(const void* data, size_t length, void* ctx);
+using SkDeserialTypefaceProc = sk_sp<SkTypeface> (*)(const void* data, size_t length, void* ctx);
 
 struct SK_API SkSerialProcs {
     SkSerialPictureProc fPictureProc = nullptr;

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

@@ -56,69 +56,6 @@ public:
         return this->isAImage(nullptr, (SkTileMode*)nullptr) != nullptr;
     }
 
-    // TODO(skbug.com/8941): Have Android use SkAndroidFrameworkUtils, move types to SkShaderBase,
-    // and delete asAGradient().
-#ifndef SK_BUILD_FOR_ANDROID_FRAMEWORK
-private:
-#endif
-
-    /**
-     *  If the shader subclass can be represented as a gradient, asAGradient
-     *  returns the matching GradientType enum (or kNone_GradientType if it
-     *  cannot). Also, if info is not null, asAGradient populates info with
-     *  the relevant (see below) parameters for the gradient.  fColorCount
-     *  is both an input and output parameter.  On input, it indicates how
-     *  many entries in fColors and fColorOffsets can be used, if they are
-     *  non-NULL.  After asAGradient has run, fColorCount indicates how
-     *  many color-offset pairs there are in the gradient.  If there is
-     *  insufficient space to store all of the color-offset pairs, fColors
-     *  and fColorOffsets will not be altered.  fColorOffsets specifies
-     *  where on the range of 0 to 1 to transition to the given color.
-     *  The meaning of fPoint and fRadius is dependant on the type of gradient.
-     *
-     *  None:
-     *      info is ignored.
-     *  Color:
-     *      fColorOffsets[0] is meaningless.
-     *  Linear:
-     *      fPoint[0] and fPoint[1] are the end-points of the gradient
-     *  Radial:
-     *      fPoint[0] and fRadius[0] are the center and radius
-     *  Conical:
-     *      fPoint[0] and fRadius[0] are the center and radius of the 1st circle
-     *      fPoint[1] and fRadius[1] are the center and radius of the 2nd circle
-     *  Sweep:
-     *      fPoint[0] is the center of the sweep.
-     */
-
-    enum GradientType {
-        kNone_GradientType,
-        kColor_GradientType,
-        kLinear_GradientType,
-        kRadial_GradientType,
-        kSweep_GradientType,
-        kConical_GradientType,
-    };
-
-    struct GradientInfo {
-        int         fColorCount    = 0;        //!< In-out parameter, specifies passed size
-                                               //   of fColors/fColorOffsets on input, and
-                                               //   actual number of colors/offsets on
-                                               //   output.
-        SkColor*    fColors        = nullptr;  //!< The colors in the gradient.
-        SkScalar*   fColorOffsets  = nullptr;  //!< The unit offset for color transitions.
-        SkPoint     fPoint[2];                 //!< Type specific, see above.
-        SkScalar    fRadius[2];                //!< Type specific, see above.
-        SkTileMode  fTileMode;
-        uint32_t    fGradientFlags = 0;        //!< see SkGradientShader::Flags
-    };
-
-    GradientType asAGradient(GradientInfo* info) const;
-
-#ifndef SK_BUILD_FOR_ANDROID_FRAMEWORK
-public:
-#endif
-
     //////////////////////////////////////////////////////////////////////////
     //  Methods to create combinations or variants of shaders
 
@@ -148,7 +85,7 @@ public:
     static sk_sp<SkShader> Color(const SkColor4f&, sk_sp<SkColorSpace>);
     static sk_sp<SkShader> Blend(SkBlendMode mode, sk_sp<SkShader> dst, sk_sp<SkShader> src);
     static sk_sp<SkShader> Blend(sk_sp<SkBlender>, sk_sp<SkShader> dst, sk_sp<SkShader> src);
-
+    static sk_sp<SkShader> CoordClamp(sk_sp<SkShader>, const SkRect& subset);
 private:
     SkShaders() = delete;
 };

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

@@ -10,6 +10,8 @@
 
 #include "include/core/SkScalar.h"
 
+#include <cstdint>
+
 struct SkISize {
     int32_t fWidth;
     int32_t fHeight;

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

@@ -5,117 +5,9 @@
  * found in the LICENSE file.
  */
 
-#ifndef SkSpan_DEFINED
-#define SkSpan_DEFINED
+// We want SkSpan to be a public API, but it is also fundamental to many of our internal types.
+// Thus, we have a public file that clients can include. This file defers to the private copy
+// so we do not have a dependency cycle from our "base" files to our "core" files.
 
-#include <cstddef>
-#include <initializer_list>
-#include <iterator>
-#include <type_traits>
-#include <utility>
-#include "include/private/SkTLogic.h"
+#include "include/private/base/SkSpan_impl.h" // IWYU pragma: export
 
-// Add macro to check the lifetime of initializer_list arguments. initializer_list has a very
-// short life span, and can only be used as a parameter, and not as a variable.
-#if defined(__clang__) && defined(__has_cpp_attribute) && __has_cpp_attribute(clang::lifetimebound)
-#define SK_CHECK_IL_LIFETIME [[clang::lifetimebound]]
-#else
-#define SK_CHECK_IL_LIFETIME
-#endif
-
-/**
- * SkSpan holds a reference to contiguous data of type T along with a count. SkSpan does not own
- * the data itself but is merely a reference, therefore you must take care with the lifetime of
- * the underlying data.
- *
- * SkSpan is a count and a pointer into existing array or data type that stores its data in
- * contiguous memory like std::vector. Any container that works with std::size() and std::data()
- * can be used.
- *
- * SkSpan makes a convenient parameter for a routine to accept array like things. This allows you to
- * write the routine without overloads for all different container types.
- *
- * Example:
- *     void routine(SkSpan<const int> a) { ... }
- *
- *     std::vector v = {1, 2, 3, 4, 5};
- *
- *     routine(a);
- *
- * A word of caution when working with initializer_list, initializer_lists have a lifetime that is
- * limited to the current statement. The following is correct and safe:
- *
- * Example:
- *     routine({1,2,3,4,5});
- *
- * The following is undefined, and will result in erratic execution:
- *
- * Bad Example:
- *     initializer_list l = {1, 2, 3, 4, 5};   // The data behind l dies at the ;.
- *     routine(l);
- */
-template <typename T>
-class SkSpan {
-public:
-    constexpr SkSpan() : fPtr{nullptr}, fSize{0} {}
-    constexpr SkSpan(T* ptr, size_t size) : fPtr{ptr}, fSize{size} {
-        SkASSERT(ptr || size == 0);  // disallow nullptr + a nonzero size
-        SkASSERT(size < kMaxSize);
-    }
-    template <typename U, typename = typename std::enable_if<std::is_same<const U, T>::value>::type>
-    constexpr SkSpan(const SkSpan<U>& that) : fPtr(std::data(that)), fSize{std::size(that)} {}
-    constexpr SkSpan(const SkSpan& o) = default;
-    template<size_t N> constexpr SkSpan(T(&a)[N]) : SkSpan(a, N) { }
-    template<typename Container>
-    constexpr SkSpan(Container& c) : SkSpan{std::data(c), std::size(c)} { }
-    SkSpan(std::initializer_list<T> il SK_CHECK_IL_LIFETIME)
-            : SkSpan(std::data(il), std::size(il)) {}
-
-    constexpr SkSpan& operator=(const SkSpan& that) = default;
-
-    constexpr T& operator [] (size_t i) const {
-        SkASSERT(i < this->size());
-        return fPtr[i];
-    }
-    constexpr T& front() const { return fPtr[0]; }
-    constexpr T& back()  const { return fPtr[fSize - 1]; }
-    constexpr T* begin() const { return fPtr; }
-    constexpr T* end() const { return fPtr + fSize; }
-    constexpr auto rbegin() const { return std::make_reverse_iterator(this->end()); }
-    constexpr auto rend() const { return std::make_reverse_iterator(this->begin()); }
-    constexpr T* data() const { return this->begin(); }
-    constexpr size_t size() const { return fSize; }
-    constexpr bool empty() const { return fSize == 0; }
-    constexpr size_t size_bytes() const { return fSize * sizeof(T); }
-    constexpr SkSpan<T> first(size_t prefixLen) const {
-        SkASSERT(prefixLen <= this->size());
-        return SkSpan{fPtr, prefixLen};
-    }
-    constexpr SkSpan<T> last(size_t postfixLen) const {
-        SkASSERT(postfixLen <= this->size());
-        return SkSpan{fPtr + (this->size() - postfixLen), postfixLen};
-    }
-    constexpr SkSpan<T> subspan(size_t offset) const {
-        return this->subspan(offset, this->size() - offset);
-    }
-    constexpr SkSpan<T> subspan(size_t offset, size_t count) const {
-        SkASSERT(offset <= this->size());
-        SkASSERT(count <= this->size() - offset);
-        return SkSpan{fPtr + offset, count};
-    }
-
-private:
-    static const constexpr size_t kMaxSize = std::numeric_limits<size_t>::max() / sizeof(T);
-    T* fPtr;
-    size_t fSize;
-};
-
-template <typename Container>
-SkSpan(Container&) ->
-        SkSpan<std::remove_pointer_t<decltype(std::data(std::declval<Container&>()))>>;
-
-template <typename T>
-SkSpan(std::initializer_list<T>) ->
-    SkSpan<std::remove_pointer_t<decltype(std::data(std::declval<std::initializer_list<T>>()))>>;
-
-#endif  // SkSpan_DEFINED

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

@@ -11,15 +11,16 @@
 #include "include/core/SkData.h"
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkScalar.h"
-#include "include/private/SkTo.h"
-
-#include <memory.h>
-
-class SkStream;
-class SkStreamRewindable;
-class SkStreamSeekable;
+#include "include/core/SkTypes.h"
+#include "include/private/base/SkCPUTypes.h"
+#include "include/private/base/SkTo.h"
+
+#include <cstdint>
+#include <cstdio>
+#include <cstring>
+#include <memory>
+#include <utility>
 class SkStreamAsset;
-class SkStreamMemory;
 
 /**
  *  SkStream -- abstraction for a source of bytes. Subclasses can be backed by
@@ -255,10 +256,10 @@ public:
 
     bool writeText(const char text[]) {
         SkASSERT(text);
-        return this->write(text, strlen(text));
+        return this->write(text, std::strlen(text));
     }
 
-    bool newline() { return this->write("\n", strlen("\n")); }
+    bool newline() { return this->write("\n", std::strlen("\n")); }
 
     bool writeDecAsText(int32_t);
     bool writeBigDecAsText(int64_t, int minDigits = 0);
@@ -296,8 +297,6 @@ private:
 
 ////////////////////////////////////////////////////////////////////////////////////////
 
-#include <stdio.h>
-
 /** A stream that wraps a C FILE* file stream. */
 class SK_API SkFILEStream : public SkStreamAsset {
 public:

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

@@ -11,15 +11,16 @@
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkScalar.h"
 #include "include/core/SkTypes.h"
-#include "include/private/SkMalloc.h"
-#include "include/private/SkTArray.h"
-#include "include/private/SkTo.h"
+#include "include/private/base/SkTo.h"
+#include "include/private/base/SkTypeTraits.h"
 
-#include <stdarg.h>
-#include <string.h>
 #include <atomic>
+#include <cstdarg>
+#include <cstddef>
+#include <cstdint>
 #include <string>
 #include <string_view>
+#include <type_traits>
 
 /*  Some helper functions for C strings */
 static inline bool SkStrStartsWith(const char string[], const char prefixStr[]) {
@@ -128,6 +129,7 @@ public:
 
     bool        isEmpty() const { return 0 == fRec->fLength; }
     size_t      size() const { return (size_t) fRec->fLength; }
+    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]; }
 
@@ -173,8 +175,8 @@ public:
     SkString& operator=(SkString&&);
     SkString& operator=(const char text[]);
 
-    char* writable_str();
-    char& operator[](size_t n) { return this->writable_str()[n]; }
+    char* data();
+    char& operator[](size_t n) { return this->data()[n]; }
 
     void reset();
     /** String contents are preserved on resize. (For destructive resize, `set(nullptr, length)`.)
@@ -286,22 +288,4 @@ static inline void swap(SkString& a, SkString& b) {
     a.swap(b);
 }
 
-enum SkStrSplitMode {
-    // Strictly return all results. If the input is ",," and the separator is ',' this will return
-    // an array of three empty strings.
-    kStrict_SkStrSplitMode,
-
-    // Only nonempty results will be added to the results. Multiple separators will be
-    // coalesced. Separators at the beginning and end of the input will be ignored.  If the input is
-    // ",," and the separator is ',', this will return an empty vector.
-    kCoalesce_SkStrSplitMode
-};
-
-// Split str on any characters in delimiters into out.  (Think, strtok with a sane API.)
-void SkStrSplit(const char* str, const char* delimiters, SkStrSplitMode splitMode,
-                SkTArray<SkString>* out);
-inline void SkStrSplit(const char* str, const char* delimiters, SkTArray<SkString>* out) {
-    SkStrSplit(str, delimiters, kCoalesce_SkStrSplitMode, out);
-}
-
 #endif

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

@@ -9,7 +9,7 @@
 #define SkStrokeRec_DEFINED
 
 #include "include/core/SkPaint.h"
-#include "include/private/SkMacros.h"
+#include "include/private/base/SkMacros.h"
 
 class SkPath;