@shopify/react-native-skia 0.1.192 → 0.1.193

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

@@ -8,46 +8,52 @@
 #ifndef GrDirectContext_DEFINED
 #define GrDirectContext_DEFINED
 
+#include "include/core/SkColor.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypes.h"
+#include "include/gpu/GpuTypes.h"
+#include "include/gpu/GrContextOptions.h"
 #include "include/gpu/GrRecordingContext.h"
+#include "include/gpu/GrTypes.h"
 
-#include "include/gpu/GrBackendSurface.h"
-
-// We shouldn't need this but currently Android is relying on this being include transitively.
-#include "include/core/SkUnPreMultiply.h"
+#include <chrono>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <string_view>
 
 class GrAtlasManager;
 class GrBackendSemaphore;
+class GrBackendFormat;
+class GrBackendTexture;
+class GrBackendRenderTarget;
 class GrClientMappedBufferManager;
-class GrDirectContextPriv;
 class GrContextThreadSafeProxy;
-struct GrD3DBackendContext;
-class GrFragmentProcessor;
+class GrDirectContextPriv;
 class GrGpu;
-struct GrGLInterface;
-struct GrMtlBackendContext;
-struct GrMockOptions;
-class GrPath;
 class GrResourceCache;
 class GrResourceProvider;
-class GrSurfaceProxy;
-class GrTextureProxy;
-struct GrVkBackendContext;
-
+class SkData;
 class SkImage;
-class SkString;
-class SkSurfaceCharacterization;
-class SkSurfaceProps;
+class SkPixmap;
 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
 
 namespace skgpu {
-class Swizzle;
-namespace v1 { class SmallPathAtlasMgr; }
-}
-
-namespace sktext::gpu {
-class StrikeCache;
+    class MutableTextureState;
+#if !defined(SK_ENABLE_OPTIMIZE_SIZE)
+    namespace ganesh { class SmallPathAtlasMgr; }
+#endif
 }
