@shopify/react-native-skia 0.1.129 → 0.1.130

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

@@ -9,8 +9,8 @@
 #define GrRecordingContext_DEFINED
 
 #include "include/core/SkRefCnt.h"
-#include "include/private/GrImageContext.h"
 #include "include/private/SkTArray.h"
+#include "include/private/gpu/ganesh/GrImageContext.h"
 
 #if GR_GPU_STATS && GR_TEST_UTILS
 #include <map>
@@ -26,13 +26,16 @@ class GrProgramDesc;
 class GrProgramInfo;
 class GrProxyProvider;
 class GrRecordingContextPriv;
-class GrSubRunAllocator;
 class GrSurfaceProxy;
 class GrTextBlobRedrawCoordinator;
 class GrThreadSafeCache;
 class SkArenaAlloc;
 class SkJSONWriter;
 
+namespace sktext::gpu {
+class SubRunAllocator;
+}
+
 #if GR_TEST_UTILS
 class SkString;
 #endif
@@ -90,7 +93,9 @@ public:
      * rendering is supported for the color type. 0 is returned if rendering to this color type
      * is not supported at all.
      */
-    SK_API int maxSurfaceSampleCountForColorType(SkColorType) const;
+    SK_API int maxSurfaceSampleCountForColorType(SkColorType colorType) const {
+        return INHERITED::maxSurfaceSampleCountForColorType(colorType);
+    }
 
     // Provides access to functions that aren't part of the public API.
     GrRecordingContextPriv priv();
@@ -100,17 +105,19 @@ public:
     // GrRecordingContext. Arenas does not maintain ownership of the pools it groups together.
     class Arenas {
     public:
-        Arenas(SkArenaAlloc*, GrSubRunAllocator*);
+        Arenas(SkArenaAlloc*, sktext::gpu::SubRunAllocator*);
 
         // For storing pipelines and other complex data as-needed by ops
         SkArenaAlloc* recordTimeAllocator() { return fRecordTimeAllocator; }
 
         // For storing GrTextBlob SubRuns
-        GrSubRunAllocator* recordTimeSubRunAllocator() { return fRecordTimeSubRunAllocator; }
+        sktext::gpu::SubRunAllocator* recordTimeSubRunAllocator() {
+            return fRecordTimeSubRunAllocator;
+        }
 
     private:
         SkArenaAlloc* fRecordTimeAllocator;
-        GrSubRunAllocator* fRecordTimeSubRunAllocator;
+        sktext::gpu::SubRunAllocator* fRecordTimeSubRunAllocator;
     };
 
 protected:
@@ -131,7 +138,7 @@ protected:
     private:
         bool fDDLRecording;
         std::unique_ptr<SkArenaAlloc> fRecordTimeAllocator;
-        std::unique_ptr<GrSubRunAllocator> fRecordTimeSubRunAllocator;
+        std::unique_ptr<sktext::gpu::SubRunAllocator> fRecordTimeSubRunAllocator;
     };
 
     GrRecordingContext(sk_sp<GrContextThreadSafeProxy>, bool ddlRecording);

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

@@ -11,22 +11,22 @@
 #include "include/gpu/GrTypes.h"
 
 #ifdef SK_GL
-#include "include/private/GrGLTypesPriv.h"
+#include "include/private/gpu/ganesh/GrGLTypesPriv.h"
 #endif
 #ifdef SK_VULKAN
-#include "include/private/GrVkTypesPriv.h"
+#include "include/private/gpu/ganesh/GrVkTypesPriv.h"
 #endif
 #ifdef SK_DIRECT3D
-#include "include/private/GrD3DTypesMinimal.h"
+#include "include/private/gpu/ganesh/GrD3DTypesMinimal.h"
 struct GrD3DSurfaceInfo;
 #endif
 #ifdef SK_METAL
-#include "include/private/GrMtlTypesPriv.h"
+#include "include/private/gpu/ganesh/GrMtlTypesPriv.h"
 #endif
 #ifdef SK_DAWN
