@shopify/react-native-skia 0.1.233 → 0.1.236

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

@@ -18,9 +18,11 @@
 #include <chrono>
 #include <vector>
 
+struct AHardwareBuffer;
 class SkCanvas;
 struct SkImageInfo;
 class SkPixmap;
+class SkTraceMemoryDump;
 
 namespace skgpu {
 class RefCntedCallback;
@@ -65,7 +67,7 @@ struct SK_API RecorderOptions final {
 
     sk_sp<ImageProvider> fImageProvider;
 
-    const size_t kDefaultRecorderBudget = 256 * (1 << 20);
+    static constexpr size_t kDefaultRecorderBudget = 256 * (1 << 20);
     // What is the budget for GPU resources allocated and held by this Recorder.
     size_t fGpuBudgetInBytes = kDefaultRecorderBudget;
 };
@@ -79,6 +81,8 @@ public:
 
     ~Recorder();
 
+    BackendApi backend() const;
+
     std::unique_ptr<Recording> snap();
 
     ImageProvider* clientImageProvider() { return fClientImageProvider.get(); }
@@ -97,6 +101,14 @@ public:
      */
     BackendTexture createBackendTexture(SkISize dimensions, const TextureInfo&);
 
+#ifdef SK_BUILD_FOR_ANDROID
+    BackendTexture createBackendTexture(AHardwareBuffer*,
+                                        bool isRenderable,
+                                        bool isProtectedContent,
+                                        SkISize dimensions,
+                                        bool fromAndroidWindow = false) const;
+#endif
+
     /**
      * If possible, updates a backend texture with the provided pixmap data. The client
      * should check the return value to see if the update was successful. The client is required
@@ -154,6 +166,17 @@ public:
      */
     void performDeferredCleanup(std::chrono::milliseconds msNotUsed);
 
+    /**
+     * Returns the number of bytes of gpu memory currently budgeted in the Recorder's cache.
+     */
+    size_t currentBudgetedBytes() const;
+
+    /**
+     * Enumerates all cached GPU resources owned by the Recorder and dumps their memory to
+     * traceMemoryDump.
+     */
+    void dumpMemoryStatistics(SkTraceMemoryDump* traceMemoryDump) const;
+
     // Provides access to functions that aren't part of the public API.
     RecorderPriv priv();
     const RecorderPriv priv() const;  // NOLINT(readability-const-return-type)
@@ -167,8 +190,6 @@ private:
 
     SingleOwner* singleOwner() const { return &fSingleOwner; }
 
-    BackendApi backend() const;
-
     // We keep track of all Devices that are connected to a Recorder. This allows the client to
     // safely delete an SkSurface or a Recorder in any order. If the client deletes the Recorder
     // we need to notify all Devices that the Recorder is no longer valid. If we delete the

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

@@ -21,8 +21,11 @@ class Recorder;
 }  // namespace skgpu::graphite
 
 namespace SkSurfaces {
+using ReleaseContext = void*;
+using TextureReleaseProc = void (*)(ReleaseContext);
+
 /**
- * The 'asImage' and 'makeImageCopy' API/entry points are currently only available for
+ * The 'AsImage' and 'AsImageCopy' API/entry points are currently only available for
  * Graphite.
  *
  * In this API, SkSurface no longer supports copy-on-write behavior. Instead, when creating
@@ -75,7 +78,9 @@ SK_API sk_sp<SkSurface> WrapBackendTexture(skgpu::graphite::Recorder*,
                                            const skgpu::graphite::BackendTexture&,
                                            SkColorType colorType,
                                            sk_sp<SkColorSpace> colorSpace,
-                                           const SkSurfaceProps* props);
+                                           const SkSurfaceProps* props,
+                                           TextureReleaseProc = nullptr,
+                                           ReleaseContext = nullptr);
 }  // namespace SkSurfaces
 
 #endif  // skgpu_graphite_Surface_DEFINED

package/cpp/skia/include/gpu/graphite/dawn/DawnBackendContext.h

@@ -8,16 +8,55 @@
 #ifndef skgpu_graphite_DawnBackendContext_DEFINED
 #define skgpu_graphite_DawnBackendContext_DEFINED
 
-#include "webgpu/webgpu_cpp.h"
+#include "include/core/SkTypes.h"
+#include "webgpu/webgpu_cpp.h"  // NO_G3_REWRITE
 
 namespace skgpu::graphite {
 
+/**
+ * WebGPU needs to allow the main thread loop to run to detect GPU progress. Dawn native has a
+ * function wgpu::Dawn::Tick(), not present in WebGPU, that can be used to detect GPU progress.
+ *
+ * When compiling using Emscripten/WASM the -s ASYNCIFY option can be used to yield. E.g.:
+ *
+ * EM_ASYNC_JS(void, asyncSleep, (), {
+ *                 await new Promise((resolve, _) = > {
+ *                     setTimeout(resolve, 0);
+ *                 })
+ *             });
+ *
+ * WebGPUTickFunction(wgpu::Device&) { asyncSleep(); }
+ *
+ * If no DawnTickFunction is provided then the graphite::Context will be "non-yielding". This
+ * implies the following restrictions on the Context:
+ *
+ * 1) SyncToCpu::kYes is disallowed as a parameter to Context::submit.
+ * 2) The client must guarantee that GPU work has completed before destroying Context as Context
+ *    cannot await the work completion in its destructor. Context reports whether it is awaiting
+ *    GPU work completion via Context::hasUnfinishedGpuWork().
+ *
+ * Using a non-yielding Context makes it possible to build and run Graphite/Dawn on WebGPU without
+ * -s ASYNCIFY.
+ */
+using DawnTickFunction = void(const wgpu::Device& device);
+
+#if !defined(__EMSCRIPTEN__)
+SK_API inline void DawnNativeTickFunction(const wgpu::Device& device) { device.Tick(); }
+#endif
+
 // The DawnBackendContext contains all of the base Dawn objects needed by the graphite Dawn
 // backend. The client will create this object and pass it into the Context::MakeDawn factory call
 // when setting up Skia.
 struct SK_API DawnBackendContext {
     wgpu::Device fDevice;
-    wgpu::Queue  fQueue;
+    wgpu::Queue fQueue;
+    // See comment on DawnTickFunction.
+    DawnTickFunction* fTick =
+#if defined(__EMSCRIPTEN__)
+            nullptr;
+#else
+            DawnNativeTickFunction;
+#endif
 };
 
 } // namespace skgpu::graphite

