@shopify/react-native-skia 1.3.13 → 1.4.0

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

@@ -0,0 +1,130 @@
+/*
+ * 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 GrYUVABackendTextures_DEFINED
+#define GrYUVABackendTextures_DEFINED
+
+#include "include/core/SkTypes.h"
+#include "include/core/SkYUVAInfo.h"
+#include "include/gpu/GpuTypes.h"
+#include "include/gpu/ganesh/GrBackendSurface.h"
+#include "include/gpu/ganesh/GrTypes.h"
+
+#include <array>
+#include <cstddef>
+
+enum SkYUVColorSpace : int;
+
+/**
+ * A description of a set GrBackendTextures that hold the planar data described by a SkYUVAInfo.
+ */
+class SK_API GrYUVABackendTextureInfo {
+public:
+    static constexpr auto kMaxPlanes = SkYUVAInfo::kMaxPlanes;
+
+    /** Default GrYUVABackendTextureInfo is invalid. */
+    GrYUVABackendTextureInfo() = default;
+
+    /**
+     * Initializes a GrYUVABackendTextureInfo to describe a set of textures that can store the
+     * planes indicated by the SkYUVAInfo. The texture dimensions are taken from the SkYUVAInfo's
+     * plane dimensions. All the described textures share a common origin. The planar image this
+     * describes will be mip mapped if all the textures are individually mip mapped as indicated
+     * by skgpu::Mipmapped. This will produce an invalid result (return false from isValid()) if the
+     * passed formats' channels don't agree with SkYUVAInfo.
+     */
+    GrYUVABackendTextureInfo(const SkYUVAInfo&,
+                             const GrBackendFormat[kMaxPlanes],
+                             skgpu::Mipmapped,
+                             GrSurfaceOrigin);
+
+    GrYUVABackendTextureInfo(const GrYUVABackendTextureInfo&) = default;
+
+    GrYUVABackendTextureInfo& operator=(const GrYUVABackendTextureInfo&) = default;
+
+    bool operator==(const GrYUVABackendTextureInfo&) const;
+    bool operator!=(const GrYUVABackendTextureInfo& that) const { return !(*this == that); }
+
+    const SkYUVAInfo& yuvaInfo() const { return fYUVAInfo; }
+
+    SkYUVColorSpace yuvColorSpace() const { return fYUVAInfo.yuvColorSpace(); }
+
+    skgpu::Mipmapped mipmapped() const { return fMipmapped; }
+
+    GrSurfaceOrigin textureOrigin() const { return fTextureOrigin; }
+
+    /** The number of SkPixmap planes, 0 if this GrYUVABackendTextureInfo is invalid. */
+    int numPlanes() const { return fYUVAInfo.numPlanes(); }
+
+    /** Format of the ith plane, or invalid format if i >= numPlanes() */
+    const GrBackendFormat& planeFormat(int i) const { return fPlaneFormats[i]; }
+
+    /**
+     * Returns true if this has been configured with a valid SkYUVAInfo with compatible texture
+     * formats.
+     */
+    bool isValid() const { return fYUVAInfo.isValid(); }
+
+    /**
+     * Computes a YUVALocations representation of the planar layout. The result is guaranteed to be
+     * valid if this->isValid().
+     */
+    SkYUVAInfo::YUVALocations toYUVALocations() const;
+
+private:
+    SkYUVAInfo fYUVAInfo;
+    GrBackendFormat fPlaneFormats[kMaxPlanes];
+    skgpu::Mipmapped fMipmapped = skgpu::Mipmapped::kNo;
+    GrSurfaceOrigin fTextureOrigin = kTopLeft_GrSurfaceOrigin;
+};
+
+/**
+ * A set of GrBackendTextures that hold the planar data for an image described a SkYUVAInfo.
+ */
+class SK_API GrYUVABackendTextures {
+public:
+    GrYUVABackendTextures() = default;
+    GrYUVABackendTextures(const GrYUVABackendTextures&) = delete;
+    GrYUVABackendTextures(GrYUVABackendTextures&&) = default;
+
+    GrYUVABackendTextures& operator=(const GrYUVABackendTextures&) = delete;
+    GrYUVABackendTextures& operator=(GrYUVABackendTextures&&) = default;
+
+    GrYUVABackendTextures(const SkYUVAInfo&,
+                          const GrBackendTexture[SkYUVAInfo::kMaxPlanes],
+                          GrSurfaceOrigin textureOrigin);
+
+    const std::array<GrBackendTexture, SkYUVAInfo::kMaxPlanes>& textures() const {
+        return fTextures;
+    }
+
+    GrBackendTexture texture(int i) const {
+        SkASSERT(i >= 0 && i < SkYUVAInfo::kMaxPlanes);
+        return fTextures[static_cast<size_t>(i)];
+    }
+
+    const SkYUVAInfo& yuvaInfo() const { return fYUVAInfo; }
+
+    int numPlanes() const { return fYUVAInfo.numPlanes(); }
+
+    GrSurfaceOrigin textureOrigin() const { return fTextureOrigin; }
+
+    bool isValid() const { return fYUVAInfo.isValid(); }
+
+    /**
+     * Computes a YUVALocations representation of the planar layout. The result is guaranteed to be
+     * valid if this->isValid().
+     */
+    SkYUVAInfo::YUVALocations toYUVALocations() const;
+
+private:
+    SkYUVAInfo fYUVAInfo;
+    std::array<GrBackendTexture, SkYUVAInfo::kMaxPlanes> fTextures;
+    GrSurfaceOrigin fTextureOrigin = kTopLeft_GrSurfaceOrigin;
+};
+
+#endif

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

