/src/skia/include/gpu/ganesh/GrContextOptions.h

Source (jump to first uncovered line)
/*
 * 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/ganesh/GrDriverBugWorkarounds.h"
#include "include/gpu/ganesh/GrTypes.h"
#include "include/gpu/ShaderErrorHandler.h"
#include "include/private/gpu/ganesh/GrTypesPriv.h"

#include <optional>
#include <vector>

class SkExecutor;

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), at the end of a GPU submission, or checking framebuffer completeness. The
     * results of shader compilation and program linking are always checked, regardless of this
     * option. 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;

    /** Default minimum size to use when allocating buffers for uploading data to textures. The
        larger the value the more uploads can be packed into one buffer, but at the cost of
        more gpu memory allocated that may not be used. Uploads larger than the minimum will still
        work by allocating a dedicated buffer. */
    size_t fMinimumStagingBufferSize = 64 * 1024;

    /**
     * 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;

    /**
     * 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 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
     * inernally 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;

    /**
     * If true, the caps will never support mipmaps.
     */
    bool fSuppressMipmapSupport = false;

    /**
     * If true, the TessellationPathRenderer will not be used for path rendering.
     * If false, will fallback to any driver workarounds, if set.
     */
    bool fDisableTessellationPathRenderer = false;

    /**
     * If true, and if supported, enables hardware tessellation in the caps.
     * DEPRECATED: This value is ignored; experimental hardware tessellation is always disabled.
     */
    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 Slugs.
     */
    bool fSupportBilerpFromGlyphAtlas = false;

    /**
     * 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;

    /**
     * Currently on ARM Android we disable the use of GL TexStorage because of memory regressions.
     * However, some clients may still want to use TexStorage. For example, TexStorage support is
     * required for creating protected textures.
     *
     * This flag has no impact on non GL backends.
     */
    bool fAlwaysUseTexStorageWhenAvailable = false;

    /**
     * Optional callback that can be passed into the GrDirectContext which will be called when the
     * GrDirectContext is about to be destroyed. When this call is made, it will be safe for the
     * client to delete the GPU backend context that is backing the GrDirectContext. The
     * GrDirectContextDestroyedContext will be passed back to the client in the callback.
     */
    GrDirectContextDestroyedContext fContextDeleteContext = nullptr;
    GrDirectContextDestroyedProc fContextDeleteProc = nullptr;

#if defined(GPU_TEST_UTILS)
    /**
     * Private options that are only meant for testing within Skia's tools.
     */

    /**
     * Testing-only mode to exercise allocation failures in the flush-time callback objects.
     * For now it only simulates allocation failure during the preFlush callback.
     */
    bool fFailFlushTimeCallbacks = false;

    /**
     * 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 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;

    /**
     * Maximum width and height of internal texture atlases.
     */
    int  fMaxTextureAtlasSize = 2048;
#endif

    GrDriverBugWorkarounds fDriverBugWorkarounds;
};

#endif

Coverage Report

Created: 2024-09-14 07:19

