rngine 0.8.0 → 0.8.2

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

@@ -0,0 +1,211 @@
+/*
+ * 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 GrSurfaceCharacterization_DEFINED
+#define GrSurfaceCharacterization_DEFINED
+
+#include "include/core/SkColorSpace.h" // IWYU pragma: keep
+#include "include/core/SkColorType.h"
+#include "include/core/SkImageInfo.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkSize.h"
+#include "include/core/SkSurfaceProps.h"
+#include "include/core/SkTypes.h"
+#include "include/gpu/GpuTypes.h"
+#include "include/gpu/ganesh/GrBackendSurface.h"
+#include "include/gpu/ganesh/GrContextThreadSafeProxy.h"
+#include "include/gpu/ganesh/GrTypes.h"
+#include "include/private/SkDebug.h"
+
+#include <cstddef>
+#include <utility>
+
+/** \class GrSurfaceCharacterization
+    A surface characterization contains all the information Ganesh requires to makes its internal
+    rendering decisions. When passed into a GrDeferredDisplayListRecorder it will copy the
+    data and pass it on to the GrDeferredDisplayList if/when it is created. Note that both of
+    those objects (the Recorder and the DisplayList) will take a ref on the
+    GrContextThreadSafeProxy and SkColorSpace objects.
+*/
+class SK_API GrSurfaceCharacterization {
+public:
+    enum class Textureable : bool { kNo = false, kYes = true };
+    enum class UsesGLFBO0 : bool { kNo = false, kYes = true };
+    // This flag indicates that the backing VkImage for this Vulkan surface will have the
+    // VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT set. This bit allows skia to handle advanced blends
+    // more optimally in a shader by being able to directly read the dst values.
+    enum class VkRTSupportsInputAttachment : bool { kNo = false, kYes = true };
+    // This flag indicates if the surface is wrapping a raw Vulkan secondary command buffer.
+    enum class VulkanSecondaryCBCompatible : bool { kNo = false, kYes = true };
+
+    GrSurfaceCharacterization()
+            : fCacheMaxResourceBytes(0)
+            , fOrigin(kBottomLeft_GrSurfaceOrigin)
+            , fSampleCnt(0)
+            , fIsTextureable(Textureable::kYes)
+            , fIsMipmapped(skgpu::Mipmapped::kYes)
+            , fUsesGLFBO0(UsesGLFBO0::kNo)
+            , fVulkanSecondaryCBCompatible(VulkanSecondaryCBCompatible::kNo)
+            , fIsProtected(skgpu::Protected::kNo)
+            , fSurfaceProps() {}
+
+    GrSurfaceCharacterization(GrSurfaceCharacterization&&) = default;
+    GrSurfaceCharacterization& operator=(GrSurfaceCharacterization&&) = default;
+
+    GrSurfaceCharacterization(const GrSurfaceCharacterization&) = default;
+    GrSurfaceCharacterization& operator=(const GrSurfaceCharacterization& other) = default;
+    bool operator==(const GrSurfaceCharacterization& other) const;
+    bool operator!=(const GrSurfaceCharacterization& other) const {
+        return !(*this == other);
+    }
+
+    /*
+     * Return a new surface characterization with the only difference being a different width
+     * and height
+     */
+    GrSurfaceCharacterization createResized(int width, int height) const;
+
+    /*
+     * Return a new surface characterization with only a replaced color space
+     */
+    GrSurfaceCharacterization createColorSpace(sk_sp<SkColorSpace>) const;
+
+    /*
+     * Return a new surface characterization with the backend format replaced. A colorType
+     * must also be supplied to indicate the interpretation of the new format.
+     */
+    GrSurfaceCharacterization createBackendFormat(SkColorType colorType,
+                                                  const GrBackendFormat& backendFormat) const;
+
+    /*
+     * Return a new surface characterization with just a different use of FBO0 (in GL)
+     */
+    GrSurfaceCharacterization createFBO0(bool usesGLFBO0) const;
+
+    GrContextThreadSafeProxy* contextInfo() const { return fContextInfo.get(); }
+    sk_sp<GrContextThreadSafeProxy> refContextInfo() const { return fContextInfo; }
+    size_t cacheMaxResourceBytes() const { return fCacheMaxResourceBytes; }
+
+    bool isValid() const { return kUnknown_SkColorType != fImageInfo.colorType(); }
+
+    const SkImageInfo& imageInfo() const { return fImageInfo; }
+    const GrBackendFormat& backendFormat() const { return fBackendFormat; }
+    GrSurfaceOrigin origin() const { return fOrigin; }
+    SkISize dimensions() const { return fImageInfo.dimensions(); }
+    int width() const { return fImageInfo.width(); }
+    int height() const { return fImageInfo.height(); }
+    SkColorType colorType() const { return fImageInfo.colorType(); }
+    int sampleCount() const { return fSampleCnt; }
+    bool isTextureable() const { return Textureable::kYes == fIsTextureable; }
+    bool isMipMapped() const { return skgpu::Mipmapped::kYes == fIsMipmapped; }
+    bool usesGLFBO0() const { return UsesGLFBO0::kYes == fUsesGLFBO0; }
+    bool vkRTSupportsInputAttachment() const {
+        return VkRTSupportsInputAttachment::kYes == fVkRTSupportsInputAttachment;
+    }
+    bool vulkanSecondaryCBCompatible() const {
+        return VulkanSecondaryCBCompatible::kYes == fVulkanSecondaryCBCompatible;
+    }
+    skgpu::Protected isProtected() const { return fIsProtected; }
+    SkColorSpace* colorSpace() const { return fImageInfo.colorSpace(); }
+    sk_sp<SkColorSpace> refColorSpace() const { return fImageInfo.refColorSpace(); }
+    const SkSurfaceProps& surfaceProps()const { return fSurfaceProps; }
+
+private:
+    friend class SkSurface_Ganesh;           // for 'set' & 'config'
+    friend class GrVkSecondaryCBDrawContext; // for 'set' & 'config'
+    friend class GrContextThreadSafeProxy; // for private ctor
+    friend class GrVkContextThreadSafeProxy;    // for private ctor
+    friend class GrDeferredDisplayListRecorder; // for 'config'
+    friend class SkSurface; // for 'config'
+
+    SkDEBUGCODE(void validate() const;)
+
+            GrSurfaceCharacterization(sk_sp<GrContextThreadSafeProxy> contextInfo,
+                                      size_t cacheMaxResourceBytes,
+                                      const SkImageInfo& ii,
+                                      const GrBackendFormat& backendFormat,
+                                      GrSurfaceOrigin origin,
+                                      int sampleCnt,
+                                      Textureable isTextureable,
+                                      skgpu::Mipmapped isMipmapped,
+                                      UsesGLFBO0 usesGLFBO0,
+                                      VkRTSupportsInputAttachment vkRTSupportsInputAttachment,
+                                      VulkanSecondaryCBCompatible vulkanSecondaryCBCompatible,
+                                      skgpu::Protected isProtected,
+                                      const SkSurfaceProps& surfaceProps)
+            : fContextInfo(std::move(contextInfo))
+            , fCacheMaxResourceBytes(cacheMaxResourceBytes)
+            , fImageInfo(ii)
+            , fBackendFormat(std::move(backendFormat))
+            , fOrigin(origin)
+            , fSampleCnt(sampleCnt)
+            , fIsTextureable(isTextureable)
+            , fIsMipmapped(isMipmapped)
+            , fUsesGLFBO0(usesGLFBO0)
+            , fVkRTSupportsInputAttachment(vkRTSupportsInputAttachment)
+            , fVulkanSecondaryCBCompatible(vulkanSecondaryCBCompatible)
+            , fIsProtected(isProtected)
+            , fSurfaceProps(surfaceProps) {
+        if (fSurfaceProps.flags() & SkSurfaceProps::kDynamicMSAA_Flag) {
+            // Dynamic MSAA is not currently supported with DDL.
+            *this = {};
+        }
+        SkDEBUGCODE(this->validate());
+    }
+
+    void set(sk_sp<GrContextThreadSafeProxy> contextInfo,
+             size_t cacheMaxResourceBytes,
+             const SkImageInfo& ii,
+             const GrBackendFormat& backendFormat,
+             GrSurfaceOrigin origin,
+             int sampleCnt,
+             Textureable isTextureable,
+             skgpu::Mipmapped isMipmapped,
+             UsesGLFBO0 usesGLFBO0,
+             VkRTSupportsInputAttachment vkRTSupportsInputAttachment,
+             VulkanSecondaryCBCompatible vulkanSecondaryCBCompatible,
+             skgpu::Protected isProtected,
+             const SkSurfaceProps& surfaceProps) {
+        if (surfaceProps.flags() & SkSurfaceProps::kDynamicMSAA_Flag) {
+            // Dynamic MSAA is not currently supported with DDL.
+            *this = {};
+        } else {
+            fContextInfo = std::move(contextInfo);
+            fCacheMaxResourceBytes = cacheMaxResourceBytes;
+
+            fImageInfo = ii;
+            fBackendFormat = std::move(backendFormat);
+            fOrigin = origin;
+            fSampleCnt = sampleCnt;
+            fIsTextureable = isTextureable;
+            fIsMipmapped = isMipmapped;
+            fUsesGLFBO0 = usesGLFBO0;
+            fVkRTSupportsInputAttachment = vkRTSupportsInputAttachment;
+            fVulkanSecondaryCBCompatible = vulkanSecondaryCBCompatible;
+            fIsProtected = isProtected;
+            fSurfaceProps = surfaceProps;
+        }
+        SkDEBUGCODE(this->validate());
+    }
+
+    sk_sp<GrContextThreadSafeProxy> fContextInfo;
+    size_t                          fCacheMaxResourceBytes;
+
+    SkImageInfo                     fImageInfo;
+    GrBackendFormat                 fBackendFormat;
+    GrSurfaceOrigin                 fOrigin;
+    int                             fSampleCnt;
+    Textureable                     fIsTextureable;
+    skgpu::Mipmapped                fIsMipmapped;
+    UsesGLFBO0                      fUsesGLFBO0;
+    VkRTSupportsInputAttachment     fVkRTSupportsInputAttachment;
+    VulkanSecondaryCBCompatible     fVulkanSecondaryCBCompatible;
+    skgpu::Protected                fIsProtected;
+    SkSurfaceProps                  fSurfaceProps;
+};
+
+#endif

