@shopify/react-native-skia 0.1.212 → 0.1.214

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

@@ -12,52 +12,42 @@
 #include "include/private/base/SkFloatBits.h"
 #include "include/private/base/SkMath.h"
 
-#include <cfloat>
 #include <cmath>
 #include <cstdint>
 #include <cstring>
-
-constexpr float SK_FloatSqrt2 = 1.41421356f;
-constexpr float SK_FloatPI    = 3.14159265f;
-constexpr double SK_DoublePI  = 3.14159265358979323846264338327950288;
-
-// C++98 cmath std::pow seems to be the earliest portable way to get float pow.
-// However, on Linux including cmath undefines isfinite.
-// http://gcc.gnu.org/bugzilla/show_bug.cgi?id=14608
-static inline float sk_float_pow(float base, float exp) {
-    return powf(base, exp);
-}
-
-#define sk_float_sqrt(x)        sqrtf(x)
-#define sk_float_sin(x)         sinf(x)
-#define sk_float_cos(x)         cosf(x)
-#define sk_float_tan(x)         tanf(x)
-#define sk_float_floor(x)       floorf(x)
-#define sk_float_ceil(x)        ceilf(x)
-#define sk_float_trunc(x)       truncf(x)
-#ifdef SK_BUILD_FOR_MAC
-#    define sk_float_acos(x)    static_cast<float>(acos(x))
-#    define sk_float_asin(x)    static_cast<float>(asin(x))
-#else
-#    define sk_float_acos(x)    acosf(x)
-#    define sk_float_asin(x)    asinf(x)
-#endif
-#define sk_float_atan2(y,x)     atan2f(y,x)
-#define sk_float_abs(x)         fabsf(x)
-#define sk_float_copysign(x, y) copysignf(x, y)
-#define sk_float_mod(x,y)       fmodf(x,y)
-#define sk_float_exp(x)         expf(x)
-#define sk_float_log(x)         logf(x)
-
-constexpr int sk_float_sgn(float x) {
+#include <limits>
+
+inline constexpr float SK_FloatSqrt2 = 1.41421356f;
+inline constexpr float SK_FloatPI    = 3.14159265f;
+inline constexpr double SK_DoublePI  = 3.14159265358979323846264338327950288;
+
+static inline float sk_float_sqrt(float x) { return std::sqrt(x); }
+static inline float sk_float_sin(float x) { return std::sin(x); }
+static inline float sk_float_cos(float x) { return std::cos(x); }
+static inline float sk_float_tan(float x) { return std::tan(x); }
+static inline float sk_float_floor(float x) { return std::floor(x); }
+static inline float sk_float_ceil(float x) { return std::ceil(x); }
+static inline float sk_float_trunc(float x) { return std::trunc(x); }
+static inline float sk_float_acos(float x) { return std::acos(x); }
+static inline float sk_float_asin(float x) { return std::asin(x); }
+static inline float sk_float_atan2(float y, float x) { return std::atan2(y,x); }
+static inline float sk_float_abs(float x) { return std::fabs(x); }
+static inline float sk_float_copysign(float x, float y) { return std::copysign(x, y); }
+static inline float sk_float_mod(float x, float y) { return std::fmod(x,y); }
+static inline float sk_float_pow(float x, float y) { return std::pow(x, y); }
+static inline float sk_float_exp(float x) { return std::exp(x); }
+static inline float sk_float_log(float x) { return std::log(x); }
+static inline float sk_float_log2(float x) { return std::log2(x); }
+
+static constexpr int sk_float_sgn(float x) {
     return (0.0f < x) - (x < 0.0f);
 }
 
-constexpr float sk_float_degrees_to_radians(float degrees) {
+static constexpr float sk_float_degrees_to_radians(float degrees) {
     return degrees * (SK_FloatPI / 180);
 }
 
-constexpr float sk_float_radians_to_degrees(float radians) {
+static constexpr float sk_float_radians_to_degrees(float radians) {
     return radians * (180 / SK_FloatPI);
 }
 
@@ -66,16 +56,6 @@ constexpr float sk_float_radians_to_degrees(float radians) {
 // as floatf(x + .5f), they would be 1 higher than expected.
 #define sk_float_round(x) (float)sk_double_round((double)(x))
 
-// can't find log2f on android, but maybe that just a tool bug?
-#ifdef SK_BUILD_FOR_ANDROID
-    static inline float sk_float_log2(float x) {
-        const double inv_ln_2 = 1.44269504088896;
-        return (float)(log(x) * inv_ln_2);
-    }
-#else
-    #define sk_float_log2(x)        log2f(x)
-#endif
-
 static inline bool sk_float_isfinite(float x) {
     return SkFloatBits_IsFinite(SkFloat2Bits(x));
 }
@@ -97,22 +77,20 @@ static inline bool sk_float_isinf(float x) {
     return SkFloatBits_IsInf(SkFloat2Bits(x));
 }
 
-static inline bool sk_float_isnan(float x) {
-    return !(x == x);
-}
-
-#define sk_double_isnan(a)          sk_float_isnan(a)
+static constexpr bool sk_float_isnan(float x) { return x != x; }
+static constexpr bool sk_double_isnan(double x) { return x != x; }
 
-#define SK_MaxS32FitsInFloat    2147483520
-#define SK_MinS32FitsInFloat    -SK_MaxS32FitsInFloat
+inline constexpr int SK_MaxS32FitsInFloat = 2147483520;
+inline constexpr int SK_MinS32FitsInFloat = -SK_MaxS32FitsInFloat;
 
-#define SK_MaxS64FitsInFloat    (SK_MaxS64 >> (63-24) << (63-24))   // 0x7fffff8000000000
-#define SK_MinS64FitsInFloat    -SK_MaxS64FitsInFloat
+// 0x7fffff8000000000
+inline constexpr int64_t SK_MaxS64FitsInFloat = SK_MaxS64 >> (63-24) << (63-24);
+inline constexpr int64_t SK_MinS64FitsInFloat = -SK_MaxS64FitsInFloat;
 
 /**
  *  Return the closest int for the given float. Returns SK_MaxS32FitsInFloat for NaN.
  */
-static inline int sk_float_saturate2int(float x) {
+static constexpr int sk_float_saturate2int(float x) {
     x = x < SK_MaxS32FitsInFloat ? x : SK_MaxS32FitsInFloat;
     x = x > SK_MinS32FitsInFloat ? x : SK_MinS32FitsInFloat;
     return (int)x;
@@ -121,7 +99,7 @@ static inline int sk_float_saturate2int(float x) {
 /**
  *  Return the closest int for the given double. Returns SK_MaxS32 for NaN.
  */
-static inline int sk_double_saturate2int(double x) {
+static constexpr int sk_double_saturate2int(double x) {
     x = x < SK_MaxS32 ? x : SK_MaxS32;
     x = x > SK_MinS32 ? x : SK_MinS32;
     return (int)x;
@@ -130,7 +108,7 @@ static inline int sk_double_saturate2int(double x) {
 /**
  *  Return the closest int64_t for the given float. Returns SK_MaxS64FitsInFloat for NaN.
  */
-static inline int64_t sk_float_saturate2int64(float x) {
+static constexpr int64_t sk_float_saturate2int64(float x) {
     x = x < SK_MaxS64FitsInFloat ? x : SK_MaxS64FitsInFloat;
     x = x > SK_MinS64FitsInFloat ? x : SK_MinS64FitsInFloat;
     return (int64_t)x;
@@ -155,72 +133,47 @@ static inline int64_t sk_float_saturate2int64(float x) {
 // Clang thinks this is undefined, but it's actually implementation defined to return either
 // the largest float or infinity (one of the two bracketing representable floats).  Good enough!
 SK_NO_SANITIZE("float-cast-overflow")
-static inline float sk_double_to_float(double x) {
+static constexpr float sk_double_to_float(double x) {
     return static_cast<float>(x);
 }
 
-#define SK_FloatNaN                 std::numeric_limits<float>::quiet_NaN()
-#define SK_FloatInfinity            (+std::numeric_limits<float>::infinity())
-#define SK_FloatNegativeInfinity    (-std::numeric_limits<float>::infinity())
+inline constexpr float SK_FloatNaN = std::numeric_limits<float>::quiet_NaN();
+inline constexpr float SK_FloatInfinity = std::numeric_limits<float>::infinity();
+inline constexpr float SK_FloatNegativeInfinity = -SK_FloatInfinity;
 
-#define SK_DoubleNaN                std::numeric_limits<double>::quiet_NaN()
+inline constexpr double SK_DoubleNaN = std::numeric_limits<double>::quiet_NaN();
 
-// Returns false if any of the floats are outside of [0...1]
-// Returns true if count is 0
+// Calculate the midpoint between a and b. Similar to std::midpoint in c++20.
+static constexpr float sk_float_midpoint(float a, float b) {
+    // Use double math to avoid underflow and overflow.
+    return static_cast<float>(0.5 * (static_cast<double>(a) + b));
+}
+
+// Returns false if any of the floats are outside the range [0...1].
+// Returns true if count is 0.
 bool sk_floats_are_unit(const float array[], size_t count);
 
 static inline float sk_float_rsqrt_portable(float x) { return 1.0f / sk_float_sqrt(x); }
 static inline float sk_float_rsqrt         (float x) { return 1.0f / sk_float_sqrt(x); }
 
-// Returns the log2 of the provided value, were that value to be rounded up to the next power of 2.
-// Returns 0 if value <= 0:
-// Never returns a negative number, even if value is NaN.
-//
-//     sk_float_nextlog2((-inf..1]) -> 0
-//     sk_float_nextlog2((1..2]) -> 1
-//     sk_float_nextlog2((2..4]) -> 2
-//     sk_float_nextlog2((4..8]) -> 3
-//     ...
-static inline int sk_float_nextlog2(float x) {
-    uint32_t bits = (uint32_t)SkFloat2Bits(x);
-    bits += (1u << 23) - 1u;  // Increment the exponent for non-powers-of-2.
-    int exp = ((int32_t)bits >> 23) - 127;
-    return exp & ~(exp >> 31);  // Return 0 for negative or denormalized floats, and exponents < 0.
-}
-
-// This is the number of significant digits we can print in a string such that when we read that
-// string back we get the floating point number we expect.  The minimum value C requires is 6, but
-// most compilers support 9
-#ifdef FLT_DECIMAL_DIG
-#define SK_FLT_DECIMAL_DIG FLT_DECIMAL_DIG
-#else
-#define SK_FLT_DECIMAL_DIG 9
-#endif
+// The number of significant digits to print.
+inline constexpr int SK_FLT_DECIMAL_DIG = std::numeric_limits<float>::max_digits10;
 
-// IEEE defines how float divide behaves for non-finite values and zero-denoms, but C does not
+// IEEE defines how float divide behaves for non-finite values and zero-denoms, but C does not,
 // so we have a helper that suppresses the possible undefined-behavior warnings.
-
 SK_NO_SANITIZE("float-divide-by-zero")
-static inline float sk_ieee_float_divide(float numer, float denom) {
+static constexpr float sk_ieee_float_divide(float numer, float denom) {
     return numer / denom;
 }
 
 SK_NO_SANITIZE("float-divide-by-zero")
-static inline double sk_ieee_double_divide(double numer, double denom) {
+static constexpr double sk_ieee_double_divide(double numer, double denom) {
     return numer / denom;
 }
 
-// While we clean up divide by zero, we'll replace places that do divide by zero with this TODO.
-static inline float sk_ieee_float_divide_TODO_IS_DIVIDE_BY_ZERO_SAFE_HERE(float n, float d) {
-    return sk_ieee_float_divide(n,d);
-}
-
-static inline float sk_fmaf(float f, float m, float a) {
-#if defined(FP_FAST_FMA)
-    return std::fmaf(f,m,a);
-#else
-    return f*m+a;
-#endif
+// Return a*b + c.
+static inline float sk_fmaf(float a, float b, float c) {
+    return std::fma(a, b, c);
 }
 
 // Returns true iff the provided number is within a small epsilon of 0.

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

@@ -9,6 +9,7 @@
 #define SkSpan_DEFINED
 
 #include "include/private/base/SkAssert.h"
+#include "include/private/base/SkDebug.h"
 #include "include/private/base/SkTo.h"
 
 #include <cstddef>
@@ -82,11 +83,10 @@ public:
     constexpr SkSpan& operator=(const SkSpan& that) = default;
 
     constexpr T& operator [] (size_t i) const {
-        SkASSERT(i < this->size());
-        return fPtr[i];
+        return fPtr[sk_collection_check_bounds(i, this->size())];
     }
-    constexpr T& front() const { return fPtr[0]; }
-    constexpr T& back()  const { return fPtr[fSize - 1]; }
+    constexpr T& front() const { sk_collection_not_empty(this->empty()); return fPtr[0]; }
+    constexpr T& back()  const { sk_collection_not_empty(this->empty()); 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()); }
@@ -96,24 +96,30 @@ public:
     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};
+        return SkSpan{fPtr, sk_collection_check_length(prefixLen, fSize)};
     }
     constexpr SkSpan<T> last(size_t postfixLen) const {
-        SkASSERT(postfixLen <= this->size());
-        return SkSpan{fPtr + (this->size() - postfixLen), postfixLen};
+        return SkSpan{fPtr + (this->size() - postfixLen),
+                      sk_collection_check_length(postfixLen, fSize)};
     }
     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};
+        const size_t safeOffset = sk_collection_check_length(offset, fSize);
+
+        // Should read offset + count > size(), but that could overflow. We know that safeOffset
+        // is <= size, therefore the subtraction will not overflow.
+        if (count > this->size() - safeOffset) SK_UNLIKELY {
+            // The count is too large.
+            SkUNREACHABLE;
+        }
+        return SkSpan{fPtr + safeOffset, count};
     }
 
 private:
-    static const constexpr size_t kMaxSize = std::numeric_limits<size_t>::max() / sizeof(T);
+    static constexpr size_t kMaxSize = std::numeric_limits<size_t>::max() / sizeof(T);
+
     T* fPtr;
     size_t fSize;
 };

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

@@ -12,6 +12,7 @@
 #include "include/private/base/SkAssert.h"
 #include "include/private/base/SkAttributes.h"
 #include "include/private/base/SkContainers.h"
+#include "include/private/base/SkDebug.h"
 #include "include/private/base/SkMalloc.h"
 #include "include/private/base/SkMath.h"
 #include "include/private/base/SkSpan_impl.h"
@@ -277,7 +278,7 @@ public:
      * Removes the last element. Not safe to call when size() == 0.
      */
     void pop_back() {
-        SkASSERT(fSize > 0);
+        sk_collection_not_empty(this->empty());
         --fSize;
         fData[fSize].~T();
     }
@@ -386,15 +387,11 @@ public:
      * Get the i^th element.
      */
     T& operator[] (int i) {
-        SkASSERT(i < this->size());
-        SkASSERT(i >= 0);
-        return fData[i];
+        return fData[sk_collection_check_bounds(i, this->size())];
     }
 
     const T& operator[] (int i) const {
-        SkASSERT(i < this->size());
-        SkASSERT(i >= 0);
-        return fData[i];
+        return fData[sk_collection_check_bounds(i, this->size())];
     }
 
     T& at(int i) { return (*this)[i]; }
@@ -403,30 +400,38 @@ public:
     /**
      * equivalent to operator[](0)
      */
-    T& front() { SkASSERT(fSize > 0); return fData[0];}
+    T& front() {
+        sk_collection_not_empty(this->empty());
+        return fData[0];
+    }
 
-    const T& front() const { SkASSERT(fSize > 0); return fData[0];}
+    const T& front() const {
+        sk_collection_not_empty(this->empty());
+        return fData[0];
+    }
 
     /**
      * equivalent to operator[](size() - 1)
      */
-    T& back() { SkASSERT(fSize); return fData[fSize - 1];}
+    T& back() {
+        sk_collection_not_empty(this->empty());
+        return fData[fSize - 1];
+    }
 
-    const T& back() const { SkASSERT(fSize > 0); return fData[fSize - 1];}
+    const T& back() const {
+        sk_collection_not_empty(this->empty());
+        return fData[fSize - 1];
+    }
 
     /**
      * equivalent to operator[](size()-1-i)
      */
     T& fromBack(int i) {
-        SkASSERT(i >= 0);
-        SkASSERT(i < this->size());
-        return fData[fSize - i - 1];
+        return (*this)[fSize - i - 1];
     }
 
     const T& fromBack(int i) const {
-        SkASSERT(i >= 0);
-        SkASSERT(i < this->size());
-        return fData[fSize - i - 1];
+        return (*this)[fSize - i - 1];
     }
 
     bool operator==(const TArray<T, MEM_MOVE>& right) const {

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

@@ -10,6 +10,7 @@
 
 #include "include/private/base/SkAPI.h"
 #include "include/private/base/SkAssert.h"
+#include "include/private/base/SkDebug.h"
 #include "include/private/base/SkTo.h"
 
 #include <algorithm>
@@ -152,20 +153,18 @@ public:
     const T* end() const { return this->data() + this->size(); }
 
     T& operator[](int index) {
-        SkASSERT(index < this->size());
-        return this->data()[index];
+        return this->data()[sk_collection_check_bounds(index, this->size())];
     }
     const T& operator[](int index) const {
-        SkASSERT(index < this->size());
-        return this->data()[index];
+        return this->data()[sk_collection_check_bounds(index, this->size())];
     }
 
     const T& back() const {
-        SkASSERT(this->size() > 0);
+        sk_collection_not_empty(this->empty());
         return this->data()[this->size() - 1];
     }
     T& back() {
-        SkASSERT(this->size() > 0);
+        sk_collection_not_empty(this->empty());
         return this->data()[this->size() - 1];
     }
 

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

@@ -13,6 +13,7 @@
 #include "include/private/base/SkDebug.h"
 #include "include/private/base/SkMalloc.h"
 #include "include/private/base/SkTLogic.h"
+#include "include/private/base/SkTo.h"
 
 #include <array>
 #include <cstddef>
@@ -98,49 +99,69 @@ namespace skia_private {
 template <typename T> class AutoTArray  {
 public:
     AutoTArray() {}
-    /** Allocate count number of T elements
-     */
-    explicit AutoTArray(int count) {
-        SkASSERT(count >= 0);
-        if (count) {
-            fArray.reset(new T[count]);
-        }
-        SkDEBUGCODE(fCount = count;)
+    // Allocate size number of T elements
+    explicit AutoTArray(size_t size) {
+        fSize = check_size_bytes_too_big<T>(size);
+        fData.reset(size > 0 ? new T[size] : nullptr);
     }
 
-    AutoTArray(AutoTArray&& other) : fArray(std::move(other.fArray)) {
-        SkDEBUGCODE(fCount = other.fCount; other.fCount = 0;)
+    // TODO: remove when all uses are gone.
+    explicit AutoTArray(int size) : AutoTArray(SkToSizeT(size)) {}
+
+    AutoTArray(AutoTArray&& other) : fData(std::move(other.fData)) {
+        fSize = std::exchange(other.fSize, 0);
     }
     AutoTArray& operator=(AutoTArray&& other) {
         if (this != &other) {
-            fArray = std::move(other.fArray);
-            SkDEBUGCODE(fCount = other.fCount; other.fCount = 0;)
+            fData = std::move(other.fData);
+            fSize = std::exchange(other.fSize, 0);
         }
         return *this;
     }
 
-    /** Reallocates given a new count. Reallocation occurs even if new count equals old count.
-     */
-    void reset(int count = 0) { *this = AutoTArray(count); }
+    // Reallocates given a new count. Reallocation occurs even if new count equals old count.
+    void reset(size_t count = 0) {
+        *this = AutoTArray(count);
+    }
 
-    /** Return the array of T elements. Will be NULL if count == 0
-     */
-    T* get() const { return fArray.get(); }
+    T* get() const { return fData.get(); }
 
-    /** Return the nth element in the array
-     */
-    T&  operator[](int index) const {
-        SkASSERT((unsigned)index < (unsigned)fCount);
-        return fArray[index];
+    T&  operator[](size_t index) const {
+        return fData[sk_collection_check_bounds(index, fSize)];
     }
 
-    /** Aliases matching other types, like std::vector. */
-    const T* data() const { return fArray.get(); }
-    T* data() { return fArray.get(); }
+    const T* data() const { return fData.get(); }
+    T* data() { return fData.get(); }
+
+    size_t size() const { return fSize; }
+    bool empty() const { return fSize == 0; }
+    size_t size_bytes() const { return sizeof(T) * fSize; }
+
+    T* begin() {
+        return fData;
+    }
+    const T* begin() const {
+        return fData;
+    }
+
+    // It's safe to use fItemArray + fSize because if fItemArray is nullptr then adding 0 is
+    // valid and returns nullptr. See [expr.add] in the C++ standard.
+    T* end() {
+        if (fData == nullptr) {
+            SkASSERT(fSize == 0);
+        }
+        return fData + fSize;
+    }
+    const T* end() const {
+        if (fData == nullptr) {
+            SkASSERT(fSize == 0);
+        }
+        return fData + fSize;
+    }
 
 private:
-    std::unique_ptr<T[]> fArray;
-    SkDEBUGCODE(int fCount = 0;)
+    std::unique_ptr<T[]> fData;
+    size_t fSize = 0;
 };
 
 /** Wraps AutoTArray, with room for kCountRequested elements preallocated.
@@ -223,8 +244,7 @@ public:
     /** Return the nth element in the array
      */
     T&  operator[](int index) const {
-        SkASSERT(index < fCount);
-        return fArray[index];
+        return fArray[sk_collection_check_bounds(index, fCount)];
     }
 
     /** Aliases matching other types, like std::vector. */

package/cpp/skia/include/private/chromium/GrDeferredDisplayListRecorder.h

@@ -10,7 +10,6 @@
 
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkTypes.h"
-#include "include/gpu/GrTypes.h"
 #include "include/private/chromium/GrDeferredDisplayList.h"
 #include "include/private/chromium/GrSurfaceCharacterization.h"
 
@@ -25,6 +24,10 @@ class GrPromiseImageTexture;
 class SkSurface;
 enum SkAlphaType : int;
 enum SkColorType : int;
+enum GrSurfaceOrigin : int;
+namespace skgpu {
+enum class Mipmapped : bool;
+}
 
 /*
  * This class is intended to be used as:
@@ -64,7 +67,7 @@ public:
     sk_sp<SkImage> makePromiseTexture(const GrBackendFormat& backendFormat,
                                       int width,
                                       int height,
-                                      GrMipmapped mipmapped,
+                                      skgpu::Mipmapped mipmapped,
                                       GrSurfaceOrigin origin,
                                       SkColorType colorType,
                                       SkAlphaType alphaType,

package/cpp/skia/include/private/chromium/GrSurfaceCharacterization.h

@@ -144,7 +144,7 @@ private:
             : fContextInfo(std::move(contextInfo))
             , fCacheMaxResourceBytes(cacheMaxResourceBytes)
             , fImageInfo(ii)
-            , fBackendFormat(backendFormat)
+            , fBackendFormat(std::move(backendFormat))
             , fOrigin(origin)
             , fSampleCnt(sampleCnt)
             , fIsTextureable(isTextureable)
@@ -182,7 +182,7 @@ private:
             fCacheMaxResourceBytes = cacheMaxResourceBytes;
 
             fImageInfo = ii;
-            fBackendFormat = backendFormat;
+            fBackendFormat = std::move(backendFormat);
             fOrigin = origin;
             fSampleCnt = sampleCnt;
             fIsTextureable = isTextureable;

package/cpp/skia/include/private/chromium/SkChromeRemoteGlyphCache.h

@@ -8,20 +8,23 @@
 #ifndef SkChromeRemoteGlyphCache_DEFINED
 #define SkChromeRemoteGlyphCache_DEFINED
 
-#include <memory>
-#include <vector>
-
-#include "include/core/SkData.h"
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkTypeface.h"
-#include "include/utils/SkNoDrawCanvas.h"
+#include "include/private/base/SkAPI.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <vector>
 
-struct SkPackedGlyphID;
 class SkAutoDescriptor;
+class SkCanvas;
+class SkColorSpace;
 class SkStrikeCache;
 class SkStrikeClientImpl;
-class SkStrikeServer;
 class SkStrikeServerImpl;
+class SkSurfaceProps;
+struct SkDeserialProcs;
 namespace sktext::gpu { class Slug; }
 
 using SkDiscardableHandleId = uint32_t;
@@ -140,7 +143,9 @@ public:
 
     // Given a buffer, unflatten into a slug making sure to do the typefaceID translation from
     // renderer to GPU. Returns nullptr if there was a problem.
-    sk_sp<sktext::gpu::Slug> deserializeSlugForTest(const void* data, size_t size) const;
+    sk_sp<sktext::gpu::Slug> deserializeSlugForTest(const void* data,
+                                                    size_t size,
+                                                    const SkDeserialProcs&) const;
 
 private:
     std::unique_ptr<SkStrikeClientImpl> fImpl;

package/cpp/skia/include/private/chromium/SkDiscardableMemory.h

@@ -47,7 +47,7 @@ public:
      *
      * Nested calls to lock are not allowed.
      */
-    virtual bool SK_WARN_UNUSED_RESULT lock() = 0;
+    [[nodiscard]] virtual bool lock() = 0;
 
     /**
      * Returns the current pointer for the discardable memory. This call is ONLY