@shopify/react-native-skia 0.1.115

package/cpp/skia/include/gpu/GrBackendSurfaceMutableState.h

@@ -0,0 +1,91 @@
+/*
+ * 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 GrBackendSurfaceMutableState_DEFINED
+#define GrBackendSurfaceMutableState_DEFINED
+
+#include "include/gpu/GrTypes.h"
+
+#ifdef SK_VULKAN
+#include "include/private/GrVkTypesPriv.h"
+#endif
+
+/**
+ * Since Skia and clients can both modify gpu textures and their connected state, Skia needs a way
+ * for clients to inform us if they have modifiend any of this state. In order to not need setters
+ * for every single API and state, we use this class to be a generic wrapper around all the mutable
+ * state. This class is used for calls that inform Skia of these texture/image state changes by the
+ * client as well as for requesting state changes to be done by Skia. The backend specific state
+ * that is wrapped by this class are:
+ *
+ * Vulkan: VkImageLayout and QueueFamilyIndex
+ */
+class SK_API GrBackendSurfaceMutableState {
+public:
+    GrBackendSurfaceMutableState() {}
+
+#ifdef SK_VULKAN
+    GrBackendSurfaceMutableState(VkImageLayout layout, uint32_t queueFamilyIndex)
+            : fVkState(layout, queueFamilyIndex)
+            , fBackend(GrBackend::kVulkan)
+            , fIsValid(true) {}
+#endif
+
+    GrBackendSurfaceMutableState(const GrBackendSurfaceMutableState& that);
+    GrBackendSurfaceMutableState& operator=(const GrBackendSurfaceMutableState& that);
+
+#ifdef SK_VULKAN
+    // If this class is not Vulkan backed it will return value of VK_IMAGE_LAYOUT_UNDEFINED.
+    // Otherwise it will return the VkImageLayout.
+    VkImageLayout getVkImageLayout() const {
+        if (this->isValid() && fBackend != GrBackendApi::kVulkan) {
+            return VK_IMAGE_LAYOUT_UNDEFINED;
+        }
+        return fVkState.getImageLayout();
+    }
+
+    // If this class is not Vulkan backed it will return value of VK_QUEUE_FAMILY_IGNORED.
+    // Otherwise it will return the VkImageLayout.
+    uint32_t getQueueFamilyIndex() const {
+        if (this->isValid() && fBackend != GrBackendApi::kVulkan) {
+            return VK_QUEUE_FAMILY_IGNORED;
+        }
+        return fVkState.getQueueFamilyIndex();
+    }
+#endif
+
+    // Returns true if the backend mutable state has been initialized.
+    bool isValid() const { return fIsValid; }
+
+    GrBackendApi backend() const { return fBackend; }
+
+private:
+    friend class GrBackendSurfaceMutableStateImpl;
+    friend class GrVkGpu;
+
+#ifdef SK_VULKAN
+    void setVulkanState(VkImageLayout layout, uint32_t queueFamilyIndex) {
+        SkASSERT(!this->isValid() || fBackend == GrBackendApi::kVulkan);
+        fVkState.setImageLayout(layout);
+        fVkState.setQueueFamilyIndex(queueFamilyIndex);
+        fBackend = GrBackendApi::kVulkan;
+        fIsValid = true;
+    }
+#endif
+
+    union {
+        char fPlaceholder;
+#ifdef SK_VULKAN
+        GrVkSharedImageInfo fVkState;
+#endif
+    };
+
+    GrBackend fBackend = GrBackendApi::kMock;
+    bool fIsValid = false;
+};
+
+#endif

package/cpp/skia/include/gpu/GrConfig.h