package/cpp/skia/include/gpu/graphite/dawn/DawnTypes.h

@@ -9,7 +9,7 @@
 #define skgpu_graphite_DawnTypes_DEFINED
 
 #include "include/gpu/graphite/GraphiteTypes.h"
-#include "webgpu/webgpu_cpp.h"
+#include "webgpu/webgpu_cpp.h"  // NO_G3_REWRITE
 
 namespace skgpu::graphite {
 
@@ -18,19 +18,24 @@ struct DawnTextureInfo {
     Mipmapped fMipmapped = Mipmapped::kNo;
 
     // wgpu::TextureDescriptor properties
+    // `fFormat` for multiplanar formats corresponds to the plane TextureView's format.
     wgpu::TextureFormat fFormat = wgpu::TextureFormat::Undefined;
-    wgpu::TextureUsage  fUsage = wgpu::TextureUsage::None;
+    wgpu::TextureUsage fUsage = wgpu::TextureUsage::None;
+    // TODO(b/308944094): Migrate aspect information to BackendTextureViews.
+    wgpu::TextureAspect fAspect = wgpu::TextureAspect::All;
 
     DawnTextureInfo() = default;
     DawnTextureInfo(const wgpu::Texture& texture);
     DawnTextureInfo(uint32_t sampleCount,
                     Mipmapped mipmapped,
-                    wgpu::TextureFormat format,
-                    wgpu::TextureUsage usage)
+                    wgpu::TextureFormat viewFormat,
+                    wgpu::TextureUsage usage,
+                    wgpu::TextureAspect aspect)
             : fSampleCount(sampleCount)
             , fMipmapped(mipmapped)
-            , fFormat(format)
-            , fUsage(usage) {}
+            , fFormat(viewFormat)
+            , fUsage(usage)
+            , fAspect(aspect) {}
 };
 
 } // namespace skgpu::graphite

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