@@ -11,7 +11,7 @@
 #include "include/core/SkImage.h"
 #include "include/core/SkRefCnt.h"
 #include "include/gpu/GpuTypes.h"
-#include "include/gpu/GrTypes.h"
+#include "include/gpu/ganesh/GrTypes.h"
 #include "include/private/base/SkAPI.h"
 
 #include <functional>

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

@@ -11,7 +11,7 @@
 #include "include/core/SkImageInfo.h"
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkSurface.h"
-#include "include/gpu/GrTypes.h"
+#include "include/gpu/ganesh/GrTypes.h"
 #include "include/private/base/SkAPI.h"
 
 class GrBackendRenderTarget;

package/cpp/skia/include/gpu/ganesh/d3d/GrD3DBackendContext.h

@@ -0,0 +1,35 @@
+/*
+ * 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 GrD3DBackendContext_DEFINED
+#define GrD3DBackendContext_DEFINED
+
+// GrD3DTypes.h includes d3d12.h, which in turn includes windows.h, which redefines many
+// common identifiers such as:
+// * interface
+// * small
+// * near
+// * far
+// * CreateSemaphore
+// * MemoryBarrier
+//
+// You should only include GrD3DBackendContext.h if you are prepared to rename those identifiers.
+#include "include/gpu/ganesh/d3d/GrD3DTypes.h"
+
+#include "include/gpu/ganesh/GrTypes.h"
+
+// The BackendContext contains all of the base D3D objects needed by the GrD3DGpu. The assumption
+// is that the client will set these up and pass them to the GrD3DGpu constructor.
+struct SK_API GrD3DBackendContext {
+    gr_cp<IDXGIAdapter1> fAdapter;
+    gr_cp<ID3D12Device> fDevice;
+    gr_cp<ID3D12CommandQueue> fQueue;
+    sk_sp<GrD3DMemoryAllocator> fMemoryAllocator;
+    GrProtected fProtectedContext = GrProtected::kNo;
+};
+
+#endif

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

@@ -0,0 +1,248 @@
+
+/*
+ * 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 GrD3DTypes_DEFINED
+#define GrD3DTypes_DEFINED
+
+// This file includes d3d12.h, which in turn includes windows.h, which redefines many
+// common identifiers such as:
+// * interface
+// * small
+// * near
+// * far
+// * CreateSemaphore
+// * MemoryBarrier
+//
+// You should only include this header if you need the Direct3D definitions and are
+// prepared to rename those identifiers.
+
+#include "include/core/SkRefCnt.h"
+#include "include/gpu/GpuTypes.h"
+#include <d3d12.h>
+#include <dxgi1_4.h>
+
+class GrD3DGpu;
+
+ /** Check if the argument is non-null, and if so, call obj->AddRef() and return obj.
+  */
+template <typename T> static inline T* GrSafeComAddRef(T* obj) {
+    if (obj) {
+        obj->AddRef();
+    }
+    return obj;
+}
+
+/** Check if the argument is non-null, and if so, call obj->Release()
+ */
+template <typename T> static inline void GrSafeComRelease(T* obj) {
+    if (obj) {
+        obj->Release();
+    }
+}
+
+template <typename T> class gr_cp {
+public:
+    using element_type = T;
+
+    constexpr gr_cp() : fObject(nullptr) {}
+    constexpr gr_cp(std::nullptr_t) : fObject(nullptr) {}
+
+    /**
+     *  Shares the underlying object by calling AddRef(), so that both the argument and the newly
+     *  created gr_cp both have a reference to it.
+     */
+    gr_cp(const gr_cp<T>& that) : fObject(GrSafeComAddRef(that.get())) {}
+
+    /**
+     *  Move the underlying object from the argument to the newly created gr_cp. Afterwards only
+     *  the new gr_cp will have a reference to the object, and the argument will point to null.
+     *  No call to AddRef() or Release() will be made.
+     */
+    gr_cp(gr_cp<T>&& that) : fObject(that.release()) {}
+
+    /**
+     *  Adopt the bare object into the newly created gr_cp.
+     *  No call to AddRef() or Release() will be made.
+     */
+    explicit gr_cp(T* obj) {
+        fObject = obj;
+    }
+
+    /**
+     *  Calls Release() on the underlying object pointer.
+     */
+    ~gr_cp() {
+        GrSafeComRelease(fObject);
+        SkDEBUGCODE(fObject = nullptr);
+    }
+
+    /**
+     *  Shares the underlying object referenced by the argument by calling AddRef() on it. If this
+     *  gr_cp previously had a reference to an object (i.e. not null) it will call Release()
+     *  on that object.
+     */
+    gr_cp<T>& operator=(const gr_cp<T>& that) {
+        if (this != &that) {
+            this->reset(GrSafeComAddRef(that.get()));
+        }
+        return *this;
+    }
+
+    /**
+     *  Move the underlying object from the argument to the gr_cp. If the gr_cp
+     *  previously held a reference to another object, Release() will be called on that object.
+     *  No call to AddRef() will be made.
+     */
+    gr_cp<T>& operator=(gr_cp<T>&& that) {
+        this->reset(that.release());
+        return *this;
+    }
+
+    explicit operator bool() const { return this->get() != nullptr; }
+
+    T* get() const { return fObject; }
+    T* operator->() const { return fObject; }
+    T** operator&() { return &fObject; }
+
+    /**
+     *  Adopt the new object, and call Release() on any previously held object (if not null).
+     *  No call to AddRef() will be made.
+     */
+    void reset(T* object = nullptr) {
+        T* oldObject = fObject;
+        fObject = object;
+        GrSafeComRelease(oldObject);
+    }
+
+    /**
+     *  Shares the new object by calling AddRef() on it. If this gr_cp previously had a
+     *  reference to an object (i.e. not null) it will call Release() on that object.
+     */
+    void retain(T* object) {
+        if (this->fObject != object) {
+            this->reset(GrSafeComAddRef(object));
+        }
+    }
+
+    /**
+     *  Return the original object, and set the internal object to nullptr.
+     *  The caller must assume ownership of the object, and manage its reference count directly.
+     *  No call to Release() will be made.
+     */
+    [[nodiscard]] T* release() {
+        T* obj = fObject;
+        fObject = nullptr;
+        return obj;
+    }
+
+private:
+    T* fObject;
+};
+
+template <typename T> inline bool operator==(const gr_cp<T>& a,
+                                             const gr_cp<T>& b) {
+    return a.get() == b.get();
+}
+
+template <typename T> inline bool operator!=(const gr_cp<T>& a,
+                                             const gr_cp<T>& b) {
+    return a.get() != b.get();
+}
+
+// interface classes for the GPU memory allocator
+class GrD3DAlloc : public SkRefCnt {
+public:
+    ~GrD3DAlloc() override = default;
+};
+
+class GrD3DMemoryAllocator : public SkRefCnt {
+public:
+    virtual gr_cp<ID3D12Resource> createResource(D3D12_HEAP_TYPE, const D3D12_RESOURCE_DESC*,
+                                                 D3D12_RESOURCE_STATES initialResourceState,
+                                                 sk_sp<GrD3DAlloc>* allocation,
+                                                 const D3D12_CLEAR_VALUE*) = 0;
+    virtual gr_cp<ID3D12Resource> createAliasingResource(sk_sp<GrD3DAlloc>& allocation,
+                                                         uint64_t localOffset,
+                                                         const D3D12_RESOURCE_DESC*,
+                                                         D3D12_RESOURCE_STATES initialResourceState,
+                                                         const D3D12_CLEAR_VALUE*) = 0;
+};
+
+// Note: there is no notion of Borrowed or Adopted resources in the D3D backend,
+// so Ganesh will ref fResource once it's asked to wrap it.
+// Clients are responsible for releasing their own ref to avoid memory leaks.
+struct GrD3DTextureResourceInfo {
+    gr_cp<ID3D12Resource>    fResource             = nullptr;
+    sk_sp<GrD3DAlloc>        fAlloc                = nullptr;
+    D3D12_RESOURCE_STATES    fResourceState        = D3D12_RESOURCE_STATE_COMMON;
+    DXGI_FORMAT              fFormat               = DXGI_FORMAT_UNKNOWN;
+    uint32_t                 fSampleCount          = 1;
+    uint32_t                 fLevelCount           = 0;
+    unsigned int             fSampleQualityPattern = DXGI_STANDARD_MULTISAMPLE_QUALITY_PATTERN;
+    skgpu::Protected         fProtected            = skgpu::Protected::kNo;
+
+    GrD3DTextureResourceInfo() = default;
+
+    GrD3DTextureResourceInfo(ID3D12Resource* resource,
+                             const sk_sp<GrD3DAlloc> alloc,
+                             D3D12_RESOURCE_STATES resourceState,
+                             DXGI_FORMAT format,
+                             uint32_t sampleCount,
+                             uint32_t levelCount,
+                             unsigned int sampleQualityLevel,
+                             skgpu::Protected isProtected = skgpu::Protected::kNo)
+            : fResource(resource)
+            , fAlloc(alloc)
+            , fResourceState(resourceState)
+            , fFormat(format)
+            , fSampleCount(sampleCount)
+            , fLevelCount(levelCount)
+            , fSampleQualityPattern(sampleQualityLevel)
+            , fProtected(isProtected) {}
+
+    GrD3DTextureResourceInfo(const GrD3DTextureResourceInfo& info,
+                             D3D12_RESOURCE_STATES resourceState)
+            : fResource(info.fResource)
+            , fAlloc(info.fAlloc)
+            , fResourceState(resourceState)
+            , fFormat(info.fFormat)
+            , fSampleCount(info.fSampleCount)
+            , fLevelCount(info.fLevelCount)
+            , fSampleQualityPattern(info.fSampleQualityPattern)
+            , fProtected(info.fProtected) {}
+
+#if defined(GPU_TEST_UTILS)
+    bool operator==(const GrD3DTextureResourceInfo& that) const {
+        return fResource == that.fResource && fResourceState == that.fResourceState &&
+               fFormat == that.fFormat && fSampleCount == that.fSampleCount &&
+               fLevelCount == that.fLevelCount &&
+               fSampleQualityPattern == that.fSampleQualityPattern && fProtected == that.fProtected;
+    }
+#endif
+};
+
+struct GrD3DFenceInfo {
+    GrD3DFenceInfo()
+        : fFence(nullptr)
+        , fValue(0) {
+    }
+
+    gr_cp<ID3D12Fence> fFence;
+    uint64_t           fValue;  // signal value for the fence
+};
+
+struct GrD3DSurfaceInfo {
+    uint32_t fSampleCount = 1;
+    uint32_t fLevelCount = 0;
+    skgpu::Protected fProtected = skgpu::Protected::kNo;
+
+    DXGI_FORMAT fFormat = DXGI_FORMAT_UNKNOWN;
+    unsigned int fSampleQualityPattern = DXGI_STANDARD_MULTISAMPLE_QUALITY_PATTERN;
+};
+
+#endif

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