@@ -0,0 +1,53 @@
+
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrConfig_DEFINED
+#define GrConfig_DEFINED
+
+#include "include/core/SkTypes.h"
+
+/**
+ *  Gr defines are set to 0 or 1, rather than being undefined or defined
+ */
+
+#if !defined(GR_CACHE_STATS)
+  #if defined(SK_DEBUG) || defined(SK_DUMP_STATS)
+      #define GR_CACHE_STATS  1
+  #else
+      #define GR_CACHE_STATS  0
+  #endif
+#endif
+
+#if !defined(GR_GPU_STATS)
+  #if defined(SK_DEBUG) || defined(SK_DUMP_STATS) || GR_TEST_UTILS
+      #define GR_GPU_STATS    1
+  #else
+      #define GR_GPU_STATS    0
+  #endif
+#endif
+
+#endif
+
+/**
+ *  GR_STRING makes a string of X where X is expanded before conversion to a string
+ *  if X itself contains macros.
+ */
+#define GR_STRING(X) GR_STRING_IMPL(X)
+#define GR_STRING_IMPL(X) #X
+
+/**
+ *  GR_CONCAT concatenates X and Y  where each is expanded before
+ *  contanenation if either contains macros.
+ */
+#define GR_CONCAT(X,Y) GR_CONCAT_IMPL(X,Y)
+#define GR_CONCAT_IMPL(X,Y) X##Y
+
+/**
+ *  Creates a string of the form "<filename>(<linenumber>) : "
+ */
+#define GR_FILE_AND_LINE_STR __FILE__ "(" GR_STRING(__LINE__) ") : "

package/cpp/skia/include/gpu/GrContextOptions.h

