@shopify/react-native-skia 1.11.9-next.1 → 1.11.10

package/cpp/skia/include/gpu/graphite/mtl/MtlGraphiteTypes.h

@@ -8,19 +8,27 @@
 #ifndef skgpu_graphite_MtlGraphiteTypes_DEFINED
 #define skgpu_graphite_MtlGraphiteTypes_DEFINED
 
-#if __OBJC__  // <Metal/Metal.h> only works when compiled for Objective C
-
 #include "include/core/SkTypes.h"
 
+#if __OBJC__  // <Metal/Metal.h> only works when compiled for Objective C
+#include "include/gpu/graphite/BackendTexture.h"
 #include "include/gpu/graphite/GraphiteTypes.h"
-#include "include/gpu/graphite/mtl/MtlGraphiteTypesUtils.h"
+#include "include/gpu/graphite/TextureInfo.h"
+#include "include/ports/SkCFObject.h"
 #include "include/private/base/SkAPI.h"
 
 #import <CoreFoundation/CoreFoundation.h>
 #import <Metal/Metal.h>
 #import <TargetConditionals.h>
 
+#if TARGET_OS_SIMULATOR
+#define SK_API_AVAILABLE_CA_METAL_LAYER SK_API_AVAILABLE(macos(10.11), ios(13.0), tvos(13.0))
+#else  // TARGET_OS_SIMULATOR
+#define SK_API_AVAILABLE_CA_METAL_LAYER SK_API_AVAILABLE(macos(10.11), ios(8.0), tvos(9.0))
+#endif  // TARGET_OS_SIMULATOR
+
 namespace skgpu::graphite {
+
 struct SK_API MtlTextureInfo {
     uint32_t fSampleCount = 1;
     skgpu::Mipmapped fMipmapped = skgpu::Mipmapped::kNo;
@@ -45,7 +53,31 @@ struct SK_API MtlTextureInfo {
             , fStorageMode(storageMode)
             , fFramebufferOnly(framebufferOnly) {}
 };
-}  // namespace skgpu::graphite
+
+namespace TextureInfos {
+SK_API TextureInfo MakeMetal(const MtlTextureInfo&);
+SK_API TextureInfo MakeMetal(CFTypeRef mtlTexture);
+
+SK_API bool GetMtlTextureInfo(const TextureInfo&, MtlTextureInfo*);
+}  // namespace TextureInfos
+
+namespace BackendTextures {
+// The BackendTexture will not call retain or release on the passed in CFTypeRef. Thus the
+// client must keep the CFTypeRef valid until they are no longer using the BackendTexture.
+SK_API BackendTexture MakeMetal(SkISize dimensions, CFTypeRef mtlTexture);
+
+SK_API CFTypeRef GetMtlTexture(const BackendTexture&);
+}  // namespace BackendTextures
+
+namespace BackendSemaphores {
+// TODO(b/286088355) Determine creator's responsibility for setting refcnt.
+SK_API BackendSemaphore MakeMetal(CFTypeRef mtlEvent, uint64_t value);
+
+SK_API CFTypeRef GetMtlEvent(const BackendSemaphore&);
+SK_API uint64_t GetMtlValue(const BackendSemaphore&);
+}  // namespace BackendSemaphores
+
+} // namespace skgpu::graphite
 
 #endif  // __OBJC__
 

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

