@shopify/react-native-skia 0.1.115

package/cpp/skia/include/private/GrContext_Base.h

@@ -0,0 +1,92 @@
+/*
+ * Copyright 2019 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrContext_Base_DEFINED
+#define GrContext_Base_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/gpu/GrBackendSurface.h"
+#include "include/gpu/GrContextOptions.h"
+#include "include/gpu/GrTypes.h"
+
+class GrBaseContextPriv;
+class GrCaps;
+class GrContextThreadSafeProxy;
+class GrDirectContext;
+class GrImageContext;
+class GrRecordingContext;
+
+class GrContext_Base : public SkRefCnt {
+public:
+    ~GrContext_Base() override;
+
+    /*
+     * Safely downcast to a GrDirectContext.
+     */
+    virtual GrDirectContext* asDirectContext() { return nullptr; }
+
+    /*
+     * The 3D API backing this context
+     */
+    SK_API GrBackendApi backend() const;
+
+    /*
+     * Retrieve the default GrBackendFormat for a given SkColorType and renderability.
+     * It is guaranteed that this backend format will be the one used by the GrContext
+     * SkColorType and SkSurfaceCharacterization-based createBackendTexture methods.
+     *
+     * The caller should check that the returned format is valid.
+     */
+    SK_API GrBackendFormat defaultBackendFormat(SkColorType, GrRenderable) const;
+
+    SK_API GrBackendFormat compressedBackendFormat(SkImage::CompressionType) const;
+
+    // TODO: When the public version is gone, rename to refThreadSafeProxy and add raw ptr ver.
+    sk_sp<GrContextThreadSafeProxy> threadSafeProxy();
+
+    // Provides access to functions that aren't part of the public API.
+    GrBaseContextPriv priv();
+    const GrBaseContextPriv priv() const;  // NOLINT(readability-const-return-type)
+
+protected:
+    friend class GrBaseContextPriv; // for hidden functions
+
+    GrContext_Base(sk_sp<GrContextThreadSafeProxy>);
+
+    virtual bool init();
+
+    /**
+     * An identifier for this context. The id is used by all compatible contexts. For example,
+     * if SkImages are created on one thread using an image creation context, then fed into a
+     * DDL Recorder on second thread (which has a recording context) and finally replayed on
+     * a third thread with a direct context, then all three contexts will report the same id.
+     * It is an error for an image to be used with contexts that report different ids.
+     */
+    uint32_t contextID() const;
+
+    bool matches(GrContext_Base* candidate) const {
+        return candidate && candidate->contextID() == this->contextID();
+    }
+
+    /*
+     * The options in effect for this context
+     */
+    const GrContextOptions& options() const;
+
+    const GrCaps* caps() const;
+    sk_sp<const GrCaps> refCaps() const;
+
+    virtual GrImageContext* asImageContext() { return nullptr; }
+    virtual GrRecordingContext* asRecordingContext() { return nullptr; }
+
+    sk_sp<GrContextThreadSafeProxy>         fThreadSafeProxy;
+
+private:
+    using INHERITED = SkRefCnt;
+};
+
+#endif