package/shared/skia/include/private/chromium/GrVkSecondaryCBDrawContext.h

@@ -0,0 +1,131 @@
+/*
+ * Copyright 2019 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrVkSecondaryCBDrawContext_DEFINED
+#define GrVkSecondaryCBDrawContext_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkSurfaceProps.h"
+#include "include/core/SkTypes.h"
+
+#include <memory>
+
+class GrBackendSemaphore;
+class GrDeferredDisplayList;
+class GrRecordingContext;
+class GrSurfaceCharacterization;
+struct GrVkDrawableInfo;
+namespace skgpu::ganesh {
+class Device;
+}
+class SkCanvas;
+struct SkImageInfo;
+class SkSurfaceProps;
+
+/**
+ * This class is a private header that is intended to only be used inside of Chromium. This requires
+ * Chromium to burrow in and include this specifically since it is not part of skia's public include
+ * directory.
+ */
+
+/**
+ * This class is used to draw into an external Vulkan secondary command buffer that is imported
+ * by the client. The secondary command buffer that gets imported must already have had begin called
+ * on it with VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT. Thus any draws to the imported
+ * command buffer cannot require changing the render pass. This requirement means that certain types
+ * of draws will not be supported when using a GrVkSecondaryCBDrawContext. This includes:
+ *     Draws that require a dst copy for blending will be dropped
+ *     Text draws will be dropped (these may require intermediate uploads of text data)
+ *     Read and Write pixels will not work
+ *     Any other draw that requires a copy will fail (this includes using backdrop filter with save
+ *         layer).
+ *     Stenciling is also disabled, but that should not restrict any actual draws from working.
+ *
+ * While using a GrVkSecondaryCBDrawContext, the client can also draw into normal SkSurfaces and
+ * then draw those SkSufaces (as SkImages) into the GrVkSecondaryCBDrawContext. If any of the
+ * previously mentioned unsupported draws are needed by the client, they can draw them into an
+ * offscreen surface, and then draw that into the GrVkSecondaryCBDrawContext.
+ *
+ * After all drawing to the GrVkSecondaryCBDrawContext has been done, the client must call flush()
+ * on the GrVkSecondaryCBDrawContext to actually fill in the secondary VkCommandBuffer with the
+ * draws.
+ *
+ * Additionally, the client must keep the GrVkSecondaryCBDrawContext alive until the secondary
+ * VkCommandBuffer has been submitted and all work finished on the GPU. Before deleting the
+ * GrVkSecondaryCBDrawContext, the client must call releaseResources() so that Skia can cleanup
+ * any internal objects that were created for the draws into the secondary command buffer.
+ */
+class SK_SPI GrVkSecondaryCBDrawContext : public SkRefCnt {
+public:
+    static sk_sp<GrVkSecondaryCBDrawContext> Make(GrRecordingContext*,
+                                                  const SkImageInfo&,
+                                                  const GrVkDrawableInfo&,
+                                                  const SkSurfaceProps* props);
+
+    ~GrVkSecondaryCBDrawContext() override;
+
+    SkCanvas* getCanvas();
+
+    // Records all the draws to the imported secondary command buffer and sets any dependent
+    // offscreen draws to the GPU.
+    void flush();
+
+    /** Inserts a list of GPU semaphores that Skia will have the driver wait on before executing
+        commands for this secondary CB. The wait semaphores will get added to the VkCommandBuffer
+        owned by this GrContext when flush() is called, and not the command buffer which the
+        Secondary CB is from. This will guarantee that the driver waits on the semaphores before
+        the secondary command buffer gets executed. We will submit the semphore to wait at
+        VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT and VK_PIPELINE_STAGE_TRANSFER_BIT. If this
+        call returns false, then the GPU back end will not wait on any passed in semaphores, and the
+        client will still own the semaphores, regardless of the value of deleteSemaphoresAfterWait.
+
+        If deleteSemaphoresAfterWait is false then Skia will not delete the semaphores. In this case
+        it is the client's responsibility to not destroy or attempt to reuse the semaphores until it
+        knows that Skia has finished waiting on them. This can be done by using finishedProcs
+        on flush calls.
+
+        @param numSemaphores               size of waitSemaphores array
+        @param waitSemaphores              array of semaphore containers
+        @paramm deleteSemaphoresAfterWait  who owns and should delete the semaphores
+        @return                            true if GPU is waiting on semaphores
+    */
+    bool wait(int numSemaphores,
+              const GrBackendSemaphore waitSemaphores[],
+              bool deleteSemaphoresAfterWait = true);
+
+    // This call will release all resources held by the draw context. The client must call
+    // releaseResources() before deleting the drawing context. However, the resources also include
+    // any Vulkan resources that were created and used for draws. Therefore the client must only
+    // call releaseResources() after submitting the secondary command buffer, and waiting for it to
+    // finish on the GPU. If it is called earlier then some vulkan objects may be deleted while they
+    // are still in use by the GPU.
+    void releaseResources();
+
+    const SkSurfaceProps& props() const { return fProps; }
+
+    // TODO: Fill out these calls to support DDL
+    bool characterize(GrSurfaceCharacterization* characterization) const;
+
+#ifndef SK_DDL_IS_UNIQUE_POINTER
+    bool draw(sk_sp<const GrDeferredDisplayList> deferredDisplayList);
+#else
+    bool draw(const GrDeferredDisplayList* deferredDisplayList);
+#endif
+
+    bool isCompatible(const GrSurfaceCharacterization& characterization) const;
+
+private:
+    explicit GrVkSecondaryCBDrawContext(sk_sp<skgpu::ganesh::Device>, const SkSurfaceProps*);
+
+    sk_sp<skgpu::ganesh::Device> fDevice;
+    std::unique_ptr<SkCanvas> fCachedCanvas;
+    const SkSurfaceProps      fProps;
+
+    using INHERITED = SkRefCnt;
+};
+
+#endif

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