@@ -15,7 +15,6 @@ namespace skgpu::graphite {
 
 class Context;
 class PaintOptions;
-class PrecompileContext;
 
 /**
  *  Describes the required properties of a RenderPass that will be combined with the
@@ -34,12 +33,12 @@ struct SK_API RenderPassProperties {
  * drawing. Graphite will always be able to perform an inline compilation if some SkPaint
  * combination was omitted from precompilation.
  *
- *   @param precompileContext    thread-safe helper holding required portions of the Context
+ *   @param context              the Context to which the actual draws will be submitted
  *   @param paintOptions         captures a set of SkPaints that will be drawn
  *   @param drawTypes            communicates which primitives those paints will be drawn with
  *   @param renderPassProperties describes the RenderPasses needed for the desired Pipelines
  */
-void SK_API Precompile(PrecompileContext* precompileContext,
+void SK_API Precompile(Context* context,
                        const PaintOptions& paintOptions,
                        DrawTypeFlags drawTypes,
                        SkSpan<const RenderPassProperties> renderPassProperties);

package/cpp/skia/include/pathops/SkPathOps.h

@@ -65,15 +65,7 @@ bool SK_API Simplify(const SkPath& path, SkPath* result);
     @param result The tight bounds of the path.
     @return True if the bounds could be computed.
   */
-[[deprecated]]
-static inline bool TightBounds(const SkPath& path, SkRect* result) {
-    auto rect = path.computeTightBounds();
-    if (rect.isFinite()) {
-        *result = rect;
-        return true;
-    }
-    return false;
-}
+bool SK_API TightBounds(const SkPath& path, SkRect* result);
 
 /** Set the result with fill type winding to area equivalent to path.
     Returns true if successful. Does not detect if path contains contours which

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

@@ -13,11 +13,8 @@
 
 class SkFontMgr;
 class SkFontConfigInterface;
-class SkFontScanner;
 
 /** Creates a SkFontMgr which wraps a SkFontConfigInterface. */
 SK_API sk_sp<SkFontMgr> SkFontMgr_New_FCI(sk_sp<SkFontConfigInterface> fci);
-SK_API sk_sp<SkFontMgr> SkFontMgr_New_FCI(sk_sp<SkFontConfigInterface> fci,
-                                          std::unique_ptr<SkFontScanner> scanner);
 
 #endif // #ifndef SkFontMgr_FontConfigInterface_DEFINED

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

@@ -28,6 +28,15 @@
 class SkMatrix;
 class SkRRect;
 
+// These are computed from a stream of verbs
+struct SkPathVerbAnalysis {
+    bool     valid;
+    int      points, weights;
+    unsigned segmentMask;
+};
+SkPathVerbAnalysis sk_path_analyze_verbs(const uint8_t verbs[], int count);
+
+
 /**
  * Holds the path verbs and points. It is versioned by a generation ID. None of its public methods
  * modify the contents. To modify or append to the verbs/points wrap the SkPathRef in an
@@ -532,12 +541,7 @@ private:
 
     void callGenIDChangeListeners();
 
-    PointsArray fPoints;
-    VerbsArray fVerbs;
-    ConicWeightsArray fConicWeights;
-
     mutable SkRect   fBounds;
-    SkRect           fArcOval;
 
     enum {
         kEmptyGenID = 1, // GenID reserved for path ref with zero points and zero verbs.
@@ -545,25 +549,27 @@ private:
     mutable uint32_t    fGenerationID;
     SkIDChangeListener::List fGenIDChangeListeners;
 
-    SkDEBUGCODE(std::atomic<int> fEditorsAttached;) // assert only one editor in use at any time.
-
-    SkScalar    fArcStartAngle;
-    SkScalar    fArcSweepAngle;
+    PointsArray fPoints;
+    VerbsArray fVerbs;
+    ConicWeightsArray fConicWeights;
 
-    PathType fType;
+    SkDEBUGCODE(std::atomic<int> fEditorsAttached;) // assert only one editor in use at any time.
 
     mutable uint8_t  fBoundsIsDirty;
+    mutable bool     fIsFinite;    // only meaningful if bounds are valid
 
+    PathType fType;
+    // Both the circle and rrect special cases have a notion of direction and starting point
+    // The next two variables store that information for either.
+    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;
-
-    mutable bool     fIsFinite;    // only meaningful if bounds are valid
-    // Both the circle and rrect special cases have a notion of direction and starting point
-    // The next two variables store that information for either.
-    bool     fRRectOrOvalIsCCW;
+    SkRect      fArcOval;
+    SkScalar    fArcStartAngle;
+    SkScalar    fArcSweepAngle;
 
     friend class PathRefTest_Private;
     friend class ForceIsRRect_Private; // unit test isRRect

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

@@ -56,26 +56,20 @@
  * Used to ignore sanitizer warnings.
  */
 #if !defined(SK_NO_SANITIZE)
-  #if defined(__has_attribute)
-    #if __has_attribute(no_sanitize)
-      // This should be for clang and versions of gcc >= 8.0
-      #define SK_NO_SANITIZE(A) SK_ATTRIBUTE(no_sanitize(A))
-    #else
-      // For compilers that don't support sanitization, just do nothing.
-      #define SK_NO_SANITIZE(A)
-    #endif
-  #else // no __has_attribute, e.g. MSVC
-    #define SK_NO_SANITIZE(A)
-  #endif
+#  define SK_NO_SANITIZE(A) SK_ATTRIBUTE(no_sanitize(A))
 #endif
 
 /**
- * Used to ignore CFI sanitizer warnings, supported only by Clang at the moment.
+ * Helper macro to define no_sanitize attributes only with clang.
  */
-#if defined(__clang__)
-  #define SK_NO_SANITIZE_CFI SK_NO_SANITIZE("cfi")
-#else
-  #define SK_NO_SANITIZE_CFI
+#if defined(__clang__) && defined(__has_attribute)
+  #if __has_attribute(no_sanitize)
+    #define SK_CLANG_NO_SANITIZE(A) SK_NO_SANITIZE(A)
+  #endif
+#endif
+
+#if !defined(SK_CLANG_NO_SANITIZE)
+  #define SK_CLANG_NO_SANITIZE(A)
 #endif
 
 /**

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

@@ -14,14 +14,6 @@
 #include "include/private/base/SkThreadAnnotations.h"
 #include "include/private/base/SkThreadID.h"
 
-/**
- * class SkMutex
- *
- * This allows us to have a mutex without needing the one in
- * the C++ std library which does not work with all clients.
- * go/cstyle#Disallowed_Stdlib
- */
-
 class SK_CAPABILITY("mutex") SkMutex {
 public:
     constexpr SkMutex() = default;

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

@@ -617,7 +617,7 @@ private:
     // unpredictable location in memory. Of course, TArray won't actually use fItemArray in this
     // way, and we don't want to construct a T before the user requests one. There's no real risk
     // here, so disable CFI when doing these casts.
-    SK_NO_SANITIZE_CFI
+    SK_CLANG_NO_SANITIZE("cfi")
     static T* TCast(void* buffer) {
         return (T*)buffer;
     }

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

@@ -13,9 +13,9 @@
 #include "include/private/base/SkDebug.h"
 #include "include/private/base/SkTo.h"
 
+#include <algorithm>
 #include <cstddef>
 #include <initializer_list>
-#include <utility>
 
 class SK_SPI SkTDStorage {
 public:

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

@@ -15,7 +15,6 @@
 #include "include/private/base/SkTLogic.h"
 #include "include/private/base/SkTo.h"
 
-#include <algorithm>
 #include <array>
 #include <cstddef>
 #include <cstdint>
@@ -95,8 +94,7 @@ public:
 
 
 namespace skia_private {
-/** Allocate an array of T elements on the heap. Once this goes out of scope, the
- *  elements will be cleaned up "auto"matically.
+/** Allocate an array of T elements, and free the array in the destructor
  */
 template <typename T> class AutoTArray  {
 public:
@@ -166,10 +164,7 @@ private:
     size_t fSize = 0;
 };
 
-/** Like AutoTArray with room for kCountRequested elements preallocated on
- *  the Stack. If count exceeds the space of the preallocation, the elements
- *  will live on the heap. Once this goes out of scope, the elements will be
- *  cleaned up "auto"matically.
+/** Wraps AutoTArray, with room for kCountRequested elements preallocated.
  */
 template <int kCountRequested, typename T> class AutoSTArray {
 public:
@@ -261,25 +256,17 @@ private:
 #if defined(SK_BUILD_FOR_GOOGLE3)
     // Stack frame size is limited for SK_BUILD_FOR_GOOGLE3. 4k is less than the actual max,
     // but some functions have multiple large stack allocations.
-    static constexpr int kMaxBytes = 4 * 1024;
-    static constexpr int kMinCount = kCountRequested * sizeof(T) > kMaxBytes
+    static const int kMaxBytes = 4 * 1024;
+    static const int kCount = kCountRequested * sizeof(T) > kMaxBytes
         ? kMaxBytes / sizeof(T)
         : kCountRequested;
 #else
-    static constexpr int kMinCount = kCountRequested;
+    static const int kCount = kCountRequested;
 #endif
 
-    // Because we are also storing an int, there is a tiny bit of padding that
-    // the C++ compiler adds after fStorage if sizeof(T) <= alignof(T*).
-    // Thus, we can expand how many elements are stored on the stack to make use of this
-    // (e.g. 1 extra element for 4 byte T if kCountRequested was even).
-    static_assert(alignof(int) <= alignof(T*) || alignof(int) <= alignof(T));
-    static constexpr int kCount =
-            SkAlignTo(kMinCount*sizeof(T) + sizeof(int), std::max(alignof(T*), alignof(T))) / sizeof(T);
-
-    T* fArray;
-    alignas(T) std::byte fStorage[kCount * sizeof(T)];
     int fCount;
+    T* fArray;
+    alignas(T) char fStorage[kCount * sizeof(T)];
 };
 
 /** Manages an array of T elements, freeing the array in the destructor.
@@ -422,16 +409,16 @@ public:
 
 private:
     // Since we use uint32_t storage, we might be able to get more elements for free.
-    static constexpr size_t kCountWithPadding = SkAlign4(kCountRequested*sizeof(T)) / sizeof(T);
+    static const size_t kCountWithPadding = SkAlign4(kCountRequested*sizeof(T)) / sizeof(T);
 #if defined(SK_BUILD_FOR_GOOGLE3)
     // Stack frame size is limited for SK_BUILD_FOR_GOOGLE3. 4k is less than the actual max, but some functions
     // have multiple large stack allocations.
-    static constexpr size_t kMaxBytes = 4 * 1024;
-    static constexpr size_t kCount = kCountRequested * sizeof(T) > kMaxBytes
+    static const size_t kMaxBytes = 4 * 1024;
+    static const size_t kCount = kCountRequested * sizeof(T) > kMaxBytes
         ? kMaxBytes / sizeof(T)
         : kCountWithPadding;
 #else
-    static constexpr size_t kCount = kCountWithPadding;
+    static const size_t kCount = kCountWithPadding;
 #endif
 
     T*          fPtr;

package/cpp/skia/include/private/gpu/ganesh/GrTypesPriv.h

@@ -539,7 +539,7 @@ SK_MAKE_BITFIELD_CLASS_OPS(GpuPathRenderers)
 enum class GrColorType {
     kUnknown,
     kAlpha_8,
-    kBGR_565,    // This corresponds to kRGB_565_SkColorType, which is misnamed.
+    kBGR_565,
     kRGB_565,
     kABGR_4444,  // This name differs from SkColorType. kARGB_4444_SkColorType is misnamed.
     kRGBA_8888,

package/cpp/skia/include/sksl/SkSLDebugTrace.h

@@ -16,6 +16,9 @@ namespace SkSL {
 
 class DebugTrace : public SkRefCnt {
 public:
+    /** Serializes a debug trace to JSON which can be parsed by our debugger. */
+    virtual void writeTrace(SkWStream* w) const = 0;
+
     /** Generates a human-readable dump of the debug trace. */
     virtual void dump(SkWStream* o) const = 0;
 };

package/cpp/skia/modules/skcms/src/Transform_inl.h

@@ -904,19 +904,24 @@ STAGE(load_1010102, NoCtx) {
 }
 
 STAGE(load_101010x_XR, NoCtx) {
+    static constexpr float min = -0.752941f;
+    static constexpr float max = 1.25098f;
+    static constexpr float range = max - min;
     U32 rgba = load<U32>(src + 4*i);
-    r = cast<F>(((rgba >>  0) & 0x3ff) - 384) / 510.0f;
-    g = cast<F>(((rgba >> 10) & 0x3ff) - 384) / 510.0f;
-    b = cast<F>(((rgba >> 20) & 0x3ff) - 384) / 510.0f;
+    r = cast<F>((rgba >>  0) & 0x3ff) * (1/1023.0f) * range + min;
+    g = cast<F>((rgba >> 10) & 0x3ff) * (1/1023.0f) * range + min;
+    b = cast<F>((rgba >> 20) & 0x3ff) * (1/1023.0f) * range + min;
 }
 
 STAGE(load_10101010_XR, NoCtx) {
+    static constexpr float min = -0.752941f;
+    static constexpr float max = 1.25098f;
+    static constexpr float range = max - min;
     U64 rgba = load<U64>(src + 8 * i);
-    // Each channel is 16 bits, where the 6 low bits are padding.
-    r = cast<F>(((rgba >> ( 0+6)) & 0x3ff) - 384) / 510.0f;
-    g = cast<F>(((rgba >> (16+6)) & 0x3ff) - 384) / 510.0f;
-    b = cast<F>(((rgba >> (32+6)) & 0x3ff) - 384) / 510.0f;
-    a = cast<F>(((rgba >> (48+6)) & 0x3ff) - 384) / 510.0f;
+    r = cast<F>((rgba >>  (0+6)) & 0x3ff) * (1/1023.0f) * range + min;
+    g = cast<F>((rgba >> (16+6)) & 0x3ff) * (1/1023.0f) * range + min;
+    b = cast<F>((rgba >> (32+6)) & 0x3ff) * (1/1023.0f) * range + min;
+    a = cast<F>((rgba >> (48+6)) & 0x3ff) * (1/1023.0f) * range + min;
 }
 
 STAGE(load_161616LE, NoCtx) {
@@ -1305,17 +1310,12 @@ FINAL_STAGE(store_8888, NoCtx) {
 }
 
 FINAL_STAGE(store_101010x_XR, NoCtx) {
-    store(dst + 4*i, cast<U32>(to_fixed((r * 510) + 384)) <<  0
-                   | cast<U32>(to_fixed((g * 510) + 384)) << 10
-                   | cast<U32>(to_fixed((b * 510) + 384)) << 20);
-}
-
-FINAL_STAGE(store_10101010_XR, NoCtx) {
-    // Each channel is 16 bits, where the 6 low bits are padding.
-    store(dst + 8*i, cast<U64>(to_fixed((r * 510) + 384)) << ( 0+6)
-                   | cast<U64>(to_fixed((g * 510) + 384)) << (16+6)
-                   | cast<U64>(to_fixed((b * 510) + 384)) << (32+6)
-                   | cast<U64>(to_fixed((a * 510) + 384)) << (48+6));
+    static constexpr float min = -0.752941f;
+    static constexpr float max = 1.25098f;
+    static constexpr float range = max - min;
+    store(dst + 4*i, cast<U32>(to_fixed(((r - min) / range) * 1023)) <<  0
+                   | cast<U32>(to_fixed(((g - min) / range) * 1023)) << 10
+                   | cast<U32>(to_fixed(((b - min) / range) * 1023)) << 20);
 }
 
 FINAL_STAGE(store_1010102, NoCtx) {
@@ -1521,7 +1521,7 @@ FINAL_STAGE(store_ffff, NoCtx) {
 // NOLINTNEXTLINE(misc-definitions-in-headers)
 void run_program(const Op* program, const void** contexts, SKCMS_MAYBE_UNUSED ptrdiff_t programSize,
                  const char* src, char* dst, int n,
-                size_t src_bpp, size_t dst_bpp) {
+                 const size_t src_bpp, const size_t dst_bpp) {
 #if SKCMS_HAS_MUSTTAIL
     // Convert the program into an array of tailcall stages.
     StageFn stages[32];

package/cpp/skia/modules/skcms/src/skcms_Transform.h

@@ -101,7 +101,6 @@ namespace skcms_private {
     M(store_161616BE)      \
     M(store_16161616BE)    \
     M(store_101010x_XR)    \
-    M(store_10101010_XR)   \
     M(store_hhh)           \
     M(store_hhhh)          \
     M(store_fff)           \
@@ -145,21 +144,21 @@ namespace baseline {
 
 void run_program(const Op* program, const void** contexts, ptrdiff_t programSize,
                  const char* src, char* dst, int n,
-                size_t src_bpp, size_t dst_bpp);
+                 const size_t src_bpp, const size_t dst_bpp);
 
 }
 namespace hsw {
 
 void run_program(const Op* program, const void** contexts, ptrdiff_t programSize,
                  const char* src, char* dst, int n,
-                size_t src_bpp, size_t dst_bpp);
+                 const size_t src_bpp, const size_t dst_bpp);
 
 }
 namespace skx {
 
 void run_program(const Op* program, const void** contexts, ptrdiff_t programSize,
                  const char* src, char* dst, int n,
-                size_t src_bpp, size_t dst_bpp);
+                 const size_t src_bpp, const size_t dst_bpp);
 
 }
 }  // namespace skcms_private

package/cpp/skia/modules/skcms/src/skcms_public.h

@@ -105,9 +105,6 @@ SKCMS_API bool skcms_TransferFunction_isHLGish (const skcms_TransferFunction*);
 // Unified representation of 'curv' or 'para' tag data, or a 1D table from 'mft1' or 'mft2'
 typedef union skcms_Curve {
     struct {
-        // this needs to line up with alias_of_table_entries so we can tell if there are or
-        // are not table entries. If this is 0, this struct is a parametric function,
-        // otherwise it's a table entry.
         uint32_t alias_of_table_entries;
         skcms_TransferFunction parametric;
     };
@@ -126,44 +123,44 @@ typedef struct skcms_A2B {
     // Optional: N 1D "A" curves, followed by an N-dimensional CLUT.
     // If input_channels == 0, these curves and CLUT are skipped,
     // Otherwise, input_channels must be in [1, 4].
+    uint32_t        input_channels;
     skcms_Curve     input_curves[4];
+    uint8_t         grid_points[4];
     const uint8_t*  grid_8;
     const uint8_t*  grid_16;
-    uint32_t        input_channels;
-    uint8_t         grid_points[4];
 
     // Optional: 3 1D "M" curves, followed by a color matrix.
     // If matrix_channels == 0, these curves and matrix are skipped,
     // Otherwise, matrix_channels must be 3.
+    uint32_t        matrix_channels;
     skcms_Curve     matrix_curves[3];
     skcms_Matrix3x4 matrix;
-    uint32_t        matrix_channels;
 
     // Required: 3 1D "B" curves. Always present, and output_channels must be 3.
-    uint32_t        output_channels; // list first to pack with matrix_channels
+    uint32_t        output_channels;
     skcms_Curve     output_curves[3];
 } skcms_A2B;
 
 typedef struct skcms_B2A {
     // Required: 3 1D "B" curves. Always present, and input_channels must be 3.
-    skcms_Curve     input_curves[3];
     uint32_t        input_channels;
+    skcms_Curve     input_curves[3];
 
     // Optional: a color matrix, followed by 3 1D "M" curves.
     // If matrix_channels == 0, this matrix and these curves are skipped,
     // Otherwise, matrix_channels must be 3.
-    uint32_t        matrix_channels; // list first to pack with input_channels
-    skcms_Curve     matrix_curves[3];
+    uint32_t        matrix_channels;
     skcms_Matrix3x4 matrix;
+    skcms_Curve     matrix_curves[3];
 
     // Optional: an N-dimensional CLUT, followed by N 1D "A" curves.
     // If output_channels == 0, this CLUT and these curves are skipped,
     // Otherwise, output_channels must be in [1, 4].
-    skcms_Curve     output_curves[4];
+    uint32_t        output_channels;
+    uint8_t         grid_points[4];
     const uint8_t*  grid_8;
     const uint8_t*  grid_16;
-    uint8_t         grid_points[4];
-    uint32_t        output_channels;
+    skcms_Curve     output_curves[4];
 } skcms_B2A;
 
 typedef struct skcms_CICP {
@@ -185,31 +182,30 @@ typedef struct skcms_ICCProfile {
 
     // If we can parse red, green and blue transfer curves from the profile,
     // trc will be set to those three curves, and has_trc will be true.
+    bool                   has_trc;
     skcms_Curve            trc[3];
 
     // If this profile's gamut can be represented by a 3x3 transform to XYZD50,
     // skcms_Parse() sets toXYZD50 to that transform and has_toXYZD50 to true.
+    bool                   has_toXYZD50;
     skcms_Matrix3x3        toXYZD50;
 
     // If the profile has a valid A2B0 or A2B1 tag, skcms_Parse() sets A2B to
     // that data, and has_A2B to true.  skcms_ParseWithA2BPriority() does the
     // same following any user-provided prioritization of A2B0, A2B1, or A2B2.
+    bool                   has_A2B;
     skcms_A2B              A2B;
 
     // If the profile has a valid B2A0 or B2A1 tag, skcms_Parse() sets B2A to
     // that data, and has_B2A to true.  skcms_ParseWithA2BPriority() does the
     // same following any user-provided prioritization of B2A0, B2A1, or B2A2.
+    bool                   has_B2A;
     skcms_B2A              B2A;
 
     // If the profile has a valid CICP tag, skcms_Parse() sets CICP to that data,
     // and has_CICP to true.
-    skcms_CICP             CICP;
-
-    bool                   has_trc;
-    bool                   has_toXYZD50;
-    bool                   has_A2B;
-    bool                   has_B2A;
     bool                   has_CICP;
+    skcms_CICP             CICP;
 } skcms_ICCProfile;
 
 // The sRGB color profile is so commonly used that we offer a canonical skcms_ICCProfile for it.

package/cpp/skia/modules/skresources/include/SkResources.h

@@ -108,10 +108,8 @@ public:
     static sk_sp<MultiFrameImageAsset> Make(std::unique_ptr<SkCodec>,
                                             ImageDecodeStrategy = ImageDecodeStrategy::kLazyDecode);
 
-    bool isMultiFrame() override;
 
-    // Animation duration, in ms.
-    float duration() const;
+    bool isMultiFrame() override;
 
     sk_sp<SkImage> getFrame(float t) override;
 

package/cpp/skia/modules/svg/include/SkSVGCircle.h

@@ -42,7 +42,7 @@ protected:
 
     SkPath onAsPath(const SkSVGRenderContext&) const override;
 
-    SkRect onTransformableObjectBoundingBox(const SkSVGRenderContext&) const override;
+    SkRect onObjectBoundingBox(const SkSVGRenderContext&) const override;
 
 private:
     SkSVGCircle();

package/cpp/skia/modules/svg/include/SkSVGContainer.h

@@ -29,7 +29,7 @@ protected:
 
     SkPath onAsPath(const SkSVGRenderContext&) const override;
 
-    SkRect onTransformableObjectBoundingBox(const SkSVGRenderContext&) const final;
+    SkRect onObjectBoundingBox(const SkSVGRenderContext&) const override;
 
     bool hasChildren() const final;
 

package/cpp/skia/modules/svg/include/SkSVGFeLightSource.h

@@ -20,7 +20,7 @@
 class SK_API SkSVGFeLightSource : public SkSVGHiddenContainer {
 public:
     void appendChild(sk_sp<SkSVGNode>) final {
-        SkDEBUGF("cannot append child nodes to an SVG light source.\n");
+        SkDebugf("cannot append child nodes to an SVG light source.\n");
     }
 
 protected:

package/cpp/skia/modules/svg/include/SkSVGImage.h

@@ -31,13 +31,13 @@ public:
     }
 
     void appendChild(sk_sp<SkSVGNode>) override {
-        SkDEBUGF("cannot append child nodes to this element.\n");
+        SkDebugf("cannot append child nodes to this element.\n");
     }
 
     bool onPrepareToRender(SkSVGRenderContext*) const override;
     void onRender(const SkSVGRenderContext&) const override;
     SkPath onAsPath(const SkSVGRenderContext&) const override;
-    SkRect onTransformableObjectBoundingBox(const SkSVGRenderContext&) const override;
+    SkRect onObjectBoundingBox(const SkSVGRenderContext&) const override;
 
     struct ImageInfo {
         sk_sp<SkImage> fImage;

package/cpp/skia/modules/svg/include/SkSVGPath.h

@@ -35,7 +35,7 @@ protected:
 
     SkPath onAsPath(const SkSVGRenderContext&) const override;
 
-    SkRect onTransformableObjectBoundingBox(const SkSVGRenderContext&) const override;
+    SkRect onObjectBoundingBox(const SkSVGRenderContext&) const override;
 
 private:
     SkSVGPath();

package/cpp/skia/modules/svg/include/SkSVGPoly.h

@@ -43,7 +43,7 @@ protected:
 
     SkPath onAsPath(const SkSVGRenderContext&) const override;
 
-    SkRect onTransformableObjectBoundingBox(const SkSVGRenderContext&) const override;
+    SkRect onObjectBoundingBox(const SkSVGRenderContext&) const override;
 
 private:
     SkSVGPoly(SkSVGTag);

package/cpp/skia/modules/svg/include/SkSVGRect.h

@@ -44,7 +44,7 @@ protected:
 
     SkPath onAsPath(const SkSVGRenderContext&) const override;
 
-    SkRect onTransformableObjectBoundingBox(const SkSVGRenderContext&) const override;
+    SkRect onObjectBoundingBox(const SkSVGRenderContext&) const override;
 
 private:
     SkSVGRect();