package/cpp/skia/include/private/GrD3DTypesMinimal.h

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2020 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrD3DTypesMinimal_DEFINED
+#define GrD3DTypesMinimal_DEFINED
+
+// Minimal definitions of Direct3D types, without including d3d12.h
+
+#include "include/core/SkRefCnt.h"
+
+#include <dxgiformat.h>
+
+#include "include/gpu/GrTypes.h"
+
+struct ID3D12Resource;
+class GrD3DResourceState;
+typedef int GrD3DResourceStateEnum;
+struct GrD3DSurfaceInfo;
+struct GrD3DTextureResourceInfo;
+struct GrD3DTextureResourceSpec;
+struct GrD3DFenceInfo;
+
+// This struct is to used to store the the actual information about the Direct3D backend image on
+// GrBackendTexture and GrBackendRenderTarget. When a client calls getD3DTextureInfo on a
+// GrBackendTexture/RenderTarget, we use the GrD3DBackendSurfaceInfo to create a snapshot
+// GrD3DTextureResourceInfo object. Internally, this uses a ref count GrD3DResourceState object to
+// track the current D3D12_RESOURCE_STATES which can be shared with an internal GrD3DTextureResource
+// so that state updates can be seen by all users of the texture.
+struct GrD3DBackendSurfaceInfo {
+    GrD3DBackendSurfaceInfo(const GrD3DTextureResourceInfo& info, GrD3DResourceState* state);
+
+    void cleanup();
+
+    GrD3DBackendSurfaceInfo& operator=(const GrD3DBackendSurfaceInfo&) = delete;
+
+    // Assigns the passed in GrD3DBackendSurfaceInfo to this object. if isValid is true we will also
+    // attempt to unref the old fLayout on this object.
+    void assign(const GrD3DBackendSurfaceInfo&, bool isValid);
+
+    void setResourceState(GrD3DResourceStateEnum state);
+
+    sk_sp<GrD3DResourceState> getGrD3DResourceState() const;
+
+    GrD3DTextureResourceInfo snapTextureResourceInfo() const;
+
+    bool isProtected() const;
+#if GR_TEST_UTILS
+    bool operator==(const GrD3DBackendSurfaceInfo& that) const;
+#endif
+
+private:
+    GrD3DTextureResourceInfo* fTextureResourceInfo;
+    GrD3DResourceState* fResourceState;
+};
+
+struct GrD3DTextureResourceSpecHolder {
+public:
+    GrD3DTextureResourceSpecHolder(const GrD3DSurfaceInfo&);
+
+    void cleanup();
+
+    GrD3DSurfaceInfo getSurfaceInfo(uint32_t sampleCount,
+                                    uint32_t levelCount,
+                                    GrProtected isProtected) const;
+
+private:
+    GrD3DTextureResourceSpec* fSpec;
+};
+
+#endif

package/cpp/skia/include/private/GrDawnTypesPriv.h

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrDawnTypesPriv_DEFINED
+#define GrDawnTypesPriv_DEFINED
+
+#include "include/gpu/dawn/GrDawnTypes.h"
+
+struct GrDawnTextureSpec {
+    GrDawnTextureSpec() {}
+    GrDawnTextureSpec(const GrDawnSurfaceInfo& info) : fFormat(info.fFormat) {}
+
+    wgpu::TextureFormat fFormat;
+};
+
+GrDawnSurfaceInfo GrDawnTextureSpecToSurfaceInfo(const GrDawnTextureSpec& dawnSpec,
+                                                 uint32_t sampleCount,
+                                                 uint32_t levelCount,
+                                                 GrProtected isProtected);
+
+#endif
+

package/cpp/skia/include/private/GrGLTypesPriv.h

