@shopify/react-native-skia 0.1.157 → 0.1.159

package/cpp/skia/include/encode/SkEncoder.h

@@ -14,6 +14,23 @@
 
 class SK_API SkEncoder : SkNoncopyable {
 public:
+    /**
+     * A single frame to be encoded into an animated image.
+     *
+     * If a frame does not fit in the canvas size, this is an error.
+     * TODO(skia:13705): Add offsets when we have support for an encoder that supports using
+     * offsets.
+     */
+    struct SK_API Frame {
+        /**
+         *  Pixmap of the frame.
+         */
+        SkPixmap pixmap;
+        /**
+         *  Duration of the frame in millseconds.
+         */
+        int duration;
+    };
 
     /**
      *  Encode |numRows| rows of input.  If the caller requests more rows than are remaining

package/cpp/skia/include/encode/SkWebpEncoder.h

@@ -8,6 +8,7 @@
 #ifndef SkWebpEncoder_DEFINED
 #define SkWebpEncoder_DEFINED
 
+#include "include/core/SkSpan.h"
 #include "include/encode/SkEncoder.h"
 
 class SkWStream;
@@ -43,6 +44,22 @@ namespace SkWebpEncoder {
      *  Returns true on success.  Returns false on an invalid or unsupported |src|.
      */
     SK_API bool Encode(SkWStream* dst, const SkPixmap& src, const Options& options);
+
+    /**
+     *  Encode the |src| frames to the |dst| stream.
+     *  |options| may be used to control the encoding behavior.
+     *
+     *  The size of the first frame will be used as the canvas size. If any other frame does
+     *  not match the canvas size, this is an error.
+     *
+     *  Returns true on success.  Returns false on an invalid or unsupported |src|.
+     *
+     *  Note: libwebp API also supports set background color, loop limit and customize
+     *  lossy/lossless for each frame. These could be added later as needed.
+     */
+    SK_API bool EncodeAnimated(SkWStream* dst,
+                               SkSpan<const SkEncoder::Frame> src,
+                               const Options& options);
 } // namespace SkWebpEncoder
 
 #endif

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

@@ -16,6 +16,16 @@
 
 namespace skgpu {
 
+/**
+ * Possible 3D APIs that may be used by Graphite.
+ */
+enum class BackendApi : unsigned {
+    kDawn,
+    kMetal,
+    kVulkan,
+    kMock,
+};
+
 /**
  * Value passed into various callbacks to tell the client the result of operations connected to a
  * specific callback. The actual interpretation of kFailed and kSuccess are dependent on the
@@ -27,6 +37,14 @@ enum class CallbackResult : bool {
 };
 
 
+/**
+ * Is the data protected on the GPU or not.
+ */
+enum class Protected : bool {
+    kNo = false,
+    kYes = true,
+};
+
 } // namespace skgpu
 
 #endif // skgpu_GpuTypes_DEFINED

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

@@ -8,9 +8,14 @@
 #ifndef GrBackendSurface_DEFINED
 #define GrBackendSurface_DEFINED
 
+// This include of GrBackendSurfaceMutableState is not needed here, but some clients were depending
+// on the include here instead of including it themselves. Adding this back here until we can fix
+// up clients so it can be removed.
 #include "include/gpu/GrBackendSurfaceMutableState.h"
+
 #include "include/gpu/GrSurfaceInfo.h"
 #include "include/gpu/GrTypes.h"
+#include "include/gpu/MutableTextureState.h"
 #ifdef SK_GL
 #include "include/gpu/gl/GrGLTypes.h"
 #include "include/private/gpu/ganesh/GrGLTypesPriv.h"
@@ -25,11 +30,16 @@
 #include "include/gpu/dawn/GrDawnTypes.h"
 #endif
 
-class GrBackendSurfaceMutableStateImpl;
+#include <string>
+
 class GrVkImageLayout;
 class GrGLTextureParameters;
 class GrColorFormatDesc;
 
+namespace skgpu {
+class MutableTextureStateRef;
+}
+
 #ifdef SK_DAWN
 #include "webgpu/webgpu_cpp.h"
 #endif