-#include "include/private/GrDawnTypesPriv.h"
+#include "include/private/gpu/ganesh/GrDawnTypesPriv.h"
 #endif
-#include "include/private/GrMockTypesPriv.h"
+#include "include/private/gpu/ganesh/GrMockTypesPriv.h"
 
 class GrSurfaceInfo {
 public:

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

@@ -22,7 +22,7 @@ static constexpr int Success = 0;
 #undef None
 static constexpr int None = 0L;
 #endif
-#include "dawn/webgpu_cpp.h"
+#include "webgpu/webgpu_cpp.h"
 
 struct GrDawnTextureInfo {
     wgpu::Texture       fTexture;

package/cpp/skia/include/gpu/gl/GrGLFunctions.h

@@ -96,6 +96,7 @@ using GrGLGenVertexArraysFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLsizei n, GrGLuint
 using GrGLGetBufferParameterivFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLenum pname, GrGLint* params);
 using GrGLGetErrorFn = GrGLenum GR_GL_FUNCTION_TYPE();
 using GrGLGetFramebufferAttachmentParameterivFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLenum attachment, GrGLenum pname, GrGLint* params);
+using GrGLGetFloatvFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum pname, GrGLfloat* params);
 using GrGLGetIntegervFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum pname, GrGLint* params);
 using GrGLGetMultisamplefvFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum pname, GrGLuint index, GrGLfloat* val);
 using GrGLGetProgramBinaryFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint program, GrGLsizei bufsize, GrGLsizei* length, GrGLenum* binaryFormat, void* binary);
@@ -142,7 +143,8 @@ using GrGLReadPixelsFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLint x, GrGLint y, GrGL
 using GrGLRenderbufferStorageFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLenum internalformat, GrGLsizei width, GrGLsizei height);
 using GrGLRenderbufferStorageMultisampleFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLsizei samples, GrGLenum internalformat, GrGLsizei width, GrGLsizei height);
 using GrGLResolveMultisampleFramebufferFn = GrGLvoid GR_GL_FUNCTION_TYPE();
-using GrGLSamplerParameteriFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint sampler, GrGLenum pname, GrGLint params);
+using GrGLSamplerParameterfFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint sampler, GrGLenum pname, GrGLfloat param);
+using GrGLSamplerParameteriFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint sampler, GrGLenum pname, GrGLint param);
 using GrGLSamplerParameterivFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint sampler, GrGLenum pname, const GrGLint* params);
 using GrGLScissorFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLint x, GrGLint y, GrGLsizei width, GrGLsizei height);
 // GL_CHROMIUM_bind_uniform_location

package/cpp/skia/include/gpu/gl/GrGLInterface.h

@@ -31,8 +31,6 @@ struct GrGLInterface;
  * appropriate one to build.
  */
 SK_API sk_sp<const GrGLInterface> GrGLMakeNativeInterface();