@@ -0,0 +1,150 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkChromeRemoteGlyphCache_DEFINED
+#define SkChromeRemoteGlyphCache_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypeface.h"
+#include "include/private/SkAPI.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <vector>
+
+class SkAutoDescriptor;
+class SkCanvas;
+class SkColorSpace;
+class SkStrikeCache;
+class SkStrikeClientImpl;
+class SkStrikeServerImpl;
+class SkSurfaceProps;
+namespace sktext::gpu { class Slug; }
+
+using SkDiscardableHandleId = uint32_t;
+// This class is not thread-safe.
+class SkStrikeServer {
+public:
+    // An interface used by the server to create handles for pinning SkStrike
+    // entries on the remote client.
+    class DiscardableHandleManager {
+    public:
+        SK_SPI virtual ~DiscardableHandleManager() = default;
+
+        // Creates a new *locked* handle and returns a unique ID that can be used to identify
+        // it on the remote client.
+        SK_SPI virtual SkDiscardableHandleId createHandle() = 0;
+
+        // Returns true if the handle could be successfully locked. The server can
+        // assume it will remain locked until the next set of serialized entries is
+        // pulled from the SkStrikeServer.
+        // If returns false, the cache entry mapped to the handle has been deleted
+        // on the client. Any subsequent attempts to lock the same handle are not
+        // allowed.
+        SK_SPI virtual bool lockHandle(SkDiscardableHandleId) = 0;
+
+        // Returns true if a handle has been deleted on the remote client. It is
+        // invalid to use a handle id again with this manager once this returns true.
+        SK_SPI virtual bool isHandleDeleted(SkDiscardableHandleId) = 0;
+    };
+
+    SK_SPI explicit SkStrikeServer(DiscardableHandleManager* discardableHandleManager);
+    SK_SPI ~SkStrikeServer();
+
+    // Create an analysis SkCanvas used to populate the SkStrikeServer with ops
+    // which will be serialized and rendered using the SkStrikeClient.
+    SK_API std::unique_ptr<SkCanvas> makeAnalysisCanvas(int width, int height,
+                                                        const SkSurfaceProps& props,
+                                                        sk_sp<SkColorSpace> colorSpace,
+                                                        bool DFTSupport,
+                                                        bool DFTPerspSupport = true);
+
+    // Serializes the strike data captured using a canvas returned by ::makeAnalysisCanvas. Any
+    // handles locked using the DiscardableHandleManager will be assumed to be
+    // unlocked after this call.
+    SK_SPI void writeStrikeData(std::vector<uint8_t>* memory);
+
+    // Testing helpers
+    void setMaxEntriesInDescriptorMapForTesting(size_t count);
+    size_t remoteStrikeMapSizeForTesting() const;
+
+private:
+    SkStrikeServerImpl* impl();
+
+    std::unique_ptr<SkStrikeServerImpl> fImpl;
+};
+
+class SkStrikeClient {
+public:
+    // This enum is used in histogram reporting in chromium. Please don't re-order the list of
+    // entries, and consider it to be append-only.
+    enum CacheMissType : uint32_t {
+        // Hard failures where no fallback could be found.
+        kFontMetrics = 0,
+        kGlyphMetrics = 1,
+        kGlyphImage = 2,
+        kGlyphPath = 3,
+
+        // (DEPRECATED) The original glyph could not be found and a fallback was used.
+        kGlyphMetricsFallback = 4,
+        kGlyphPathFallback    = 5,
+
+        kGlyphDrawable = 6,
+        kLast = kGlyphDrawable
+    };
+
+    // An interface to delete handles that may be pinned by the remote server.
+    class DiscardableHandleManager : public SkRefCnt {
+    public:
+        ~DiscardableHandleManager() override = default;
+
+        // Returns true if the handle was unlocked and can be safely deleted. Once
+        // successful, subsequent attempts to delete the same handle are invalid.
+        virtual bool deleteHandle(SkDiscardableHandleId) = 0;
+
+        virtual void assertHandleValid(SkDiscardableHandleId) {}
+
+        virtual void notifyCacheMiss(CacheMissType type, int fontSize) = 0;
+
+        struct ReadFailureData {
+            size_t memorySize;
+            size_t bytesRead;
+            uint64_t typefaceSize;
+            uint64_t strikeCount;
+            uint64_t glyphImagesCount;
+            uint64_t glyphPathsCount;
+        };
+        virtual void notifyReadFailure(const ReadFailureData& data) {}
+    };
+
+    SK_SPI explicit SkStrikeClient(sk_sp<DiscardableHandleManager>,
+                                   bool isLogging = true,
+                                   SkStrikeCache* strikeCache = nullptr);
+    SK_SPI ~SkStrikeClient();
+
+    // Deserializes the strike data from a SkStrikeServer. All messages generated
+    // from a server when serializing the ops must be deserialized before the op
+    // is rasterized.
+    // Returns false if the data is invalid.
+    SK_SPI bool readStrikeData(const volatile void* memory, size_t memorySize);
+
+    // Given a descriptor re-write the Rec mapping the typefaceID from the renderer to the
+    // corresponding typefaceID on the GPU.
+    SK_SPI bool translateTypefaceID(SkAutoDescriptor* descriptor) const;
+
+    // Testing helpers
+    sk_sp<SkTypeface> retrieveTypefaceUsingServerIDForTest(SkTypefaceID) const;
+
+    // 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;
+
+private:
+    std::unique_ptr<SkStrikeClientImpl> fImpl;
+};
+#endif  // SkChromeRemoteGlyphCache_DEFINED