@@ -0,0 +1,17 @@
+/*
+ * Copyright 2019 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#ifndef GrGLAssembleHelpers_DEFINED
+#define GrGLAssembleHelpers_DEFINED
+
+#include "include/gpu/ganesh/gl/GrGLAssembleInterface.h"
+#include "include/gpu/ganesh/gl/GrGLFunctions.h"
+#include "include/gpu/ganesh/gl/GrGLTypes.h"
+
+void GrGetEGLQueryAndDisplay(GrEGLQueryStringFn** queryString, GrEGLDisplay* display,
+                             void* ctx, GrGLGetProc get);
+
+#endif  // GrGLAssembleHelpers_DEFINED

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

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2014 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#ifndef GrGLAssembleInterface_DEFINED
+#define GrGLAssembleInterface_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/gpu/ganesh/gl/GrGLInterface.h"
+#include "include/private/base/SkAPI.h"
+
+typedef GrGLFuncPtr (*GrGLGetProc)(void* ctx, const char name[]);
+
+/**
+ * Generic function for creating a GrGLInterface for an either OpenGL or GLES. It calls
+ * get() to get each function address. ctx is a generic ptr passed to and interpreted by get().
+ */
+SK_API sk_sp<const GrGLInterface> GrGLMakeAssembledInterface(void *ctx, GrGLGetProc get);
+
+/**
+ * Generic function for creating a GrGLInterface for an OpenGL (but not GLES) context. It calls
+ * get() to get each function address. ctx is a generic ptr passed to and interpreted by get().
+ */
+SK_API sk_sp<const GrGLInterface> GrGLMakeAssembledGLInterface(void *ctx, GrGLGetProc get);
+
+/**
+ * Generic function for creating a GrGLInterface for an OpenGL ES (but not Open GL) context. It
+ * calls get() to get each function address. ctx is a generic ptr passed to and interpreted by
+ * get().
+ */
+SK_API sk_sp<const GrGLInterface> GrGLMakeAssembledGLESInterface(void *ctx, GrGLGetProc get);
+
+/**
+ * Generic function for creating a GrGLInterface for a WebGL (similar to OpenGL ES) context. It
+ * calls get() to get each function address. ctx is a generic ptr passed to and interpreted by
+ * get().
+ */
+SK_API sk_sp<const GrGLInterface> GrGLMakeAssembledWebGLInterface(void *ctx, GrGLGetProc get);
+
+/** Deprecated version of GrGLMakeAssembledInterface() that returns a bare pointer. */
+SK_API const GrGLInterface* GrGLAssembleInterface(void *ctx, GrGLGetProc get);
+
+#endif  // GrGLAssembleInterface_DEFINED

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