@@ -0,0 +1,107 @@
+/*
+ * Copyright 2019 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "include/core/SkRefCnt.h"
+#include "include/gpu/gl/GrGLTypes.h"
+
+#ifndef GrGLTypesPriv_DEFINED
+#define GrGLTypesPriv_DEFINED
+
+static constexpr int kGrGLColorFormatCount = static_cast<int>(GrGLFormat::kLastColorFormat) + 1;
+
+class GrGLTextureParameters : public SkNVRefCnt<GrGLTextureParameters> {
+public:
+    // We currently consider texture parameters invalid on all textures
+    // GrContext::resetContext(). We use this type to track whether instances of
+    // GrGLTextureParameters were updated before or after the most recent resetContext(). At 10
+    // resets / frame and 60fps a 64bit timestamp will overflow in about a billion years.
+    // TODO: Require clients to use GrBackendTexture::glTextureParametersModified() to invalidate
+    // texture parameters and get rid of timestamp checking.
+    using ResetTimestamp = uint64_t;
+
+    // This initializes the params to have an expired timestamp. They'll be considered invalid the
+    // first time the texture is used unless set() is called.
+    GrGLTextureParameters() = default;
+
+    // This is texture parameter state that is overridden when a non-zero sampler object is bound.
+    struct SamplerOverriddenState {
+        SamplerOverriddenState();
+        void invalidate();
+
+        GrGLenum fMinFilter;
+        GrGLenum fMagFilter;
+        GrGLenum fWrapS;
+        GrGLenum fWrapT;
+        GrGLfloat fMinLOD;
+        GrGLfloat fMaxLOD;
+        // We always want the border color to be transparent black, so no need to store 4 floats.
+        // Just track if it's been invalidated and no longer the default
+        bool fBorderColorInvalid;
+    };
+
+    // Texture parameter state that is not overridden by a bound sampler object.
+    struct NonsamplerState {
+        NonsamplerState();
+        void invalidate();
+
+        GrGLint fBaseMipMapLevel;
+        GrGLint fMaxMipmapLevel;
+        bool    fSwizzleIsRGBA;
+    };
+
+    void invalidate();
+
+    ResetTimestamp resetTimestamp() const { return fResetTimestamp; }
+    const SamplerOverriddenState& samplerOverriddenState() const { return fSamplerOverriddenState; }
+    const NonsamplerState& nonsamplerState() const { return fNonsamplerState; }
+
+    // SamplerOverriddenState is optional because we don't track it when we're using sampler
+    // objects.
+    void set(const SamplerOverriddenState* samplerState,
+             const NonsamplerState& nonsamplerState,
+             ResetTimestamp currTimestamp);
+
+private:
+    static constexpr ResetTimestamp kExpiredTimestamp = 0;
+
+    SamplerOverriddenState fSamplerOverriddenState;
+    NonsamplerState fNonsamplerState;
+    ResetTimestamp fResetTimestamp = kExpiredTimestamp;
+};
+
+class GrGLBackendTextureInfo {
+public:
+    GrGLBackendTextureInfo(const GrGLTextureInfo& info, GrGLTextureParameters* params)
+            : fInfo(info), fParams(params) {}
+    GrGLBackendTextureInfo(const GrGLBackendTextureInfo&) = delete;
+    GrGLBackendTextureInfo& operator=(const GrGLBackendTextureInfo&) = delete;
+    const GrGLTextureInfo& info() const { return fInfo; }
+    GrGLTextureParameters* parameters() const { return fParams; }
+    sk_sp<GrGLTextureParameters> refParameters() const { return sk_ref_sp(fParams); }
+
+    void cleanup();
+    void assign(const GrGLBackendTextureInfo&, bool thisIsValid);
+
+private:
+    GrGLTextureInfo fInfo;
+    GrGLTextureParameters* fParams;
+};
+
+struct GrGLTextureSpec {
+    GrGLTextureSpec() : fTarget(0), fFormat(0) {}
+    GrGLTextureSpec(const GrGLSurfaceInfo& info) : fTarget(info.fTarget), fFormat(info.fFormat) {}
+
+    GrGLenum fTarget;
+    GrGLenum fFormat;
+};
+
+GrGLSurfaceInfo GrGLTextureSpecToSurfaceInfo(const GrGLTextureSpec& glSpec,
+                                             uint32_t sampleCount,
+                                             uint32_t levelCount,
+                                             GrProtected isProtected);
+
+#endif

package/cpp/skia/include/private/GrImageContext.h

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2019 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrImageContext_DEFINED
+#define GrImageContext_DEFINED
+
+#include "include/private/GrContext_Base.h"
+#include "include/private/GrSingleOwner.h"
+
+class GrImageContextPriv;
+
+// This is now just a view on a ThreadSafeProxy, that SkImages can attempt to
+// downcast to a GrDirectContext as a backdoor to some operations. Once we remove the backdoors,
+// this goes away and SkImages just hold ThreadSafeProxies.
+class GrImageContext : public GrContext_Base {
+public:
+    ~GrImageContext() override;
+
+    // Provides access to functions that aren't part of the public API.
+    GrImageContextPriv priv();
+    const GrImageContextPriv priv() const;  // NOLINT(readability-const-return-type)
+
+protected:
+    friend class GrImageContextPriv; // for hidden functions
+
+    GrImageContext(sk_sp<GrContextThreadSafeProxy>);
+
+    SK_API virtual void abandonContext();
+    SK_API virtual bool abandoned();
+
+    /** This is only useful for debug purposes */
+    GrSingleOwner* singleOwner() const { return &fSingleOwner; }
+
+    GrImageContext* asImageContext() override { return this; }
+
+private:
+    // When making promise images, we currently need a placeholder GrImageContext instance to give
+    // to the SkImage that has no real power, just a wrapper around the ThreadSafeProxy.
+    // TODO: De-power SkImage to ThreadSafeProxy or at least figure out a way to share one instance.
+    static sk_sp<GrImageContext> MakeForPromiseImage(sk_sp<GrContextThreadSafeProxy>);
+
+    // In debug builds we guard against improper thread handling
+    // This guard is passed to the GrDrawingManager and, from there to all the
+    // GrSurfaceDrawContexts.  It is also passed to the GrResourceProvider and SkGpuDevice.
+    // TODO: Move this down to GrRecordingContext.
+    mutable GrSingleOwner            fSingleOwner;
+
+    using INHERITED = GrContext_Base;
+};
+
+#endif