-// Deprecated alternative to GrGLMakeNativeInterface().
-SK_API const GrGLInterface* GrGLCreateNativeInterface();
 
 /**
  * GrContext uses the following interface to make all calls into OpenGL. When a
@@ -170,6 +168,7 @@ public:
         GrGLFunction<GrGLGetBufferParameterivFn> fGetBufferParameteriv;
         GrGLFunction<GrGLGetErrorFn> fGetError;
         GrGLFunction<GrGLGetFramebufferAttachmentParameterivFn> fGetFramebufferAttachmentParameteriv;
+        GrGLFunction<GrGLGetFloatvFn> fGetFloatv;
         GrGLFunction<GrGLGetIntegervFn> fGetIntegerv;
         GrGLFunction<GrGLGetMultisamplefvFn> fGetMultisamplefv;
         GrGLFunction<GrGLGetProgramBinaryFn> fGetProgramBinary;
@@ -248,6 +247,7 @@ public:
         GrGLFunction<GrGLBindUniformLocationFn> fBindUniformLocation;
 
         GrGLFunction<GrGLResolveMultisampleFramebufferFn> fResolveMultisampleFramebuffer;
+        GrGLFunction<GrGLSamplerParameterfFn> fSamplerParameterf;
         GrGLFunction<GrGLSamplerParameteriFn> fSamplerParameteri;
         GrGLFunction<GrGLSamplerParameterivFn> fSamplerParameteriv;
         GrGLFunction<GrGLScissorFn> fScissor;

package/cpp/skia/include/gpu/graphite/BackendTexture.h

@@ -0,0 +1,64 @@
+/*
+ * 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 skgpu_graphite_BackendTexture_DEFINED
+#define skgpu_graphite_BackendTexture_DEFINED
+
+#include "include/core/SkSize.h"
+#include "include/gpu/graphite/GraphiteTypes.h"
+#include "include/gpu/graphite/TextureInfo.h"
+
+#ifdef SK_METAL
+#include "include/gpu/graphite/mtl/MtlTypes.h"
+#endif
+
+namespace skgpu::graphite {
+
+class BackendTexture {
+public:
+    BackendTexture() {}
+#ifdef SK_METAL
+    // The BackendTexture will not call retain or release on the passed in MtlHandle. Thus the
+    // client must keep the MtlHandle valid until they are no longer using the BackendTexture.
+    BackendTexture(SkISize dimensions, MtlHandle mtlTexture);
+#endif
+
+    BackendTexture(const BackendTexture&);
+
+    ~BackendTexture();
+
+    BackendTexture& operator=(const BackendTexture&);
+
+    bool operator==(const BackendTexture&) const;
+    bool operator!=(const BackendTexture& that) const { return !(*this == that); }
+
+    bool isValid() const { return fInfo.isValid(); }
+    BackendApi backend() const { return fInfo.backend(); }
+
+    SkISize dimensions() const { return fDimensions; }
+
+    const TextureInfo& info() const { return fInfo; }
+
+#ifdef SK_METAL
+    MtlHandle getMtlTexture() const;
+#endif
+
+private:
+    SkISize fDimensions;
+    TextureInfo fInfo;
+
+    union {
+#ifdef SK_METAL
+        MtlHandle fMtlTexture;
+#endif
+    };
+};
+
+} // namespace skgpu::graphite
+
+#endif // skgpu_graphite_BackendTexture_DEFINED
+

package/cpp/skia/include/gpu/graphite/Context.h

@@ -0,0 +1,124 @@
+/*
+ * 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 skgpu_graphite_Context_DEFINED
+#define skgpu_graphite_Context_DEFINED
+
+#include <vector>
+#include "include/core/SkBlendMode.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkShader.h"
+#include "include/core/SkTileMode.h"
+#include "include/private/SkNoncopyable.h"
+
+#include "include/gpu/graphite/GraphiteTypes.h"
+
+namespace skgpu::graphite {
+
+class BackendTexture;
+class CommandBuffer;
+class ContextPriv;
+class GlobalCache;
+class Gpu;
+struct MtlBackendContext;
+class Recorder;
+class Recording;
+class TextureInfo;
+
+struct ShaderCombo {
+    enum class ShaderType {
+        kNone, // does not modify color buffer, e.g. depth and/or stencil only
+        kSolidColor,
+        kLinearGradient,
+        kRadialGradient,
+        kSweepGradient,
+        kConicalGradient
+    };
+
+    ShaderCombo() {}
+    ShaderCombo(std::vector<ShaderType> types,
+                std::vector<SkTileMode> tileModes)
+            : fTypes(std::move(types))
+            , fTileModes(std::move(tileModes)) {
+    }
+    std::vector<ShaderType> fTypes;
+    std::vector<SkTileMode> fTileModes;
+};
+
+struct PaintCombo {
+    std::vector<ShaderCombo> fShaders;
+    std::vector<SkBlendMode> fBlendModes;
+};
+
+class Context final {
+public:
+    Context(const Context&) = delete;
+    Context(Context&&) = delete;
+    Context& operator=(const Context&) = delete;
+    Context& operator=(Context&&) = delete;
+
+    ~Context();
+
+#ifdef SK_METAL
+    static std::unique_ptr<Context> MakeMetal(const skgpu::graphite::MtlBackendContext&);
+#endif
+
+    BackendApi backend() const { return fBackend; }
+
+    std::unique_ptr<Recorder> makeRecorder();
+
+    void insertRecording(const InsertRecordingInfo&);
+    void submit(SyncToCpu = SyncToCpu::kNo);
+
+    /**
+     * Checks whether any asynchronous work is complete and if so calls related callbacks.
+     */
+    void checkAsyncWorkCompletion();
+
+    void preCompile(const PaintCombo&);
+
+    /**
+     * Creates a new backend gpu texture matching the dimensinos and TextureInfo. If an invalid
+     * TextureInfo or a TextureInfo Skia can't support is passed in, this will return an invalid
+     * BackendTexture. Thus the client should check isValid on the returned BackendTexture to know
+     * if it succeeded or not.
+     *
+     * If this does return a valid BackendTexture, the caller is required to use
+     * Context::deleteBackendTexture to delete that texture.
+     */
+    BackendTexture createBackendTexture(SkISize dimensions, const TextureInfo&);
+
+    /**
+     * Called to delete the passed in BackendTexture. This should only be called if the
+     * BackendTexture was created by calling Context::createBackendTexture. If the BackendTexture is
+     * not valid or does not match the BackendApi of the Context then nothing happens.
+     *
+     * Otherwise this will delete/release the backend object that is wrapped in the BackendTexture.
+     * The BackendTexture will be reset to an invalid state and should not be used again.
+     */
+    void deleteBackendTexture(BackendTexture&);
+
+    // Provides access to functions that aren't part of the public API.
+    ContextPriv priv();
+    const ContextPriv priv() const;  // NOLINT(readability-const-return-type)
+
+protected:
+    Context(sk_sp<Gpu>, BackendApi);
+
+private:
+    friend class ContextPriv;
+
+    sk_sp<CommandBuffer> fCurrentCommandBuffer;
+
+    sk_sp<Gpu> fGpu;
+    sk_sp<GlobalCache> fGlobalCache;
+    BackendApi fBackend;
+};
+
+} // namespace skgpu::graphite
+
+#endif // skgpu_graphite_Context_DEFINED