package/shared/skia/include/private/chromium/SkCodecsICCProfileChromium.h

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2026 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkCodecsICCProfileChromium_DEFINED
+#define SkCodecsICCProfileChromium_DEFINED
+
+#include <memory>
+
+#include "include/core/SkData.h"
+#include "include/core/SkRefCnt.h"
+#include "include/private/SkAPI.h"
+#include "modules/skcms/skcms.h"
+
+namespace SkCodecs {
+
+// Allows Chromium code that does not use SkCodec to parse ICC profiles
+// using the same parser that SkCodec uses (skcms or moxcms).
+class SK_API ICCProfileChromium {
+public:
+    virtual ~ICCProfileChromium() = default;
+
+    // Force all ICC profile parsing to use skcms instead of the build-default
+    // parser. This is intended for Chromium to have a kill-switch to fall back
+    // to skcms if moxcms causes issues in the field.
+    //
+    // This is a global setting and is NOT thread-safe with respect to concurrent
+    // codec operations. It should be called once early during process startup.
+    static void ForceSkcms(bool forceSkcms);
+
+    // Returns nullptr if parsing fails. May retain `data`. Uses the parser
+    // selected by ForceSkcms (defaults to the build-default parser).
+    static std::unique_ptr<ICCProfileChromium> Make(sk_sp<SkData> data);
+
+    // Return the parsed profile. The pointers in the structure are guaranteed
+    // to be valid until `this` is destroyed.
+    virtual const skcms_ICCProfile& GetProfile() const = 0;
+
+protected:
+    ICCProfileChromium() = default;
+
+private:
+    ICCProfileChromium(const ICCProfileChromium&) = delete;
+    ICCProfileChromium& operator=(const ICCProfileChromium&) = delete;
+};
+
+}  // namespace SkCodecs
+
+#endif  // SkCodecsICCProfileChromium_DEFINED

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

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkDiscardableMemory_DEFINED
+#define SkDiscardableMemory_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypes.h"
+
+/**
+ *  Interface for discardable memory. Implementation is provided by the
+ *  embedder.
+ */
+class SK_SPI SkDiscardableMemory {
+public:
+    /**
+     *  Factory method that creates, initializes and locks an SkDiscardableMemory
+     *  object. If either of these steps fails, a nullptr pointer will be returned.
+     */
+    static SkDiscardableMemory* Create(size_t bytes);
+
+    /**
+     *  Factory class that creates, initializes and locks an SkDiscardableMemory
+     *  object. If either of these steps fails, a nullptr pointer will be returned.
+     */
+    class Factory : public SkRefCnt {
+    public:
+        virtual SkDiscardableMemory* create(size_t bytes) = 0;
+    private:
+        using INHERITED = SkRefCnt;
+    };
+
+    /** Must not be called while locked.
+     */
+    virtual ~SkDiscardableMemory() {}
+
+    /**
+     * Locks the memory, prevent it from being discarded. Once locked. you may
+     * obtain a pointer to that memory using the data() method.
+     *
+     * lock() may return false, indicating that the underlying memory was
+     * discarded and that the lock failed.
+     *
+     * Nested calls to lock are not allowed.
+     */
+    [[nodiscard]] virtual bool lock() = 0;
+
+    /**
+     * Returns the current pointer for the discardable memory. This call is ONLY
+     * valid when the discardable memory object is locked.
+     */
+    virtual void* data() = 0;
+
+    /**
+     * Unlock the memory so that it can be purged by the system. Must be called
+     * after every successful lock call.
+     */
+    virtual void unlock() = 0;
+
+protected:
+    SkDiscardableMemory() = default;
+    SkDiscardableMemory(const SkDiscardableMemory&) = delete;
+    SkDiscardableMemory& operator=(const SkDiscardableMemory&) = delete;
+};
+
+#endif

package/shared/skia/include/private/chromium/SkExifChromium.h

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2026 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkExifChromium_DEFINED
+#define SkExifChromium_DEFINED
+
+#include "include/private/SkAPI.h"
+
+namespace SkExif {
+
+// Force all EXIF parsing to use the C++ SkExif parser instead of the
+// build-default parser. This is intended for Chromium to have a kill-switch
+// to fall back to the C++ implementation if rust_exif causes issues in the
+// field.
+//
+// This is a global setting and is NOT thread-safe with respect to concurrent
+// codec operations. It should be called once early during process startup.
+SK_API void ForceSkExif(bool forceSkExif);
+
+}  // namespace SkExif
+
+#endif  // SkExifChromium_DEFINED