package/cpp/skia/include/private/GrMockTypesPriv.h

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrMockTypesPriv_DEFINED
+#define GrMockTypesPriv_DEFINED
+
+#include "include/gpu/mock/GrMockTypes.h"
+
+struct GrMockTextureSpec {
+    GrMockTextureSpec()
+            : fColorType(GrColorType::kUnknown)
+             , fCompressionType(SkImage::CompressionType::kNone) {}
+    GrMockTextureSpec(const GrMockSurfaceInfo& info)
+            : fColorType(info.fColorType)
+            , fCompressionType(info.fCompressionType) {}
+
+    GrColorType fColorType = GrColorType::kUnknown;
+    SkImage::CompressionType fCompressionType = SkImage::CompressionType::kNone;
+};
+
+GrMockSurfaceInfo GrMockTextureSpecToSurfaceInfo(const GrMockTextureSpec& mockSpec,
+                                                 uint32_t sampleCount,
+                                                 uint32_t levelCount,
+                                                 GrProtected isProtected);
+
+#endif
+

package/cpp/skia/include/private/GrMtlTypesPriv.h

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2021 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrMtlTypesPriv_DEFINED
+#define GrMtlTypesPriv_DEFINED
+
+#include "include/gpu/GrTypes.h"
+#include "include/gpu/mtl/GrMtlTypes.h"
+
+///////////////////////////////////////////////////////////////////////////////
+
+#ifdef __APPLE__
+
+#include <TargetConditionals.h>
+
+#if defined(SK_BUILD_FOR_MAC)
+#if __MAC_OS_X_VERSION_MAX_ALLOWED >= 110000
+#define GR_METAL_SDK_VERSION 230
+#elif __MAC_OS_X_VERSION_MAX_ALLOWED >= 101500
+#define GR_METAL_SDK_VERSION 220
+#elif __MAC_OS_X_VERSION_MAX_ALLOWED >= 101400
+#define GR_METAL_SDK_VERSION 210
+#else
+#error Must use at least 10.14 SDK to build Metal backend for MacOS
+#endif
+#else
+#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 140000 || __TV_OS_VERSION_MAX_ALLOWED >= 140000
+#define GR_METAL_SDK_VERSION 230
+#elif __IPHONE_OS_VERSION_MAX_ALLOWED >= 130000 || __TV_OS_VERSION_MAX_ALLOWED >= 130000
+#define GR_METAL_SDK_VERSION 220
+#elif __IPHONE_OS_VERSION_MAX_ALLOWED >= 120000 || __TV_OS_VERSION_MAX_ALLOWED >= 120000
+#define GR_METAL_SDK_VERSION 210
+#else
+#error Must use at least 12.00 SDK to build Metal backend for iOS
+#endif
+#endif
+
+#if __has_feature(objc_arc) && __has_attribute(objc_externally_retained)
+#define GR_NORETAIN __attribute__((objc_externally_retained))
+#define GR_NORETAIN_BEGIN \
+    _Pragma("clang attribute push (__attribute__((objc_externally_retained)), apply_to=any(function,objc_method))")
+#define GR_NORETAIN_END _Pragma("clang attribute pop")
+#else
+#define GR_NORETAIN
+#define GR_NORETAIN_BEGIN
+#define GR_NORETAIN_END
+#endif
+
+struct GrMtlTextureSpec {
+    GrMtlTextureSpec()
+            : fFormat(0)
+            , fUsage(0)
+            , fStorageMode(0) {}
+    GrMtlTextureSpec(const GrMtlSurfaceInfo& info)
+            : fFormat(info.fFormat)
+            , fUsage(info.fUsage)
+            , fStorageMode(info.fStorageMode) {}
+
+    GrMTLPixelFormat fFormat;
+    GrMTLTextureUsage fUsage;
+    GrMTLStorageMode fStorageMode;
+};
+
+GrMtlSurfaceInfo GrMtlTextureSpecToSurfaceInfo(const GrMtlTextureSpec& mtlSpec,
+                                               uint32_t sampleCount,
+                                               uint32_t levelCount,
+                                               GrProtected isProtected);
+
+#endif  // __APPLE__
+
+#endif  // GrMtlTypesPriv_DEFINED