package/cpp/skia/include/gpu/graphite/GraphiteTypes.h

@@ -0,0 +1,71 @@
+/*
+ * 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 skgpu_graphite_GraphiteTypes_DEFINED
+#define skgpu_graphite_GraphiteTypes_DEFINED
+
+#include "include/core/SkTypes.h"
+#include "include/gpu/GpuTypes.h"
+
+#include <memory>
+
+namespace skgpu::graphite {
+
+class Recording;
+
+using GpuFinishedContext = void*;
+using GpuFinishedProc = void (*)(GpuFinishedContext finishedContext, CallbackResult);
+
+/**
+ * The fFinishedProc is called when the Recording has been submitted and finished on the GPU, or
+ * when there is a failure that caused it not to be submitted. The callback will always be called
+ * and the caller can use the callback to know it is safe to free any resources associated with
+ * the Recording that they may be holding onto. If the Recording is successfully submitted to the
+ * GPU the callback will be called with CallbackResult::kSuccess once the GPU has finished. All
+ * other cases where some failure occured it will be called with CallbackResult::kFailed.
+ */
+struct InsertRecordingInfo {
+    Recording* fRecording = nullptr;
+    GpuFinishedContext fFinishedContext = nullptr;
+    GpuFinishedProc fFinishedProc = nullptr;
+};
+
+/**
+ * Actually submit work to the GPU and track its completion
+ */
+enum class SyncToCpu : bool {
+    kYes = true,
+    kNo = false
+};
+
+/**
+ * Possible 3D APIs that may be used by Graphite.
+ */
+enum class BackendApi : unsigned {
+    kMetal,
+    kMock,
+};
+
+/**
+ * Is the texture mipmapped or not
+ */
+enum class Mipmapped: bool {
+    kNo = false,
+    kYes = true,
+};
+
+/**
+ * Is the data protected on the GPU or not.
+ */
+enum class Protected : bool {
+    kNo = false,
+    kYes = true,
+};
+
+} // namespace skgpu::graphite
+
+#endif // skgpu_graphite_GraphiteTypes_DEFINED

