Revert "Reland "Take GrContext private, GrDDLContext inherit from GrRecordingContext""
This reverts commit ff13ffbeacec5335cfdb84c8a9d20bb78e10da58.
Reason for revert: Blink in g3
Original change's description:
> Reland "Take GrContext private, GrDDLContext inherit from GrRecordingContext"
>
> This reverts commit 89bdc90ac877dc8cd49c86c35a20d9df0d3b9016.
>
> Reason for revert: Fix metal
>
> Original change's description:
> > Revert "Take GrContext private, GrDDLContext inherit from GrRecordingContext"
> >
> > This reverts commit d2daa94edeca88281796524fae45f38f11a7bef2.
> >
> > Reason for revert: Metaru
> >
> > Original change's description:
> > > Take GrContext private, GrDDLContext inherit from GrRecordingContext
> > >
> > > Woo!
> > >
> > > Change-Id: I8d201b709343dc18cad31ea740575285dd035f35
> > > Docs-Preview: https://skia.org/?cl=317436
> > > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/317436
> > > Reviewed-by: Robert Phillips <robertphillips@google.com>
> > > Reviewed-by: Brian Salomon <bsalomon@google.com>
> > > Commit-Queue: Adlai Holler <adlai@google.com>
> >
> > TBR=bsalomon@google.com,robertphillips@google.com,adlai@google.com
> >
> > Change-Id: I9b58dee285fbdc49ebc8e76df5da0fe224cf9787
> > No-Presubmit: true
> > No-Tree-Checks: true
> > No-Try: true
> > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/318758
> > Reviewed-by: Adlai Holler <adlai@google.com>
> > Commit-Queue: Adlai Holler <adlai@google.com>
>
> TBR=bsalomon@google.com,robertphillips@google.com,adlai@google.com
>
>
> Change-Id: Id4b10795193a904cd4ed8c36e60e74abe3b6702a
> Docs-Preview: https://skia.org/?cl=318759
> Cq-Include-Trybots: luci.skia.skia.primary:Build-Mac10.15.5-Clang-arm64-Debug-iOS_Metal,Build-Mac-Clang-x86_64-Debug-Metal
> Reviewed-on: https://skia-review.googlesource.com/c/skia/+/318759
> Commit-Queue: Adlai Holler <adlai@google.com>
> Reviewed-by: Adlai Holler <adlai@google.com>
TBR=bsalomon@google.com,robertphillips@google.com,adlai@google.com
Change-Id: Ib20fe933120d56b72efaec73a0bedec60bc28def
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/319184
Commit-Queue: Adlai Holler <adlai@google.com>
Reviewed-by: Adlai Holler <adlai@google.com>
diff --git a/include/gpu/GrContext.h b/include/gpu/GrContext.h
new file mode 100644
index 0000000..0a96abc
--- /dev/null
+++ b/include/gpu/GrContext.h
@@ -0,0 +1,772 @@
+/*
+ * 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 GrContext_DEFINED
+#define GrContext_DEFINED
+
+#include "include/core/SkMatrix.h"
+#include "include/core/SkPathEffect.h"
+#include "include/core/SkTypes.h"
+#include "include/gpu/GrBackendSurface.h"
+#include "include/gpu/GrContextOptions.h"
+#include "include/gpu/GrRecordingContext.h"
+
+// We shouldn't need this but currently Android is relying on this being include transitively.
+#include "include/core/SkUnPreMultiply.h"
+
+class GrAtlasManager;
+class GrBackendSemaphore;
+class GrCaps;
+class GrClientMappedBufferManager;
+class GrContextPriv;
+class GrContextThreadSafeProxy;
+struct GrD3DBackendContext;
+class GrFragmentProcessor;
+struct GrGLInterface;
+class GrGpu;
+struct GrMockOptions;
+class GrPath;
+class GrRenderTargetContext;
+class GrResourceCache;
+class GrResourceProvider;
+class GrSmallPathAtlasMgr;
+class GrStrikeCache;
+class GrSurfaceProxy;
+class GrSwizzle;
+class GrTextureProxy;
+struct GrVkBackendContext;
+
+class SkImage;
+class SkString;
+class SkSurfaceCharacterization;
+class SkSurfaceProps;
+class SkTaskGroup;
+class SkTraceMemoryDump;
+
+class SK_API GrContext : public GrRecordingContext {
+public:
+#ifndef SK_DISABLE_LEGACY_CONTEXT_FACTORIES
+
+#ifdef SK_GL
+ /**
+ * Creates a GrContext for a backend context. If no GrGLInterface is provided then the result of
+ * GrGLMakeNativeInterface() is used if it succeeds.
+ */
+ static sk_sp<GrContext> MakeGL(sk_sp<const GrGLInterface>, const GrContextOptions&);
+ static sk_sp<GrContext> MakeGL(sk_sp<const GrGLInterface>);
+ static sk_sp<GrContext> MakeGL(const GrContextOptions&);
+ static sk_sp<GrContext> MakeGL();
+#endif
+
+#ifdef SK_VULKAN
+ /**
+ * The Vulkan context (VkQueue, VkDevice, VkInstance) must be kept alive until the returned
+ * GrContext is destroyed. This also means that any objects created with this GrContext (e.g.
+ * SkSurfaces, SkImages, etc.) must also be released as they may hold refs on the GrContext.
+ * Once all these objects and the GrContext are released, then it is safe to delete the vulkan
+ * objects.
+ */
+ static sk_sp<GrContext> MakeVulkan(const GrVkBackendContext&, const GrContextOptions&);
+ static sk_sp<GrContext> MakeVulkan(const GrVkBackendContext&);
+#endif
+
+#ifdef SK_METAL
+ /**
+ * Makes a GrContext which uses Metal as the backend. The device parameter is an MTLDevice
+ * and queue is an MTLCommandQueue which should be used by the backend. These objects must
+ * have a ref on them which can be transferred to Ganesh which will release the ref when the
+ * GrContext is destroyed.
+ */
+ static sk_sp<GrContext> MakeMetal(void* device, void* queue, const GrContextOptions& options);
+ static sk_sp<GrContext> MakeMetal(void* device, void* queue);
+#endif
+
+#ifdef SK_DIRECT3D
+ /**
+ * Makes a GrContext which uses Direct3D as the backend. The Direct3D context
+ * must be kept alive until the returned GrContext is first destroyed or abandoned.
+ */
+ static sk_sp<GrContext> MakeDirect3D(const GrD3DBackendContext&,
+ const GrContextOptions& options);
+ static sk_sp<GrContext> MakeDirect3D(const GrD3DBackendContext&);
+#endif
+
+#ifdef SK_DAWN
+ static sk_sp<GrContext> MakeDawn(const wgpu::Device& device, const GrContextOptions& options);
+ static sk_sp<GrContext> MakeDawn(const wgpu::Device& device);
+#endif
+
+ static sk_sp<GrContext> MakeMock(const GrMockOptions*, const GrContextOptions&);
+ static sk_sp<GrContext> MakeMock(const GrMockOptions*);
+
+#endif // SK_DISABLE_LEGACY_CONTEXT_FACTORIES
+
+ ~GrContext() override;
+
+ // TODO: Remove this from public after migrating Chrome.
+ sk_sp<GrContextThreadSafeProxy> threadSafeProxy();
+
+ /**
+ * The GrContext normally assumes that no outsider is setting state
+ * within the underlying 3D API's context/device/whatever. This call informs
+ * the context that the state was modified and it should resend. Shouldn't
+ * be called frequently for good performance.
+ * The flag bits, state, is dpendent on which backend is used by the
+ * context, either GL or D3D (possible in future).
+ */
+ void resetContext(uint32_t state = kAll_GrBackendState);
+
+ /**
+ * If the backend is GrBackendApi::kOpenGL, then all texture unit/target combinations for which
+ * the GrContext has modified the bound texture will have texture id 0 bound. This does not
+ * flush the GrContext. Calling resetContext() does not change the set that will be bound
+ * to texture id 0 on the next call to resetGLTextureBindings(). After this is called
+ * all unit/target combinations are considered to have unmodified bindings until the GrContext
+ * subsequently modifies them (meaning if this is called twice in a row with no intervening
+ * GrContext usage then the second call is a no-op.)
+ */
+ void resetGLTextureBindings();
+
+ /**
+ * Abandons all GPU resources and assumes the underlying backend 3D API context is no longer
+ * usable. Call this if you have lost the associated GPU context, and thus internal texture,
+ * buffer, etc. references/IDs are now invalid. Calling this ensures that the destructors of the
+ * GrContext and any of its created resource objects will not make backend 3D API calls. Content
+ * rendered but not previously flushed may be lost. After this function is called all subsequent
+ * calls on the GrContext will fail or be no-ops.
+ *
+ * The typical use case for this function is that the underlying 3D context was lost and further
+ * API calls may crash.
+ *
+ * For Vulkan, even if the device becomes lost, the VkQueue, VkDevice, or VkInstance used to
+ * create the GrContext must be kept alive even after abandoning the context. Those objects must
+ * live for the lifetime of the GrContext object itself. The reason for this is so that
+ * we can continue to delete any outstanding GrBackendTextures/RenderTargets which must be
+ * cleaned up even in a device lost state.
+ */
+ void abandonContext() override;
+
+ /**
+ * Returns true if the context was abandoned or if the if the backend specific context has
+ * gotten into an unrecoverarble, lost state (e.g. in Vulkan backend if we've gotten a
+ * VK_ERROR_DEVICE_LOST). If the backend context is lost, this call will also abandon the
+ * GrContext.
+ */
+ bool abandoned() override;
+
+ /**
+ * Checks if the underlying 3D API reported an out-of-memory error. If this returns true it is
+ * reset and will return false until another out-of-memory error is reported by the 3D API. If
+ * the context is abandoned then this will report false.
+ *
+ * Currently this is implemented for:
+ *
+ * OpenGL [ES] - Note that client calls to glGetError() may swallow GL_OUT_OF_MEMORY errors and
+ * therefore hide the error from Skia. Also, it is not advised to use this in combination with
+ * enabling GrContextOptions::fSkipGLErrorChecks. That option may prevent GrContext from ever
+ * checking the GL context for OOM.
+ *
+ * Vulkan - Reports true if VK_ERROR_OUT_OF_HOST_MEMORY or VK_ERROR_OUT_OF_DEVICE_MEMORY has
+ * occurred.
+ */
+ bool oomed();
+
+ /**
+ * This is similar to abandonContext() however the underlying 3D context is not yet lost and
+ * the GrContext will cleanup all allocated resources before returning. After returning it will
+ * assume that the underlying context may no longer be valid.
+ *
+ * The typical use case for this function is that the client is going to destroy the 3D context
+ * but can't guarantee that GrContext will be destroyed first (perhaps because it may be ref'ed
+ * elsewhere by either the client or Skia objects).
+ *
+ * For Vulkan, even if the device becomes lost, the VkQueue, VkDevice, or VkInstance used to
+ * create the GrContext must be alive before calling releaseResourcesAndAbandonContext.
+ */
+ virtual void releaseResourcesAndAbandonContext();
+
+ ///////////////////////////////////////////////////////////////////////////
+ // Resource Cache
+
+ /** DEPRECATED
+ * Return the current GPU resource cache limits.
+ *
+ * @param maxResources If non-null, will be set to -1.
+ * @param maxResourceBytes If non-null, returns maximum number of bytes of
+ * video memory that can be held in the cache.
+ */
+ void getResourceCacheLimits(int* maxResources, size_t* maxResourceBytes) const;
+
+ /**
+ * Return the current GPU resource cache limit in bytes.
+ */
+ size_t getResourceCacheLimit() const;
+
+ /**
+ * Gets the current GPU resource cache usage.
+ *
+ * @param resourceCount If non-null, returns the number of resources that are held in the
+ * cache.
+ * @param maxResourceBytes If non-null, returns the total number of bytes of video memory held
+ * in the cache.
+ */
+ void getResourceCacheUsage(int* resourceCount, size_t* resourceBytes) const;
+
+ /**
+ * Gets the number of bytes in the cache consumed by purgeable (e.g. unlocked) resources.
+ */
+ size_t getResourceCachePurgeableBytes() const;
+
+ /** DEPRECATED
+ * Specify the GPU resource cache limits. If the current cache exceeds the maxResourceBytes
+ * limit, it will be purged (LRU) to keep the cache within the limit.
+ *
+ * @param maxResources Unused.
+ * @param maxResourceBytes The maximum number of bytes of video memory
+ * that can be held in the cache.
+ */
+ void setResourceCacheLimits(int maxResources, size_t maxResourceBytes);
+
+ /**
+ * Specify the GPU resource cache limit. If the cache currently exceeds this limit,
+ * it will be purged (LRU) to keep the cache within the limit.
+ *
+ * @param maxResourceBytes The maximum number of bytes of video memory
+ * that can be held in the cache.
+ */
+ void setResourceCacheLimit(size_t maxResourceBytes);
+
+ /**
+ * Frees GPU created by the context. Can be called to reduce GPU memory
+ * pressure.
+ */
+ virtual void freeGpuResources();
+
+ /**
+ * Purge GPU resources that haven't been used in the past 'msNotUsed' milliseconds or are
+ * otherwise marked for deletion, regardless of whether the context is under budget.
+ */
+ void performDeferredCleanup(std::chrono::milliseconds msNotUsed);
+
+ // Temporary compatibility API for Android.
+ void purgeResourcesNotUsedInMs(std::chrono::milliseconds msNotUsed) {
+ this->performDeferredCleanup(msNotUsed);
+ }
+
+ /**
+ * Purge unlocked resources from the cache until the the provided byte count has been reached
+ * or we have purged all unlocked resources. The default policy is to purge in LRU order, but
+ * can be overridden to prefer purging scratch resources (in LRU order) prior to purging other
+ * resource types.
+ *
+ * @param maxBytesToPurge the desired number of bytes to be purged.
+ * @param preferScratchResources If true scratch resources will be purged prior to other
+ * resource types.
+ */
+ void purgeUnlockedResources(size_t bytesToPurge, bool preferScratchResources);
+
+ /**
+ * This entry point is intended for instances where an app has been backgrounded or
+ * suspended.
+ * If 'scratchResourcesOnly' is true all unlocked scratch resources will be purged but the
+ * unlocked resources with persistent data will remain. If 'scratchResourcesOnly' is false
+ * then all unlocked resources will be purged.
+ * In either case, after the unlocked resources are purged a separate pass will be made to
+ * ensure that resource usage is under budget (i.e., even if 'scratchResourcesOnly' is true
+ * some resources with persistent data may be purged to be under budget).
+ *
+ * @param scratchResourcesOnly If true only unlocked scratch resources will be purged prior
+ * enforcing the budget requirements.
+ */
+ void purgeUnlockedResources(bool scratchResourcesOnly);
+
+ /**
+ * Gets the maximum supported texture size.
+ */
+ using GrRecordingContext::maxTextureSize;
+
+ /**
+ * Gets the maximum supported render target size.
+ */
+ using GrRecordingContext::maxRenderTargetSize;
+
+ /**
+ * Can a SkImage be created with the given color type.
+ */
+ using GrRecordingContext::colorTypeSupportedAsImage;
+
+ /**
+ * Can a SkSurface be created with the given color type. To check whether MSAA is supported
+ * use maxSurfaceSampleCountForColorType().
+ */
+ using GrRecordingContext::colorTypeSupportedAsSurface;
+
+ /**
+ * 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.
+ */
+ using GrRecordingContext::maxSurfaceSampleCountForColorType;
+
+ ///////////////////////////////////////////////////////////////////////////
+ // Misc.
+
+ /**
+ * Inserts a list of GPU semaphores that the current GPU-backed API must wait on before
+ * executing any more commands on the GPU. 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.
+ */
+ bool wait(int numSemaphores, const GrBackendSemaphore* waitSemaphores,
+ bool deleteSemaphoresAfterWait = true);
+
+ /**
+ * Call to ensure all drawing to the context has been flushed and submitted to the underlying 3D
+ * API. This is equivalent to calling GrContext::flush with a default GrFlushInfo followed by
+ * GrContext::submit.
+ */
+ void flushAndSubmit() {
+ this->flush(GrFlushInfo());
+ this->submit();
+ }
+
+ /**
+ * Call to ensure all drawing to the context has been flushed to underlying 3D API specific
+ * objects. A call to GrContext::submit is always required to ensure work is actually sent to
+ * the gpu. Some specific API details:
+ * GL: Commands are actually sent to the driver, but glFlush is never called. Thus some
+ * sync objects from the flush will not be valid until a submission occurs.
+ *
+ * Vulkan/Metal/D3D/Dawn: Commands are recorded to the backend APIs corresponding command
+ * buffer or encoder objects. However, these objects are not sent to the gpu until a
+ * submission occurs.
+ *
+ * If the return is GrSemaphoresSubmitted::kYes, only initialized GrBackendSemaphores will be
+ * submitted to the gpu during the next submit call (it is possible Skia failed to create a
+ * subset of the semaphores). The client should not wait on these semaphores until after submit
+ * has been called, and must keep them alive until then. If this call returns
+ * GrSemaphoresSubmitted::kNo, the GPU backend will not submit any semaphores to be signaled on
+ * the GPU. Thus the client should not have the GPU wait on any of the semaphores passed in with
+ * the GrFlushInfo. Regardless of whether semaphores were submitted to the GPU or not, the
+ * client is still responsible for deleting any initialized semaphores.
+ * Regardleess of semaphore submission the context will still be flushed. It should be
+ * emphasized that a return value of GrSemaphoresSubmitted::kNo does not mean the flush did not
+ * happen. It simply means there were no semaphores submitted to the GPU. A caller should only
+ * take this as a failure if they passed in semaphores to be submitted.
+ */
+ GrSemaphoresSubmitted flush(const GrFlushInfo& info);
+
+ void flush() { this->flush({}); }
+
+ /**
+ * Submit outstanding work to the gpu from all previously un-submitted flushes. The return
+ * value of the submit will indicate whether or not the submission to the GPU was successful.
+ *
+ * If the call returns true, all previously passed in semaphores in flush calls will have been
+ * submitted to the GPU and they can safely be waited on. The caller should wait on those
+ * semaphores or perform some other global synchronization before deleting the semaphores.
+ *
+ * If it returns false, then those same semaphores will not have been submitted and we will not
+ * try to submit them again. The caller is free to delete the semaphores at any time.
+ *
+ * If the syncCpu flag is true this function will return once the gpu has finished with all
+ * submitted work.
+ */
+ bool submit(bool syncCpu = false);
+
+ /**
+ * Checks whether any asynchronous work is complete and if so calls related callbacks.
+ */
+ void checkAsyncWorkCompletion();
+
+ // Provides access to functions that aren't part of the public API.
+ GrContextPriv priv();
+ const GrContextPriv priv() const; // NOLINT(readability-const-return-type)
+
+ /** Enumerates all cached GPU resources and dumps their memory to traceMemoryDump. */
+ // Chrome is using this!
+ void dumpMemoryStatistics(SkTraceMemoryDump* traceMemoryDump) const;
+
+ bool supportsDistanceFieldText() const;
+
+ void storeVkPipelineCacheData();
+
+ // Returns the gpu memory size of the the texture that backs the passed in SkImage. Returns 0 if
+ // the SkImage is not texture backed. For external format textures this will also return 0 as we
+ // cannot determine the correct size.
+ static size_t ComputeImageSize(sk_sp<SkImage> image, GrMipmapped, bool useNextPow2 = 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 {
+ return INHERITED::defaultBackendFormat(ct, renderable);
+ }
+
+ /**
+ * The explicitly allocated backend texture API allows clients to use Skia to create backend
+ * objects outside of Skia proper (i.e., Skia's caching system will not know about them.)
+ *
+ * It is the client's responsibility to delete all these objects (using deleteBackendTexture)
+ * before deleting the GrContext used to create them. If the backend is Vulkan, the textures must
+ * be deleted before abandoning the GrContext as well. Additionally, clients should only delete
+ * these objects on the thread for which that GrContext is active.
+ *
+ * The client is responsible for ensuring synchronization between different uses
+ * of the backend object (i.e., wrapping it in a surface, rendering to it, deleting the
+ * surface, rewrapping it in a image and drawing the image will require explicit
+ * sychronization on the client's part).
+ */
+
+ /**
+ * If possible, create an uninitialized backend texture. The client should ensure that the
+ * returned backend texture is valid.
+ * For the Vulkan backend the layout of the created VkImage will be:
+ * VK_IMAGE_LAYOUT_UNDEFINED.
+ */
+ GrBackendTexture createBackendTexture(int width, int height,
+ const GrBackendFormat&,
+ GrMipmapped,
+ GrRenderable,
+ GrProtected = GrProtected::kNo);
+
+ /**
+ * If possible, create an uninitialized backend texture. The client should ensure that the
+ * returned backend texture is valid.
+ * If successful, the created backend texture will be compatible with the provided
+ * SkColorType.
+ * For the Vulkan backend the layout of the created VkImage will be:
+ * VK_IMAGE_LAYOUT_UNDEFINED.
+ */
+ GrBackendTexture createBackendTexture(int width, int height,
+ SkColorType,
+ GrMipmapped,
+ GrRenderable,
+ GrProtected = GrProtected::kNo);
+
+ /**
+ * If possible, create a backend texture initialized to a particular color. The client should
+ * ensure that the returned backend texture is valid. The client can pass in a finishedProc
+ * to be notified when the data has been uploaded by the gpu and the texture can be deleted. The
+ * client is required to call GrContext::submit to send the upload work to the gpu. The
+ * finishedProc will always get called even if we failed to create the GrBackendTexture.
+ * For the Vulkan backend the layout of the created VkImage will be:
+ * VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
+ */
+ GrBackendTexture createBackendTexture(int width, int height,
+ const GrBackendFormat&,
+ const SkColor4f& color,
+ GrMipmapped,
+ GrRenderable,
+ GrProtected = GrProtected::kNo,
+ GrGpuFinishedProc finishedProc = nullptr,
+ GrGpuFinishedContext finishedContext = nullptr);
+
+ /**
+ * If possible, create a backend texture initialized to a particular color. The client should
+ * ensure that the returned backend texture is valid. The client can pass in a finishedProc
+ * to be notified when the data has been uploaded by the gpu and the texture can be deleted. The
+ * client is required to call GrContext::submit to send the upload work to the gpu. The
+ * finishedProc will always get called even if we failed to create the GrBackendTexture.
+ * If successful, the created backend texture will be compatible with the provided
+ * SkColorType.
+ * For the Vulkan backend the layout of the created VkImage will be:
+ * VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
+ */
+ GrBackendTexture createBackendTexture(int width, int height,
+ SkColorType,
+ const SkColor4f& color,
+ GrMipmapped,
+ GrRenderable,
+ GrProtected = GrProtected::kNo,
+ GrGpuFinishedProc finishedProc = nullptr,
+ GrGpuFinishedContext finishedContext = nullptr);
+
+ /**
+ * If possible, create a backend texture initialized with the provided pixmap data. The client
+ * should ensure that the returned backend texture is valid. The client can pass in a
+ * finishedProc to be notified when the data has been uploaded by the gpu and the texture can be
+ * deleted. The client is required to call GrContext::submit to send the upload work to the gpu.
+ * The finishedProc will always get called even if we failed to create the GrBackendTexture.
+ * If successful, the created backend texture will be compatible with the provided
+ * pixmap(s). Compatible, in this case, means that the backend format will be the result
+ * of calling defaultBackendFormat on the base pixmap's colortype. The src data can be deleted
+ * when this call returns.
+ * If numLevels is 1 a non-mipMapped texture will result. If a mipMapped texture is desired
+ * the data for all the mipmap levels must be provided. In the mipmapped case all the
+ * colortypes of the provided pixmaps must be the same. Additionally, all the miplevels
+ * must be sized correctly (please see SkMipmap::ComputeLevelSize and ComputeLevelCount).
+ * Note: the pixmap's alphatypes and colorspaces are ignored.
+ * For the Vulkan backend the layout of the created VkImage will be:
+ * VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
+ */
+ GrBackendTexture createBackendTexture(const SkPixmap srcData[], int numLevels,
+ GrRenderable, GrProtected,
+ GrGpuFinishedProc finishedProc = nullptr,
+ GrGpuFinishedContext finishedContext = nullptr);
+
+ // Helper version of above for a single level.
+ GrBackendTexture createBackendTexture(const SkPixmap& srcData,
+ GrRenderable renderable,
+ GrProtected isProtected,
+ GrGpuFinishedProc finishedProc = nullptr,
+ GrGpuFinishedContext finishedContext = nullptr) {
+ return this->createBackendTexture(&srcData, 1, renderable, isProtected, finishedProc,
+ finishedContext);
+ }
+
+ /**
+ * If possible, updates a backend texture to be filled to a particular color. The client should
+ * check the return value to see if the update was successful. The client can pass in a
+ * finishedProc to be notified when the data has been uploaded by the gpu and the texture can be
+ * deleted. The client is required to call GrContext::submit to send the upload work to the gpu.
+ * The finishedProc will always get called even if we failed to update the GrBackendTexture.
+ * For the Vulkan backend after a successful update the layout of the created VkImage will be:
+ * VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
+ */
+ bool updateBackendTexture(const GrBackendTexture&,
+ const SkColor4f& color,
+ GrGpuFinishedProc finishedProc,
+ GrGpuFinishedContext finishedContext);
+
+ /**
+ * If possible, updates a backend texture to be filled to a particular color. The data in
+ * GrBackendTexture and passed in color is interpreted with respect to the passed in
+ * SkColorType. The client should check the return value to see if the update was successful.
+ * The client can pass in a finishedProc to be notified when the data has been uploaded by the
+ * gpu and the texture can be deleted. The client is required to call GrContext::submit to send
+ * the upload work to the gpu. The finishedProc will always get called even if we failed to
+ * update the GrBackendTexture.
+ * For the Vulkan backend after a successful update the layout of the created VkImage will be:
+ * VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
+ */
+ bool updateBackendTexture(const GrBackendTexture&,
+ SkColorType skColorType,
+ const SkColor4f& color,
+ GrGpuFinishedProc finishedProc,
+ GrGpuFinishedContext finishedContext);
+
+ /**
+ * If possible, updates a backend texture filled with the provided pixmap data. The client
+ * should check the return value to see if the update was successful. The client can pass in a
+ * finishedProc to be notified when the data has been uploaded by the gpu and the texture can be
+ * deleted. The client is required to call GrContext::submit to send the upload work to the gpu.
+ * The finishedProc will always get called even if we failed to create the GrBackendTexture.
+ * The backend texture must be compatible with the provided pixmap(s). Compatible, in this case,
+ * means that the backend format is compatible with the base pixmap's colortype. The src data
+ * can be deleted when this call returns.
+ * If the backend texture is mip mapped, the data for all the mipmap levels must be provided.
+ * In the mipmapped case all the colortypes of the provided pixmaps must be the same.
+ * Additionally, all the miplevels must be sized correctly (please see
+ * SkMipmap::ComputeLevelSize and ComputeLevelCount).
+ * Note: the pixmap's alphatypes and colorspaces are ignored.
+ * For the Vulkan backend after a successful update the layout of the created VkImage will be:
+ * VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
+ */
+ bool updateBackendTexture(const GrBackendTexture&,
+ const SkPixmap srcData[],
+ int numLevels,
+ GrGpuFinishedProc finishedProc,
+ GrGpuFinishedContext finishedContext);
+
+ /**
+ * Retrieve the GrBackendFormat for a given SkImage::CompressionType. This is
+ * guaranteed to match the backend format used by the following
+ * createCompressedsBackendTexture methods that take a CompressionType.
+ * The caller should check that the returned format is valid.
+ */
+ GrBackendFormat compressedBackendFormat(SkImage::CompressionType compression) const {
+ return INHERITED::compressedBackendFormat(compression);
+ }
+
+ /**
+ *If possible, create a compressed backend texture initialized to a particular color. The
+ * client should ensure that the returned backend texture is valid. The client can pass in a
+ * finishedProc to be notified when the data has been uploaded by the gpu and the texture can be
+ * deleted. The client is required to call GrContext::submit to send the upload work to the gpu.
+ * The finishedProc will always get called even if we failed to create the GrBackendTexture.
+ * For the Vulkan backend the layout of the created VkImage will be:
+ * VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
+ */
+ GrBackendTexture createCompressedBackendTexture(int width, int height,
+ const GrBackendFormat&,
+ const SkColor4f& color,
+ GrMipmapped,
+ GrProtected = GrProtected::kNo,
+ GrGpuFinishedProc finishedProc = nullptr,
+ GrGpuFinishedContext finishedContext = nullptr);
+
+ GrBackendTexture createCompressedBackendTexture(int width, int height,
+ SkImage::CompressionType,
+ const SkColor4f& color,
+ GrMipmapped,
+ GrProtected = GrProtected::kNo,
+ GrGpuFinishedProc finishedProc = nullptr,
+ GrGpuFinishedContext finishedContext = nullptr);
+
+ /**
+ * If possible, create a backend texture initialized with the provided raw data. The client
+ * should ensure that the returned backend texture is valid. The client can pass in a
+ * finishedProc to be notified when the data has been uploaded by the gpu and the texture can be
+ * deleted. The client is required to call GrContext::submit to send the upload work to the gpu.
+ * The finishedProc will always get called even if we failed to create the GrBackendTexture
+ * If numLevels is 1 a non-mipMapped texture will result. If a mipMapped texture is desired
+ * the data for all the mipmap levels must be provided. Additionally, all the miplevels
+ * must be sized correctly (please see SkMipmap::ComputeLevelSize and ComputeLevelCount).
+ * For the Vulkan backend the layout of the created VkImage will be:
+ * VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
+ */
+ GrBackendTexture createCompressedBackendTexture(int width, int height,
+ const GrBackendFormat&,
+ const void* data, size_t dataSize,
+ GrMipmapped,
+ GrProtected = GrProtected::kNo,
+ GrGpuFinishedProc finishedProc = nullptr,
+ GrGpuFinishedContext finishedContext = nullptr);
+
+ GrBackendTexture createCompressedBackendTexture(int width, int height,
+ SkImage::CompressionType,
+ const void* data, size_t dataSize,
+ GrMipmapped,
+ GrProtected = GrProtected::kNo,
+ GrGpuFinishedProc finishedProc = nullptr,
+ GrGpuFinishedContext finishedContext = nullptr);
+
+ /**
+ * If possible, updates a backend texture filled with the provided color. If the texture is
+ * mipmapped, all levels of the mip chain will be updated to have the supplied color. The client
+ * should check the return value to see if the update was successful. The client can pass in a
+ * finishedProc to be notified when the data has been uploaded by the gpu and the texture can be
+ * deleted. The client is required to call GrContext::submit to send the upload work to the gpu.
+ * The finishedProc will always get called even if we failed to create the GrBackendTexture.
+ * For the Vulkan backend after a successful update the layout of the created VkImage will be:
+ * VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
+ */
+ bool updateCompressedBackendTexture(const GrBackendTexture&,
+ const SkColor4f& color,
+ GrGpuFinishedProc finishedProc,
+ GrGpuFinishedContext finishedContext);
+
+ /**
+ * If possible, updates a backend texture filled with the provided raw data. The client
+ * should check the return value to see if the update was successful. The client can pass in a
+ * finishedProc to be notified when the data has been uploaded by the gpu and the texture can be
+ * deleted. The client is required to call GrContext::submit to send the upload work to the gpu.
+ * The finishedProc will always get called even if we failed to create the GrBackendTexture.
+ * If a mipMapped texture is passed in, the data for all the mipmap levels must be provided.
+ * Additionally, all the miplevels must be sized correctly (please see
+ * SkMipMap::ComputeLevelSize and ComputeLevelCount).
+ * For the Vulkan backend after a successful update the layout of the created VkImage will be:
+ * VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
+ */
+ bool updateCompressedBackendTexture(const GrBackendTexture&,
+ const void* data,
+ size_t dataSize,
+ GrGpuFinishedProc finishedProc,
+ GrGpuFinishedContext finishedContext);
+
+ /**
+ * Updates the state of the GrBackendTexture/RenderTarget to have the passed in
+ * GrBackendSurfaceMutableState. All objects that wrap the backend surface (i.e. SkSurfaces and
+ * SkImages) will also be aware of this state change. This call does not submit the state change
+ * to the gpu, but requires the client to call GrContext::submit to send it to the GPU. The work
+ * for this call is ordered linearly with all other calls that require GrContext::submit to be
+ * called (e.g updateBackendTexture and flush). If finishedProc is not null then it will be
+ * called with finishedContext after the state transition is known to have occurred on the GPU.
+ *
+ * See GrBackendSurfaceMutableState to see what state can be set via this call.
+ *
+ * If the backend API is Vulkan, the caller can set the GrBackendSurfaceMutableState's
+ * VkImageLayout to VK_IMAGE_LAYOUT_UNDEFINED or queueFamilyIndex to VK_QUEUE_FAMILY_IGNORED to
+ * tell Skia to not change those respective states.
+ *
+ * If previousState is not null and this returns true, then Skia will have filled in
+ * previousState to have the values of the state before this call.
+ */
+ bool setBackendTextureState(const GrBackendTexture&,
+ const GrBackendSurfaceMutableState&,
+ GrBackendSurfaceMutableState* previousState = nullptr,
+ GrGpuFinishedProc finishedProc = nullptr,
+ GrGpuFinishedContext finishedContext = nullptr);
+ bool setBackendRenderTargetState(const GrBackendRenderTarget&,
+ const GrBackendSurfaceMutableState&,
+ GrBackendSurfaceMutableState* previousState = nullptr,
+ GrGpuFinishedProc finishedProc = nullptr,
+ GrGpuFinishedContext finishedContext = nullptr);
+
+ void deleteBackendTexture(GrBackendTexture);
+
+ // This interface allows clients to pre-compile shaders and populate the runtime program cache.
+ // The key and data blobs should be the ones passed to the PersistentCache, in SkSL format.
+ //
+ // Steps to use this API:
+ //
+ // 1) Create a GrContext as normal, but set fPersistentCache on GrContextOptions to something
+ // that will save the cached shader blobs. Set fShaderCacheStrategy to kSkSL. This will
+ // ensure that the blobs are SkSL, and are suitable for pre-compilation.
+ // 2) Run your application, and save all of the key/data pairs that are fed to the cache.
+ //
+ // 3) Switch over to shipping your application. Include the key/data pairs from above.
+ // 4) At startup (or any convenient time), call precompileShader for each key/data pair.
+ // This will compile the SkSL to create a GL program, and populate the runtime cache.
+ //
+ // This is only guaranteed to work if the context/device used in step #2 are created in the
+ // same way as the one used in step #4, and the same GrContextOptions are specified.
+ // Using cached shader blobs on a different device or driver are undefined.
+ bool precompileShader(const SkData& key, const SkData& data);
+
+#ifdef SK_ENABLE_DUMP_GPU
+ /** Returns a string with detailed information about the context & GPU, in JSON format. */
+ SkString dump() const;
+#endif
+
+protected:
+ GrContext(sk_sp<GrContextThreadSafeProxy>);
+
+ bool init() override;
+
+ virtual GrAtlasManager* onGetAtlasManager() = 0;
+ virtual GrSmallPathAtlasMgr* onGetSmallPathAtlasMgr() = 0;
+
+private:
+ friend class GrDirectContext; // for access to fGpu
+
+ // fTaskGroup must appear before anything that uses it (e.g. fGpu), so that it is destroyed
+ // after all of its users. Clients of fTaskGroup will generally want to ensure that they call
+ // wait() on it as they are being destroyed, to avoid the possibility of pending tasks being
+ // invoked after objects they depend upon have already been destroyed.
+ std::unique_ptr<SkTaskGroup> fTaskGroup;
+ std::unique_ptr<GrStrikeCache> fStrikeCache;
+ sk_sp<GrGpu> fGpu;
+ GrResourceCache* fResourceCache;
+ GrResourceProvider* fResourceProvider;
+
+ bool fDidTestPMConversions;
+ // true if the PM/UPM conversion succeeded; false otherwise
+ bool fPMUPMConversionsRoundTrip;
+
+ GrContextOptions::PersistentCache* fPersistentCache;
+ GrContextOptions::ShaderErrorHandler* fShaderErrorHandler;
+
+ std::unique_ptr<GrClientMappedBufferManager> fMappedBufferManager;
+
+ // TODO: have the GrClipStackClip use renderTargetContexts and rm this friending
+ friend class GrContextPriv;
+
+ using INHERITED = GrRecordingContext;
+};
+
+#endif
diff --git a/include/gpu/GrDirectContext.h b/include/gpu/GrDirectContext.h
index ccaa2fc..a37bf0b 100644
--- a/include/gpu/GrDirectContext.h
+++ b/include/gpu/GrDirectContext.h
@@ -8,7 +8,7 @@
#ifndef GrDirectContext_DEFINED
#define GrDirectContext_DEFINED
-#include "include/private/GrContext.h"
+#include "include/gpu/GrContext.h"
class GrAtlasManager;
class GrSmallPathAtlasMgr;