@@ -267,38 +277,44 @@ public:
     GrBackendTexture(int width,
                      int height,
                      GrMipmapped,
-                     const GrGLTextureInfo& glInfo);
+                     const GrGLTextureInfo& glInfo,
+                     std::string_view label = {});
 #endif
 
 #ifdef SK_VULKAN
     GrBackendTexture(int width,
                      int height,
-                     const GrVkImageInfo& vkInfo);
+                     const GrVkImageInfo& vkInfo,
+                     std::string_view label = {});
 #endif
 
 #ifdef SK_METAL
     GrBackendTexture(int width,
                      int height,
                      GrMipmapped,
-                     const GrMtlTextureInfo& mtlInfo);
+                     const GrMtlTextureInfo& mtlInfo,
+                     std::string_view label = {});
 #endif
 
 #ifdef SK_DIRECT3D
     GrBackendTexture(int width,
                      int height,
-                     const GrD3DTextureResourceInfo& d3dInfo);
+                     const GrD3DTextureResourceInfo& d3dInfo,
+                     std::string_view label = {});
 #endif
 
 #ifdef SK_DAWN
     GrBackendTexture(int width,
                      int height,
-                     const GrDawnTextureInfo& dawnInfo);
+                     const GrDawnTextureInfo& dawnInfo,
+                     std::string_view label = {});
 #endif
 
     GrBackendTexture(int width,
                      int height,
                      GrMipmapped,
-                     const GrMockTextureInfo& mockInfo);
+                     const GrMockTextureInfo& mockInfo,
+                     std::string_view label = {});
 
     GrBackendTexture(const GrBackendTexture& that);
 
@@ -309,6 +325,7 @@ public:
     SkISize dimensions() const { return {fWidth, fHeight}; }
     int width() const { return fWidth; }
     int height() const { return fHeight; }
+    std::string_view getLabel() const { return fLabel; }
     GrMipmapped mipmapped() const { return fMipmapped; }
     bool hasMipmaps() const { return fMipmapped == GrMipmapped::kYes; }
     /** deprecated alias of hasMipmaps(). */
@@ -372,7 +389,7 @@ public:
     // that can be set from this function are:
     //
     // Vulkan: VkImageLayout and QueueFamilyIndex
-    void setMutableState(const GrBackendSurfaceMutableState&);
+    void setMutableState(const skgpu::MutableTextureState&);
 
     // Returns true if we are working with protected content.
     bool isProtected() const;
@@ -389,7 +406,7 @@ public:
 
 private:
     friend class GrVkGpu;  // for getMutableState
-    sk_sp<GrBackendSurfaceMutableStateImpl> getMutableState() const;
+    sk_sp<skgpu::MutableTextureStateRef> getMutableState() const;
 
 #ifdef SK_GL
     friend class GrGLTexture;
@@ -398,7 +415,8 @@ private:
                      int height,
                      GrMipmapped,
                      const GrGLTextureInfo,
-                     sk_sp<GrGLTextureParameters>);
+                     sk_sp<GrGLTextureParameters>,
+                     std::string_view label = {});
     sk_sp<GrGLTextureParameters> getGLTextureParams() const;
 #endif
 
@@ -407,7 +425,8 @@ private:
     GrBackendTexture(int width,
                      int height,
                      const GrVkImageInfo& vkInfo,
-                     sk_sp<GrBackendSurfaceMutableStateImpl> mutableState);
+                     sk_sp<skgpu::MutableTextureStateRef> mutableState,
+                     std::string_view label = {});
 #endif
 
 #ifdef SK_DIRECT3D
@@ -416,7 +435,8 @@ private:
     GrBackendTexture(int width,
                      int height,
                      const GrD3DTextureResourceInfo& vkInfo,
-                     sk_sp<GrD3DResourceState> state);
+                     sk_sp<GrD3DResourceState> state,
+                     std::string_view label = {});
     sk_sp<GrD3DResourceState> getGrD3DResourceState() const;
 #endif
 
@@ -426,6 +446,7 @@ private:
     bool fIsValid;
     int fWidth;         //<! width in pixels
     int fHeight;        //<! height in pixels
