@shopify/react-native-skia 2.6.0 → 2.6.2

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

@@ -11,6 +11,7 @@
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkSize.h"
 #include "include/core/SkSpan.h"
+#include "include/gpu/graphite/GraphiteTypes.h"
 #include "include/private/base/SkAPI.h"
 #include "include/private/base/SkMath.h"
 
@@ -45,11 +46,12 @@ struct SK_API ContextOptions {
 
     /**
      * Specifies the number of samples Graphite should use when performing internal draws with MSAA
-     * (hardware capabilities permitting).
+     * (hardware capabilities permitting). This represents the maximum that will be used; if a
+     * a specific format supports only lower values, those may be used instead.
      *
      * If <= 1, Graphite will disable internal code paths that use multisampling.
      */
-    uint8_t fInternalMultisampleCount = 4;
+    SampleCount fInternalMultisampleCount = SampleCount::k4;
 
     /**
      * If set, this specifies the max width/height of MSAA textures that Graphite should use for
@@ -68,13 +70,6 @@ struct SK_API ContextOptions {
      */
     float fMinimumPathSizeForMSAA = 0;
 
-    /**
-     * Will the client make sure to only ever be executing one thread that uses the Context and all
-     * derived classes (e.g. Recorders, Recordings, etc.) at a time. If so we can possibly make some
-     * objects (e.g. VulkanMemoryAllocator) not thread safe to improve single thread performance.
-     */
-    bool fClientWillExternallySynchronizeAllThreads = false;
-
     /**
      * The maximum size of cache textures used for Skia's Glyph cache.
      */
@@ -140,17 +135,6 @@ struct SK_API ContextOptions {
     bool fSetBackendLabels = false;
 #endif
 
-    /**
-     * If Skia is creating a default VMA allocator for the Vulkan backend this value will be used
-     * for the preferredLargeHeapBlockSize. If the value is not set, then Skia will use an
-     * internally defined default size.
-     *
-     * However, it is highly discouraged to have Skia make a default allocator (and support for
-     * doing so will be removed soon,  b/321962001). Instead clients should create their own
-     * allocator to pass into Skia where they can fine tune this value themeselves.
-     */
-    std::optional<uint64_t> fVulkanVMALargeHeapBlockSize;
-
     /**
      * Client-provided context that is passed to the client-provided PipelineCachingCallback
      * and the (deprecated) PipelineCallback.

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

@@ -14,6 +14,7 @@
 #include "include/gpu/GpuTypes.h"
 
 #include <memory>
+#include <string>
 
 class SkSurface;
 
@@ -52,16 +53,24 @@ public:
         kAddCommandsFailed,
         // Internal failure, shader pipeline compilation failed (driver issue, or disk corruption),
         // state unrecoverable.
-        kAsyncShaderCompilesFailed
+        kAsyncShaderCompilesFailed,
+        // The inserted Recording is out of order from what the Context expects (when
+        // `[Context|Recorder]Options::fRequireOrderedRecordings` is true), which can either
+        // represent a client synchronization error or an internal failure when a prior dependent
+        // Recording failed for some reason, no CB changes but state likely unrecoverable.
+        kOutOfOrderRecording,
     };
 
-    constexpr InsertStatus() : fValue(kSuccess) {}
-    /*implicit*/ constexpr InsertStatus(V v) : fValue(v) {}
+    InsertStatus() : fValue(kSuccess) {}
+    /*implicit*/ InsertStatus(V v) : fValue(v) {}
+    InsertStatus(V v, std::string message) : fValue(v), fMessage(std::move(message)) {}
 
     operator InsertStatus::V() const {
         return fValue;
     }
 
+    const std::string& message() const { return fMessage; }
+
     // Assist migration from old bool return value of insertRecording; kSuccess is true,
     // all other error statuses are false.
     // NOTE: This is intentionally not explicit so that InsertStatus can be assigned correctly to
@@ -73,6 +82,7 @@ public:
 
 private:
     V fValue;
+    std::string fMessage;
 };
 
 /**
@@ -148,7 +158,7 @@ struct InsertRecordingInfo {
  * and the caller can use the callback to know it is safe to free any resources associated with
  * the Recording that they may be holding onto. If the Recording is successfully submitted to the
  * GPU the callback will be called with CallbackResult::kSuccess once the GPU has finished. All
- * other cases where some failure occured it will be called with CallbackResult::kFailed.
+ * other cases where some failure occurred it will be called with CallbackResult::kFailed.
  */
 struct InsertFinishInfo {
     InsertFinishInfo() = default;
@@ -209,50 +219,26 @@ enum class DepthStencilFlags : int {
     kDepthStencil = kDepth | kStencil,
 };
 
-// NOTE: This can be converted to just an `enum class SampleCount {}` once clients are migrated
-// off of writing integer values into backend TextureInfo fields or ContextOptions.
-class SampleCount {
-public:
-    // Do not refer to V directly; use these constants as if SampleCount were a class enum, e.g.
-    // SampleCount::k4.
-    enum V : uint8_t {
-        k1  = 1,
-        k2  = 2,
-        k4  = 4,
-        k8  = 8,
-        k16 = 16
-    };
-
-    constexpr SampleCount() : fValue(k1) {}
-    /*implicit*/ constexpr SampleCount(V v) : fValue(v) {}
-
-    // Behave like an enum
-    constexpr bool operator ==(const SampleCount& o) const { return fValue == o.fValue; }
-    constexpr bool operator  <(const SampleCount& o) const { return fValue  < o.fValue; }
-    constexpr bool operator <=(const SampleCount& o) const { return fValue <= o.fValue; }
-    constexpr bool operator  >(const SampleCount& o) const { return fValue  > o.fValue; }
-    constexpr bool operator >=(const SampleCount& o) const { return fValue >= o.fValue; }
-
-    // This needs to be explicit so that ternaries that return constants mixed with variables aren't
-    // ambiguous; internal code can cast for switch statements.
-    explicit constexpr operator SampleCount::V() const { return fValue; }
-    explicit constexpr operator uint8_t()        const { return (uint8_t) fValue; }
-    explicit constexpr operator unsigned int()   const { return (unsigned int) fValue; }
-
-    // Assist migration from old code that would assign integers to sample count fields that used
-    // to be uint8_t and are now more strictly typed to SampleCount. Asserts if the value doesn't
-    // match a SampleCount value.
-    /*implicit*/ constexpr SampleCount(uint8_t v) : fValue((V) v) {
-        SkASSERT(v == 1 || v == 2 || v == 4 || v == 8 || v == 16);
-    }
-    constexpr SampleCount& operator=(uint8_t sampleCount) {
-        return (*this = SampleCount(sampleCount));
-    }
-
-private:
-    V fValue;
+enum class SampleCount : uint8_t {
+    k1  = 1,
+    k2  = 2,
+    k4  = 4,
+    k8  = 8,
+    k16 = 16
 };
 
+/**
+ * Convert an integer value to a strictly typed SampleCount value, rounding down to the lowest
+ * valid sample count if needed if `sampleCount` is not already equivalent.
+ */
+constexpr SampleCount ToSampleCount(uint32_t sampleCount) {
+    return sampleCount >= 16 ? SampleCount::k16 :
+           sampleCount >= 8  ? SampleCount::k8  :
+           sampleCount >= 4  ? SampleCount::k4  :
+           sampleCount >= 2  ? SampleCount::k2  :
+                               SampleCount::k1;
+}
+
 /*
  * This enum allows mapping from a set of observed RenderSteps (e.g., from a GraphicsPipeline
  * printout) to the correct 'drawTypes' parameter needed by the Precompilation API.

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

@@ -291,7 +291,7 @@ private:
 
     // NOTE: These are stored by pointer to allow them to be forward declared.
     std::unique_ptr<TaskList> fRootTaskList;
-    // Aggregated one-time uploads that preceed all tasks in the root task list.
+    // Aggregated one-time uploads that precede all tasks in the root task list.
     std::unique_ptr<UploadList> fRootUploads;
 
     std::unique_ptr<DrawBufferManager> fDrawBufferManager;

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

@@ -76,6 +76,8 @@ SK_API sk_sp<SkSurface> RenderTarget(skgpu::graphite::Recorder*,
  * 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.
+ *
+ * DEPRECATED: Use WrapBackendTexture that does not take a `colorType`.
  */
 SK_API sk_sp<SkSurface> WrapBackendTexture(skgpu::graphite::Recorder*,
                                            const skgpu::graphite::BackendTexture&,
@@ -85,6 +87,35 @@ SK_API sk_sp<SkSurface> WrapBackendTexture(skgpu::graphite::Recorder*,
                                            TextureReleaseProc = nullptr,
                                            ReleaseContext = nullptr,
                                            std::string_view label = {});
+/**
+ * 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 and dimensions are supported by the context that created the recorder. The color type
+ * reported by the SkSurface's image info is inferred from backend texture's format, matching as
+ * closely as possible when a texture format is not representable exactly as an SkColorType. This
+ * is fine as the SkColorType represents the data layout were the texture to be read to CPU memory.
+ *
+ * For single-channel texture formats, the alpha-only SkColorType is selected as that is more
+ * consistently defined for data types. The implication of this is that the alpha channel output
+ * from fragment shading will be what's stored in the texture, regardless of whether its format was
+ * A or R.
+ *
+ * For other formats and color types, the ambiguities between BGR and RGB channel order are
+ * irrelevant for rendering and sampling on the GPU. Those swizzles can reliably be handled by the
+ * hardware and there's no semantic change for the related SkColorTypes.
+ */
+SK_API sk_sp<SkSurface> WrapBackendTexture(skgpu::graphite::Recorder*,
+                                           const skgpu::graphite::BackendTexture&,
+                                           sk_sp<SkColorSpace> colorSpace,
+                                           const SkSurfaceProps* props,
+                                           TextureReleaseProc = nullptr,
+                                           ReleaseContext = nullptr,
+                                           std::string_view label = {});
 }  // namespace SkSurfaces
 
 #endif  // skgpu_graphite_Surface_DEFINED

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

@@ -46,7 +46,7 @@ private:
     public:
         virtual ~Data() = default;
 
-        Data(uint8_t sampleCount, skgpu::Mipmapped mipmapped)
+        Data(SampleCount sampleCount, skgpu::Mipmapped mipmapped)
                 : fSampleCount(sampleCount)
                 , fMipmapped(mipmapped) {}
 
@@ -56,11 +56,7 @@ private:
         Data& operator=(const Data&) = default;
 
         // NOTE: These fields are accessible via the backend-specific subclasses.
-
-        // Must be a valid SampleCount value, or TextureInfo creation will fail to wrap the backend
-        // specific data. This is not strongly typed so that it can be assigned directly from the
-        // backend GPU API's representation, which is often just an integer.
-        uint8_t fSampleCount = 1;
+        SampleCount fSampleCount = SampleCount::k1;
         Mipmapped fMipmapped = Mipmapped::kNo;
 
     private:
@@ -95,7 +91,7 @@ public:
 
     Protected isProtected() const { return fProtected; }
     SampleCount sampleCount() const {
-        return fData.has_value() ? static_cast<SampleCount>(fData->fSampleCount) : SampleCount::k1;
+        return fData.has_value() ? fData->fSampleCount : SampleCount::k1;
     }
     Mipmapped mipmapped() const {
         return fData.has_value() ? fData->fMipmapped   : Mipmapped::kNo;
@@ -119,9 +115,6 @@ private:
             : fBackend(BackendTextureData::kBackend)
             , fViewFormat(data.viewFormat())
             , fProtected(data.isProtected()) {
-        // TextureInfoPriv should not construct a TextureInfo if `data` would fail this assert.
-        SkASSERT(data.fSampleCount == 1 || data.fSampleCount == 2 || data.fSampleCount == 4 ||
-                 data.fSampleCount == 8 || data.fSampleCount == 16);
         fData.emplace<BackendTextureData>(data);
     }
 

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

@@ -48,7 +48,7 @@ public:
 
     explicit DawnTextureInfo(WGPUTexture texture);
 
-    DawnTextureInfo(uint32_t sampleCount,
+    DawnTextureInfo(SampleCount sampleCount,
                     Mipmapped mipmapped,
                     wgpu::TextureFormat format,
                     wgpu::TextureUsage usage,
@@ -61,7 +61,7 @@ public:
                               aspect,
                               /*slice=*/0) {}
 
-    DawnTextureInfo(uint32_t sampleCount,
+    DawnTextureInfo(SampleCount sampleCount,
                     Mipmapped mipmapped,
                     wgpu::TextureFormat format,
                     wgpu::TextureFormat viewFormat,
@@ -76,7 +76,7 @@ public:
             , fSlice(slice) {}
 
 #if !defined(__EMSCRIPTEN__)
-    DawnTextureInfo(uint32_t sampleCount,
+    DawnTextureInfo(SampleCount sampleCount,
                     Mipmapped mipmapped,
                     wgpu::TextureFormat format,
                     wgpu::TextureFormat viewFormat,

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

@@ -35,7 +35,7 @@ public:
 
     MtlTextureInfo() = default;
     explicit MtlTextureInfo(CFTypeRef mtlTexture);
-    MtlTextureInfo(uint32_t sampleCount,
+    MtlTextureInfo(SampleCount sampleCount,
                    skgpu::Mipmapped mipmapped,
                    MTLPixelFormat format,
                    MTLTextureUsage usage,

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

@@ -12,7 +12,7 @@
 
 #include "include/core/SkBlendMode.h"
 #include "include/core/SkImageInfo.h"
-#include "include/effects/SkGradientShader.h"
+#include "include/effects/SkGradient.h"
 
 class SkColorSpace;
 
@@ -202,19 +202,19 @@ namespace PrecompileShaders {
         kNoLarge = kSmall | kMedium,
     };
 
-    // --- This block of four matches all the factories in SkGradientShader (SkGradientShader.h)
+    // --- This block of four matches all the factories in SkGradientShader (SkGradient.h)
     SK_API sk_sp<PrecompileShader> LinearGradient(
             GradientShaderFlags = GradientShaderFlags::kAll,
-            SkGradientShader::Interpolation = SkGradientShader::Interpolation());
+            SkGradient::Interpolation = SkGradient::Interpolation());
     SK_API sk_sp<PrecompileShader> RadialGradient(
             GradientShaderFlags = GradientShaderFlags::kAll,
-            SkGradientShader::Interpolation = SkGradientShader::Interpolation());
+            SkGradient::Interpolation = SkGradient::Interpolation());
     SK_API sk_sp<PrecompileShader> TwoPointConicalGradient(
             GradientShaderFlags = GradientShaderFlags::kAll,
-            SkGradientShader::Interpolation = SkGradientShader::Interpolation());
+            SkGradient::Interpolation = SkGradient::Interpolation());
     SK_API sk_sp<PrecompileShader> SweepGradient(
             GradientShaderFlags = GradientShaderFlags::kAll,
-            SkGradientShader::Interpolation = SkGradientShader::Interpolation());
+            SkGradient::Interpolation = SkGradient::Interpolation());
 
     // Normally, SkPicture shaders are only created via SkPicture::makeShader. Since the
     // SkPicture to be drawn, most likely, won't be available at precompilation time, this

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

@@ -18,8 +18,9 @@ namespace skgpu::graphite {
 class SK_API VulkanTextureInfo final : public TextureInfo::Data {
 public:
     // VkImageCreateInfo properties
-    // Currently the only supported flag is VK_IMAGE_CREATE_PROTECTED_BIT. Any other flag will not
-    // be accepted
+    // Currently the only supported flags are VK_IMAGE_CREATE_PROTECTED_BIT and, when
+    // VK_EXT_multisampled_render_to_single_sampled is present and enabled,
+    // VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT. Other flags are not accepted.
     VkImageCreateFlags fFlags = 0;
     VkFormat           fFormat = VK_FORMAT_UNDEFINED;
     VkImageTiling      fImageTiling = VK_IMAGE_TILING_OPTIMAL;
@@ -46,7 +47,8 @@ public:
                       VkSharingMode sharingMode,
                       VkImageAspectFlags aspectMask,
                       VulkanYcbcrConversionInfo ycbcrConversionInfo)
-            : Data(static_cast<uint8_t>(sampleCount), mipmapped)
+            // VkSampleCountFlagBits is value equivalent to SampleCount
+            : Data(static_cast<SampleCount>(sampleCount), mipmapped)
             , fFlags(flags)
             , fFormat(format)
             , fImageTiling(imageTiling)

package/cpp/skia/include/gpu/graphite/vk/precompile/VulkanPrecompileShader.h

@@ -27,7 +27,7 @@ namespace PrecompileShaders {
 
     @return A precompile shader for a specific type of YCbCr image
 */
-SK_API sk_sp<PrecompileShader> VulkanYCbCrImage(skgpu::VulkanYcbcrConversionInfo& YCbCrInfo,
+SK_API sk_sp<PrecompileShader> VulkanYCbCrImage(const skgpu::VulkanYcbcrConversionInfo& YCbCrInfo,
                                                 ImageShaderFlags = ImageShaderFlags::kAll,
                                                 SkSpan<const SkColorInfo> = {},
                                                 SkSpan<const SkTileMode> = { kAllTileModes });

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

@@ -39,7 +39,7 @@ struct SK_API VulkanBackendContext {
     // fDeviceFeatures and fDeviceFeatures2 are null we will assume no features are enabled.
     const VkPhysicalDeviceFeatures*  fDeviceFeatures = nullptr;
     const VkPhysicalDeviceFeatures2* fDeviceFeatures2 = nullptr;
-    // Optional. The client may provide an inplementation of a VulkanMemoryAllocator for Skia to use
+    // The client must provide an inplementation of a VulkanMemoryAllocator for Skia to use
     // for allocating Vulkan resources that use VkDeviceMemory.
     sk_sp<VulkanMemoryAllocator>     fMemoryAllocator;
     skgpu::VulkanGetProc             fGetProc;

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

@@ -201,6 +201,10 @@ private:
     const char* fLoadStoreOpNoneExtension = nullptr;
     // VK_EXT_conservative_rasterization
     const char* fConservativeRasterizationExtension = nullptr;
+#if defined(SK_BUILD_FOR_ANDROID)
+    // VK_ANDROID_external_memory_android_hardware_buffer
+    const char* fExternalMemoryAHardwareBufferExtension = nullptr;
+#endif
 
     // Extensions that the other extensions above depend on:
     // Dependency of VK_EXT_graphics_pipeline_library: VK_KHR_pipeline_library
@@ -210,6 +214,10 @@ private:
     const char* fFormatFeatureFlags2Extension = nullptr;
     // Dependency of VK_EXT_multisampled_render_to_single_sampled: VK_KHR_depth_stencil_resolve
     const char* fDepthStencilResolveExtension = nullptr;
+#if defined(SK_BUILD_FOR_ANDROID)
+    // Dependency of VK_ANDROID_external_memory_android_hardware_buffer: VK_EXT_queue_family_foreign
+    const char* fQueueFamilyForeignExtension = nullptr;
+#endif
 };
 
 }  // namespace skgpu

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

@@ -16,6 +16,7 @@
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkTypes.h"
 #include "include/private/SkHdrMetadata.h"
+#include "include/private/base/SkAPI.h"
 #include "include/private/base/SkTo.h"
 #include "modules/skcms/skcms.h"
 
@@ -24,22 +25,12 @@
 #include <tuple>
 #include <utility>
 
-struct SkEncodedInfo {
-public:
-    class ICCProfile {
-    public:
-        static std::unique_ptr<ICCProfile> Make(sk_sp<const SkData>);
-        static std::unique_ptr<ICCProfile> Make(const skcms_ICCProfile&);
-
-        const skcms_ICCProfile* profile() const { return &fProfile; }
-        sk_sp<const SkData> data() const { return fData; }
-    private:
-        ICCProfile(const skcms_ICCProfile&, sk_sp<const SkData> = nullptr);
-
-        skcms_ICCProfile     fProfile;
-        sk_sp<const SkData>  fData;
-    };
+namespace SkCodecs {
+class ColorProfile;
+}
 
+struct SK_API SkEncodedInfo {
+public:
     enum Alpha {
         kOpaque_Alpha,
         kUnpremul_Alpha,
@@ -106,75 +97,41 @@ public:
         kYCCK_Color,
     };
 
-    static SkEncodedInfo Make(int width, int height, Color color, Alpha alpha,
-            int bitsPerComponent) {
-        return Make(width, height, color, alpha, bitsPerComponent, nullptr);
-    }
+    static SkEncodedInfo Make(
+        int width, int height, Color color, Alpha alpha, int bitsPerComponent);
 
-    static SkEncodedInfo Make(int width, int height, Color color,
-            Alpha alpha, int bitsPerComponent, std::unique_ptr<ICCProfile> profile) {
-        return Make(width, height, color, alpha, /*bitsPerComponent*/ bitsPerComponent,
-                std::move(profile), /*colorDepth*/ bitsPerComponent);
-    }
+    static SkEncodedInfo Make(
+        int width, int height, Color color, Alpha alpha, int bitsPerComponent,
+        std::unique_ptr<SkCodecs::ColorProfile> profile);
 
-    static SkEncodedInfo Make(int width, int height, Color color,
-            Alpha alpha, int bitsPerComponent, std::unique_ptr<ICCProfile> profile,
-            int colorDepth) {
-        return Make(width, height, color, alpha, bitsPerComponent, colorDepth, std::move(profile),
-                    skhdr::Metadata::MakeEmpty());
-    }
+    static SkEncodedInfo Make(
+        int width, int height, Color color, Alpha alpha, int bitsPerComponent,
+        std::unique_ptr<SkCodecs::ColorProfile> profile, int colorDepth);
 
-    static SkEncodedInfo Make(int width, int height, Color color,
-            Alpha alpha, int bitsPerComponent, int colorDepth, std::unique_ptr<ICCProfile> profile,
-            const skhdr::Metadata& hdrMetadata) {
-        SkASSERT(1 == bitsPerComponent ||
-                 2 == bitsPerComponent ||
-                 4 == bitsPerComponent ||
-                 8 == bitsPerComponent ||
-                 16 == bitsPerComponent);
-        VerifyColor(color, alpha, bitsPerComponent);
-        return SkEncodedInfo(width,
-                             height,
-                             color,
-                             alpha,
-                             SkToU8(bitsPerComponent),
-                             SkToU8(colorDepth),
-                             std::move(profile),
-                             hdrMetadata);
-    }
+    static SkEncodedInfo Make(
+        int width, int height, Color color, Alpha alpha, int bitsPerComponent,
+        int colorDepth,
+        std::unique_ptr<SkCodecs::ColorProfile> profile, const skhdr::Metadata& hdrMetadata);
 
     /*
      * Returns a recommended SkImageInfo.
      *
      * TODO: Leave this up to the client.
      */
-    SkImageInfo makeImageInfo() const {
-        auto ct =  kGray_Color == fColor ? kGray_8_SkColorType   :
-                 kXAlpha_Color == fColor ? kAlpha_8_SkColorType  :
-                    k565_Color == fColor ? kRGB_565_SkColorType  :
-                                           kN32_SkColorType      ;
-        auto alpha = kOpaque_Alpha == fAlpha ? kOpaque_SkAlphaType
-                                             : kUnpremul_SkAlphaType;
-        sk_sp<SkColorSpace> cs = fProfile ? SkColorSpace::Make(*fProfile->profile())
-                                          : nullptr;
-        if (!cs) {
-            cs = SkColorSpace::MakeSRGB();
-        }
-        return SkImageInfo::Make(fWidth, fHeight, ct, alpha, std::move(cs));
-    }
+    SkImageInfo makeImageInfo() const;
 
     int   width() const { return fWidth;  }
     int  height() const { return fHeight; }
     Color color() const { return fColor;  }
     Alpha alpha() const { return fAlpha;  }
     bool opaque() const { return fAlpha == kOpaque_Alpha; }
-    const skcms_ICCProfile* profile() const {
-        if (!fProfile) return nullptr;
-        return fProfile->profile();
-    }
-    sk_sp<const SkData> profileData() const {
-        if (!fProfile) return nullptr;
-        return fProfile->data();
+
+    // TODO(https://issues.skia.org/issues/464217864): Remove direct access to the
+    // skcms_ICCProfile and change profileData() to serialize a new profile.
+    const skcms_ICCProfile* profile() const;
+    sk_sp<const SkData> profileData() const;
+    const SkCodecs::ColorProfile* colorProfile() const {
+        return fColorProfile.get();
     }
 
     uint8_t bitsPerComponent() const { return fBitsPerComponent; }
@@ -208,20 +165,11 @@ public:
     SkEncodedInfo(const SkEncodedInfo& orig) = delete;
     SkEncodedInfo& operator=(const SkEncodedInfo&) = delete;
 
-    SkEncodedInfo(SkEncodedInfo&& orig) = default;
-    SkEncodedInfo& operator=(SkEncodedInfo&&) = default;
+    SkEncodedInfo(SkEncodedInfo&& orig);
+    SkEncodedInfo& operator=(SkEncodedInfo&&);
 
     // Explicit copy method, to avoid accidental copying.
-    SkEncodedInfo copy() const {
-        return SkEncodedInfo(fWidth,
-                             fHeight,
-                             fColor,
-                             fAlpha,
-                             fBitsPerComponent,
-                             fColorDepth,
-                             fProfile ? std::make_unique<const ICCProfile>(*fProfile) : nullptr,
-                             fHdrMetadata);
-    }
+    SkEncodedInfo copy() const;
 
     // Return number of bits of R/G/B channel
     uint8_t getColorDepth() const {
@@ -234,23 +182,13 @@ public:
         return fHdrMetadata;
     }
 
+    ~SkEncodedInfo();
+
 private:
-    SkEncodedInfo(int width,
-                  int height,
-                  Color color,
-                  Alpha alpha,
-                  uint8_t bitsPerComponent,
-                  uint8_t colorDepth,
-                  std::unique_ptr<const ICCProfile> profile,
-                  const skhdr::Metadata& hdrMetadata)
-            : fWidth(width)
-            , fHeight(height)
-            , fColor(color)
-            , fAlpha(alpha)
-            , fBitsPerComponent(bitsPerComponent)
-            , fColorDepth(colorDepth)
-            , fProfile(std::move(profile))
-            , fHdrMetadata(hdrMetadata) {}
+    SkEncodedInfo(
+        int width, int height, Color color, Alpha alpha, uint8_t bitsPerComponent,
+        uint8_t colorDepth,
+        std::unique_ptr<SkCodecs::ColorProfile> profile, const skhdr::Metadata& hdrMetadata);
 
     static void VerifyColor(Color color, Alpha alpha, int bitsPerComponent) {
         // Avoid `-Wunused-parameter` warnings on non-debug builds.
@@ -298,14 +236,14 @@ private:
         SkASSERT(false);  // Unrecognized `color` enum value.
     }
 
-    int                               fWidth;
-    int                               fHeight;
-    Color                                   fColor;
-    Alpha                             fAlpha;
-    uint8_t                           fBitsPerComponent;
-    uint8_t                           fColorDepth;
-    std::unique_ptr<const ICCProfile> fProfile;
-    skhdr::Metadata                   fHdrMetadata;
+    int     fWidth;
+    int     fHeight;
+    Color   fColor;
+    Alpha   fAlpha;
+    uint8_t fBitsPerComponent;
+    uint8_t fColorDepth;
+    std::unique_ptr<const SkCodecs::ColorProfile> fColorProfile;
+    skhdr::Metadata                               fHdrMetadata;
 };
 
 #endif