@@ -0,0 +1,364 @@
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrContextOptions_DEFINED
+#define GrContextOptions_DEFINED
+
+#include "include/core/SkData.h"
+#include "include/core/SkString.h"
+#include "include/core/SkTypes.h"
+#include "include/gpu/GrDriverBugWorkarounds.h"
+#include "include/gpu/GrTypes.h"
+#include "include/gpu/ShaderErrorHandler.h"
+#include "include/private/GrTypesPriv.h"
+
+#include <vector>
+
+class SkExecutor;
+
+#if SK_SUPPORT_GPU
+struct SK_API GrContextOptions {
+    enum class Enable {
+        /** Forces an option to be disabled. */
+        kNo,
+        /** Forces an option to be enabled. */
+        kYes,
+        /**
+         * Uses Skia's default behavior, which may use runtime properties (e.g. driver version).
+         */
+        kDefault
+    };
+
+    enum class ShaderCacheStrategy {
+        kSkSL,
+        kBackendSource,
+        kBackendBinary,
+    };
+
+    /**
+     * Abstract class which stores Skia data in a cache that persists between sessions. Currently,
+     * Skia stores compiled shader binaries (only when glProgramBinary / glGetProgramBinary are
+     * supported) when provided a persistent cache, but this may extend to other data in the future.
+     */
+    class SK_API PersistentCache {
+    public:
+        virtual ~PersistentCache() = default;
+
+        /**
+         * Returns the data for the key if it exists in the cache, otherwise returns null.
+         */
+        virtual sk_sp<SkData> load(const SkData& key) = 0;
+
+        // Placeholder until all clients override the 3-parameter store(), then remove this, and
+        // make that version pure virtual.
+        virtual void store(const SkData& /*key*/, const SkData& /*data*/) { SkASSERT(false); }
+
+        /**
+         * Stores data in the cache, indexed by key. description provides a human-readable
+         * version of the key.
+         */
+        virtual void store(const SkData& key, const SkData& data, const SkString& /*description*/) {
+            this->store(key, data);
+        }
+
+    protected:
+        PersistentCache() = default;
+        PersistentCache(const PersistentCache&) = delete;
+        PersistentCache& operator=(const PersistentCache&) = delete;
+    };
+
+    using ShaderErrorHandler = skgpu::ShaderErrorHandler;
+
+    GrContextOptions() {}
+
+    // Suppress prints for the GrContext.
+    bool fSuppressPrints = false;
+
+    /**
+     * Controls whether we check for GL errors after functions that allocate resources (e.g.
+     * glTexImage2D), for shader compilation success, and program link success. Ignored on
+     * backends other than GL.
+     */
+    Enable fSkipGLErrorChecks = Enable::kDefault;
+
+    /** Overrides: These options override feature detection using backend API queries. These
+        overrides can only reduce the feature set or limits, never increase them beyond the
+        detected values. */
+
+    int  fMaxTextureSizeOverride = SK_MaxS32;
+
+    /** the threshold in bytes above which we will use a buffer mapping API to map vertex and index
+        buffers to CPU memory in order to update them.  A value of -1 means the GrContext should
+        deduce the optimal value for this platform. */
+    int  fBufferMapThreshold = -1;
+
+    /**
+     * Executor to handle threaded work within Ganesh. If this is nullptr, then all work will be
+     * done serially on the main thread. To have worker threads assist with various tasks, set this
+     * to a valid SkExecutor instance. Currently, used for software path rendering, but may be used
+     * for other tasks.
+     */
+    SkExecutor* fExecutor = nullptr;
+
+    /** Construct mipmaps manually, via repeated downsampling draw-calls. This is used when
+        the driver's implementation (glGenerateMipmap) contains bugs. This requires mipmap
+        level control (ie desktop or ES3). */
+    bool fDoManualMipmapping = false;
+
+    /**
+     * Disables the use of coverage counting shortcuts to render paths. Coverage counting can cause
+     * artifacts along shared edges if care isn't taken to ensure both contours wind in the same
+     * direction.
+     */
+    // FIXME: Once this is removed from Chrome and Android, rename to fEnable"".
+    bool fDisableCoverageCountingPaths = true;
+
+    /**
+     * Disables distance field rendering for paths. Distance field computation can be expensive,
+     * and yields no benefit if a path is not rendered multiple times with different transforms.
+     */
+    bool fDisableDistanceFieldPaths = false;
+
+    /**
+     * If true this allows path mask textures to be cached. This is only really useful if paths
+     * are commonly rendered at the same scale and fractional translation.
+     */
+    bool fAllowPathMaskCaching = true;
+
+    /**
+     * If true, the GPU will not be used to perform YUV -> RGB conversion when generating
+     * textures from codec-backed images.
+     */
+    bool fDisableGpuYUVConversion = false;
+
+    /**
+     * The maximum size of cache textures used for Skia's Glyph cache.
+     */
+    size_t fGlyphCacheTextureMaximumBytes = 2048 * 1024 * 4;
+
+    /**
+     * Below this threshold size in device space distance field fonts won't be used. Distance field
+     * fonts don't support hinting which is more important at smaller sizes.
+     */
+    float fMinDistanceFieldFontSize = 18;
+
+    /**
+     * Above this threshold size in device space glyphs are drawn as individual paths.
+     */
+#if defined(SK_BUILD_FOR_ANDROID)
+    float fGlyphsAsPathsFontSize = 384;
+#elif defined(SK_BUILD_FOR_MAC)
+    float fGlyphsAsPathsFontSize = 256;
+#else
+    float fGlyphsAsPathsFontSize = 324;
+#endif
+
+    /**
+     * Can the glyph atlas use multiple textures. If allowed, the each texture's size is bound by
+     * fGlypheCacheTextureMaximumBytes.
+     */
+    Enable fAllowMultipleGlyphCacheTextures = Enable::kDefault;
+
+    /**
+     * Bugs on certain drivers cause stencil buffers to leak. This flag causes Skia to avoid
+     * allocating stencil buffers and use alternate rasterization paths, avoiding the leak.
+     */
+    bool fAvoidStencilBuffers = false;
+
+    /**
+     * If true, texture fetches from mip-mapped textures will be biased to read larger MIP levels.
+     * This has the effect of sharpening those textures, at the cost of some aliasing, and possible
+     * performance impact.
+     */
+    bool fSharpenMipmappedTextures = false;
+
+    /**
+     * Enables driver workaround to use draws instead of HW clears, e.g. glClear on the GL backend.
+     */
+    Enable fUseDrawInsteadOfClear = Enable::kDefault;
+
+    /**
+     * Allow Ganesh to more aggressively reorder operations to reduce the number of render passes.
+     * Offscreen draws will be done upfront instead of interrupting the main render pass when
+     * possible. May increase VRAM usage, but still observes the resource cache limit.
+     * Enabled by default.
+     */
+    Enable fReduceOpsTaskSplitting = Enable::kDefault;
+
+    /**
+     * Some ES3 contexts report the ES2 external image extension, but not the ES3 version.
+     * If support for external images is critical, enabling this option will cause Ganesh to limit
+     * shaders to the ES2 shading language in that situation.
+     */
+    bool fPreferExternalImagesOverES3 = false;
+
+    /**
+     * Disables correctness workarounds that are enabled for particular GPUs, OSes, or drivers.
+     * This does not affect code path choices that are made for perfomance reasons nor does it
+     * override other GrContextOption settings.
+     */
+    bool fDisableDriverCorrectnessWorkarounds = false;
+
+    /**
+     * Maximum number of GPU programs or pipelines to keep active in the runtime cache.
+     */
+    int fRuntimeProgramCacheSize = 256;
+
+    /**
+     * Cache in which to store compiled shader binaries between runs.
+     */
+    PersistentCache* fPersistentCache = nullptr;
+
+    /**
+     * This affects the usage of the PersistentCache. We can cache SkSL, backend source (GLSL), or
+     * backend binaries (GL program binaries). By default we cache binaries, but if the driver's
+     * binary loading/storing is believed to have bugs, this can be limited to caching GLSL.
+     * Caching GLSL strings still saves CPU work when a GL program is created.
+     */
+    ShaderCacheStrategy fShaderCacheStrategy = ShaderCacheStrategy::kBackendBinary;
+
+    /**
+     * If present, use this object to report shader compilation failures. If not, report failures
+     * via SkDebugf and assert.
+     */
+    ShaderErrorHandler* fShaderErrorHandler = nullptr;
+
+    /**
+     * Specifies the number of samples Ganesh should use when performing internal draws with MSAA
+     * (hardware capabilities permitting).
+     *
+     * If 0, Ganesh will disable internal code paths that use multisampling.
+     */
+    int  fInternalMultisampleCount = 4;
+
+    /**
+     * In Skia's vulkan backend a single GrContext submit equates to the submission of a single
+     * primary command buffer to the VkQueue. This value specifies how many vulkan secondary command
+     * buffers we will cache for reuse on a given primary command buffer. A single submit may use
+     * more than this many secondary command buffers, but after the primary command buffer is
+     * finished on the GPU it will only hold on to this many secondary command buffers for reuse.
+     *
+     * A value of -1 means we will pick a limit value internally.
+     */
+    int fMaxCachedVulkanSecondaryCommandBuffers = -1;
+
+    /**
+     * If true, the caps will never support mipmaps.
+     */
+    bool fSuppressMipmapSupport = false;
+
+    /**
+     * If true, and if supported, enables hardware tessellation in the caps.
+     */
+    bool fEnableExperimentalHardwareTessellation = false;
+
+    /**
+     * If true, then add 1 pixel padding to all glyph masks in the atlas to support bi-lerp
+     * rendering of all glyphs. This must be set to true to use GrSlug.
+     */
+    #if defined(SK_EXPERIMENTAL_SIMULATE_DRAWGLYPHRUNLIST_WITH_SLUG)
+    bool fSupportBilerpFromGlyphAtlas = true;
+    #else
+    bool fSupportBilerpFromGlyphAtlas = false;
+    #endif
+
+    /**
+     * Uses a reduced variety of shaders. May perform less optimally in steady state but can reduce
+     * jank due to shader compilations.
+     */
+    bool fReducedShaderVariations = false;
+
+    /**
+     * If true, then allow to enable MSAA on new Intel GPUs.
+     */
+    bool fAllowMSAAOnNewIntel = false;
+
+#if GR_TEST_UTILS
+    /**
+     * Private options that are only meant for testing within Skia's tools.
+     */
+
+    /**
+     * Prevents use of dual source blending, to test that all xfer modes work correctly without it.
+     */
+    bool fSuppressDualSourceBlending = false;
+
+    /**
+     * Prevents the use of non-coefficient-based blend equations, for testing dst reads, barriers,
+     * and in-shader blending.
+     */
+    bool fSuppressAdvancedBlendEquations = false;
+
+    /**
+     * Prevents the use of framebuffer fetches, for testing dst reads and texture barriers.
+     */
+    bool fSuppressFramebufferFetch = false;
+
+    /**
+     * If greater than zero and less than the actual hardware limit, overrides the maximum number of
+     * tessellation segments supported by the caps.
+     */
+    int  fMaxTessellationSegmentsOverride = 0;
+
+    /**
+     * If true, then all paths are processed as if "setIsVolatile" had been called.
+     */
+    bool fAllPathsVolatile = false;
+
+    /**
+     * Render everything in wireframe
+     */
+    bool fWireframeMode = false;
+
+    /**
+     * Enforces clearing of all textures when they're created.
+     */
+    bool fClearAllTextures = false;
+
+    /**
+     * Randomly generate a (false) GL_OUT_OF_MEMORY error
+     */
+    bool fRandomGLOOM = false;
+
+    /**
+     * Force off support for write/transfer pixels row bytes in caps.
+     */
+    bool fDisallowWriteAndTransferPixelRowBytes = false;
+
+    /**
+     * Include or exclude specific GPU path renderers.
+     */
+    GpuPathRenderers fGpuPathRenderers = GpuPathRenderers::kDefault;
+
+    /**
+     * Specify the GPU resource cache limit. Equivalent to calling `setResourceCacheLimit` on the
+     * context at construction time.
+     *
+     * A value of -1 means use the default limit value.
+     */
+    int fResourceCacheLimitOverride = -1;
+
+    /**
+     * If true, then always try to use hardware tessellation, regardless of how small a path may be.
+     */
+    bool fAlwaysPreferHardwareTessellation = false;
+
+    /**
+     * Maximum width and height of internal texture atlases.
+     */
+    int  fMaxTextureAtlasSize = 2048;
+#endif
+
+    GrDriverBugWorkarounds fDriverBugWorkarounds;
+};
+#else
+struct GrContextOptions {
+    struct PersistentCache {};
+};
+#endif
+
+#endif