+    const std::string fLabel;
     GrMipmapped fMipmapped;
     GrBackendApi fBackend;
     GrTextureType fTextureType;
@@ -449,7 +470,7 @@ private:
     GrDawnTextureInfo fDawnInfo;
 #endif
 
-    sk_sp<GrBackendSurfaceMutableStateImpl> fMutableState;
+    sk_sp<skgpu::MutableTextureStateRef> fMutableState;
 };
 
 class SK_API GrBackendRenderTarget {
@@ -570,7 +591,7 @@ public:
     // that can be set from this function are:
     //
     // Vulkan: VkImageLayout and QueueFamilyIndex
-    void setMutableState(const GrBackendSurfaceMutableState&);
+    void setMutableState(const skgpu::MutableTextureState&);
 
     // Returns true if we are working with protected content.
     bool isProtected() const;
@@ -585,14 +606,14 @@ public:
 
 private:
     friend class GrVkGpu; // for getMutableState
-    sk_sp<GrBackendSurfaceMutableStateImpl> getMutableState() const;
+    sk_sp<skgpu::MutableTextureStateRef> getMutableState() const;
 
 #ifdef SK_VULKAN
     friend class GrVkRenderTarget;
     GrBackendRenderTarget(int width,
                           int height,
                           const GrVkImageInfo& vkInfo,
-                          sk_sp<GrBackendSurfaceMutableStateImpl> mutableState);
+                          sk_sp<skgpu::MutableTextureStateRef> mutableState);
 #endif
 
 #ifdef SK_DIRECT3D
@@ -636,7 +657,7 @@ private:
 #ifdef SK_DAWN
     GrDawnRenderTargetInfo  fDawnInfo;
 #endif
-    sk_sp<GrBackendSurfaceMutableStateImpl> fMutableState;
+    sk_sp<skgpu::MutableTextureStateRef> fMutableState;
 };
 
 #endif

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

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

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