package/cpp/skia/include/private/GrSingleOwner.h

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrSingleOwner_DEFINED
+#define GrSingleOwner_DEFINED
+
+#include "include/core/SkTypes.h"
+
+#ifdef SK_DEBUG
+#include "include/private/SkMutex.h"
+#include "include/private/SkThreadID.h"
+
+#define GR_ASSERT_SINGLE_OWNER(obj) \
+    GrSingleOwner::AutoEnforce debug_SingleOwner(obj, __FILE__, __LINE__);
+
+// This is a debug tool to verify an object is only being used from one thread at a time.
+class GrSingleOwner {
+public:
+     GrSingleOwner() : fOwner(kIllegalThreadID), fReentranceCount(0) {}
+
+     struct AutoEnforce {
+         AutoEnforce(GrSingleOwner* so, const char* file, int line)
+                : fFile(file), fLine(line), fSO(so) {
+             fSO->enter(file, line);
+         }
+         ~AutoEnforce() { fSO->exit(fFile, fLine); }
+
+         const char* fFile;
+         int fLine;
+         GrSingleOwner* fSO;
+     };
+
+private:
+     void enter(const char* file, int line) {
+         SkAutoMutexExclusive lock(fMutex);
+         SkThreadID self = SkGetThreadID();
+         SkASSERTF(fOwner == self || fOwner == kIllegalThreadID, "%s:%d Single owner failure.",
+                   file, line);
+         fReentranceCount++;
+         fOwner = self;
+     }
+
+     void exit(const char* file, int line) {
+         SkAutoMutexExclusive lock(fMutex);
+         SkASSERTF(fOwner == SkGetThreadID(), "%s:%d Single owner failure.", file, line);
+         fReentranceCount--;
+         if (fReentranceCount == 0) {
+             fOwner = kIllegalThreadID;
+         }
+     }
+
+     SkMutex fMutex;
+     SkThreadID fOwner    SK_GUARDED_BY(fMutex);
+     int fReentranceCount SK_GUARDED_BY(fMutex);
+};
+#else
+#define GR_ASSERT_SINGLE_OWNER(obj)
+class GrSingleOwner {}; // Provide a no-op implementation so we can pass pointers to constructors
+#endif
+
+#endif