@shopify/react-native-skia 0.1.158 → 0.1.160

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

@@ -19,6 +19,7 @@ enum class SkFilterMode {
 
     kLast = kLinear,
 };
+static constexpr int kSkFilterModeCount = static_cast<int>(SkFilterMode::kLast) + 1;
 
 enum class SkMipmapMode {
     kNone,      // ignore mipmap levels, sample from the "base"
@@ -27,6 +28,7 @@ enum class SkMipmapMode {
 
     kLast = kLinear,
 };
+static constexpr int kSkMipmapModeCount = static_cast<int>(SkMipmapMode::kLast) + 1;
 
 /*
  *  Specify B and C (each between 0...1) to create a shader that applies the corresponding
@@ -60,7 +62,7 @@ struct SK_API SkSamplingOptions {
     const SkFilterMode     filter   = SkFilterMode::kNearest;
     const SkMipmapMode     mipmap   = SkMipmapMode::kNone;
 
-    SkSamplingOptions() = default;
+    constexpr SkSamplingOptions() = default;
     SkSamplingOptions(const SkSamplingOptions&) = default;
     SkSamplingOptions& operator=(const SkSamplingOptions& that) {
         this->~SkSamplingOptions();   // A pedantic no-op.
@@ -68,19 +70,19 @@ struct SK_API SkSamplingOptions {
         return *this;
     }
 
-    SkSamplingOptions(SkFilterMode fm, SkMipmapMode mm)
+    constexpr SkSamplingOptions(SkFilterMode fm, SkMipmapMode mm)
         : filter(fm)
         , mipmap(mm) {}
 
-    explicit SkSamplingOptions(SkFilterMode fm)
+    explicit constexpr SkSamplingOptions(SkFilterMode fm)
         : filter(fm)
         , mipmap(SkMipmapMode::kNone) {}
 
-    explicit SkSamplingOptions(const SkCubicResampler& c)
+    explicit constexpr SkSamplingOptions(const SkCubicResampler& c)
         : useCubic(true)
         , cubic(c) {}
 
-    static SkSamplingOptions Aniso(int maxAniso) {
+    static constexpr SkSamplingOptions Aniso(int maxAniso) {
         return SkSamplingOptions{std::max(maxAniso, 1)};
     }
 
@@ -97,7 +99,7 @@ struct SK_API SkSamplingOptions {
     bool isAniso() const { return maxAniso != 0; }
 
 private:
-    SkSamplingOptions(int maxAniso) : maxAniso(maxAniso) {}
+    constexpr SkSamplingOptions(int maxAniso) : maxAniso(maxAniso) {}
 };
 
 #endif

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

@@ -22,13 +22,14 @@ typedef float SkScalar;
 #define SK_ScalarTanPIOver8         0.414213562f
 #define SK_ScalarRoot2Over2         0.707106781f
 #define SK_ScalarMax                3.402823466e+38f
+#define SK_ScalarMin                (-SK_ScalarMax)
 #define SK_ScalarInfinity           SK_FloatInfinity
 #define SK_ScalarNegativeInfinity   SK_FloatNegativeInfinity
 #define SK_ScalarNaN                SK_FloatNaN
 
 #define SkScalarFloorToScalar(x)    sk_float_floor(x)
 #define SkScalarCeilToScalar(x)     sk_float_ceil(x)
-#define SkScalarRoundToScalar(x)    sk_float_floor((x) + 0.5f)
+#define SkScalarRoundToScalar(x)    sk_float_round(x)
 #define SkScalarTruncToScalar(x)    sk_float_trunc(x)
 
 #define SkScalarFloorToInt(x)       sk_float_floor2int(x)
@@ -62,8 +63,6 @@ typedef float SkScalar;
 #define SkScalarToDouble(x)     static_cast<double>(x)
 #define SkDoubleToScalar(x)     sk_double_to_float(x)
 
-#define SK_ScalarMin            (-SK_ScalarMax)
-
 static inline bool SkScalarIsNaN(SkScalar x) { return x != x; }
 
 /** Returns true if x is not NaN and not infinite
@@ -78,26 +77,6 @@ static inline bool SkScalarsAreFinite(const SkScalar array[], int count) {
     return sk_floats_are_finite(array, count);
 }
 
-/**
- *  Variant of SkScalarRoundToInt, that performs the rounding step (adding 0.5) explicitly using
- *  double, to avoid possibly losing the low bit(s) of the answer before calling floor().
- *
- *  This routine will likely be slower than SkScalarRoundToInt(), and should only be used when the
- *  extra precision is known to be valuable.
- *
- *  In particular, this catches the following case:
- *      SkScalar x = 0.49999997;
- *      int ix = SkScalarRoundToInt(x);
- *      SkASSERT(0 == ix);    // <--- fails
- *      ix = SkDScalarRoundToInt(x);
- *      SkASSERT(0 == ix);    // <--- succeeds
- */
-static inline int SkDScalarRoundToInt(SkScalar x) {
-    double xx = x;
-    xx += 0.5;
-    return (int)floor(xx);
-}
-
 /** Returns the fractional part of the scalar. */
 static inline SkScalar SkScalarFraction(SkScalar x) {
     return x - SkScalarTruncToScalar(x);
@@ -145,14 +124,16 @@ static inline bool SkScalarNearlyEqual(SkScalar x, SkScalar y,
     return SkScalarAbs(x-y) <= tolerance;
 }
 
+#define SK_ScalarSinCosNearlyZero   (SK_Scalar1 / (1 << 16))
+
 static inline float SkScalarSinSnapToZero(SkScalar radians) {
     float v = SkScalarSin(radians);
-    return SkScalarNearlyZero(v) ? 0.0f : v;
+    return SkScalarNearlyZero(v, SK_ScalarSinCosNearlyZero) ? 0.0f : v;
 }
 
 static inline float SkScalarCosSnapToZero(SkScalar radians) {
     float v = SkScalarCos(radians);
-    return SkScalarNearlyZero(v) ? 0.0f : v;
+    return SkScalarNearlyZero(v, SK_ScalarSinCosNearlyZero) ? 0.0f : v;
 }
 
 /** Linearly interpolate between A and B, based on t.

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

@@ -56,6 +56,12 @@ 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
@@ -92,24 +98,26 @@ public:
         kRadial_GradientType,
         kSweep_GradientType,
         kConical_GradientType,
-        kLast_GradientType = kConical_GradientType,
     };
 
     struct GradientInfo {
-        int         fColorCount;    //!< In-out parameter, specifies passed size
-                                    //   of fColors/fColorOffsets on input, and
-                                    //   actual number of colors/offsets on
-                                    //   output.
-        SkColor*    fColors;        //!< The colors in the gradient.
-        SkScalar*   fColorOffsets;  //!< The unit offset for color transitions.
-        SkPoint     fPoint[2];      //!< Type specific, see above.
-        SkScalar    fRadius[2];     //!< Type specific, see above.
+        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; //!< see SkGradientShader::Flags
+        uint32_t    fGradientFlags = 0;        //!< see SkGradientShader::Flags
     };
 
-    // DEPRECATED. skbug.com/8941
-    virtual GradientType asAGradient(GradientInfo* info) const;
+    GradientType asAGradient(GradientInfo* info) const;
+
+#ifndef SK_BUILD_FOR_ANDROID_FRAMEWORK
+public:
+#endif
 
     //////////////////////////////////////////////////////////////////////////
     //  Methods to create combinations or variants of shaders

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

@@ -9,29 +9,67 @@
 #define SkSpan_DEFINED
 
 #include <cstddef>
+#include <initializer_list>
 #include <iterator>
 #include <type_traits>
 #include <utility>
 #include "include/private/SkTLogic.h"
 
+// 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
+
 /**
- * An SkSpan is a view of a contiguous collection of elements of type T. It can be directly
- * constructed from a pointer and size. SkMakeSpan can be used to construct one from an array,
- * or a container (like std::vector).
+ * 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:
  *
- * With C++17, we could add template deduction guides that eliminate the need for SkMakeSpan:
- *     https://skia-review.googlesource.com/c/skia/+/320264
+ * 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(that.data()), fSize{that.size()} {}
+    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;
 
@@ -67,23 +105,17 @@ public:
     }
 
 private:
-    static constexpr size_t kMaxSize = std::numeric_limits<size_t>::max() / sizeof(T);
+    static const constexpr size_t kMaxSize = std::numeric_limits<size_t>::max() / sizeof(T);
     T* fPtr;
     size_t fSize;
 };
 
-template <typename T, typename S> inline constexpr SkSpan<T> SkMakeSpan(T* p, S s) {
-    return SkSpan<T>{p, SkTo<size_t>(s)};
-}
-
-template <size_t N, typename T> inline constexpr SkSpan<T> SkMakeSpan(T (&a)[N]) {
-    return SkSpan<T>{a, N};
-}
-
 template <typename Container>
-inline auto SkMakeSpan(Container& c)
-        -> SkSpan<typename std::remove_reference<decltype(*(c.data()))>::type> {
-    return {c.data(), c.size()};
-}
+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

@@ -122,7 +122,7 @@ public:
     }
 
 //SkStreamSeekable
-    /** Returns true if this stream can report it's current position. */
+    /** Returns true if this stream can report its current position. */
     virtual bool hasPosition() const { return false; }
     /** Returns the current position in the stream. If this cannot be done, returns 0. */
     virtual size_t getPosition() const { return 0; }
@@ -140,7 +140,7 @@ public:
     virtual bool move(long /*offset*/) { return false; }
 
 //SkStreamAsset
-    /** Returns true if this stream can report it's total length. */
+    /** Returns true if this stream can report its total length. */
     virtual bool hasLength() const { return false; }
     /** Returns the total length of the stream. If this cannot be done, returns 0. */
     virtual size_t getLength() const { return 0; }

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

@@ -184,10 +184,12 @@ public:
     void set(const SkString& src) { *this = src; }
     void set(const char text[]);
     void set(const char text[], size_t len);
+    void set(std::string_view str) { this->set(str.data(), str.size()); }
 
-    void insert(size_t offset, const SkString& src) { this->insert(offset, src.c_str(), src.size()); }
     void insert(size_t offset, const char text[]);
     void insert(size_t offset, const char text[], size_t len);
+    void insert(size_t offset, const SkString& str) { this->insert(offset, str.c_str(), str.size()); }
+    void insert(size_t offset, std::string_view str) { this->insert(offset, str.data(), str.size()); }
     void insertUnichar(size_t offset, SkUnichar);
     void insertS32(size_t offset, int32_t value);
     void insertS64(size_t offset, int64_t value, int minDigits = 0);
@@ -196,9 +198,10 @@ public:
     void insertHex(size_t offset, uint32_t value, int minDigits = 0);
     void insertScalar(size_t offset, SkScalar);
 
-    void append(const SkString& str) { this->insert((size_t)-1, str); }
     void append(const char text[]) { this->insert((size_t)-1, text); }
     void append(const char text[], size_t len) { this->insert((size_t)-1, text, len); }
+    void append(const SkString& str) { this->insert((size_t)-1, str.c_str(), str.size()); }
+    void append(std::string_view str) { this->insert((size_t)-1, str.data(), str.size()); }
     void appendUnichar(SkUnichar uni) { this->insertUnichar((size_t)-1, uni); }
     void appendS32(int32_t value) { this->insertS32((size_t)-1, value); }
     void appendS64(int64_t value, int minDigits = 0) { this->insertS64((size_t)-1, value, minDigits); }
@@ -207,9 +210,10 @@ public:
     void appendHex(uint32_t value, int minDigits = 0) { this->insertHex((size_t)-1, value, minDigits); }
     void appendScalar(SkScalar value) { this->insertScalar((size_t)-1, value); }
 
-    void prepend(const SkString& str) { this->insert(0, str); }
     void prepend(const char text[]) { this->insert(0, text); }
     void prepend(const char text[], size_t len) { this->insert(0, text, len); }
+    void prepend(const SkString& str) { this->insert(0, str.c_str(), str.size()); }
+    void prepend(std::string_view str) { this->insert(0, str.data(), str.size()); }
     void prependUnichar(SkUnichar uni) { this->insertUnichar(0, uni); }
     void prependS32(int32_t value) { this->insertS32(0, value); }
     void prependS64(int32_t value, int minDigits = 0) { this->insertS64(0, value, minDigits); }
@@ -235,6 +239,8 @@ public:
      */
     void swap(SkString& other);
 
+    using sk_is_trivially_relocatable = std::true_type;
+
 private:
     struct Rec {
     public:
@@ -259,6 +265,8 @@ private:
     };
     sk_sp<Rec> fRec;
 
+    static_assert(::sk_is_trivially_relocatable<decltype(fRec)>::value);
+
 #ifdef SK_DEBUG
     const SkString& validate() const;
 #else

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

@@ -21,24 +21,31 @@
 #include <android/hardware_buffer.h>
 #endif
 
-#ifdef SK_METAL
+#if SK_SUPPORT_GPU && defined(SK_METAL)
 #include "include/gpu/mtl/GrMtlTypes.h"
 #endif
 
 class SkCanvas;
+class SkCapabilities;
 class SkDeferredDisplayList;
 class SkPaint;
 class SkSurfaceCharacterization;
 class GrBackendRenderTarget;
 class GrBackendSemaphore;
-class GrBackendSurfaceMutableState;
 class GrBackendTexture;
 class GrDirectContext;
 class GrRecordingContext;
 class GrRenderTarget;
 enum GrSurfaceOrigin: int;
 
-namespace skgpu::graphite { class Recorder; }
+namespace skgpu {
+class MutableTextureState;
+}
+
+namespace skgpu::graphite {
+class BackendTexture;
+class Recorder;
+}
 
 /** \class SkSurface
     SkSurface is responsible for managing the pixels that a canvas draws into. The pixels can be
@@ -391,7 +398,41 @@ public:
                                                     );
 #endif
 
-#ifdef SK_METAL
+#ifdef SK_GRAPHITE_ENABLED
+    /**
+     * In Graphite, while clients hold a ref on an SkSurface, the backing gpu object does _not_
+     * count against the budget. Once an SkSurface is freed, the backing gpu object may or may
+     * not become a scratch (i.e., reusable) resource but, if it does, it will be counted against
+     * the budget.
+     */
+    static sk_sp<SkSurface> MakeGraphite(
+            skgpu::graphite::Recorder*,
+            const SkImageInfo& imageInfo,
+            skgpu::graphite::Mipmapped = skgpu::graphite::Mipmapped::kNo,
+            const SkSurfaceProps* surfaceProps = nullptr);
+
+    /**
+     * Wraps a GPU-backed texture in an SkSurface. Depending on the backend gpu API, the caller may
+     * be required to ensure the texture is valid for the lifetime of the returned SkSurface. The
+     * required lifetimes for the specific apis are:
+     *     Metal: Skia will call retain on the underlying MTLTexture so the caller can drop it once
+     *            this call returns.
+     *
+     * SkSurface is returned if all the parameters are valid. The backendTexture is valid if its
+     * format agrees with colorSpace and recorder; for instance, if backendTexture has an sRGB
+     * configuration, then the recorder must support sRGB, and colorSpace must be present. Further,
+     * backendTexture's width and height must not exceed the recorder's capabilities, and the
+     * recorder must be able to support the back-end texture.
+     */
+    static sk_sp<SkSurface> MakeGraphiteFromBackendTexture(skgpu::graphite::Recorder*,
+                                                           const skgpu::graphite::BackendTexture&,
+                                                           SkColorType colorType,
+                                                           sk_sp<SkColorSpace> colorSpace,
+                                                           const SkSurfaceProps* props);
+
+#endif // SK_GRAPHITE_ENABLED
+
+#if SK_SUPPORT_GPU && defined(SK_METAL)
     /** Creates SkSurface from CAMetalLayer.
         Returned SkSurface takes a reference on the CAMetalLayer. The ref on the layer will be
         released when the SkSurface is destroyed.
@@ -600,6 +641,12 @@ public:
     */
     SkCanvas* getCanvas();
 
+    /** Returns SkCapabilities that describes the capabilities of the SkSurface's device.
+
+        @return  SkCapabilities of SkSurface's device.
+    */
+    sk_sp<const SkCapabilities> capabilities();
+
     /** Returns a compatible SkSurface, or nullptr. Returned SkSurface contains
         the same raster, GPU, or null properties as the original. Returned SkSurface
         does not share the same pixels.
@@ -787,6 +834,36 @@ public:
     using RescaleGamma = SkImage::RescaleGamma;
     using RescaleMode  = SkImage::RescaleMode;
 
+    /** Makes surface pixel data available to caller, possibly asynchronously.
+
+        Currently asynchronous reads are only supported on the GPU backend and only when the
+        underlying 3D API supports transfer buffers and CPU/GPU synchronization primitives. In all
+        other cases this operates synchronously.
+
+        Data is read from the source sub-rectangle, then converted to the color space, color type,
+        and alpha type of 'info'. A 'srcRect' that is not contained by the bounds of the surface
+        causes failure.
+
+        When the pixel data is ready the caller's ReadPixelsCallback is called with a
+        AsyncReadResult containing pixel data in the requested color type, alpha type, and color
+        space. The AsyncReadResult will have count() == 1. Upon failure the callback is called
+        with nullptr for AsyncReadResult. For a GPU surface this flushes work but a submit must
+        occur to guarantee a finite time before the callback is called.
+
+        The data is valid for the lifetime of AsyncReadResult with the exception that if the
+        SkSurface is GPU-backed the data is immediately invalidated if the context is abandoned
+        or destroyed.
+
+        @param info            info of the requested pixels
+        @param srcRect         subrectangle of surface to read
+        @param callback        function to call with result of the read
+        @param context         passed to callback
+     */
+    void asyncReadPixels(const SkImageInfo& info,
+                         const SkIRect& srcRect,
+                         ReadPixelsCallback callback,
+                         ReadPixelsContext context);
+
     /** Makes surface pixel data available to caller, possibly asynchronously. It can also rescale
         the surface pixels.
 
@@ -990,15 +1067,15 @@ public:
         The GrFlushInfo describes additional options to flush. Please see documentation at
         GrFlushInfo for more info.
 
-        If a GrBackendSurfaceMutableState is passed in, at the end of the flush we will transition
-        the surface to be in the state requested by the GrBackendSurfaceMutableState. If the surface
+        If a skgpu::MutableTextureState is passed in, at the end of the flush we will transition
+        the surface to be in the state requested by the skgpu::MutableTextureState. If the surface
         (or SkImage or GrBackendSurface wrapping the same backend object) is used again after this
         flush the state may be changed and no longer match what is requested here. This is often
         used if the surface will be used for presenting or external use and the client wants backend
         object to be prepped for that use. A finishedProc or semaphore on the GrFlushInfo will also
         include the work for any requested state change.
 
-        If the backend API is Vulkan, the caller can set the GrBackendSurfaceMutableState's
+        If the backend API is Vulkan, the caller can set the skgpu::MutableTextureState's
         VkImageLayout to VK_IMAGE_LAYOUT_UNDEFINED or queueFamilyIndex to VK_QUEUE_FAMILY_IGNORED to
         tell Skia to not change those respective states.
 
@@ -1022,7 +1099,7 @@ public:
         @param access  optional state change request after flush
     */
     GrSemaphoresSubmitted flush(const GrFlushInfo& info,
-                                const GrBackendSurfaceMutableState* newState = nullptr);
+                                const skgpu::MutableTextureState* newState = nullptr);
 #endif // SK_SUPPORT_GPU
 
     void flush();

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

@@ -20,6 +20,10 @@ struct SkRSXform;
 struct SkSerialProcs;
 struct SkDeserialProcs;
 
+namespace sktext {
+class GlyphRunList;
+}
+
 /** \class SkTextBlob
     SkTextBlob combines multiple text runs into an immutable container. Each text
     run consists of glyphs, SkPaint, and position. Only parts of SkPaint related to
@@ -250,8 +254,7 @@ private:
         fCacheID.store(cacheID);
     }
 
-    friend class SkGlyphRunList;
-    friend class GrTextBlobCache;
+    friend class sktext::GlyphRunList;
     friend class SkTextBlobBuilder;
     friend class SkTextBlobPriv;
     friend class SkTextBlobRunIterator;

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

@@ -193,9 +193,9 @@
 #else
     #include "include/config/SkUserConfig.h"
 #endif
+// IWYU pragma: end_exports
 #include <stddef.h>
 #include <stdint.h>
-// IWYU pragma: end_exports
 
 // Post SkUserConfig.h checks and such.
 #if !defined(SK_DEBUG) && !defined(SK_RELEASE)
@@ -236,7 +236,7 @@
 #  define SK_SUPPORT_GPU 1
 #endif
 
-#if SK_SUPPORT_GPU || SK_GRAPHITE_ENABLED
+#if SK_SUPPORT_GPU || defined(SK_GRAPHITE_ENABLED)
 #  if !defined(SK_ENABLE_SKSL)
 #    define SK_ENABLE_SKSL
 #  endif
@@ -340,14 +340,6 @@
 #  endif
 #endif
 
-#if !defined(SK_MAYBE_UNUSED)
-#  if defined(__clang__) || defined(__GNUC__)
-#    define SK_MAYBE_UNUSED [[maybe_unused]]
-#  else
-#    define SK_MAYBE_UNUSED
-#  endif
-#endif
-
 /**
  * If your judgment is better than the compiler's (i.e. you've profiled it),
  * you can use SK_ALWAYS_INLINE to force inlining. E.g.
@@ -529,6 +521,15 @@ static inline constexpr int64_t SkLeftShift(int64_t value, int32_t shift) {
 
 /** @return the number of entries in an array (not a pointer)
 */
+// The SkArrayCountHelper template returns a type 'char (&)[N]', a reference to an array of
+// char with N elements, where N is deduced using function parameter type deduction. This is then
+// used in the sizeof operator in SK_ARRAY_COUNT. The sizeof operator ignores the reference, and
+// just evaluates the size of the array type.
+//
+// DEPRECATED: use std::size() instead.
+// Note: Rarely, std::size(z) can't deduce the type of z during compile time for static_assert
+// while SK_ARRAY_COUNT can. It can't be deduced because z is part of class, and the class' this
+// pointer is not a valid constexpr expression. Use SkASSERT instead.
 template <typename T, size_t N> char (&SkArrayCountHelper(T (&array)[N]))[N];
 #define SK_ARRAY_COUNT(array) (sizeof(SkArrayCountHelper(array)))
 

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

@@ -35,14 +35,9 @@ public:
     void appendInt(const char* owner, const char* name, int value);
     void appendFloat(const char* owner, const char* name, float value);
     void appendName(const char* owner, const char* attrName, const char* value);
-    void appendString(const char* owner, const char* attrName, const char* value);
     void appendFloatArray(const char* owner,
                           const char* name,
                           const std::vector<float>& value);
-    // Deprecated.
-    void appendStringArray(const char* owner,
-                           const char* attrName,
-                           const std::vector<SkString>& values);
     void appendNodeIdArray(const char* owner,
                            const char* attrName,
                            const std::vector<int>& nodeIds);

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

@@ -8,7 +8,12 @@
 #ifndef Sk1DPathEffect_DEFINED
 #define Sk1DPathEffect_DEFINED
 
-#include "include/core/SkPathEffect.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkTypes.h"
+
+class SkPath;
+class SkPathEffect;
 
 class SK_API SkPath1DPathEffect {
 public:

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

@@ -8,10 +8,13 @@
 #ifndef Sk2DPathEffect_DEFINED
 #define Sk2DPathEffect_DEFINED
 
-#include "include/core/SkPathEffect.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkTypes.h"
 
 class SkMatrix;
 class SkPath;
+class SkPathEffect;
 
 class SK_API SkLine2DPathEffect {
 public:

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

@@ -9,6 +9,7 @@
 #define SkColorMatrix_DEFINED
 
 #include "include/core/SkImageInfo.h"
+#include "include/core/SkTypes.h"
 
 #include <algorithm>
 #include <array>

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

@@ -9,17 +9,14 @@
 #define SkColorMatrixFilter_DEFINED
 
 #include "include/core/SkColorFilter.h"
-#include "include/effects/SkColorMatrix.h"
 
+// (DEPRECATED) This factory function is deprecated. Please use the one in
+// SkColorFilters (i.e., Lighting).
 class SK_API SkColorMatrixFilter : public SkColorFilter {
 public:
-    /**
-     *  Create a colorfilter that multiplies the RGB channels by one color, and
-     *  then adds a second color, pinning the result for each component to
-     *  [0..255]. The alpha components of the mul and add arguments
-     *  are ignored.
-     */
-    static sk_sp<SkColorFilter> MakeLightingFilter(SkColor mul, SkColor add);
+    static sk_sp<SkColorFilter> MakeLightingFilter(SkColor mul, SkColor add) {
+        return SkColorFilters::Lighting(mul, add);
+    }
 };
 
 #endif