@@ -252,7 +252,7 @@ struct SK_API GrContextOptions {
 
     /**
      * If true, then add 1 pixel padding to all glyph masks in the atlas to support bi-lerp
-     * rendering of all glyphs. This must be set to true to use GrSlug.
+     * rendering of all glyphs. This must be set to true to use Slugs.
      */
     #if defined(SK_EXPERIMENTAL_SIMULATE_DRAWGLYPHRUNLIST_WITH_SLUG) || \
         defined(SK_EXPERIMENTAL_SIMULATE_DRAWGLYPHRUNLIST_WITH_SLUG_SERIALIZE) || \

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

@@ -21,12 +21,13 @@
 class GrBackendFormat;
 class GrCaps;
 class GrContextThreadSafeProxyPriv;
-class GrTextBlobRedrawCoordinator;
 class GrThreadSafeCache;
 class GrThreadSafePipelineBuilder;
 class SkSurfaceCharacterization;
 class SkSurfaceProps;
 
+namespace sktext::gpu { class TextBlobRedrawCoordinator; }
+
 /**
  * Can be used to perform actions related to the generating GrContext in a thread safe manner. The
  * proxy does not access the 3D API (e.g. OpenGL) that backs the generating GrContext.
@@ -149,14 +150,14 @@ private:
     // `init` method on GrContext_Base).
     void init(sk_sp<const GrCaps>, sk_sp<GrThreadSafePipelineBuilder>);
 
-    const GrBackendApi                           fBackend;
-    const GrContextOptions                       fOptions;
-    const uint32_t                               fContextID;
-    sk_sp<const GrCaps>                          fCaps;
-    std::unique_ptr<GrTextBlobRedrawCoordinator> fTextBlobRedrawCoordinator;
-    std::unique_ptr<GrThreadSafeCache>           fThreadSafeCache;
-    sk_sp<GrThreadSafePipelineBuilder>           fPipelineBuilder;
-    std::atomic<bool>                            fAbandoned{false};
+    const GrBackendApi                                      fBackend;
+    const GrContextOptions                                  fOptions;
+    const uint32_t                                          fContextID;
+    sk_sp<const GrCaps>                                     fCaps;
+    std::unique_ptr<sktext::gpu::TextBlobRedrawCoordinator> fTextBlobRedrawCoordinator;
+    std::unique_ptr<GrThreadSafeCache>                      fThreadSafeCache;
+    sk_sp<GrThreadSafePipelineBuilder>                      fPipelineBuilder;
+    std::atomic<bool>                                       fAbandoned{false};
 };
 
 #else // !SK_SUPPORT_GPU

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

@@ -148,6 +148,9 @@ public:
      * The typical use case for this function is that the underlying 3D context was lost and further
      * API calls may crash.
      *
+     * This call is not valid to be made inside ReleaseProcs passed into SkSurface or SkImages. The
+     * call will simply fail (and assert in debug) if it is called while inside a ReleaseProc.
+     *
      * For Vulkan, even if the device becomes lost, the VkQueue, VkDevice, or VkInstance used to
      * create the context must be kept alive even after abandoning the context. Those objects must
      * live for the lifetime of the context object itself. The reason for this is so that
@@ -445,11 +448,13 @@ public:
       * 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);
+    GrBackendTexture createBackendTexture(int width,
+                                          int height,
+                                          const GrBackendFormat&,
+                                          GrMipmapped,
+                                          GrRenderable,
+                                          GrProtected = GrProtected::kNo,
+                                          std::string_view label = {});
 
      /**
       * If possible, create an uninitialized backend texture. The client should ensure that the
@@ -463,7 +468,8 @@ public:
                                            SkColorType,
                                            GrMipmapped,
                                            GrRenderable,
-                                           GrProtected = GrProtected::kNo);
+                                           GrProtected = GrProtected::kNo,
+                                           std::string_view label = {});
 
      /**
       * If possible, create a backend texture initialized to a particular color. The client should
@@ -481,7 +487,8 @@ public:
                                            GrRenderable,
                                            GrProtected = GrProtected::kNo,
                                            GrGpuFinishedProc finishedProc = nullptr,
-                                           GrGpuFinishedContext finishedContext = nullptr);
+                                           GrGpuFinishedContext finishedContext = nullptr,
+                                           std::string_view label = {});
 
      /**
       * If possible, create a backend texture initialized to a particular color. The client should
@@ -501,7 +508,8 @@ public:
                                            GrRenderable,
                                            GrProtected = GrProtected::kNo,
                                            GrGpuFinishedProc finishedProc = nullptr,
-                                           GrGpuFinishedContext finishedContext = nullptr);
+                                           GrGpuFinishedContext finishedContext = nullptr,
+                                           std::string_view label = {});
 
      /**
       * If possible, create a backend texture initialized with the provided pixmap data. The client
@@ -528,7 +536,8 @@ public:
                                            GrRenderable,
                                            GrProtected,
                                            GrGpuFinishedProc finishedProc = nullptr,
-                                           GrGpuFinishedContext finishedContext = nullptr);
+                                           GrGpuFinishedContext finishedContext = nullptr,
+                                           std::string_view label = {});
 
     /**
      * Convenience version createBackendTexture() that takes just a base level pixmap.
@@ -538,9 +547,10 @@ public:
                                            GrRenderable renderable,
                                            GrProtected isProtected,
                                            GrGpuFinishedProc finishedProc = nullptr,
-                                           GrGpuFinishedContext finishedContext = nullptr) {
+                                           GrGpuFinishedContext finishedContext = nullptr,
+                                           std::string_view label = {}) {
          return this->createBackendTexture(&srcData, 1, textureOrigin, renderable, isProtected,
-                                           finishedProc, finishedContext);
+                                           finishedProc, finishedContext, label);
      }
 
     // Deprecated versions that do not take origin and assume top-left.
@@ -549,26 +559,30 @@ public:
                                           GrRenderable renderable,
                                           GrProtected isProtected,
                                           GrGpuFinishedProc finishedProc = nullptr,
-                                          GrGpuFinishedContext finishedContext = nullptr) {
+                                          GrGpuFinishedContext finishedContext = nullptr,
+                                          std::string_view label = {}) {
         return this->createBackendTexture(srcData,
                                           numLevels,
                                           kTopLeft_GrSurfaceOrigin,
                                           renderable,
                                           isProtected,
                                           finishedProc,
-                                          finishedContext);
+                                          finishedContext,
+                                          label);
     }
     GrBackendTexture createBackendTexture(const SkPixmap& srcData,
                                           GrRenderable renderable,
                                           GrProtected isProtected,
                                           GrGpuFinishedProc finishedProc = nullptr,
-                                          GrGpuFinishedContext finishedContext = nullptr) {
+                                          GrGpuFinishedContext finishedContext = nullptr,
+                                          std::string_view label = {}) {
         return this->createBackendTexture(&srcData,
                                           1,
                                           renderable,
                                           isProtected,
                                           finishedProc,
-                                          finishedContext);
+                                          finishedContext,
+                                          label);
     }
 
     /**
@@ -754,16 +768,16 @@ public:
 
     /**
      * Updates the state of the GrBackendTexture/RenderTarget to have the passed in
-     * GrBackendSurfaceMutableState. All objects that wrap the backend surface (i.e. SkSurfaces and
+     * skgpu::MutableTextureState. 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 `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.
+     * See skgpu::MutableTextureState to see what state can be set via this call.
      *
-     * If the backend API is Vulkan, the caller can set the GrBackendSurfaceMutableState's
+     * If the backend API is Vulkan, the caller can set the skgpu::MutableTextureState's
      * VkImageLayout to VK_IMAGE_LAYOUT_UNDEFINED or queueFamilyIndex to VK_QUEUE_FAMILY_IGNORED to
      * tell Skia to not change those respective states.
      *
@@ -771,13 +785,13 @@ public:
      * previousState to have the values of the state before this call.
      */
     bool setBackendTextureState(const GrBackendTexture&,
-                                const GrBackendSurfaceMutableState&,
-                                GrBackendSurfaceMutableState* previousState = nullptr,
+                                const skgpu::MutableTextureState&,
+                                skgpu::MutableTextureState* previousState = nullptr,
                                 GrGpuFinishedProc finishedProc = nullptr,
                                 GrGpuFinishedContext finishedContext = nullptr);
     bool setBackendRenderTargetState(const GrBackendRenderTarget&,
-                                     const GrBackendSurfaceMutableState&,
-                                     GrBackendSurfaceMutableState* previousState = nullptr,
+                                     const skgpu::MutableTextureState&,
+                                     skgpu::MutableTextureState* previousState = nullptr,
                                      GrGpuFinishedProc finishedProc = nullptr,
                                      GrGpuFinishedContext finishedContext = nullptr);
 
@@ -865,6 +879,12 @@ private:
     std::unique_ptr<GrResourceCache>          fResourceCache;
     std::unique_ptr<GrResourceProvider>       fResourceProvider;
 
+    // This is incremented before we start calling ReleaseProcs from GrSurfaces and decremented
+    // after. A ReleaseProc may trigger code causing another resource to get freed so we to track
+    // the count to know if we in a ReleaseProc at any level. When this is set to a value greated
+    // than zero we will not allow abandonContext calls to be made on the context.
+    int                                     fInsideReleaseProcCnt = 0;
+
     bool                                    fDidTestPMConversions;
     // true if the PM/UPM conversion succeeded; false otherwise
     bool                                    fPMUPMConversionsRoundTrip;

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

@@ -27,13 +27,14 @@ class GrProgramInfo;
 class GrProxyProvider;
 class GrRecordingContextPriv;
 class GrSurfaceProxy;
-class GrTextBlobRedrawCoordinator;
 class GrThreadSafeCache;
 class SkArenaAlloc;
+class SkCapabilities;
 class SkJSONWriter;
 
 namespace sktext::gpu {
 class SubRunAllocator;
+class TextBlobRedrawCoordinator;
 }
 
 #if GR_TEST_UTILS
@@ -97,6 +98,8 @@ public:
         return INHERITED::maxSurfaceSampleCountForColorType(colorType);
     }
 