package/cpp/skia/include/gpu/GrContextThreadSafeProxy.h

@@ -0,0 +1,159 @@
+/*
+ * 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 GrContextThreadSafeProxy_DEFINED
+#define GrContextThreadSafeProxy_DEFINED
+
+#include "include/core/SkRefCnt.h"
+
+#if SK_SUPPORT_GPU
+
+#include "include/core/SkImageInfo.h"
+#include "include/gpu/GrContextOptions.h"
+#include "include/gpu/GrTypes.h"
+
+#include <atomic>
+
+class GrBackendFormat;
+class GrCaps;
+class GrContextThreadSafeProxyPriv;
+class GrTextBlobRedrawCoordinator;
+class GrThreadSafeCache;
+class GrThreadSafePipelineBuilder;
+class SkSurfaceCharacterization;
+class SkSurfaceProps;
+
+/**
+ * Can be used to perform actions related to the generating GrContext in a thread safe manner. The
+ * proxy does not access the 3D API (e.g. OpenGL) that backs the generating GrContext.
+ */
+class SK_API GrContextThreadSafeProxy final : public SkNVRefCnt<GrContextThreadSafeProxy> {
+public:
+    ~GrContextThreadSafeProxy();
+
+    /**
+     *  Create a surface characterization for a DDL that will be replayed into the GrContext
+     *  that created this proxy. On failure the resulting characterization will be invalid (i.e.,
+     *  "!c.isValid()").
+     *
+     *  @param cacheMaxResourceBytes           The max resource bytes limit that will be in effect
+     *                                         when the DDL created with this characterization is
+     *                                         replayed.
+     *                                         Note: the contract here is that the DDL will be
+     *                                         created as if it had a full 'cacheMaxResourceBytes'
+     *                                         to use. If replayed into a GrContext that already has
+     *                                         locked GPU memory, the replay can exceed the budget.
+     *                                         To rephrase, all resource allocation decisions are
+     *                                         made at record time and at playback time the budget
+     *                                         limits will be ignored.
+     *  @param ii                              The image info specifying properties of the SkSurface
+     *                                         that the DDL created with this characterization will
+     *                                         be replayed into.
+     *                                         Note: Ganesh doesn't make use of the SkImageInfo's
+     *                                         alphaType
+     *  @param backendFormat                   Information about the format of the GPU surface that
+     *                                         will back the SkSurface upon replay
+     *  @param sampleCount                     The sample count of the SkSurface that the DDL
+     *                                         created with this characterization will be replayed
+     *                                         into
+     *  @param origin                          The origin of the SkSurface that the DDL created with
+     *                                         this characterization will be replayed into
+     *  @param surfaceProps                    The surface properties of the SkSurface that the DDL
+     *                                         created with this characterization will be replayed
+     *                                         into
+     *  @param isMipMapped                     Will the surface the DDL will be replayed into have
+     *                                         space allocated for mipmaps?
+     *  @param willUseGLFBO0                   Will the surface the DDL will be replayed into be
+     *                                         backed by GL FBO 0. This flag is only valid if using
+     *                                         an GL backend.
+     *  @param isTextureable                   Will the surface be able to act as a texture?
+     *  @param isProtected                     Will the (Vulkan) surface be DRM protected?
+     *  @param vkRTSupportsInputAttachment     Can the vulkan surface be used as in input
+                                               attachment?
+     *  @param forVulkanSecondaryCommandBuffer Will the surface be wrapping a vulkan secondary
+     *                                         command buffer via a GrVkSecondaryCBDrawContext? If
+     *                                         this is true then the following is required:
+     *                                         isTexureable = false
+     *                                         isMipMapped = false
+     *                                         willUseGLFBO0 = false
+     *                                         vkRTSupportsInputAttachment = false
+     */
+    SkSurfaceCharacterization createCharacterization(
+                                  size_t cacheMaxResourceBytes,
+                                  const SkImageInfo& ii,
+                                  const GrBackendFormat& backendFormat,
+                                  int sampleCount,
+                                  GrSurfaceOrigin origin,
+                                  const SkSurfaceProps& surfaceProps,
+                                  bool isMipMapped,
+                                  bool willUseGLFBO0 = false,
+                                  bool isTextureable = true,
+                                  GrProtected isProtected = GrProtected::kNo,
+                                  bool vkRTSupportsInputAttachment = false,
+                                  bool forVulkanSecondaryCommandBuffer = false);
+
+    /*
+     * Retrieve the default GrBackendFormat for a given SkColorType and renderability.
+     * It is guaranteed that this backend format will be the one used by the following
+     * SkColorType and SkSurfaceCharacterization-based createBackendTexture methods.
+     *
+     * The caller should check that the returned format is valid.
+     */
+    GrBackendFormat defaultBackendFormat(SkColorType ct, GrRenderable renderable) const;
+
+    /**
+     * Retrieve the GrBackendFormat for a given SkImage::CompressionType. This is
+     * guaranteed to match the backend format used by the following
+     * createCompressedBackendTexture methods that take a CompressionType.
+     *
+     * The caller should check that the returned format is valid.
+     */
+    GrBackendFormat compressedBackendFormat(SkImage::CompressionType c) const;
+
+    bool isValid() const { return nullptr != fCaps; }
+
+    bool operator==(const GrContextThreadSafeProxy& that) const {
+        // Each GrContext should only ever have a single thread-safe proxy.
+        SkASSERT((this == &that) == (this->fContextID == that.fContextID));
+        return this == &that;
+    }
+
+    bool operator!=(const GrContextThreadSafeProxy& that) const { return !(*this == that); }
+
+    // Provides access to functions that aren't part of the public API.
+    GrContextThreadSafeProxyPriv priv();
+    const GrContextThreadSafeProxyPriv priv() const;  // NOLINT(readability-const-return-type)
+
+private:
+    friend class GrContextThreadSafeProxyPriv; // for ctor and hidden methods
+
+    // DDL TODO: need to add unit tests for backend & maybe options
+    GrContextThreadSafeProxy(GrBackendApi, const GrContextOptions&);
+
+    void abandonContext();
+    bool abandoned() const;
+
+    // TODO: This should be part of the constructor but right now we have a chicken-and-egg problem
+    // with GrContext where we get the caps by creating a GPU which requires a context (see the
+    // `init` method on GrContext_Base).
+    void init(sk_sp<const GrCaps>, sk_sp<GrThreadSafePipelineBuilder>);
+
+    const GrBackendApi                           fBackend;
+    const GrContextOptions                       fOptions;
+    const uint32_t                               fContextID;
+    sk_sp<const GrCaps>                          fCaps;
+    std::unique_ptr<GrTextBlobRedrawCoordinator> fTextBlobRedrawCoordinator;
+    std::unique_ptr<GrThreadSafeCache>           fThreadSafeCache;
+    sk_sp<GrThreadSafePipelineBuilder>           fPipelineBuilder;
+    std::atomic<bool>                            fAbandoned{false};
+};
+
+#else // !SK_SUPPORT_GPU
+class SK_API GrContextThreadSafeProxy final : public SkNVRefCnt<GrContextThreadSafeProxy> {};
+#endif
+
+#endif