package/cpp/skia/include/gpu/graphite/Recorder.h

@@ -0,0 +1,104 @@
+/*
+ * 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 skgpu_graphite_Recorder_DEFINED
+#define skgpu_graphite_Recorder_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/private/SingleOwner.h"
+
+#include <vector>
+
+class SkTextureDataBlock;
+class SkUniformDataBlock;
+class SkUniformDataBlockPassThrough;  // TODO: remove
+
+namespace skgpu::graphite {
+
+class Caps;
+class Device;
+class DrawBufferManager;
+class GlobalCache;
+class Gpu;
+class RecorderPriv;
+class Recording;
+class ResourceProvider;
+class Task;
+class TaskGraph;
+class UploadBufferManager;
+
+template<typename StorageT, typename BaseT> class PipelineDataCache;
+using UniformDataCache = PipelineDataCache<SkUniformDataBlockPassThrough, SkUniformDataBlock>;
+using TextureDataCache = PipelineDataCache<std::unique_ptr<SkTextureDataBlock>, SkTextureDataBlock>;
+
+class Recorder final {
+public:
+    Recorder(const Recorder&) = delete;
+    Recorder(Recorder&&) = delete;
+    Recorder& operator=(const Recorder&) = delete;
+    Recorder& operator=(Recorder&&) = delete;
+
+    ~Recorder();
+
+    std::unique_ptr<Recording> snap();
+
+    // Provides access to functions that aren't part of the public API.
+    RecorderPriv priv();
+    const RecorderPriv priv() const;  // NOLINT(readability-const-return-type)
+
+#if GR_TEST_UTILS
+    bool deviceIsRegistered(Device*);
+#endif
+
+private:
+    friend class Context; // For ctor
+    friend class Device; // For registering and deregistering Devices;
+    friend class RecorderPriv; // for ctor and hidden methods
+
+    Recorder(sk_sp<Gpu>, sk_sp<GlobalCache>);
+
+    SingleOwner* singleOwner() const { return &fSingleOwner; }
+
+    // We keep track of all Devices that are connected to a Recorder. This allows the client to
+    // safely delete an SkSurface or a Recorder in any order. If the client deletes the Recorder
+    // we need to notify all Devices that the Recorder is no longer valid. If we delete the
+    // SkSurface/Device first we will flush all the Device's into the Recorder before deregistering
+    // it from the Recorder.
+    //
+    // We do not need to take a ref on the Device since the Device will flush and deregister itself
+    // in its dtor. There is no other need for the Recorder to know about the Device after this
+    // point.
+    //
+    // Note: We could probably get by with only registering Devices directly connected to
+    // SkSurfaces. All other one off Devices will be created in a controlled scope where the
+    // Recorder should still be valid by the time they need to flush their work when the Device is
+    // deleted. We would have to make sure we safely handle cases where a client calls saveLayer
+    // then either deletes the SkSurface or Recorder before calling restore. For simplicity we just
+    // register every device for now, but if we see extra overhead in pushing back the extra
+    // pointers, we can look into only registering SkSurface Devices.
+    void registerDevice(Device*);
+    void deregisterDevice(const Device*);
+
+    sk_sp<Gpu> fGpu;
+    std::unique_ptr<ResourceProvider> fResourceProvider;
+
+    std::unique_ptr<TaskGraph> fGraph;
+    std::unique_ptr<UniformDataCache> fUniformDataCache;
+    std::unique_ptr<TextureDataCache> fTextureDataCache;
+    std::unique_ptr<DrawBufferManager> fDrawBufferManager;
+    std::unique_ptr<UploadBufferManager> fUploadBufferManager;
+    std::vector<Device*> fTrackedDevices;
+
+    // In debug builds we guard against improper thread handling
+    // This guard is passed to the ResourceCache.
+    // TODO: Should we also pass this to Device, DrawContext, and similar classes?
+    mutable SingleOwner fSingleOwner;
+};
+
+} // namespace skgpu::graphite
+
+#endif // skgpu_graphite_Recorder_DEFINED

package/cpp/skia/include/gpu/graphite/Recording.h

@@ -0,0 +1,39 @@
+/*
+ * 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 skgpu_graphite_Recording_DEFINED
+#define skgpu_graphite_Recording_DEFINED
+
+#include "include/core/SkRefCnt.h"
+
+class SkTextureDataBlock;
+
+namespace skgpu::graphite {
+
+class CommandBuffer;
+template<typename StorageT, typename BaseT> class PipelineDataCache;
+using TextureDataCache = PipelineDataCache<std::unique_ptr<SkTextureDataBlock>, SkTextureDataBlock>;
+
+class Recording final {
+public:
+    ~Recording();
+
+protected:
+private:
+    friend class Context; // for access fCommandBuffer
+    friend class Recorder; // for ctor
+    Recording(sk_sp<CommandBuffer>, std::unique_ptr<TextureDataCache>);
+
+    sk_sp<CommandBuffer> fCommandBuffer;
+
+    // The TextureDataCache holds all the Textures and Samplers used in this Recording.
+    std::unique_ptr<TextureDataCache> fTextureDataCache;
+};
+
+} // namespace skgpu::graphite
+
+#endif // skgpu_graphite_Recording_DEFINED

package/cpp/skia/include/gpu/graphite/SkStuff.h

@@ -0,0 +1,47 @@
+/*
+ * 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 SkStuff_DEFINED
+#define SkStuff_DEFINED
+
+#include "include/core/SkImageInfo.h"
+#include "include/core/SkRefCnt.h"
+
+class SkColorSpace;
+class SkSurface;
+class SkSurfaceProps;
+
+namespace skgpu::graphite {
+    class BackendTexture;
+    class Recorder;
+}
+
+// TODO: Should be in SkSurface.h
+sk_sp<SkSurface> MakeGraphite(skgpu::graphite::Recorder*, const SkImageInfo&);
+
+/**
+ * Wraps a GPU-backed texture into SkSurface. Depending on the backend gpu API, the caller may be
+ * required to ensure the texture is valid for the lifetime of returned SkSurface. The required
+ * lifetimes for the specific apis are:
+ *     Metal: Skia will call retain on the underlying MTLTexture so the caller can drop it once this
+ *            call returns.
+ *
+ * SkSurface is returned if all parameters are valid. BackendTexture is valid if its format agrees
+ * with colorSpace and context; for instance, if backendTexture has an sRGB configuration, then
+ * context must support sRGB, and colorSpace must be present. Further, backendTexture width and
+ * height must not exceed context capabilities, and the context must be able to support back-end
+ * textures.
+ *
+ * If SK_ENABLE_GRAPHITE is not defined, this has no effect and returns nullptr.
+ */
+sk_sp<SkSurface> MakeGraphiteFromBackendTexture(skgpu::graphite::Recorder*,
+                                                const skgpu::graphite::BackendTexture&,
+                                                SkColorType colorType,
+                                                sk_sp<SkColorSpace> colorSpace,
+                                                const SkSurfaceProps* props);
+
+#endif // SkStuff_DEFINED