@@ -35,7 +35,6 @@ namespace skgpu::graphite {
 using MtlPixelFormat = unsigned int;
 using MtlTextureUsage = unsigned int;
 using MtlStorageMode = unsigned int;
-using MtlHandle = const void*;
 
 struct MtlTextureInfo {
     uint32_t fSampleCount = 1;
@@ -49,7 +48,7 @@ struct MtlTextureInfo {
     bool fFramebufferOnly = false;
 
     MtlTextureInfo() = default;
-    MtlTextureInfo(MtlHandle mtlTexture);
+    MtlTextureInfo(CFTypeRef mtlTexture);
     MtlTextureInfo(uint32_t sampleCount,
                    skgpu::Mipmapped mipmapped,
                    MtlPixelFormat format,

package/cpp/skia/include/gpu/graphite/vk/VulkanGraphiteTypes.h

@@ -33,10 +33,8 @@ struct VulkanTextureInfo {
     // However, if the VkImage is a Ycbcr format, the client can pass a specific plan here to have
     // Skia directly sample a plane. In that case the client should also pass in a VkFormat that is
     // compatible with the plane as described by the Vulkan spec.
-    VkImageAspectFlags fAspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
-    // TODO: Either Make the ycbcr conversion info shareable with Ganesh or add a version for
-    // Graphite.
-    // GrVkYcbcrConversionInfo  fYcbcrConversionInfo;
+    VkImageAspectFlags         fAspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+    VulkanYcbcrConversionInfo  fYcbcrConversionInfo;
 
     VulkanTextureInfo() = default;
     VulkanTextureInfo(uint32_t sampleCount,
@@ -46,7 +44,8 @@ struct VulkanTextureInfo {
                       VkImageTiling imageTiling,
                       VkImageUsageFlags imageUsageFlags,
                       VkSharingMode sharingMode,
-                      VkImageAspectFlags aspectMask)
+                      VkImageAspectFlags aspectMask,
+                      VulkanYcbcrConversionInfo ycbcrConversionInfo)
             : fSampleCount(sampleCount)
             , fMipmapped(mipmapped)
             , fFlags(flags)
@@ -54,7 +53,8 @@ struct VulkanTextureInfo {
             , fImageTiling(imageTiling)
             , fImageUsageFlags(imageUsageFlags)
             , fSharingMode(sharingMode)
-            , fAspectMask(aspectMask) {}
+            , fAspectMask(aspectMask)
+            , fYcbcrConversionInfo(ycbcrConversionInfo) {}
 };
 
 } // namespace skgpu::graphite

package/cpp/skia/include/gpu/mock/GrMockTypes.h

@@ -121,6 +121,7 @@ struct GrMockOptions {
         fConfigOptions[(int)GrColorType::kRGBA_8888].fTexturable = true;
         fConfigOptions[(int)GrColorType::kAlpha_8].fTexturable = true;
         fConfigOptions[(int)GrColorType::kBGR_565].fTexturable = true;
+        fConfigOptions[(int)GrColorType::kRGB_565].fTexturable = true;
 
         fConfigOptions[(int)GrColorType::kBGRA_8888] = fConfigOptions[(int)GrColorType::kRGBA_8888];
 

package/cpp/skia/include/gpu/vk/GrVkBackendContext.h

@@ -30,7 +30,7 @@ enum GrVkFeatureFlags {
     kSampleRateShading_GrVkFeatureFlag = 0x0004,
 };
 
-// It is not guarenteed VkPhysicalDeviceProperties2 will be in the client's header so we forward
+// It is not guaranteed VkPhysicalDeviceProperties2 will be in the client's header so we forward
 // declare it here to be safe.
 struct VkPhysicalDeviceFeatures2;
 

package/cpp/skia/include/gpu/vk/GrVkTypes.h

@@ -14,50 +14,7 @@
 
 using GrVkBackendMemory = skgpu::VulkanBackendMemory;
 using GrVkAlloc = skgpu::VulkanAlloc;
-
-// This struct is used to pass in the necessary information to create a VkSamplerYcbcrConversion
-// object for an VkExternalFormatANDROID.
-struct GrVkYcbcrConversionInfo {
-    bool operator==(const GrVkYcbcrConversionInfo& that) const {
-        // Invalid objects are not required to have all other fields initialized or matching.
-        if (!this->isValid() && !that.isValid()) {
-            return true;
-        }
-        return this->fFormat == that.fFormat &&
-               this->fExternalFormat == that.fExternalFormat &&
-               this->fYcbcrModel == that.fYcbcrModel &&
-               this->fYcbcrRange == that.fYcbcrRange &&
-               this->fXChromaOffset == that.fXChromaOffset &&
-               this->fYChromaOffset == that.fYChromaOffset &&
-               this->fChromaFilter == that.fChromaFilter &&
-               this->fForceExplicitReconstruction == that.fForceExplicitReconstruction;
-    }
-    bool operator!=(const GrVkYcbcrConversionInfo& that) const { return !(*this == that); }
-
-    bool isValid() const {
-        return fYcbcrModel != VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY ||
-               fExternalFormat != 0;
-    }
-
-    // Format of the source image. Must be set to VK_FORMAT_UNDEFINED for external images or
-    // a valid image format otherwise.
-    VkFormat fFormat = VK_FORMAT_UNDEFINED;
-
-    // The external format. Must be non-zero for external images, zero otherwise.
-    // Should be compatible to be used in a VkExternalFormatANDROID struct.
-    uint64_t fExternalFormat = 0;
-
-    VkSamplerYcbcrModelConversion fYcbcrModel = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY;
-    VkSamplerYcbcrRange fYcbcrRange = VK_SAMPLER_YCBCR_RANGE_ITU_FULL;
-    VkChromaLocation fXChromaOffset = VK_CHROMA_LOCATION_COSITED_EVEN;
-    VkChromaLocation fYChromaOffset = VK_CHROMA_LOCATION_COSITED_EVEN;
-    VkFilter fChromaFilter = VK_FILTER_NEAREST;
-    VkBool32 fForceExplicitReconstruction = false;
-
-    // For external images format features here should be those returned by a call to
-    // vkAndroidHardwareBufferFormatPropertiesANDROID
-    VkFormatFeatureFlags fFormatFeatures = 0;
-};
+using GrVkYcbcrConversionInfo = skgpu::VulkanYcbcrConversionInfo;
 
 /*
  * When wrapping a GrBackendTexture or GrBackendRendenderTarget, the fCurrentQueueFamily should

package/cpp/skia/include/gpu/vk/VulkanExtensions.h

@@ -57,7 +57,7 @@ public:
 #endif
 
 private:
-    void getSpecVersions(VulkanGetProc getProc, VkInstance, VkPhysicalDevice);
+    void getSpecVersions(const VulkanGetProc& getProc, VkInstance, VkPhysicalDevice);
 
     skia_private::TArray<Info> fExtensions;
 };

package/cpp/skia/include/gpu/vk/VulkanMutableTextureState.h

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef skgpu_VulkanMutableTextureState_DEFINED
+#define skgpu_VulkanMutableTextureState_DEFINED
+
+#include "include/gpu/MutableTextureState.h"
+#include "include/private/gpu/vk/SkiaVulkan.h"
+
+#include <cstdint>
+
+namespace skgpu::MutableTextureStates {
+    MutableTextureState MakeVulkan(VkImageLayout layout, uint32_t queueFamilyIndex);
+
+    VkImageLayout GetVkImageLayout(const MutableTextureState& state);
+    VkImageLayout GetVkImageLayout(const MutableTextureState* state);
+    uint32_t GetVkQueueFamilyIndex(const MutableTextureState& state);
+    uint32_t GetVkQueueFamilyIndex(const MutableTextureState* state);
+}
+
+#endif

package/cpp/skia/include/gpu/vk/VulkanTypes.h

@@ -54,6 +54,50 @@ private:
     bool fUsesSystemHeap = false;
 };
 
+// Used to pass in the necessary information to create a VkSamplerYcbcrConversion object for an
+// VkExternalFormatANDROID.
+struct VulkanYcbcrConversionInfo {
+    bool operator==(const VulkanYcbcrConversionInfo& that) const {
+        // Invalid objects are not required to have all other fields initialized or matching.
+        if (!this->isValid() && !that.isValid()) {
+            return true;
+        }
+        return this->fFormat == that.fFormat &&
+               this->fExternalFormat == that.fExternalFormat &&
+               this->fYcbcrModel == that.fYcbcrModel &&
+               this->fYcbcrRange == that.fYcbcrRange &&
+               this->fXChromaOffset == that.fXChromaOffset &&
+               this->fYChromaOffset == that.fYChromaOffset &&
+               this->fChromaFilter == that.fChromaFilter &&
+               this->fForceExplicitReconstruction == that.fForceExplicitReconstruction;
+    }
+    bool operator!=(const VulkanYcbcrConversionInfo& that) const { return !(*this == that); }
+
+    bool isValid() const {
+        return fYcbcrModel != VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY ||
+               fExternalFormat != 0;
+    }
+
+    // Format of the source image. Must be set to VK_FORMAT_UNDEFINED for external images or
+    // a valid image format otherwise.
+    VkFormat fFormat = VK_FORMAT_UNDEFINED;
+
+    // The external format. Must be non-zero for external images, zero otherwise.
+    // Should be compatible to be used in a VkExternalFormatANDROID struct.
+    uint64_t fExternalFormat = 0;
+
+    VkSamplerYcbcrModelConversion fYcbcrModel = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY;
+    VkSamplerYcbcrRange fYcbcrRange           = VK_SAMPLER_YCBCR_RANGE_ITU_FULL;
+    VkChromaLocation fXChromaOffset           = VK_CHROMA_LOCATION_COSITED_EVEN;
+    VkChromaLocation fYChromaOffset           = VK_CHROMA_LOCATION_COSITED_EVEN;
+    VkFilter fChromaFilter                    = VK_FILTER_NEAREST;
+    VkBool32 fForceExplicitReconstruction     = false;
+
+    // For external images format features here should be those returned by a call to
+    // vkAndroidHardwareBufferFormatPropertiesANDROID
+    VkFormatFeatureFlags fFormatFeatures = 0;
+};
+
 } // namespace skgpu
 
 #endif // skgpu_VulkanTypes_DEFINED

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

@@ -95,13 +95,10 @@ public:
      *  Return an SkTypeface for the given FontIdentity.
      *
      *  The default implementation simply returns a new typeface built using data obtained from
-     *  openStream(), but derived classes may implement more complex caching schemes.
+     *  openStream() using the provided SkFontMgr, but derived classes may implement more
+     *  complex caching schemes.
      */
-    virtual sk_sp<SkTypeface> makeTypeface(const FontIdentity& identity) {
-        return SkTypeface::MakeFromStream(std::unique_ptr<SkStreamAsset>(this->openStream(identity)),
-                                          identity.fTTCIndex);
-
-    }
+    virtual sk_sp<SkTypeface> makeTypeface(const FontIdentity& identity, sk_sp<SkFontMgr> mgr);
 
     /**
      *  Return a singleton instance of a direct subclass that calls into

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

@@ -29,6 +29,7 @@ public:
         static std::unique_ptr<ICCProfile> Make(const skcms_ICCProfile&);
 
         const skcms_ICCProfile* profile() const { return &fProfile; }
+        sk_sp<SkData> data() const { return fData; }
     private:
         ICCProfile(const skcms_ICCProfile&, sk_sp<SkData> = nullptr);
 
@@ -197,6 +198,10 @@ public:
         if (!fProfile) return nullptr;
         return fProfile->profile();
     }
+    sk_sp<SkData> profileData() const {
+        if (!fProfile) return nullptr;
+        return fProfile->data();
+    }
 
     uint8_t bitsPerComponent() const { return fBitsPerComponent; }
 

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

@@ -0,0 +1,102 @@
+/*
+ * Copyright 2023 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkExif_DEFINED
+#define SkExif_DEFINED
+
+#include "include/codec/SkEncodedOrigin.h"
+#include "include/core/SkData.h"
+#include "include/core/SkRefCnt.h"
+#include "include/private/base/SkAPI.h"
+
+#include <cstdint>
+
+class SK_API SkExifMetadata {
+public:
+    /*
+     * Parse the metadata specified in |data|.
+     */
+    SkExifMetadata(const sk_sp<SkData> data);
+
+    /*
+     * If the image encoded origin is specified, populate |out| and return true. Otherwise return
+     * false.
+     */
+    bool getOrigin(SkEncodedOrigin* out) const {
+        if (fOriginPresent && out) *out = fOriginValue;
+        return fOriginPresent;
+    }
+
+    /*
+     * If the HDR headroom is specified, populate |out| and return true. Otherwise return false.
+     */
+    bool getHdrHeadroom(float* out) const {
+        if (fHdrHeadroomPresent && out) *out = fHdrHeadroomValue;
+        return fHdrHeadroomPresent;
+    }
+
+    /*
+     * If resolution unit, x, or y is specified, populate |out| and return true. Otherwise return
+     * false.
+     */
+    bool getResolutionUnit(uint16_t* out) const {
+        if (fResolutionUnitPresent && out) *out = fResolutionUnitValue;
+        return fResolutionUnitPresent;
+    }
+    bool getXResolution(float* out) const {
+        if (fXResolutionPresent && out) *out = fXResolutionValue;
+        return fXResolutionPresent;
+    }
+    bool getYResolution(float* out) const {
+        if (fYResolutionPresent && out) *out = fYResolutionValue;
+        return fYResolutionPresent;
+    }
+
+    /*
+     * If pixel dimension x or y is specified, populate |out| and return true. Otherwise return
+     * false.
+     */
+    bool getPixelXDimension(uint32_t* out) const {
+        if (fPixelXDimensionPresent && out) *out = fPixelXDimensionValue;
+        return fPixelXDimensionPresent;
+    }
+    bool getPixelYDimension(uint32_t* out) const {
+        if (fPixelYDimensionPresent && out) *out = fPixelYDimensionValue;
+        return fPixelYDimensionPresent;
+    }
+
+private:
+    // Helper functions and constants for parsing the data.
+    void parseIfd(uint32_t ifdOffset, bool littleEndian, bool isRoot);
+
+    // The input data.
+    const sk_sp<SkData> fData;
+
+    // The origin property.
+    bool fOriginPresent = false;
+    SkEncodedOrigin fOriginValue = kTopLeft_SkEncodedOrigin;
+
+    // The HDR headroom property.
+    bool fHdrHeadroomPresent = false;
+    float fHdrHeadroomValue = 1.f;
+
+    // Resolution.
+    bool fResolutionUnitPresent = false;
+    uint16_t fResolutionUnitValue = 0;
+    bool fXResolutionPresent = false;
+    float fXResolutionValue = 0;
+    bool fYResolutionPresent = false;
+    float fYResolutionValue = 0;
+
+    // Size in pixels.
+    bool fPixelXDimensionPresent = false;
+    uint32_t fPixelXDimensionValue = 0;
+    bool fPixelYDimensionPresent = false;
+    uint32_t fPixelYDimensionValue = 0;
+};
+
+#endif

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

@@ -9,6 +9,7 @@
 #define SkGainmapInfo_DEFINED
 
 #include "include/core/SkColor.h"
+#include "include/core/SkColorSpace.h"
 
 /**
  *  Gainmap rendering parameters. Suppose our display has HDR to SDR ratio of H and we wish to
@@ -71,12 +72,21 @@ struct SkGainmapInfo {
     };
     BaseImageType fBaseImageType = BaseImageType::kSDR;
 
+    /**
+     * If specified, color space to apply the gainmap in, otherwise the base image's color space
+     * is used. Only the color primaries are used, the transfer function is irrelevant.
+     */
+    sk_sp<SkColorSpace> fGainmapMathColorSpace = nullptr;
+
     inline bool operator==(const SkGainmapInfo& other) const {
         return fGainmapRatioMin == other.fGainmapRatioMin &&
                fGainmapRatioMax == other.fGainmapRatioMax && fGainmapGamma == other.fGainmapGamma &&
                fEpsilonSdr == other.fEpsilonSdr && fEpsilonHdr == other.fEpsilonHdr &&
                fDisplayRatioSdr == other.fDisplayRatioSdr &&
-               fDisplayRatioHdr == other.fDisplayRatioHdr && fBaseImageType == other.fBaseImageType;
+               fDisplayRatioHdr == other.fDisplayRatioHdr &&
+               fBaseImageType == other.fBaseImageType &&
+               SkColorSpace::Equals(fGainmapMathColorSpace.get(),
+                                    other.fGainmapMathColorSpace.get());
     }
     inline bool operator!=(const SkGainmapInfo& other) const { return !(*this == other); }
 

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

@@ -28,6 +28,22 @@
     #define SK_UNLIKELY
 #endif
 
+// c++23 will give us [[assume]] -- until then we're stuck with various other options:
+#if defined(__clang__)
+    #define SK_ASSUME(cond) __builtin_assume(cond)
+#elif defined(__GNUC__)
+    #if __GNUC__ >= 13
+        #define SK_ASSUME(cond) __attribute__((assume(cond)))
+    #else
+        // NOTE: This implementation could actually evaluate `cond`, which is not desirable.
+        #define SK_ASSUME(cond) ((cond) ? (void)0 : __builtin_unreachable())
+    #endif
+#elif defined(_MSC_VER)
+    #define SK_ASSUME(cond) __assume(cond)
+#else
+    #define SK_ASSUME(cond) ((void)0)
+#endif
+
 /** Called internally if we hit an unrecoverable error.
     The platform implementation must not return, but should either throw
     an exception or otherwise exit.

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

@@ -42,13 +42,8 @@ public:
     const void* front() const { return fFront; }
     const void* back() const  { return fBack; }
 
-    void* front() {
-        return (void*)((const SkDeque*)this)->front();
-    }
-
-    void* back() {
-        return (void*)((const SkDeque*)this)->back();
-    }
+    void* front() { return fFront; }
+    void* back() { return fBack; }
 
     /**
      * push_front and push_back return a pointer to the memory space

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

@@ -26,7 +26,7 @@
     // This is achieved in Skia by having a nested WORKSPACE in include/config and a cc_library
     // defined in that folder. As a result, we do not try to include SkUserConfig.h from the
     // top of Skia because Bazel sandboxing will move it to a different location.
-    #include "SkUserConfig.h"
+    #include "SkUserConfig.h"  // NO_G3_REWRITE
 #else
     #include "include/config/SkUserConfig.h"
 #endif