@@ -8,7 +8,7 @@
 #ifndef GrGLBackendSurface_DEFINED
 #define GrGLBackendSurface_DEFINED
 
-#include "include/gpu/gl/GrGLTypes.h"
+#include "include/gpu/ganesh/gl/GrGLTypes.h"
 #include "include/private/base/SkAPI.h"
 
 #include <string_view>

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

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrGLConfig_DEFINED
+#define GrGLConfig_DEFINED
+
+#include "include/private/base/SkLoadUserConfig.h"
+
+#if !defined(GR_GL_FUNCTION_TYPE)
+    #if defined(SK_BUILD_FOR_WIN)
+        #define GR_GL_FUNCTION_TYPE __stdcall
+    #else
+        #define GR_GL_FUNCTION_TYPE
+    #endif
+#endif
+
+/**
+ * The following are optional defines that can be enabled at the compiler
+ * command line, in a IDE project, in a GrUserConfig.h file, or in a GL custom
+ * file (if one is in use). If a GR_GL_CUSTOM_SETUP_HEADER is used they can
+ * also be placed there.
+ *
+ * GR_GL_LOG_CALLS: if 1 Gr can print every GL call using SkDebugf. Defaults to
+ * 0. Logging can be enabled and disabled at runtime using a debugger via to
+ * global gLogCallsGL. The initial value of gLogCallsGL is controlled by
+ * GR_GL_LOG_CALLS_START.
+ *
+ * GR_GL_LOG_CALLS_START: controls the initial value of gLogCallsGL when
+ * GR_GL_LOG_CALLS is 1. Defaults to 0.
+ *
+ * GR_GL_CHECK_ERROR: if enabled Gr can do a glGetError() after every GL call.
+ * Defaults to 1 if SK_DEBUG is set, otherwise 0. When GR_GL_CHECK_ERROR is 1
+ * this can be toggled in a debugger using the gCheckErrorGL global. The initial
+ * value of gCheckErrorGL is controlled by by GR_GL_CHECK_ERROR_START.
+ *
+ * GR_GL_CHECK_ERROR_START: controls the initial value of gCheckErrorGL
+ * when GR_GL_CHECK_ERROR is 1.  Defaults to 1.
+ *
+ */
+
+#if !defined(GR_GL_LOG_CALLS)
+    #ifdef SK_DEBUG
+        #define GR_GL_LOG_CALLS 1
+    #else
+        #define GR_GL_LOG_CALLS 0
+    #endif
+#endif
+
+#if !defined(GR_GL_LOG_CALLS_START)
+    #define GR_GL_LOG_CALLS_START 0
+#endif
+
+#if !defined(GR_GL_CHECK_ERROR)
+    #ifdef SK_DEBUG
+        #define GR_GL_CHECK_ERROR 1
+    #else
+        #define GR_GL_CHECK_ERROR 0
+    #endif
+#endif
+
+#if !defined(GR_GL_CHECK_ERROR_START)
+    #define GR_GL_CHECK_ERROR_START 1
+#endif
+
+#endif

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

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrGLExtensions_DEFINED
+#define GrGLExtensions_DEFINED
+
+#include "include/core/SkString.h"
+#include "include/gpu/ganesh/gl/GrGLFunctions.h"
+#include "include/gpu/ganesh/gl/GrGLTypes.h"
+#include "include/private/base/SkAPI.h"
+#include "include/private/base/SkTArray.h"
+
+#include <utility>
+
+class SkJSONWriter;
+
+/**
+ * This helper queries the current GL context for its extensions, remembers them, and can be
+ * queried. It supports both glGetString- and glGetStringi-style extension string APIs and will
+ * use the latter if it is available. It also will query for EGL extensions if a eglQueryString
+ * implementation is provided.
+ */
+class SK_API GrGLExtensions {
+public:
+    GrGLExtensions() {}
+
+    GrGLExtensions(const GrGLExtensions&);
+
+    GrGLExtensions& operator=(const GrGLExtensions&);
+
+    void swap(GrGLExtensions* that) {
+        using std::swap;
+        swap(fStrings, that->fStrings);
+        swap(fInitialized, that->fInitialized);
+    }
+
+    /**
+     * We sometimes need to use this class without having yet created a GrGLInterface. This version
+     * of init expects that getString is always non-NULL while getIntegerv and getStringi are non-
+     * NULL if on desktop GL with version 3.0 or higher. Otherwise it will fail.
+     */
+    bool init(GrGLStandard standard,
+              GrGLFunction<GrGLGetStringFn> getString,
+              GrGLFunction<GrGLGetStringiFn> getStringi,
+              GrGLFunction<GrGLGetIntegervFn> getIntegerv,
+              GrGLFunction<GrEGLQueryStringFn> queryString = nullptr,
+              GrEGLDisplay eglDisplay = nullptr);
+
+    bool isInitialized() const { return fInitialized; }
+
+    /**
+     * Queries whether an extension is present. This will fail if init() has not been called.
+     */
+    bool has(const char[]) const;
+
+    /**
+     * Removes an extension if present. Returns true if the extension was present before the call.
+     */
+    bool remove(const char[]);
+
+    /**
+     * Adds an extension to list
+     */
+    void add(const char[]);
+
+    void reset() { fStrings.clear(); }
+
+    void dumpJSON(SkJSONWriter*) const;
+
+private:
+    bool fInitialized = false;
+    skia_private::TArray<SkString> fStrings;
+};
+
+#endif