@pompadour/react-native-skia 1.0.0

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

@@ -0,0 +1,153 @@
+/*
+ * 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/base/SkAPI.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <vector>
+
+class SkAutoDescriptor;
+class SkCanvas;
+class SkColorSpace;
+class SkStrikeCache;
+class SkStrikeClientImpl;
+class SkStrikeServerImpl;
+class SkSurfaceProps;
+struct SkDeserialProcs;
+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 SkDeserialProcs&) const;
+
+private:
+    std::unique_ptr<SkStrikeClientImpl> fImpl;
+};
+#endif  // SkChromeRemoteGlyphCache_DEFINED

package/cpp/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/cpp/skia/include/private/chromium/SkImageChromium.h

@@ -0,0 +1,117 @@
+/*
+ * 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 SkImageChromium_DEFINED
+#define SkImageChromium_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/private/base/SkAPI.h"
+
+class GrBackendFormat;
+class GrContextThreadSafeProxy;
+class GrPromiseImageTexture;
+class GrDirectContext;
+class GrYUVABackendTextureInfo;
+class SkColorSpace;
+class SkImage;
+enum SkAlphaType : int;
+enum SkColorType : int;
+enum GrSurfaceOrigin : int;
+namespace skgpu {
+enum class Mipmapped : bool;
+}
+struct SkISize;
+
+/**
+ * These functions expose features that are only for external use in Chromium.
+ */
+
+namespace SkImages {
+
+using PromiseImageTextureContext = void*;
+using PromiseImageTextureFulfillProc = sk_sp<GrPromiseImageTexture> (*)(PromiseImageTextureContext);
+using PromiseImageTextureReleaseProc = void (*)(PromiseImageTextureContext);
+
+/** Create a new GPU-backed SkImage that is very similar to an SkImage created by BorrowTextureFrom.
+    The difference is that the caller need not have created the texture nor populated it with the
+    image pixel data. Moreover, the SkImage may be created on a thread as the creation of the
+    image does not require access to the backend API or GrDirectContext. Instead of passing a
+    GrBackendTexture the client supplies a description of the texture consisting of
+    GrBackendFormat, width, height, and skgpu::Mipmapped state. The resulting SkImage can be drawn
+    to a GrDeferredDisplayListRecorder or directly to a GPU-backed SkSurface.
+    When the actual texture is required to perform a backend API draw, textureFulfillProc will
+    be called to receive a GrBackendTexture. The properties of the GrBackendTexture must match
+    those set during the SkImage creation, and it must refer to a valid existing texture in the
+    backend API context/device, and be populated with the image pixel data. The texture cannot
+    be deleted until textureReleaseProc is called.
+    There is at most one call to each of textureFulfillProc and textureReleaseProc.
+    textureReleaseProc is always called even if image creation fails or if the
+    image is never fulfilled (e.g. it is never drawn or all draws are clipped out)
+    @param gpuContextProxy     the thread-safe proxy of the gpu context. required.
+    @param backendFormat       format of promised gpu texture
+    @param dimensions          width & height of promised gpu texture
+    @param mipmapped           mip mapped state of promised gpu texture
+    @param origin              surface origin of promised gpu texture
+    @param colorType           color type of promised gpu texture
+    @param alphaType           alpha type of promised gpu texture
+    @param colorSpace          range of colors; may be nullptr
+    @param textureFulfillProc  function called to get actual gpu texture
+    @param textureReleaseProc  function called when texture can be deleted
+    @param textureContext      state passed to textureFulfillProc and textureReleaseProc
+    @return                    created SkImage, or nullptr
+*/
+SK_API sk_sp<SkImage> PromiseTextureFrom(sk_sp<GrContextThreadSafeProxy> gpuContextProxy,
+                                         const GrBackendFormat& backendFormat,
+                                         SkISize dimensions,
+                                         skgpu::Mipmapped mipmapped,
+                                         GrSurfaceOrigin origin,
+                                         SkColorType colorType,
+                                         SkAlphaType alphaType,
+                                         sk_sp<SkColorSpace> colorSpace,
+                                         PromiseImageTextureFulfillProc textureFulfillProc,
+                                         PromiseImageTextureReleaseProc textureReleaseProc,
+                                         PromiseImageTextureContext textureContext);
+
+/** This is similar to 'PromiseTextureFrom' but it creates a GPU-backed SkImage from YUV[A] data.
+    The source data may be planar (i.e. spread across multiple textures). In
+    the extreme Y, U, V, and A are all in different planes and thus the image is specified by
+    four textures. 'backendTextureInfo' describes the planar arrangement, texture formats,
+    conversion to RGB, and origin of the textures. Separate 'textureFulfillProc' and
+    'textureReleaseProc' calls are made for each texture. Each texture has its own
+    PromiseImageTextureContext. If 'backendTextureInfo' is not valid then no release proc
+    calls are made. Otherwise, the calls will be made even on failure. 'textureContexts' has one
+    entry for each of the up to four textures, as indicated by 'backendTextureInfo'.
+    Currently the mip mapped property of 'backendTextureInfo' is ignored. However, in the
+    near future it will be required that if it is kYes then textureFulfillProc must return
+    a mip mapped texture for each plane in order to successfully draw the image.
+    @param gpuContextProxy     the thread-safe proxy of the gpu context. required.
+    @param backendTextureInfo  info about the promised yuva gpu texture
+    @param imageColorSpace     range of colors; may be nullptr
+    @param textureFulfillProc  function called to get actual gpu texture
+    @param textureReleaseProc  function called when texture can be deleted
+    @param textureContexts     state passed to textureFulfillProc and textureReleaseProc
+    @return                    created SkImage, or nullptr
+*/
+SK_API sk_sp<SkImage> PromiseTextureFromYUVA(sk_sp<GrContextThreadSafeProxy> gpuContextProxy,
+                                             const GrYUVABackendTextureInfo& backendTextureInfo,
+                                             sk_sp<SkColorSpace> imageColorSpace,
+                                             PromiseImageTextureFulfillProc textureFulfillProc,
+                                             PromiseImageTextureReleaseProc textureReleaseProc,
+                                             PromiseImageTextureContext textureContexts[]);
+
+/** Returns the GPU context associated with this image or nullptr if the image is not Ganesh-backed.
+    We expose this only to help transition certain API calls and do not intend for this to stick
+    around forever.
+*/
+SK_API GrDirectContext* GetContext(const SkImage* src);
+inline GrDirectContext* GetContext(const sk_sp<const SkImage>& src) {
+    return GetContext(src.get());
+}
+
+}  // namespace SkImages
+
+#endif

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

