@shopify/react-native-skia 0.1.212 → 0.1.214

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

@@ -62,7 +62,7 @@ enum class BackendSurfaceAccess;
 
 class SK_API GrDirectContext : public GrRecordingContext {
 public:
-#ifdef SK_GL
+#if defined(SK_GL) && !defined(SK_DISABLE_LEGACY_GL_GRDIRECTCONTEXT_FACTORIES)
     /**
      * Creates a GrDirectContext for a backend context. If no GrGLInterface is provided then the
      * result of GrGLMakeNativeInterface() is used if it succeeds.
@@ -116,12 +116,6 @@ public:
     static sk_sp<GrDirectContext> MakeDirect3D(const GrD3DBackendContext&);
 #endif
 
-#ifdef SK_DAWN
-    static sk_sp<GrDirectContext> MakeDawn(const wgpu::Device&,
-                                           const GrContextOptions&);
-    static sk_sp<GrDirectContext> MakeDawn(const wgpu::Device&);
-#endif
-
     static sk_sp<GrDirectContext> MakeMock(const GrMockOptions*, const GrContextOptions&);
     static sk_sp<GrDirectContext> MakeMock(const GrMockOptions*);
 
@@ -171,13 +165,20 @@ public:
     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
+     * Returns true if the context was abandoned or 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 this
      * context.
      */
     bool abandoned() override;
 
+    /**
+     * Returns true 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 this context.
+     */
+    bool isDeviceLost();
+
     // TODO: Remove this from public after migrating Chrome.
     sk_sp<GrContextThreadSafeProxy> threadSafeProxy();
 
@@ -272,18 +273,19 @@ public:
     /**
      * 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.
+
      *
-     * If 'scratchResourcesOnly' is true all unlocked scratch resources older than 'msNotUsed' will
-     * be purged but the unlocked resources with persistent data will remain. If
-     * 'scratchResourcesOnly' is false then all unlocked resources older than 'msNotUsed' will be
-     * purged.
-     *
-     * @param msNotUsed              Only unlocked resources not used in these last milliseconds
-     *                               will be cleaned up.
-     * @param scratchResourcesOnly   If true only unlocked scratch resources will be purged.
+     * @param msNotUsed   Only unlocked resources not used in these last milliseconds will be
+     *                    cleaned up.
+     * @param opts        Specify which resources should be cleaned up. If kScratchResourcesOnly
+     *                    then, all unlocked scratch resources older than 'msNotUsed' will be purged
+     *                    but the unlocked resources with persistent data will remain. If
+     *                    kAllResources
      */
-    void performDeferredCleanup(std::chrono::milliseconds msNotUsed,
-                                bool scratchResourcesOnly=false);
+
+    void performDeferredCleanup(
+            std::chrono::milliseconds msNotUsed,
+            GrPurgeResourceOptions opts = GrPurgeResourceOptions::kAllResources);
 
     // Temporary compatibility API for Android.
     void purgeResourcesNotUsedInMs(std::chrono::milliseconds msNotUsed) {
@@ -312,10 +314,10 @@ public:
      * 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.
+     * @param opts If kScratchResourcesOnly only unlocked scratch resources will be purged prior
+     *             enforcing the budget requirements.
      */
-    void purgeUnlockedResources(bool scratchResourcesOnly);
+    void purgeUnlockedResources(GrPurgeResourceOptions opts);
 
     /**
      * Gets the maximum supported texture size.
@@ -332,6 +334,11 @@ public:
      */
     using GrRecordingContext::colorTypeSupportedAsImage;
 
+    /**
+     * Does this context support protected content?
+     */
+    using GrRecordingContext::supportsProtectedContent;
+
     /**
      * Can a SkSurface be created with the given color type. To check whether MSAA is supported
      * use maxSurfaceSampleCountForColorType().
@@ -365,11 +372,11 @@ public:
     /**
      * 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(syncCpu).
+     * GrContext::submit(sync).
      */
-    void flushAndSubmit(bool syncCpu = false) {
+    void flushAndSubmit(GrSyncCpu sync = GrSyncCpu::kNo) {
         this->flush(GrFlushInfo());
-        this->submit(syncCpu);
+        this->submit(sync);
     }
 
     /**
@@ -391,7 +398,7 @@ public:
      * 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
+     * Regardless 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.
@@ -462,9 +469,6 @@ public:
      *  @param access  type of access the call will do on the backend object after flush
      *  @param info    flush options
      */
-    GrSemaphoresSubmitted flush(sk_sp<SkSurface> surface,
-                                SkSurfaces::BackendSurfaceAccess access,
-                                const GrFlushInfo& info);
     GrSemaphoresSubmitted flush(SkSurface* surface,
                                 SkSurfaces::BackendSurfaceAccess access,
                                 const GrFlushInfo& info);
@@ -488,9 +492,6 @@ public:
      *  @param info     flush options
      *  @param newState optional state change request after flush
      */
-    GrSemaphoresSubmitted flush(sk_sp<SkSurface> surface,
-                                const GrFlushInfo& info,
-                                const skgpu::MutableTextureState* newState = nullptr);
     GrSemaphoresSubmitted flush(SkSurface* surface,
                                 const GrFlushInfo& info,
                                 const skgpu::MutableTextureState* newState = nullptr);
@@ -503,14 +504,14 @@ public:
      *
      *  Has no effect on a CPU-backed surface.
      */
-    void flushAndSubmit(sk_sp<SkSurface> surface, bool syncCpu = false);
+    void flushAndSubmit(SkSurface* surface, GrSyncCpu sync = GrSyncCpu::kNo);
 
     /**
      * Flushes the given surface with the default GrFlushInfo.
      *
      *  Has no effect on a CPU-backed surface.
      */
-    void flush(sk_sp<SkSurface> surface);
+    void flush(SkSurface* surface);
 
     /**
      * Submit outstanding work to the gpu from all previously un-submitted flushes. The return
@@ -523,10 +524,10 @@ public:
      * 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
+     * If sync flag is GrSyncCpu::kYes, this function will return once the gpu has finished with all
      * submitted work.
      */
-    bool submit(bool syncCpu = false);
+    bool submit(GrSyncCpu sync = GrSyncCpu::kNo);
 
     /**
      * Checks whether any asynchronous work is complete and if so calls related callbacks.
@@ -574,93 +575,96 @@ public:
     GrBackendTexture createBackendTexture(int width,
                                           int height,
                                           const GrBackendFormat&,
-                                          GrMipmapped,
+                                          skgpu::Mipmapped,
                                           GrRenderable,
                                           GrProtected = GrProtected::kNo,
                                           std::string_view label = {});
 
-     /**
-      * 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,
-                                           std::string_view label = {});
+    /**
+     * 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,
+                                          skgpu::Mipmapped,
+                                          GrRenderable,
+                                          GrProtected = GrProtected::kNo,
+                                          std::string_view label = {});
 
-     /**
-      * 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 `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,
-                                           std::string_view label = {});
+    /**
+     * 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 `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,
+                                          skgpu::Mipmapped,
+                                          GrRenderable,
+                                          GrProtected = GrProtected::kNo,
+                                          GrGpuFinishedProc finishedProc = nullptr,
+                                          GrGpuFinishedContext finishedContext = nullptr,
+                                          std::string_view label = {});
 
-     /**
-      * 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 `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,
-                                           std::string_view label = {});
+    /**
+     * 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 `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,
+                                          skgpu::Mipmapped,
+                                          GrRenderable,
+                                          GrProtected = GrProtected::kNo,
+                                          GrGpuFinishedProc finishedProc = nullptr,
+                                          GrGpuFinishedContext finishedContext = nullptr,
+                                          std::string_view label = {});
 
-     /**
-      * 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 `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). The
-      * GrSurfaceOrigin controls whether the pixmap data is vertically flipped in the texture.
-      * 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,
-                                           GrSurfaceOrigin,
-                                           GrRenderable,
-                                           GrProtected,
-                                           GrGpuFinishedProc finishedProc = nullptr,
-                                           GrGpuFinishedContext finishedContext = nullptr,
-                                           std::string_view label = {});
+    /**
+     * 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 `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). The
+     * GrSurfaceOrigin controls whether the pixmap data is vertically flipped in the texture.
+     * 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,
+                                          GrSurfaceOrigin,
+                                          GrRenderable,
+                                          GrProtected,
+                                          GrGpuFinishedProc finishedProc = nullptr,
+                                          GrGpuFinishedContext finishedContext = nullptr,
+                                          std::string_view label = {});
 
     /**
      * Convenience version createBackendTexture() that takes just a base level pixmap.
@@ -786,18 +790,20 @@ public:
      * 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,
+    GrBackendTexture createCompressedBackendTexture(int width,
+                                                    int height,
                                                     const GrBackendFormat&,
                                                     const SkColor4f& color,
-                                                    GrMipmapped,
+                                                    skgpu::Mipmapped,
                                                     GrProtected = GrProtected::kNo,
                                                     GrGpuFinishedProc finishedProc = nullptr,
                                                     GrGpuFinishedContext finishedContext = nullptr);
 
-    GrBackendTexture createCompressedBackendTexture(int width, int height,
+    GrBackendTexture createCompressedBackendTexture(int width,
+                                                    int height,
                                                     SkTextureCompressionType,
                                                     const SkColor4f& color,
-                                                    GrMipmapped,
+                                                    skgpu::Mipmapped,
                                                     GrProtected = GrProtected::kNo,
                                                     GrGpuFinishedProc finishedProc = nullptr,
                                                     GrGpuFinishedContext finishedContext = nullptr);
@@ -814,18 +820,22 @@ public:
      * 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,
+    GrBackendTexture createCompressedBackendTexture(int width,
+                                                    int height,
                                                     const GrBackendFormat&,
-                                                    const void* data, size_t dataSize,
-                                                    GrMipmapped,
+                                                    const void* data,
+                                                    size_t dataSize,
+                                                    skgpu::Mipmapped,
                                                     GrProtected = GrProtected::kNo,
                                                     GrGpuFinishedProc finishedProc = nullptr,
                                                     GrGpuFinishedContext finishedContext = nullptr);
 
-    GrBackendTexture createCompressedBackendTexture(int width, int height,
+    GrBackendTexture createCompressedBackendTexture(int width,
+                                                    int height,
                                                     SkTextureCompressionType,
-                                                    const void* data, size_t dataSize,
-                                                    GrMipmapped,
+                                                    const void* data,
+                                                    size_t dataSize,
+                                                    skgpu::Mipmapped,
                                                     GrProtected = GrProtected::kNo,
                                                     GrGpuFinishedProc finishedProc = nullptr,
                                                     GrGpuFinishedContext finishedContext = nullptr);
@@ -892,7 +902,7 @@ public:
                                      GrGpuFinishedProc finishedProc = nullptr,
                                      GrGpuFinishedContext finishedContext = nullptr);
 
-    void deleteBackendTexture(GrBackendTexture);
+    void deleteBackendTexture(const 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.
@@ -996,7 +1006,7 @@ private:
     // invoked after objects they depend upon have already been destroyed.
     std::unique_ptr<SkTaskGroup>              fTaskGroup;
     std::unique_ptr<sktext::gpu::StrikeCache> fStrikeCache;
-    sk_sp<GrGpu>                              fGpu;
+    std::unique_ptr<GrGpu>                    fGpu;
     std::unique_ptr<GrResourceCache>          fResourceCache;
     std::unique_ptr<GrResourceProvider>       fResourceProvider;
 

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

@@ -83,6 +83,11 @@ public:
      */
     SK_API bool colorTypeSupportedAsImage(SkColorType) const;
 
+    /**
+     * Does this context support protected content?
+     */
+    SK_API bool supportsProtectedContent() const;
+
     /**
      * Gets the maximum supported sample count for a color type. 1 is returned if only non-MSAA
      * rendering is supported for the color type. 0 is returned if rendering to this color type
@@ -215,7 +220,7 @@ protected:
         int numPathMaskCacheHits() const { return fNumPathMaskCacheHits; }
         void incNumPathMasksCacheHits() { fNumPathMaskCacheHits++; }
 
-#if GR_TEST_UTILS
+#if defined(GR_TEST_UTILS)
         void dump(SkString* out) const;
         void dumpKeyValuePairs(skia_private::TArray<SkString>* keys,
                                skia_private::TArray<double>* values) const;
@@ -229,7 +234,7 @@ protected:
         void incNumPathMasksGenerated() {}
         void incNumPathMasksCacheHits() {}
 
-#if GR_TEST_UTILS
+#if defined(GR_TEST_UTILS)
         void dump(SkString*) const {}
         void dumpKeyValuePairs(skia_private::TArray<SkString>* keys,
                                skia_private::TArray<double>* values) const {}
@@ -237,7 +242,7 @@ protected:
 #endif // GR_GPU_STATS
     } fStats;
 
-#if GR_GPU_STATS && GR_TEST_UTILS
+#if GR_GPU_STATS && defined(GR_TEST_UTILS)
     struct DMSAAStats {
         void dumpKeyValuePairs(skia_private::TArray<SkString>* keys,
                                skia_private::TArray<double>* values) const;
@@ -265,7 +270,7 @@ private:
     std::unique_ptr<GrDrawingManager> fDrawingManager;
     std::unique_ptr<GrProxyProvider>  fProxyProvider;
 
-#if GR_TEST_UTILS
+#if defined(GR_TEST_UTILS)
     int fSuppressWarningMessages = 0;
 #endif
 };

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

@@ -23,9 +23,6 @@ struct GrD3DSurfaceInfo;
 #ifdef SK_METAL
 #include "include/private/gpu/ganesh/GrMtlTypesPriv.h"
 #endif
-#ifdef SK_DAWN
-#include "include/private/gpu/ganesh/GrDawnTypesPriv.h"
-#endif
 #include "include/private/gpu/ganesh/GrMockTypesPriv.h"
 
 class GrSurfaceInfo {
@@ -60,15 +57,6 @@ public:
             , fLevelCount(mtlInfo.fLevelCount)
             , fProtected(mtlInfo.fProtected)
             , fMtlSpec(mtlInfo) {}
-#endif
-#ifdef SK_DAWN
-    GrSurfaceInfo(const GrDawnSurfaceInfo& dawnInfo)
-            : fBackend(GrBackendApi::kDawn)
-            , fValid(true)
-            , fSampleCount(dawnInfo.fSampleCount)
-            , fLevelCount(dawnInfo.fLevelCount)
-            , fProtected(dawnInfo.fProtected)
-            , fDawnSpec(dawnInfo) {}
 #endif
     GrSurfaceInfo(const GrMockSurfaceInfo& mockInfo)
             : fBackend(GrBackendApi::kMock)
@@ -117,15 +105,6 @@ public:
         *info = GrMtlTextureSpecToSurfaceInfo(fMtlSpec, fSampleCount, fLevelCount, fProtected);
         return true;
     }
-#endif
-#ifdef SK_DAWN
-    bool getDawnSurfaceInfo(GrDawnSurfaceInfo* info) const {
-        if (!this->isValid() || fBackend != GrBackendApi::kDawn) {
-            return false;
-        }
-        *info = GrDawnTextureSpecToSurfaceInfo(fDawnSpec, fSampleCount, fLevelCount, fProtected);
-        return true;
-    }
 #endif
     bool getMockSurfaceInfo(GrMockSurfaceInfo* info) const {
         if (!this->isValid() || fBackend != GrBackendApi::kMock) {
@@ -155,9 +134,6 @@ private:
 #endif
 #ifdef SK_METAL
         GrMtlTextureSpec fMtlSpec;
-#endif
-#ifdef SK_DAWN
-        GrDawnTextureSpec fDawnSpec;
 #endif
         GrMockTextureSpec fMockSpec;
     };

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

@@ -98,13 +98,18 @@ enum class GrBackendApi : unsigned {
     kVulkan,
     kMetal,
     kDirect3D,
-    kDawn,
+
     /**
      * Mock is a backend that does not draw anything. It is used for unit tests
      * and to measure CPU overhead.
      */
     kMock,
 
+    /**
+     * Ganesh doesn't support some context types (e.g. Dawn) and will return Unsupported.
+     */
+    kUnsupported,
+
     /**
      * Added here to support the legacy GrBackend enum value and clients who referenced it using
      * GrBackend::kOpenGL_GrBackend.
@@ -241,4 +246,14 @@ enum class GrSemaphoresSubmitted : bool {
     kYes = true
 };
 
+enum class GrPurgeResourceOptions {
+    kAllResources,
+    kScratchResourcesOnly,
+};
+
+enum class GrSyncCpu : bool {
+    kNo = false,
+    kYes = true,
+};
+
 #endif

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

@@ -28,12 +28,12 @@ public:
      * planes indicated by the SkYUVAInfo. The texture dimensions are taken from the SkYUVAInfo's
      * plane dimensions. All the described textures share a common origin. The planar image this
      * describes will be mip mapped if all the textures are individually mip mapped as indicated
-     * by GrMipmapped. This will produce an invalid result (return false from isValid()) if the
+     * by skgpu::Mipmapped. This will produce an invalid result (return false from isValid()) if the
      * passed formats' channels don't agree with SkYUVAInfo.
      */
     GrYUVABackendTextureInfo(const SkYUVAInfo&,
                              const GrBackendFormat[kMaxPlanes],
-                             GrMipmapped,
+                             skgpu::Mipmapped,
                              GrSurfaceOrigin);
 
     GrYUVABackendTextureInfo(const GrYUVABackendTextureInfo&) = default;
@@ -47,7 +47,7 @@ public:
 
     SkYUVColorSpace yuvColorSpace() const { return fYUVAInfo.yuvColorSpace(); }
 
-    GrMipmapped mipmapped() const { return fMipmapped; }
+    skgpu::Mipmapped mipmapped() const { return fMipmapped; }
 
     GrSurfaceOrigin textureOrigin() const { return fTextureOrigin; }
 
@@ -72,7 +72,7 @@ public:
 private:
     SkYUVAInfo fYUVAInfo;
     GrBackendFormat fPlaneFormats[kMaxPlanes];
-    GrMipmapped fMipmapped = GrMipmapped::kNo;
+    skgpu::Mipmapped fMipmapped = skgpu::Mipmapped::kNo;
     GrSurfaceOrigin fTextureOrigin = kTopLeft_GrSurfaceOrigin;
 };
 

package/cpp/skia/include/gpu/d3d/GrD3DTypes.h

@@ -134,7 +134,7 @@ public:
      *  The caller must assume ownership of the object, and manage its reference count directly.
      *  No call to Release() will be made.
      */
-    T* SK_WARN_UNUSED_RESULT release() {
+    [[nodiscard]] T* release() {
         T* obj = fObject;
         fObject = nullptr;
         return obj;
@@ -216,7 +216,7 @@ struct GrD3DTextureResourceInfo {
             , fSampleQualityPattern(info.fSampleQualityPattern)
             , fProtected(info.fProtected) {}
 
-#if GR_TEST_UTILS
+#if defined(GR_TEST_UTILS)
     bool operator==(const GrD3DTextureResourceInfo& that) const {
         return fResource == that.fResource && fResourceState == that.fResourceState &&
                fFormat == that.fFormat && fSampleCount == that.fSampleCount &&