+    SK_API sk_sp<const SkCapabilities> skCapabilities() const;
+
     // Provides access to functions that aren't part of the public API.
     GrRecordingContextPriv priv();
     const GrRecordingContextPriv priv() const;  // NOLINT(readability-const-return-type)
@@ -189,8 +192,8 @@ protected:
     // same lifetime at the DDL itself.
     virtual void detachProgramData(SkTArray<ProgramData>*) {}
 
-    GrTextBlobRedrawCoordinator* getTextBlobRedrawCoordinator();
-    const GrTextBlobRedrawCoordinator* getTextBlobRedrawCoordinator() const;
+    sktext::gpu::TextBlobRedrawCoordinator* getTextBlobRedrawCoordinator();
+    const sktext::gpu::TextBlobRedrawCoordinator* getTextBlobRedrawCoordinator() const;
 
     GrThreadSafeCache* threadSafeCache();
     const GrThreadSafeCache* threadSafeCache() const;

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

@@ -36,37 +36,37 @@ private:
  * basic bitfield.
  */
 #define GR_MAKE_BITFIELD_CLASS_OPS(X) \
-    SK_MAYBE_UNUSED constexpr GrTFlagsMask<X> operator~(X a) { \
+    [[maybe_unused]] constexpr GrTFlagsMask<X> operator~(X a) { \
         return GrTFlagsMask<X>(~static_cast<int>(a)); \
     } \
-    SK_MAYBE_UNUSED constexpr X operator|(X a, X b) { \
+    [[maybe_unused]] constexpr X operator|(X a, X b) { \
         return static_cast<X>(static_cast<int>(a) | static_cast<int>(b)); \
     } \
-    SK_MAYBE_UNUSED inline X& operator|=(X& a, X b) { \
+    [[maybe_unused]] inline X& operator|=(X& a, X b) { \
         return (a = a | b); \
     } \
-    SK_MAYBE_UNUSED constexpr bool operator&(X a, X b) { \
+    [[maybe_unused]] constexpr bool operator&(X a, X b) { \
         return SkToBool(static_cast<int>(a) & static_cast<int>(b)); \
     } \
-    SK_MAYBE_UNUSED constexpr GrTFlagsMask<X> operator|(GrTFlagsMask<X> a, GrTFlagsMask<X> b) { \
+    [[maybe_unused]] constexpr GrTFlagsMask<X> operator|(GrTFlagsMask<X> a, GrTFlagsMask<X> b) { \
         return GrTFlagsMask<X>(a.value() | b.value()); \
     } \
-    SK_MAYBE_UNUSED constexpr GrTFlagsMask<X> operator|(GrTFlagsMask<X> a, X b) { \
+    [[maybe_unused]] constexpr GrTFlagsMask<X> operator|(GrTFlagsMask<X> a, X b) { \
         return GrTFlagsMask<X>(a.value() | static_cast<int>(b)); \
     } \
-    SK_MAYBE_UNUSED constexpr GrTFlagsMask<X> operator|(X a, GrTFlagsMask<X> b) { \
+    [[maybe_unused]] constexpr GrTFlagsMask<X> operator|(X a, GrTFlagsMask<X> b) { \
         return GrTFlagsMask<X>(static_cast<int>(a) | b.value()); \
     } \
-    SK_MAYBE_UNUSED constexpr X operator&(GrTFlagsMask<X> a, GrTFlagsMask<X> b) { \
+    [[maybe_unused]] constexpr X operator&(GrTFlagsMask<X> a, GrTFlagsMask<X> b) { \
         return static_cast<X>(a.value() & b.value()); \
     } \
-    SK_MAYBE_UNUSED constexpr X operator&(GrTFlagsMask<X> a, X b) { \
+    [[maybe_unused]] constexpr X operator&(GrTFlagsMask<X> a, X b) { \
         return static_cast<X>(a.value() & static_cast<int>(b)); \
     } \
-    SK_MAYBE_UNUSED constexpr X operator&(X a, GrTFlagsMask<X> b) { \
+    [[maybe_unused]] constexpr X operator&(X a, GrTFlagsMask<X> b) { \
         return static_cast<X>(static_cast<int>(a) & b.value()); \
     } \
-    SK_MAYBE_UNUSED inline X& operator&=(X& a, GrTFlagsMask<X> b) { \
+    [[maybe_unused]] inline X& operator&=(X& a, GrTFlagsMask<X> b) { \
         return (a = a & b); \
     } \