@@ -0,0 +1,78 @@
+/*
+ * 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 sktext_gpu_Slug_DEFINED
+#define sktext_gpu_Slug_DEFINED
+
+#include "include/core/SkRect.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkSerialProcs.h"  // IWYU pragma: keep
+#include "include/private/base/SkAPI.h"
+
+#include <cstddef>
+#include <cstdint>
+
+class SkCanvas;
+class SkData;
+class SkPaint;
+class SkReadBuffer;
+class SkStrikeClient;
+class SkTextBlob;
+class SkWriteBuffer;
+struct SkPoint;
+
+namespace sktext::gpu {
+// Slug encapsulates an SkTextBlob at a specific origin, using a specific paint. It can be
+// manipulated using matrix and clip changes to the canvas. If the canvas is transformed, then
+// the Slug will also transform with smaller glyphs using bi-linear interpolation to render. You
+// can think of a Slug as making a rubber stamp out of a SkTextBlob.
+class SK_API Slug : public SkRefCnt {
+public:
+    // Return nullptr if the blob would not draw. This is not because of clipping, but because of
+    // some paint optimization. The Slug is captured as if drawn using drawTextBlob.
+    static sk_sp<Slug> ConvertBlob(
+            SkCanvas* canvas, const SkTextBlob& blob, SkPoint origin, const SkPaint& paint);
+
+    // Serialize the slug.
+    sk_sp<SkData> serialize(const SkSerialProcs& procs = {}) const;
+    size_t serialize(void* buffer, size_t size, const SkSerialProcs& procs = {}) const;
+
+    // Set the client parameter to the appropriate SkStrikeClient when typeface ID translation
+    // is needed.
+    static sk_sp<Slug> Deserialize(const void* data,
+                                   size_t size,
+                                   const SkStrikeClient* client = nullptr,
+                                   const SkDeserialProcs& procs = {});
+    static sk_sp<Slug> MakeFromBuffer(SkReadBuffer& buffer);
+
+    // Allows clients to deserialize SkPictures that contain slug data
+    static void AddDeserialProcs(SkDeserialProcs* procs, const SkStrikeClient* client = nullptr);
+
+    // Draw the Slug obeying the canvas's mapping and clipping.
+    void draw(SkCanvas* canvas) const;
+
+    virtual SkRect sourceBounds() const = 0;
+    virtual SkRect sourceBoundsWithOrigin () const = 0;
+
+    // The paint passed into ConvertBlob; this paint is used instead of the paint resulting from
+    // the call to aboutToDraw because when we call draw(), the initial paint is needed to call
+    // aboutToDraw again to get the layer right.
+    virtual const SkPaint& initialPaint() const = 0;
+
+    virtual void doFlatten(SkWriteBuffer&) const = 0;
+
+    uint32_t uniqueID() const { return fUniqueID; }
+
+private:
+    static uint32_t NextUniqueID();
+    const uint32_t  fUniqueID{NextUniqueID()};
+};
+
+
+}  // namespace sktext::gpu
+
+#endif  // sktext_gpu_Slug_DEFINED

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

@@ -0,0 +1,104 @@
+/*
+ * Copyright 2019 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrContext_Base_DEFINED
+#define GrContext_Base_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/gpu/GrTypes.h"
+#include "include/private/base/SkAPI.h"
+
+#include <cstdint>
+
+class GrBaseContextPriv;
+class GrCaps;
+class GrContextThreadSafeProxy;
+class GrDirectContext;
+class GrImageContext;
+class GrRecordingContext;
+enum SkColorType : int;
+enum class SkTextureCompressionType;
+struct GrContextOptions;
+class GrBackendFormat;
+
+class GrContext_Base : public SkRefCnt {
+public:
+    ~GrContext_Base() override;
+
+    /*
+     * Safely downcast to a GrDirectContext.
+     */
+    virtual GrDirectContext* asDirectContext() { return nullptr; }
+
+    /*
+     * The 3D API backing this context
+     */
+    SK_API GrBackendApi backend() const;
+
+    /*
+     * Retrieve the default GrBackendFormat for a given SkColorType and renderability.
+     * It is guaranteed that this backend format will be the one used by the GrContext
+     * SkColorType and GrSurfaceCharacterization-based createBackendTexture methods.
+     *
+     * The caller should check that the returned format is valid.
+     */
+    SK_API GrBackendFormat defaultBackendFormat(SkColorType, GrRenderable) const;
+
+    SK_API GrBackendFormat compressedBackendFormat(SkTextureCompressionType) const;
+
+    /**
+     * Gets the maximum supported sample count for a color type. 1 is returned if only non-MSAA
+     * rendering is supported for the color type. 0 is returned if rendering to this color type
+     * is not supported at all.
+     */
+    SK_API int maxSurfaceSampleCountForColorType(SkColorType colorType) const;
+
+    // TODO: When the public version is gone, rename to refThreadSafeProxy and add raw ptr ver.
+    sk_sp<GrContextThreadSafeProxy> threadSafeProxy();
+
+    // Provides access to functions that aren't part of the public API.
+    GrBaseContextPriv priv();
+    const GrBaseContextPriv priv() const;  // NOLINT(readability-const-return-type)
+
+protected:
+    friend class GrBaseContextPriv; // for hidden functions
+
+    GrContext_Base(sk_sp<GrContextThreadSafeProxy>);
+
+    virtual bool init();
+
+    /**
+     * An identifier for this context. The id is used by all compatible contexts. For example,
+     * if SkImages are created on one thread using an image creation context, then fed into a
+     * DDL Recorder on second thread (which has a recording context) and finally replayed on
+     * a third thread with a direct context, then all three contexts will report the same id.
+     * It is an error for an image to be used with contexts that report different ids.
+     */
+    uint32_t contextID() const;
+
+    bool matches(GrContext_Base* candidate) const {
+        return candidate && candidate->contextID() == this->contextID();
+    }
+
+    /*
+     * The options in effect for this context
+     */
+    const GrContextOptions& options() const;
+
+    const GrCaps* caps() const;
+    sk_sp<const GrCaps> refCaps() const;
+
+    virtual GrImageContext* asImageContext() { return nullptr; }
+    virtual GrRecordingContext* asRecordingContext() { return nullptr; }
+
+    sk_sp<GrContextThreadSafeProxy>         fThreadSafeProxy;
+
+private:
+    using INHERITED = SkRefCnt;
+};
+
+#endif

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

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2020 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrD3DTypesMinimal_DEFINED
+#define GrD3DTypesMinimal_DEFINED
+
+// Minimal definitions of Direct3D types, without including d3d12.h
+
+#include "include/core/SkRefCnt.h"
+
+#include <dxgiformat.h>
+
+#include "include/gpu/GrTypes.h"
+
+struct ID3D12Resource;
+class GrD3DResourceState;
+typedef int GrD3DResourceStateEnum;
+struct GrD3DSurfaceInfo;
+struct GrD3DTextureResourceInfo;
+struct GrD3DTextureResourceSpec;
+struct GrD3DFenceInfo;
+
+// This struct is to used to store the the actual information about the Direct3D backend image on
+// GrBackendTexture and GrBackendRenderTarget. When a client calls getD3DTextureInfo on a
+// GrBackendTexture/RenderTarget, we use the GrD3DBackendSurfaceInfo to create a snapshot
+// GrD3DTextureResourceInfo object. Internally, this uses a ref count GrD3DResourceState object to
+// track the current D3D12_RESOURCE_STATES which can be shared with an internal GrD3DTextureResource
+// so that state updates can be seen by all users of the texture.
+struct GrD3DBackendSurfaceInfo {
+    GrD3DBackendSurfaceInfo(const GrD3DTextureResourceInfo& info, GrD3DResourceState* state);
+
+    void cleanup();
+
+    GrD3DBackendSurfaceInfo& operator=(const GrD3DBackendSurfaceInfo&) = delete;
+
+    // Assigns the passed in GrD3DBackendSurfaceInfo to this object. if isValid is true we will also
+    // attempt to unref the old fLayout on this object.
+    void assign(const GrD3DBackendSurfaceInfo&, bool isValid);
+
+    void setResourceState(GrD3DResourceStateEnum state);
+
+    sk_sp<GrD3DResourceState> getGrD3DResourceState() const;
+
+    GrD3DTextureResourceInfo snapTextureResourceInfo() const;
+
+    bool isProtected() const;
+#if defined(GR_TEST_UTILS)
+    bool operator==(const GrD3DBackendSurfaceInfo& that) const;
+#endif
+
+private:
+    GrD3DTextureResourceInfo* fTextureResourceInfo;
+    GrD3DResourceState* fResourceState;
+};
+
+struct GrD3DTextureResourceSpecHolder {
+public:
+    GrD3DTextureResourceSpecHolder(const GrD3DSurfaceInfo&);
+
+    void cleanup();
+
+    GrD3DSurfaceInfo getSurfaceInfo(uint32_t sampleCount,
+                                    uint32_t levelCount,
+                                    skgpu::Protected isProtected) const;
+
+private:
+    GrD3DTextureResourceSpec* fSpec;
+};
+
+#endif

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

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2019 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrImageContext_DEFINED
+#define GrImageContext_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/private/base/SingleOwner.h"
+#include "include/private/base/SkAPI.h"
+#include "include/private/gpu/ganesh/GrContext_Base.h"
+
+class GrContextThreadSafeProxy;
+class GrImageContextPriv;
+
+// This is now just a view on a ThreadSafeProxy, that SkImages can attempt to
+// downcast to a GrDirectContext as a backdoor to some operations. Once we remove the backdoors,
+// this goes away and SkImages just hold ThreadSafeProxies.
+class GrImageContext : public GrContext_Base {
+public:
+    ~GrImageContext() override;
+
+    // Provides access to functions that aren't part of the public API.
+    GrImageContextPriv priv();
+    const GrImageContextPriv priv() const;  // NOLINT(readability-const-return-type)
+
+protected:
+    friend class GrImageContextPriv; // for hidden functions
+
+    GrImageContext(sk_sp<GrContextThreadSafeProxy>);
+
+    SK_API virtual void abandonContext();
+    SK_API virtual bool abandoned();
+
+    /** This is only useful for debug purposes */
+    skgpu::SingleOwner* singleOwner() const { return &fSingleOwner; }
+
+    GrImageContext* asImageContext() override { return this; }
+
+private:
+    // When making promise images, we currently need a placeholder GrImageContext instance to give
+    // to the SkImage that has no real power, just a wrapper around the ThreadSafeProxy.
+    // TODO: De-power SkImage to ThreadSafeProxy or at least figure out a way to share one instance.
+    static sk_sp<GrImageContext> MakeForPromiseImage(sk_sp<GrContextThreadSafeProxy>);
+
+    // In debug builds we guard against improper thread handling
+    // This guard is passed to the GrDrawingManager and, from there to all the
+    // GrSurfaceDrawContexts.  It is also passed to the GrResourceProvider and SkGpuDevice.
+    // TODO: Move this down to GrRecordingContext.
+    mutable skgpu::SingleOwner fSingleOwner;
+};
+
+#endif