+namespace sktext { namespace gpu { class StrikeCache; } }
+namespace wgpu { class Device; } // IWYU pragma: keep
 
 class SK_API GrDirectContext : public GrRecordingContext {
 public:
@@ -387,7 +393,24 @@ public:
      */
     GrSemaphoresSubmitted flush(const GrFlushInfo& info);
 
-    void flush() { this->flush({}); }
+    void flush() { this->flush(GrFlushInfo()); }
+
+    /** Flushes any pending uses of texture-backed images in the GPU backend. If the image is not
+     *  texture-backed (including promise texture images) or if the GrDirectContext does not
+     *  have the same context ID as the context backing the image then this is a no-op.
+     *  If the image was not used in any non-culled draws in the current queue of work for the
+     *  passed GrDirectContext then this is a no-op unless the GrFlushInfo contains semaphores or
+     *  a finish proc. Those are respected even when the image has not been used.
+     *  @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);
+
+    /** Version of flush() that uses a default GrFlushInfo. Also submits the flushed work to the
+        GPU.
+    */
+    void flushAndSubmit(sk_sp<const SkImage> image);
 
     /**
      * Submit outstanding work to the gpu from all previously un-submitted flushes. The return
@@ -548,10 +571,7 @@ public:
                                            GrProtected isProtected,
                                            GrGpuFinishedProc finishedProc = nullptr,
                                            GrGpuFinishedContext finishedContext = nullptr,
-                                           std::string_view label = {}) {
-         return this->createBackendTexture(&srcData, 1, textureOrigin, renderable, isProtected,
-                                           finishedProc, finishedContext, label);
-     }
+                                           std::string_view label = {});
 
     // Deprecated versions that do not take origin and assume top-left.
     GrBackendTexture createBackendTexture(const SkPixmap srcData[],
@@ -560,30 +580,14 @@ public:
                                           GrProtected isProtected,
                                           GrGpuFinishedProc finishedProc = nullptr,
                                           GrGpuFinishedContext finishedContext = nullptr,
-                                          std::string_view label = {}) {
-        return this->createBackendTexture(srcData,
-                                          numLevels,
-                                          kTopLeft_GrSurfaceOrigin,
-                                          renderable,
-                                          isProtected,
-                                          finishedProc,
-                                          finishedContext,
-                                          label);
-    }
+                                          std::string_view label = {});
+
     GrBackendTexture createBackendTexture(const SkPixmap& srcData,
                                           GrRenderable renderable,
                                           GrProtected isProtected,
                                           GrGpuFinishedProc finishedProc = nullptr,
                                           GrGpuFinishedContext finishedContext = nullptr,
-                                          std::string_view label = {}) {
-        return this->createBackendTexture(&srcData,
-                                          1,
-                                          renderable,
-                                          isProtected,
-                                          finishedProc,
-                                          finishedContext,
-                                          label);
-    }
+                                          std::string_view label = {});
 
     /**
      * If possible, updates a backend texture to be filled to a particular color. The client should
@@ -662,17 +666,10 @@ public:
                              const SkPixmap srcData[],
                              int numLevels,
                              GrGpuFinishedProc finishedProc,
-                             GrGpuFinishedContext finishedContext) {
-        return this->updateBackendTexture(texture,
-                                          srcData,
-                                          numLevels,
-                                          kTopLeft_GrSurfaceOrigin,
-                                          finishedProc,
-                                          finishedContext);
-    }
+                             GrGpuFinishedContext finishedContext);
 
     /**
-     * Retrieve the GrBackendFormat for a given SkImage::CompressionType. This is
+     * Retrieve the GrBackendFormat for a given SkTextureCompressionType. This is
      * guaranteed to match the backend format used by the following
      * createCompressedBackendTexture methods that take a CompressionType.
      *
@@ -698,7 +695,7 @@ public:
                                                     GrGpuFinishedContext finishedContext = nullptr);
 
     GrBackendTexture createCompressedBackendTexture(int width, int height,
-                                                    SkImage::CompressionType,
+                                                    SkTextureCompressionType,
                                                     const SkColor4f& color,
                                                     GrMipmapped,
                                                     GrProtected = GrProtected::kNo,
@@ -726,7 +723,7 @@ public:
                                                     GrGpuFinishedContext finishedContext = nullptr);
 
     GrBackendTexture createCompressedBackendTexture(int width, int height,
-                                                    SkImage::CompressionType,
+                                                    SkTextureCompressionType,
                                                     const void* data, size_t dataSize,
                                                     GrMipmapped,
                                                     GrProtected = GrProtected::kNo,
@@ -850,7 +847,9 @@ protected:
     bool init() override;
 
     GrAtlasManager* onGetAtlasManager() { return fAtlasManager.get(); }
-    skgpu::v1::SmallPathAtlasMgr* onGetSmallPathAtlasMgr();
+#if !defined(SK_ENABLE_OPTIMIZE_SIZE)
+    skgpu::ganesh::SmallPathAtlasMgr* onGetSmallPathAtlasMgr();
+#endif
 
     GrDirectContext* asDirectContext() override { return this; }
 
@@ -868,6 +867,28 @@ private:
     // bool is used for this signal.
     void syncAllOutstandingGpuWork(bool shouldExecuteWhileAbandoned);
 
+    // This delete callback needs to be the first thing on the GrDirectContext so that it is the
+    // last thing destroyed. The callback may signal the client to clean up things that may need
+    // to survive the lifetime of some of the other objects on the GrDirectCotnext. So make sure
+    // we don't call it until all else has been destroyed.
+    class DeleteCallbackHelper {
+    public:
+        DeleteCallbackHelper(GrDirectContextDestroyedContext context,
+                             GrDirectContextDestroyedProc proc)
+                : fContext(context), fProc(proc) {}
+
+        ~DeleteCallbackHelper() {
+            if (fProc) {
+                fProc(fContext);
+            }
+        }
+
+    private:
+        GrDirectContextDestroyedContext fContext;
+        GrDirectContextDestroyedProc fProc;
+    };
+    std::unique_ptr<DeleteCallbackHelper> fDeleteCallbackHelper;
+
     const DirectContextID                   fDirectContextID;
     // 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
@@ -894,11 +915,11 @@ private:
     std::unique_ptr<GrClientMappedBufferManager> fMappedBufferManager;
     std::unique_ptr<GrAtlasManager> fAtlasManager;
 
-    std::unique_ptr<skgpu::v1::SmallPathAtlasMgr> fSmallPathAtlasMgr;
+#if !defined(SK_ENABLE_OPTIMIZE_SIZE)
+    std::unique_ptr<skgpu::ganesh::SmallPathAtlasMgr> fSmallPathAtlasMgr;
+#endif
 
     friend class GrDirectContextPriv;
-
-    using INHERITED = GrRecordingContext;
 };
 
 

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

@@ -13,7 +13,8 @@
 #ifdef SK_GPU_WORKAROUNDS_HEADER
 #include SK_GPU_WORKAROUNDS_HEADER
 #else
-// To regenerate this file, set gn arg "skia_generate_workarounds = true".
+// To regenerate this file, set gn arg "skia_generate_workarounds = true"
+// or invoke `bazel run //tools:generate_workarounds`
 // This is not rebuilt by default to avoid embedders having to have extra
 // build steps.
 #include "include/gpu/GrDriverBugWorkaroundsAutogen.h"

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

@@ -9,7 +9,8 @@
 #define GrRecordingContext_DEFINED
 
 #include "include/core/SkRefCnt.h"
-#include "include/private/SkTArray.h"
+#include "include/core/SkTypes.h"
+#include "include/private/base/SkTArray.h"
 #include "include/private/gpu/ganesh/GrImageContext.h"
 
 #if GR_GPU_STATS && GR_TEST_UTILS
@@ -190,7 +191,7 @@ protected:
     // of the programInfos matches the intended use. For example, in DDL-record mode it
     // is known that all the programInfos will have been allocated in an arena with the
     // same lifetime at the DDL itself.
-    virtual void detachProgramData(SkTArray<ProgramData>*) {}
+    virtual void detachProgramData(skia_private::TArray<ProgramData>*) {}
 
     sktext::gpu::TextBlobRedrawCoordinator* getTextBlobRedrawCoordinator();
     const sktext::gpu::TextBlobRedrawCoordinator* getTextBlobRedrawCoordinator() const;
@@ -223,7 +224,8 @@ protected:
 
 #if GR_TEST_UTILS
         void dump(SkString* out) const;
-        void dumpKeyValuePairs(SkTArray<SkString>* keys, SkTArray<double>* values) const;
+        void dumpKeyValuePairs(skia_private::TArray<SkString>* keys,
+                               skia_private::TArray<double>* values) const;
 #endif
 
     private:
@@ -236,14 +238,16 @@ protected:
 
 #if GR_TEST_UTILS
         void dump(SkString*) const {}
-        void dumpKeyValuePairs(SkTArray<SkString>* keys, SkTArray<double>* values) const {}
+        void dumpKeyValuePairs(skia_private::TArray<SkString>* keys,
+                               skia_private::TArray<double>* values) const {}
 #endif
 #endif // GR_GPU_STATS
     } fStats;
 
 #if GR_GPU_STATS && GR_TEST_UTILS
     struct DMSAAStats {
-        void dumpKeyValuePairs(SkTArray<SkString>* keys, SkTArray<double>* values) const;
+        void dumpKeyValuePairs(skia_private::TArray<SkString>* keys,
+                               skia_private::TArray<double>* values) const;
         void dump() const;
         void merge(const DMSAAStats&);
         int fNumRenderPasses = 0;

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

@@ -8,13 +8,18 @@
 #ifndef GrTypes_DEFINED
 #define GrTypes_DEFINED
 
-#include "include/core/SkMath.h"
 #include "include/core/SkTypes.h"
-#include "include/gpu/GrConfig.h"
+#include "include/private/base/SkTo.h" // IWYU pragma: keep
 
+#include <cstddef>
+#include <cstdint>
 class GrBackendSemaphore;
-class SkImage;
-class SkSurface;
+
+namespace skgpu {
+enum class Mipmapped : bool;
+enum class Protected : bool;
+enum class Renderable : bool;
+}
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -122,28 +127,20 @@ static constexpr GrBackendApi kMock_GrBackend = GrBackendApi::kMock;
 /**
  * Used to say whether a texture has mip levels allocated or not.
  */
-enum class GrMipmapped : bool {
-    kNo = false,
-    kYes = true
-};
-/** Deprecated legacy alias of GrMipmapped. */
-using GrMipMapped = GrMipmapped;
+/** 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?
  */
-enum class GrRenderable : bool {
-    kNo = false,
-    kYes = true
-};
+using GrRenderable = skgpu::Renderable;
 
 /*
  * Used to say whether texture is backed by protected memory.
  */
-enum class GrProtected : bool {
-    kNo = false,
-    kYes = true
-};
+using GrProtected = skgpu::Protected;
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -188,6 +185,9 @@ typedef void (*GrGpuFinishedProc)(GrGpuFinishedContext finishedContext);
 typedef void* GrGpuSubmittedContext;
 typedef void (*GrGpuSubmittedProc)(GrGpuSubmittedContext submittedContext, bool success);
 
+typedef void* GrDirectContextDestroyedContext;
+typedef void (*GrDirectContextDestroyedProc)(GrDirectContextDestroyedContext destroyedContext);
+
 /**
  * Struct to supply options to flush calls.
  *

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

@@ -22,7 +22,7 @@
 // prepared to rename those identifiers.
 
 #include "include/core/SkRefCnt.h"
-#include "include/gpu/GrTypes.h"
+#include "include/gpu/GpuTypes.h"
 #include <d3d12.h>
 #include <dxgi1_4.h>
 
@@ -184,7 +184,7 @@ struct GrD3DTextureResourceInfo {
     uint32_t                 fSampleCount          = 1;
     uint32_t                 fLevelCount           = 0;
     unsigned int             fSampleQualityPattern = DXGI_STANDARD_MULTISAMPLE_QUALITY_PATTERN;
-    GrProtected              fProtected            = GrProtected::kNo;
+    skgpu::Protected         fProtected            = skgpu::Protected::kNo;
 
     GrD3DTextureResourceInfo() = default;
 
@@ -195,7 +195,7 @@ struct GrD3DTextureResourceInfo {
                              uint32_t sampleCount,
                              uint32_t levelCount,
                              unsigned int sampleQualityLevel,
-                             GrProtected isProtected = GrProtected::kNo)
+                             skgpu::Protected isProtected = skgpu::Protected::kNo)
             : fResource(resource)
             , fAlloc(alloc)
             , fResourceState(resourceState)
@@ -239,7 +239,7 @@ struct GrD3DFenceInfo {
 struct GrD3DSurfaceInfo {
     uint32_t fSampleCount = 1;
     uint32_t fLevelCount = 0;
-    GrProtected fProtected = GrProtected::kNo;
+    skgpu::Protected fProtected = skgpu::Protected::kNo;
 
     DXGI_FORMAT fFormat = DXGI_FORMAT_UNKNOWN;
     unsigned int fSampleQualityPattern = DXGI_STANDARD_MULTISAMPLE_QUALITY_PATTERN;

package/cpp/skia/include/gpu/dawn/GrDawnTypes.h

@@ -8,7 +8,7 @@
 #ifndef GrDawnTypes_DEFINED
 #define GrDawnTypes_DEFINED
 
-#include "include/gpu/GrTypes.h"
+#include "include/gpu/GpuTypes.h"
 
 #ifdef Always
 #undef Always
@@ -22,7 +22,7 @@ static constexpr int Success = 0;
 #undef None
 static constexpr int None = 0L;
 #endif
-#include "webgpu/webgpu_cpp.h"
+#include "webgpu/webgpu_cpp.h" // IWYU pragma: export
 
 struct GrDawnTextureInfo {
     wgpu::Texture       fTexture;
@@ -87,7 +87,7 @@ struct GrDawnRenderTargetInfo {
 struct GrDawnSurfaceInfo {
     uint32_t fSampleCount = 1;
     uint32_t fLevelCount = 0;
-    GrProtected fProtected = GrProtected::kNo;
+    skgpu::Protected fProtected = skgpu::Protected::kNo;
 
     wgpu::TextureFormat fFormat;
 };

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

@@ -0,0 +1,77 @@
+/*
+ * 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 GrTextureGenerator_DEFINED
+#define GrTextureGenerator_DEFINED
+
+#include "include/core/SkImageGenerator.h"
+#include "include/core/SkRefCnt.h"
+#include "include/gpu/GrTypes.h"
+#include "include/private/base/SkAPI.h"
+
+#include <cstdint>
+#include <memory>
+
+class GrRecordingContext;
+class GrSurfaceProxyView;
+class SkImage;
+enum class GrImageTexGenPolicy : int;
+namespace skgpu { enum class Mipmapped : bool; }
+struct SkImageInfo;
+
+class SK_API GrTextureGenerator : public SkImageGenerator {
+public:
+     bool isTextureGenerator() const final { return true; }
+
+    /**
+     *  If the generator can natively/efficiently return its pixels as a GPU image (backed by a
+     *  texture) this will return that image. If not, this will return NULL.
+     *
+     *  Regarding the GrRecordingContext parameter:
+     *
+     *  It must be non-NULL. The generator should only succeed if:
+     *  - its internal context is the same
+     *  - it can somehow convert its texture into one that is valid for the provided context.
+     *
+     *  If the mipmapped parameter is kYes, the generator should try to create a TextureProxy that
+     *  at least has the mip levels allocated and the base layer filled in. If this is not possible,
+     *  the generator is allowed to return a non mipped proxy, but this will have some additional
+     *  overhead in later allocating mips and copying of the base layer.
+     *
+     *  GrImageTexGenPolicy determines whether or not a new texture must be created (and its budget
+     *  status) or whether this may (but is not required to) return a pre-existing texture that is
+     *  retained by the generator (kDraw).
+     */
+    GrSurfaceProxyView generateTexture(GrRecordingContext*,
+                                       const SkImageInfo& info,
+                                       skgpu::Mipmapped mipmapped,
+                                       GrImageTexGenPolicy);
+
+    virtual GrSurfaceProxyView onGenerateTexture(GrRecordingContext*, const SkImageInfo&,
+                                                 skgpu::Mipmapped, GrImageTexGenPolicy) = 0;
+
+    // Most internal SkImageGenerators produce textures and views that use kTopLeft_GrSurfaceOrigin.
+    // If the generator may produce textures with different origins (e.g.
+    // GrAHardwareBufferImageGenerator) it should override this function to return the correct
+    // origin. Implementations should be thread-safe.
+    virtual GrSurfaceOrigin origin() const { return kTopLeft_GrSurfaceOrigin; }
+
+protected:
+    GrTextureGenerator(const SkImageInfo& info, uint32_t uniqueId = kNeedNewImageUniqueID);
+};
+
+namespace SkImages {
+/**
+ *   Like SkImages::DeferredFromGenerator except allows for the use of SkGaneshTextureGenerator.
+ *
+ *   @param gen producer of textures
+ *   @return    created SkImage, or nullptr
+ */
+SK_API sk_sp<SkImage> DeferredFromTextureGenerator(std::unique_ptr<GrTextureGenerator> gen);
+}
+
+#endif  // GrTextureGenerator_DEFINED