@shopify/react-native-skia 0.1.233 → 0.1.236

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

@@ -8,60 +8,41 @@
 #ifndef GrBackendSemaphore_DEFINED
 #define GrBackendSemaphore_DEFINED
 
-#include "include/gpu/GrTypes.h"
-
-#include "include/gpu/gl/GrGLTypes.h"
+#include "include/gpu/GrTypes.h"  // IWYU pragma: keep
+#include "include/private/base/SkAPI.h"
+#include "include/private/base/SkAnySubclass.h"
 
 #ifdef SK_METAL
 #include "include/gpu/mtl/GrMtlTypes.h"
 #endif
 
-#ifdef SK_VULKAN
-#include "include/gpu/vk/GrVkTypes.h"
+#if defined(SK_VULKAN) && !defined(SK_DISABLE_LEGACY_VULKAN_BACKENDSEMAPHORE)
+#include "include/private/gpu/vk/SkiaVulkan.h"
 #endif
 
 #ifdef SK_DIRECT3D
 #include "include/private/gpu/ganesh/GrD3DTypesMinimal.h"
 #endif
 
+#include <cstddef>
+
+class GrBackendSemaphoreData;
+
 /**
  * Wrapper class for passing into and receiving data from Ganesh about a backend semaphore object.
  */
-class GrBackendSemaphore {
+class SK_API GrBackendSemaphore {
 public:
-    // For convenience we just set the backend here to OpenGL. The GrBackendSemaphore cannot be used
-    // until either init* is called, which will set the appropriate GrBackend.
-    GrBackendSemaphore()
-            : fBackend(GrBackendApi::kOpenGL), fGLSync(nullptr), fIsInitialized(false) {}
-
-#ifdef SK_DIRECT3D
-    // We only need to specify these if Direct3D is enabled, because it requires special copy
-    // characteristics.
+    // The GrBackendSemaphore cannot be used until either init* is called, which will set the
+    // appropriate GrBackend.
+    GrBackendSemaphore();
     ~GrBackendSemaphore();
     GrBackendSemaphore(const GrBackendSemaphore&);
     GrBackendSemaphore& operator=(const GrBackendSemaphore&);
-#endif
-
-    void initGL(GrGLsync sync) {
-        fBackend = GrBackendApi::kOpenGL;
-        fGLSync = sync;
-        fIsInitialized = true;
-    }
-
-#ifdef SK_VULKAN
-    void initVulkan(VkSemaphore semaphore) {
-        fBackend = GrBackendApi::kVulkan;
-        fVkSemaphore = semaphore;
-
-        fIsInitialized = true;
-    }
 
-    VkSemaphore vkSemaphore() const {
-        if (!fIsInitialized || GrBackendApi::kVulkan != fBackend) {
-            return VK_NULL_HANDLE;
-        }
-        return fVkSemaphore;
-    }
+#if defined(SK_VULKAN) && !defined(SK_DISABLE_LEGACY_VULKAN_BACKENDSEMAPHORE)
+    void initVulkan(VkSemaphore semaphore);
+    VkSemaphore vkSemaphore() const;
 #endif
 
 #ifdef SK_METAL
@@ -100,30 +81,35 @@ public:
 #endif
 
     bool isInitialized() const { return fIsInitialized; }
-
-    GrGLsync glSync() const {
-        if (!fIsInitialized || GrBackendApi::kOpenGL != fBackend) {
-            return nullptr;
-        }
-        return fGLSync;
-    }
-
+    GrBackendApi backend() const { return fBackend; }
 
 #ifdef SK_DIRECT3D
     bool getD3DFenceInfo(GrD3DFenceInfo* outInfo) const;
 #endif
 
 private:
+    friend class GrBackendSemaphorePriv;
+    friend class GrBackendSemaphoreData;
+    // Size determined by looking at the GrBackendSemaphoreData subclasses, then
+    // guessing-and-checking. Compiler will complain if this is too small - in that case,
+    // just increase the number.
+    inline constexpr static size_t kMaxSubclassSize = 16;
+    using AnySemaphoreData = SkAnySubclass<GrBackendSemaphoreData, kMaxSubclassSize>;
+
+    template <typename SemaphoreData>
+    GrBackendSemaphore(GrBackendApi api, SemaphoreData data) : fBackend(api), fIsInitialized(true) {
+        fSemaphoreData.emplace<SemaphoreData>(data);
+    }
+
 #ifdef SK_DIRECT3D
     void assignD3DFenceInfo(const GrD3DFenceInfo& info);
 #endif
 
     GrBackendApi fBackend;
+    AnySemaphoreData fSemaphoreData;
+
     union {
-        GrGLsync    fGLSync;
-#ifdef SK_VULKAN
-        VkSemaphore fVkSemaphore;
-#endif
+        void* fPlaceholder;  // TODO(293490566)
 #ifdef SK_METAL
         GrMTLHandle fMtlEvent;    // Expected to be an id<MTLEvent>
 #endif

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

@@ -25,7 +25,6 @@ class GrBackendRenderTargetData;
 
 namespace skgpu {
 class MutableTextureState;
-class MutableTextureStateRef;
 }
 
 #ifdef SK_METAL
@@ -290,7 +289,7 @@ private:
     }
 
     friend class GrVkGpu;  // for getMutableState
-    sk_sp<skgpu::MutableTextureStateRef> getMutableState() const;
+    sk_sp<skgpu::MutableTextureState> getMutableState() const;
 
 #ifdef SK_DIRECT3D
     friend class GrD3DTexture;
@@ -433,7 +432,7 @@ private:
     }
 
     friend class GrVkGpu; // for getMutableState
-    sk_sp<skgpu::MutableTextureStateRef> getMutableState() const;
+    sk_sp<skgpu::MutableTextureState> getMutableState() const;
 
 #ifdef SK_DIRECT3D
     friend class GrD3DGpu;

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

@@ -20,7 +20,6 @@
 
 class SkExecutor;
 
-#if defined(SK_GANESH)
 struct SK_API GrContextOptions {
     enum class Enable {
         /** Forces an option to be disabled. */
@@ -371,10 +370,5 @@ struct SK_API GrContextOptions {
 
     GrDriverBugWorkarounds fDriverBugWorkarounds;
 };
-#else
-struct GrContextOptions {
-    struct PersistentCache {};
-};
-#endif
 
 #endif

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

@@ -8,11 +8,8 @@
 #ifndef GrContextThreadSafeProxy_DEFINED
 #define GrContextThreadSafeProxy_DEFINED
 
-#include "include/core/SkRefCnt.h"
-
-#if defined(SK_GANESH)
-
 #include "include/core/SkImageInfo.h"
+#include "include/core/SkRefCnt.h"
 #include "include/gpu/GpuTypes.h"
 #include "include/gpu/GrContextOptions.h"
 #include "include/gpu/GrTypes.h"
@@ -34,9 +31,9 @@ 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.
  */
-class SK_API GrContextThreadSafeProxy final : public SkNVRefCnt<GrContextThreadSafeProxy> {
+class SK_API GrContextThreadSafeProxy : public SkNVRefCnt<GrContextThreadSafeProxy> {
 public:
-    ~GrContextThreadSafeProxy();
+    virtual ~GrContextThreadSafeProxy();
 
     /**
      *  Create a surface characterization for a DDL that will be replayed into the GrContext
@@ -68,7 +65,7 @@ public:
      *  @param surfaceProps                    The surface properties of the SkSurface that the DDL
      *                                         created with this characterization will be replayed
      *                                         into
-     *  @param isMipMapped                     Will the surface the DDL will be replayed into have
+     *  @param isMipmapped                     Will the surface the DDL will be replayed into have
      *                                         space allocated for mipmaps?
      *  @param willUseGLFBO0                   Will the surface the DDL will be replayed into be
      *                                         backed by GL FBO 0. This flag is only valid if using
@@ -81,24 +78,39 @@ public:
      *                                         command buffer via a GrVkSecondaryCBDrawContext? If
      *                                         this is true then the following is required:
      *                                         isTexureable = false
-     *                                         isMipMapped = false
+     *                                         isMipmapped = false
      *                                         willUseGLFBO0 = false
      *                                         vkRTSupportsInputAttachment = false
      */
     GrSurfaceCharacterization createCharacterization(
-                                  size_t cacheMaxResourceBytes,
-                                  const SkImageInfo& ii,
-                                  const GrBackendFormat& backendFormat,
-                                  int sampleCount,
-                                  GrSurfaceOrigin origin,
-                                  const SkSurfaceProps& surfaceProps,
-                                  bool isMipMapped,
-                                  bool willUseGLFBO0 = false,
-                                  bool isTextureable = true,
-                                  GrProtected isProtected = GrProtected::kNo,
-                                  bool vkRTSupportsInputAttachment = false,
-                                  bool forVulkanSecondaryCommandBuffer = false);
-
+            size_t cacheMaxResourceBytes,
+            const SkImageInfo& ii,
+            const GrBackendFormat& backendFormat,
+            int sampleCount,
+            GrSurfaceOrigin origin,
+            const SkSurfaceProps& surfaceProps,
+            skgpu::Mipmapped isMipmapped,
+            bool willUseGLFBO0 = false,
+            bool isTextureable = true,
+            skgpu::Protected isProtected = GrProtected::kNo,
+            bool vkRTSupportsInputAttachment = false,
+            bool forVulkanSecondaryCommandBuffer = false);
+
+#if !defined(SK_DISABLE_LEGACY_CREATE_CHARACTERIZATION)
+    GrSurfaceCharacterization createCharacterization(
+            size_t cacheMaxResourceBytes,
+            const SkImageInfo& ii,
+            const GrBackendFormat& backendFormat,
+            int sampleCount,
+            GrSurfaceOrigin origin,
+            const SkSurfaceProps& surfaceProps,
+            bool isMipmapped,
+            bool willUseGLFBO0 = false,
+            bool isTextureable = true,
+            skgpu::Protected isProtected = GrProtected::kNo,
+            bool vkRTSupportsInputAttachment = false,
+            bool forVulkanSecondaryCommandBuffer = false);
+#endif
     /*
      * 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
@@ -138,12 +150,13 @@ public:
     GrContextThreadSafeProxyPriv priv();
     const GrContextThreadSafeProxyPriv priv() const;  // NOLINT(readability-const-return-type)
 
-private:
-    friend class GrContextThreadSafeProxyPriv; // for ctor and hidden methods
-
+protected:
     // DDL TODO: need to add unit tests for backend & maybe options
     GrContextThreadSafeProxy(GrBackendApi, const GrContextOptions&);
 
+private:
+    friend class GrContextThreadSafeProxyPriv;  // for ctor and hidden methods
+
     void abandonContext();
     bool abandoned() const;
 
@@ -152,6 +165,13 @@ private:
     // `init` method on GrContext_Base).
     void init(sk_sp<const GrCaps>, sk_sp<GrThreadSafePipelineBuilder>);
 
+    virtual bool isValidCharacterizationForVulkan(sk_sp<const GrCaps>,
+                                                  bool isTextureable,
+                                                  skgpu::Mipmapped isMipmapped,
+                                                  skgpu::Protected isProtected,
+                                                  bool vkRTSupportsInputAttachment,
+                                                  bool forVulkanSecondaryCommandBuffer);
+
     const GrBackendApi                                      fBackend;
     const GrContextOptions                                  fOptions;
     const uint32_t                                          fContextID;
@@ -162,8 +182,4 @@ private:
     std::atomic<bool>                                       fAbandoned{false};
 };
 
-#else // !defined(SK_GANESH)
-class SK_API GrContextThreadSafeProxy final : public SkNVRefCnt<GrContextThreadSafeProxy> {};
-#endif
-
 #endif

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

@@ -41,9 +41,7 @@ class SkTaskGroup;
 class SkTraceMemoryDump;
 enum SkColorType : int;
 enum class SkTextureCompressionType;
-struct GrGLInterface;
 struct GrMockOptions;
-struct GrVkBackendContext; // IWYU pragma: keep
 struct GrD3DBackendContext; // IWYU pragma: keep
 struct GrMtlBackendContext; // IWYU pragma: keep
 
@@ -62,28 +60,6 @@ enum class BackendSurfaceAccess;
 
 class SK_API GrDirectContext : public GrRecordingContext {
 public:
-#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.
-     */
-    static sk_sp<GrDirectContext> MakeGL(sk_sp<const GrGLInterface>, const GrContextOptions&);
-    static sk_sp<GrDirectContext> MakeGL(sk_sp<const GrGLInterface>);
-    static sk_sp<GrDirectContext> MakeGL(const GrContextOptions&);
-    static sk_sp<GrDirectContext> MakeGL();
-#endif
-
-#ifdef SK_VULKAN
-    /**
-     * The Vulkan context (VkQueue, VkDevice, VkInstance) must be kept alive until the returned
-     * GrDirectContext is destroyed. This also means that any objects created with this
-     * GrDirectContext (e.g. SkSurfaces, SkImages, etc.) must also be released as they may hold
-     * refs on the GrDirectContext. Once all these objects and the GrDirectContext are released,
-     * then it is safe to delete the vulkan objects.
-     */
-    static sk_sp<GrDirectContext> MakeVulkan(const GrVkBackendContext&, const GrContextOptions&);
-    static sk_sp<GrDirectContext> MakeVulkan(const GrVkBackendContext&);
-#endif
 
 #ifdef SK_METAL
     /**
@@ -357,14 +333,17 @@ public:
 
     /**
      * 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.
+     * executing any more commands on the GPU. We only guarantee blocking transfer and fragment
+     * shader work, but may block earlier stages as well depending on the backend.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.
+     *
+     * This is not supported on the GL backend.
      */
     bool wait(int numSemaphores, const GrBackendSemaphore* waitSemaphores,
               bool deleteSemaphoresAfterWait = true);
@@ -416,13 +395,13 @@ public:
      *  @param image    the non-null image to flush.
      *  @param info     flush options
      */
-    GrSemaphoresSubmitted flush(sk_sp<const SkImage> image, const GrFlushInfo& info);
-    void flush(sk_sp<const SkImage> image);
+    GrSemaphoresSubmitted flush(const sk_sp<const SkImage>& image, const GrFlushInfo& info);
+    void flush(const sk_sp<const SkImage>& image);
 
     /** Version of flush() that uses a default GrFlushInfo. Also submits the flushed work to the
      *   GPU.
      */
-    void flushAndSubmit(sk_sp<const SkImage> image);
+    void flushAndSubmit(const sk_sp<const SkImage>& image);
 
     /** Issues pending SkSurface commands to the GPU-backed API objects and resolves any SkSurface
      *  MSAA. A call to GrDirectContext::submit is always required to ensure work is actually sent
@@ -952,7 +931,9 @@ public:
     const GrDirectContextPriv priv() const;  // NOLINT(readability-const-return-type)
 
 protected:
-    GrDirectContext(GrBackendApi backend, const GrContextOptions& options);
+    GrDirectContext(GrBackendApi backend,
+                    const GrContextOptions& options,
+                    sk_sp<GrContextThreadSafeProxy> proxy);
 
     bool init() override;
 

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

@@ -16,7 +16,6 @@
 class GrBackendSemaphore;
 
 namespace skgpu {
-enum class Mipmapped : bool;
 enum class Protected : bool;
 enum class Renderable : bool;
 }
@@ -129,14 +128,6 @@ static constexpr GrBackendApi kMock_GrBackend = GrBackendApi::kMock;
 
 ///////////////////////////////////////////////////////////////////////////////
 
-/**
- * Used to say whether a texture has mip levels allocated or not.
- */
-/** Deprecated legacy alias of skgpu::Mipmapped. */
-using GrMipmapped = skgpu::Mipmapped;
-/** Deprecated legacy alias of skgpu::Mipmapped. */
-using GrMipMapped = skgpu::Mipmapped;
-
 /*
  * Can a GrBackendObject be rendered to?
  */
@@ -220,13 +211,7 @@ typedef void (*GrDirectContextDestroyedProc)(GrDirectContextDestroyedContext des
  * The submittedProc is useful to the client to know when semaphores that were sent with the flush
  * have actually been submitted to the GPU so that they can be waited on (or deleted if the submit
  * fails).
- * Note about GL: In GL work gets sent to the driver immediately during the flush call, but we don't
- * really know when the driver sends the work to the GPU. Therefore, we treat the submitted proc as
- * we do in other backends. It will be called when the next GrContext::submit is called after the
- * flush (or possibly during the flush if there is no work to be done for the flush). The main use
- * case for the submittedProc is to know when semaphores have been sent to the GPU and even in GL
- * it is required to call GrContext::submit to flush them. So a client should be able to treat all
- * backend APIs the same in terms of how the submitted procs are treated.
+ * GrBackendSemaphores are not supported for the GL backend and will be ignored if set.
  */
 struct GrFlushInfo {
     size_t fNumSemaphores = 0;

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

@@ -8,21 +8,21 @@
 #ifndef skgpu_MutableTextureState_DEFINED
 #define skgpu_MutableTextureState_DEFINED
 
+#include "include/core/SkRefCnt.h"
 #include "include/core/SkTypes.h"
-#include "include/gpu/GpuTypes.h"
+#include "include/private/base/SkAnySubclass.h"
 
-#ifdef SK_VULKAN
+#if defined(SK_VULKAN) && !defined(SK_DISABLE_LEGACY_VULKAN_MUTABLE_TEXTURE_STATE)
 #include "include/private/gpu/vk/SkiaVulkan.h"
-#include "include/private/gpu/vk/VulkanTypesPriv.h"
 
 #include <cstdint>
 #endif
 
-#include <new>
-
-class GrVkGpu;
+#include <cstddef>
 
 namespace skgpu {
+enum class BackendApi : unsigned int;
+class MutableTextureStateData;
 
 /**
  * Since Skia and clients can both modify gpu textures and their connected state, Skia needs a way
@@ -30,95 +30,50 @@ namespace skgpu {
  * 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
+ * that is wrapped by this class are located in files like:
+ *   - include/gpu/vk/VulkanMutableTextureState.h
  */
-class SK_API MutableTextureState {
+class SK_API MutableTextureState : public SkRefCnt {
 public:
-    MutableTextureState() {}
-
-#ifdef SK_VULKAN
-    MutableTextureState(VkImageLayout layout, uint32_t queueFamilyIndex)
-            : fVkState(layout, queueFamilyIndex)
-            , fBackend(BackendApi::kVulkan)
-            , fIsValid(true) {}
-#endif
+    MutableTextureState();
+    ~MutableTextureState() override;
 
-    MutableTextureState(const MutableTextureState& that)
-            : fBackend(that.fBackend), fIsValid(that.fIsValid) {
-        if (!fIsValid) {
-            return;
-        }
-        switch (fBackend) {
-            case BackendApi::kVulkan:
-    #ifdef SK_VULKAN
-                SkASSERT(that.fBackend == BackendApi::kVulkan);
-                fVkState = that.fVkState;
-    #endif
-                break;
-            default:
-                (void)that;
-                SkUNREACHABLE;
-        }
-    }
+    MutableTextureState(const MutableTextureState& that);
 
-    MutableTextureState& operator=(const MutableTextureState& that) {
-        if (this != &that) {
-            this->~MutableTextureState();
-            new (this) MutableTextureState(that);
-        }
-        return *this;
-    }
+    MutableTextureState& operator=(const MutableTextureState& 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 != BackendApi::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 != BackendApi::kVulkan) {
-            return VK_QUEUE_FAMILY_IGNORED;
-        }
-        return fVkState.getQueueFamilyIndex();
-    }
-#endif
+    void set(const MutableTextureState& that);
 
     BackendApi backend() const { return fBackend; }
 
     // Returns true if the backend mutable state has been initialized.
     bool isValid() const { return fIsValid; }
 
+#if defined(SK_VULKAN) && !defined(SK_DISABLE_LEGACY_VULKAN_MUTABLE_TEXTURE_STATE)
+    MutableTextureState(VkImageLayout layout, uint32_t queueFamilyIndex);
+
+    VkImageLayout getVkImageLayout() const;
+    uint32_t getQueueFamilyIndex() const;
+#endif
+
 private:
-    friend class MutableTextureStateRef;
-    friend class ::GrVkGpu;
-
-#ifdef SK_VULKAN
-    void setVulkanState(VkImageLayout layout, uint32_t queueFamilyIndex) {
-        SkASSERT(!this->isValid() || fBackend == BackendApi::kVulkan);
-        fVkState.setImageLayout(layout);
-        fVkState.setQueueFamilyIndex(queueFamilyIndex);
-        fBackend = BackendApi::kVulkan;
-        fIsValid = true;
+    friend class MutableTextureStateData;
+    friend class MutableTextureStatePriv;
+    // Size determined by looking at the MutableTextureStateData subclasses, then
+    // guessing-and-checking. Compiler will complain if this is too small - in that case,
+    // just increase the number.
+    inline constexpr static size_t kMaxSubclassSize = 16;
+    using AnyStateData = SkAnySubclass<MutableTextureStateData, kMaxSubclassSize>;
+
+    template <typename StateData>
+    MutableTextureState(BackendApi api, const StateData& data) : fBackend(api), fIsValid(true) {
+        fStateData.emplace<StateData>(data);
     }
-#endif
 
-    union {
-        char fPlaceholder;
-#ifdef SK_VULKAN
-        VulkanMutableTextureState fVkState;
-#endif
-    };
+    AnyStateData fStateData;
 
-    BackendApi fBackend = BackendApi::kMock;
-    bool fIsValid = false;
+    BackendApi fBackend;
+    bool fIsValid;
 };
 
 } // namespace skgpu

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

@@ -18,7 +18,17 @@ class SK_API ShaderErrorHandler {
 public:
     virtual ~ShaderErrorHandler() = default;
 
-    virtual void compileError(const char* shader, const char* errors) = 0;
+    /**
+     * compileError(shader, errors) is kept for backward compatibility with older clients.
+     */
+    virtual void compileError([[maybe_unused]] const char* shader,
+                              [[maybe_unused]] const char* errors) {}
+    virtual void compileError(const char* shader,
+                              const char* errors,
+                              [[maybe_unused]] bool shaderWasCached) {
+        // Default implementation. Ignore shaderWasCached.
+        this->compileError(shader, errors);
+    }
 
 protected:
     ShaderErrorHandler() = default;

package/cpp/skia/include/gpu/ganesh/SkImageGanesh.h

@@ -206,7 +206,7 @@ SK_API sk_sp<SkImage> TextureFromImage(GrDirectContext*,
                                        skgpu::Mipmapped = skgpu::Mipmapped::kNo,
                                        skgpu::Budgeted = skgpu::Budgeted::kYes);
 inline sk_sp<SkImage> TextureFromImage(GrDirectContext* ctx,
-                                       sk_sp<const SkImage> img,
+                                       const sk_sp<const SkImage>& img,
                                        skgpu::Mipmapped m = skgpu::Mipmapped::kNo,
                                        skgpu::Budgeted b = skgpu::Budgeted::kYes) {
     return TextureFromImage(ctx, img.get(), m, b);
@@ -276,7 +276,7 @@ SK_API bool GetBackendTextureFromImage(const SkImage* img,
                                        GrBackendTexture* outTexture,
                                        bool flushPendingGrContextIO,
                                        GrSurfaceOrigin* origin = nullptr);
-inline bool GetBackendTextureFromImage(sk_sp<const SkImage> img,
+inline bool GetBackendTextureFromImage(const sk_sp<const SkImage>& img,
                                        GrBackendTexture* outTexture,
                                        bool flushPendingGrContextIO,
                                        GrSurfaceOrigin* origin = nullptr) {

package/cpp/skia/include/gpu/ganesh/SkSurfaceGanesh.h

@@ -199,7 +199,7 @@ SK_API GrBackendRenderTarget GetBackendRenderTarget(SkSurface*, BackendHandleAcc
     GrDirectContext::flush.
  */
 SK_API void ResolveMSAA(SkSurface* surface);
-inline void ResolveMSAA(sk_sp<SkSurface> surface) {
+inline void ResolveMSAA(const sk_sp<SkSurface>& surface) {
     return ResolveMSAA(surface.get());
 }
 

package/cpp/skia/include/gpu/ganesh/gl/GrGLDirectContext.h

@@ -17,13 +17,14 @@ struct GrGLInterface;
 
 namespace GrDirectContexts {
 /**
- * Creates a GrDirectContext for a backend context. If no GrGLInterface is provided then the
- * result of GrGLMakeNativeInterface() is used if it succeeds.
+ * Creates a GrDirectContext for a backend context. GrGLInterface must be non-null.
  */
 SK_API sk_sp<GrDirectContext> MakeGL(sk_sp<const GrGLInterface>, const GrContextOptions&);
 SK_API sk_sp<GrDirectContext> MakeGL(sk_sp<const GrGLInterface>);
+#if !defined(SK_DISABLE_LEGACY_GL_MAKE_NATIVE_INTERFACE)
 SK_API sk_sp<GrDirectContext> MakeGL(const GrContextOptions&);
 SK_API sk_sp<GrDirectContext> MakeGL();
+#endif
 }
 
 #endif

package/cpp/skia/include/gpu/ganesh/vk/GrVkBackendSemaphore.h

@@ -0,0 +1,20 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ *
+ */
+#ifndef GrVkBackendSemaphore_DEFINED
+#define GrVkBackendSemaphore_DEFINED
+
+#include "include/gpu/GrBackendSemaphore.h"
+#include "include/private/base/SkAPI.h"
+#include "include/private/gpu/vk/SkiaVulkan.h"
+
+namespace GrBackendSemaphores {
+SK_API GrBackendSemaphore MakeVk(VkSemaphore semaphore);
+SK_API VkSemaphore GetVkSemaphore(const GrBackendSemaphore&);
+}  // namespace GrBackendSemaphores
+
+#endif