Line	Count	Source (jump to first uncovered line)
1		/*
2		* Copyright 2015 Google Inc.
3		*
4		* Use of this source code is governed by a BSD-style license that can be
5		* found in the LICENSE file.
6		*/
7
8		#ifndef GrContextOptions_DEFINED
9		#define GrContextOptions_DEFINED
10
11		#include "include/core/SkData.h"
12		#include "include/core/SkString.h"
13		#include "include/core/SkTypes.h"
14		#include "include/gpu/ganesh/GrDriverBugWorkarounds.h"
15		#include "include/gpu/ganesh/GrTypes.h"
16		#include "include/gpu/ShaderErrorHandler.h"
17		#include "include/private/gpu/ganesh/GrTypesPriv.h"
18
19		#include <optional>
20		#include <vector>
21
22		class SkExecutor;
23
24		struct SK_API GrContextOptions {
25		enum class Enable {
26		/** Forces an option to be disabled. */
27		kNo,
28		/** Forces an option to be enabled. */
29		kYes,
30		/**
31		* Uses Skia's default behavior, which may use runtime properties (e.g. driver version).
32		*/
33		kDefault
34		};
35
36		enum class ShaderCacheStrategy {
37		kSkSL,
38		kBackendSource,
39		kBackendBinary,
40		};
41
42		/**
43		* Abstract class which stores Skia data in a cache that persists between sessions. Currently,
44		* Skia stores compiled shader binaries (only when glProgramBinary / glGetProgramBinary are
45		* supported) when provided a persistent cache, but this may extend to other data in the future.
46		*/
47		class SK_API PersistentCache {
48		public:
49	0	virtual ~PersistentCache() = default;
50
51		/**
52		* Returns the data for the key if it exists in the cache, otherwise returns null.
53		*/
54		virtual sk_sp<SkData> load(const SkData& key) = 0;
55
56		// Placeholder until all clients override the 3-parameter store(), then remove this, and
57		// make that version pure virtual.
58	0	virtual void store(const SkData& /key/, const SkData& /data/) { SkASSERT(false); } Unexecuted instantiation: GrContextOptions::PersistentCache::store(SkData const&, SkData const&) Unexecuted instantiation: GrContextOptions::PersistentCache::store(SkData const&, SkData const&)
59
60		/**
61		* Stores data in the cache, indexed by key. description provides a human-readable
62		* version of the key.
63		*/
64	0	virtual void store(const SkData& key, const SkData& data, const SkString& /description/) {
65	0	this->store(key, data);
66	0	}
67
68		protected:
69		PersistentCache() = default;
70		PersistentCache(const PersistentCache&) = delete;
71		PersistentCache& operator=(const PersistentCache&) = delete;
72		};
73
74		using ShaderErrorHandler = skgpu::ShaderErrorHandler;
75
76	9.03k	GrContextOptions() {}
77
78		// Suppress prints for the GrContext.
79		bool fSuppressPrints = false;
80
81		/**
82		* Controls whether we check for GL errors after functions that allocate resources (e.g.
83		* glTexImage2D), at the end of a GPU submission, or checking framebuffer completeness. The
84		* results of shader compilation and program linking are always checked, regardless of this
85		* option. Ignored on backends other than GL.
86		*/
87		Enable fSkipGLErrorChecks = Enable::kDefault;
88
89		/** Overrides: These options override feature detection using backend API queries. These
90		overrides can only reduce the feature set or limits, never increase them beyond the
91		detected values. */
92
93		int fMaxTextureSizeOverride = SK_MaxS32;
94
95		/** the threshold in bytes above which we will use a buffer mapping API to map vertex and index
96		buffers to CPU memory in order to update them. A value of -1 means the GrContext should
97		deduce the optimal value for this platform. */
98		int fBufferMapThreshold = -1;
99
100		/** Default minimum size to use when allocating buffers for uploading data to textures. The
101		larger the value the more uploads can be packed into one buffer, but at the cost of
102		more gpu memory allocated that may not be used. Uploads larger than the minimum will still
103		work by allocating a dedicated buffer. */
104		size_t fMinimumStagingBufferSize = 64 * 1024;
105
106		/**
107		* Executor to handle threaded work within Ganesh. If this is nullptr, then all work will be
108		* done serially on the main thread. To have worker threads assist with various tasks, set this
109		* to a valid SkExecutor instance. Currently, used for software path rendering, but may be used
110		* for other tasks.
111		*/
112		SkExecutor* fExecutor = nullptr;
113
114		/** Construct mipmaps manually, via repeated downsampling draw-calls. This is used when
115		the driver's implementation (glGenerateMipmap) contains bugs. This requires mipmap
116		level control (ie desktop or ES3). */
117		bool fDoManualMipmapping = false;
118
119		/**
120		* Disables the use of coverage counting shortcuts to render paths. Coverage counting can cause
121		* artifacts along shared edges if care isn't taken to ensure both contours wind in the same
122		* direction.
123		*/
124		// FIXME: Once this is removed from Chrome and Android, rename to fEnable"".
125		bool fDisableCoverageCountingPaths = true;
126
127		/**
128		* Disables distance field rendering for paths. Distance field computation can be expensive,
129		* and yields no benefit if a path is not rendered multiple times with different transforms.
130		*/
131		bool fDisableDistanceFieldPaths = false;
132
133		/**
134		* If true this allows path mask textures to be cached. This is only really useful if paths
135		* are commonly rendered at the same scale and fractional translation.
136		*/
137		bool fAllowPathMaskCaching = true;
138
139		/**
140		* If true, the GPU will not be used to perform YUV -> RGB conversion when generating
141		* textures from codec-backed images.
142		*/
143		bool fDisableGpuYUVConversion = false;
144
145		/**
146		* The maximum size of cache textures used for Skia's Glyph cache.
147		*/
148		size_t fGlyphCacheTextureMaximumBytes = 2048 * 1024 * 4;
149
150		/**
151		* Below this threshold size in device space distance field fonts won't be used. Distance field
152		* fonts don't support hinting which is more important at smaller sizes.
153		*/
154		float fMinDistanceFieldFontSize = 18;
155
156		/**
157		* Above this threshold size in device space glyphs are drawn as individual paths.
158		*/
159		#if defined(SK_BUILD_FOR_ANDROID)
160		float fGlyphsAsPathsFontSize = 384;
161		#elif defined(SK_BUILD_FOR_MAC)
162		float fGlyphsAsPathsFontSize = 256;
163		#else
164		float fGlyphsAsPathsFontSize = 324;
165		#endif
166
167		/**
168		* Can the glyph atlas use multiple textures. If allowed, the each texture's size is bound by
169		* fGlypheCacheTextureMaximumBytes.
170		*/
171		Enable fAllowMultipleGlyphCacheTextures = Enable::kDefault;
172
173		/**
174		* Bugs on certain drivers cause stencil buffers to leak. This flag causes Skia to avoid
175		* allocating stencil buffers and use alternate rasterization paths, avoiding the leak.
176		*/
177		bool fAvoidStencilBuffers = false;
178
179		/**
180		* Enables driver workaround to use draws instead of HW clears, e.g. glClear on the GL backend.
181		*/
182		Enable fUseDrawInsteadOfClear = Enable::kDefault;
183
184		/**
185		* Allow Ganesh to more aggressively reorder operations to reduce the number of render passes.
186		* Offscreen draws will be done upfront instead of interrupting the main render pass when
187		* possible. May increase VRAM usage, but still observes the resource cache limit.
188		* Enabled by default.
189		*/
190		Enable fReduceOpsTaskSplitting = Enable::kDefault;
191
192		/**
193		* Some ES3 contexts report the ES2 external image extension, but not the ES3 version.
194		* If support for external images is critical, enabling this option will cause Ganesh to limit
195		* shaders to the ES2 shading language in that situation.
196		*/
197		bool fPreferExternalImagesOverES3 = false;
198
199		/**
200		* Disables correctness workarounds that are enabled for particular GPUs, OSes, or drivers.
201		* This does not affect code path choices that are made for perfomance reasons nor does it
202		* override other GrContextOption settings.
203		*/
204		bool fDisableDriverCorrectnessWorkarounds = false;
205
206		/**
207		* Maximum number of GPU programs or pipelines to keep active in the runtime cache.
208		*/
209		int fRuntimeProgramCacheSize = 256;
210
211		/**
212		* Cache in which to store compiled shader binaries between runs.
213		*/
214		PersistentCache* fPersistentCache = nullptr;
215
216		/**
217		* This affects the usage of the PersistentCache. We can cache SkSL, backend source (GLSL), or
218		* backend binaries (GL program binaries). By default we cache binaries, but if the driver's
219		* binary loading/storing is believed to have bugs, this can be limited to caching GLSL.
220		* Caching GLSL strings still saves CPU work when a GL program is created.
221		*/
222		ShaderCacheStrategy fShaderCacheStrategy = ShaderCacheStrategy::kBackendBinary;
223
224		/**
225		* If present, use this object to report shader compilation failures. If not, report failures
226		* via SkDebugf and assert.
227		*/
228		ShaderErrorHandler* fShaderErrorHandler = nullptr;
229
230		/**
231		* Specifies the number of samples Ganesh should use when performing internal draws with MSAA
232		* (hardware capabilities permitting).
233		*
234		* If 0, Ganesh will disable internal code paths that use multisampling.
235		*/
236		int fInternalMultisampleCount = 4;
237
238		/**
239		* In Skia's vulkan backend a single GrContext submit equates to the submission of a single
240		* primary command buffer to the VkQueue. This value specifies how many vulkan secondary command
241		* buffers we will cache for reuse on a given primary command buffer. A single submit may use
242		* more than this many secondary command buffers, but after the primary command buffer is
243		* finished on the GPU it will only hold on to this many secondary command buffers for reuse.
244		*
245		* A value of -1 means we will pick a limit value internally.
246		*/
247		int fMaxCachedVulkanSecondaryCommandBuffers = -1;
248
249		/**
250		* If Skia is creating a default VMA allocator for the Vulkan backend this value will be used
251		* for the preferredLargeHeapBlockSize. If the value is not set, then Skia will use an
252		* inernally defined default size.
253		*
254		* However, it is highly discouraged to have Skia make a default allocator (and support for
255		* doing so will be removed soon, b/321962001). Instead clients should create their own
256		* allocator to pass into Skia where they can fine tune this value themeselves.
257		*/
258		std::optional<uint64_t> fVulkanVMALargeHeapBlockSize;
259
260		/**
261		* If true, the caps will never support mipmaps.
262		*/
263		bool fSuppressMipmapSupport = false;
264
265		/**
266		* If true, the TessellationPathRenderer will not be used for path rendering.
267		* If false, will fallback to any driver workarounds, if set.
268		*/
269		bool fDisableTessellationPathRenderer = false;
270
271		/**
272		* If true, and if supported, enables hardware tessellation in the caps.
273		* DEPRECATED: This value is ignored; experimental hardware tessellation is always disabled.
274		*/
275		bool fEnableExperimentalHardwareTessellation = false;
276
277		/**
278		* If true, then add 1 pixel padding to all glyph masks in the atlas to support bi-lerp
279		* rendering of all glyphs. This must be set to true to use Slugs.
280		*/
281		bool fSupportBilerpFromGlyphAtlas = false;
282
283		/**
284		* Uses a reduced variety of shaders. May perform less optimally in steady state but can reduce
285		* jank due to shader compilations.
286		*/
287		bool fReducedShaderVariations = false;
288
289		/**
290		* If true, then allow to enable MSAA on new Intel GPUs.
291		*/
292		bool fAllowMSAAOnNewIntel = false;
293
294		/**
295		* Currently on ARM Android we disable the use of GL TexStorage because of memory regressions.
296		* However, some clients may still want to use TexStorage. For example, TexStorage support is
297		* required for creating protected textures.
298		*
299		* This flag has no impact on non GL backends.
300		*/
301		bool fAlwaysUseTexStorageWhenAvailable = false;
302
303		/**
304		* Optional callback that can be passed into the GrDirectContext which will be called when the
305		* GrDirectContext is about to be destroyed. When this call is made, it will be safe for the
306		* client to delete the GPU backend context that is backing the GrDirectContext. The
307		* GrDirectContextDestroyedContext will be passed back to the client in the callback.
308		*/
309		GrDirectContextDestroyedContext fContextDeleteContext = nullptr;
310		GrDirectContextDestroyedProc fContextDeleteProc = nullptr;
311
312		#if defined(GPU_TEST_UTILS)
313		/**
314		* Private options that are only meant for testing within Skia's tools.
315		*/
316
317		/**
318		* Testing-only mode to exercise allocation failures in the flush-time callback objects.
319		* For now it only simulates allocation failure during the preFlush callback.
320		*/
321		bool fFailFlushTimeCallbacks = false;
322
323		/**
324		* Prevents use of dual source blending, to test that all xfer modes work correctly without it.
325		*/
326		bool fSuppressDualSourceBlending = false;
327
328		/**
329		* Prevents the use of non-coefficient-based blend equations, for testing dst reads, barriers,
330		* and in-shader blending.
331		*/
332		bool fSuppressAdvancedBlendEquations = false;
333
334		/**
335		* Prevents the use of framebuffer fetches, for testing dst reads and texture barriers.
336		*/
337		bool fSuppressFramebufferFetch = false;
338
339		/**
340		* If true, then all paths are processed as if "setIsVolatile" had been called.
341		*/
342		bool fAllPathsVolatile = false;
343
344		/**
345		* Render everything in wireframe
346		*/
347		bool fWireframeMode = false;
348
349		/**
350		* Enforces clearing of all textures when they're created.
351		*/
352		bool fClearAllTextures = false;
353
354		/**
355		* Randomly generate a (false) GL_OUT_OF_MEMORY error
356		*/
357		bool fRandomGLOOM = false;
358
359		/**
360		* Force off support for write/transfer pixels row bytes in caps.
361		*/
362		bool fDisallowWriteAndTransferPixelRowBytes = false;
363
364		/**
365		* Include or exclude specific GPU path renderers.
366		*/
367		GpuPathRenderers fGpuPathRenderers = GpuPathRenderers::kDefault;
368
369		/**
370		* Specify the GPU resource cache limit. Equivalent to calling `setResourceCacheLimit` on the
371		* context at construction time.
372		*
373		* A value of -1 means use the default limit value.
374		*/
375		int fResourceCacheLimitOverride = -1;
376
377		/**
378		* Maximum width and height of internal texture atlases.
379		*/
380		int fMaxTextureAtlasSize = 2048;
381		#endif
382
383		GrDriverBugWorkarounds fDriverBugWorkarounds;
384		};
385
386		#endif