@shopify/react-native-skia 2.13.0 → 2.14.0

package/cpp/api/recorder/DataTypes.h

@@ -6,8 +6,8 @@ namespace RNSkia {
 
 using Uniforms = std::map<std::string, std::vector<float>>;
 
-std::vector<float> processArray(jsi::Runtime &runtime,
-                                const jsi::Array &array) {
+inline std::vector<float> processArray(jsi::Runtime &runtime,
+                                       const jsi::Array &array) {
   std::vector<float> result;
   size_t length = array.length(runtime);
   result.reserve(length);
@@ -37,18 +37,18 @@ std::vector<float> processArray(jsi::Runtime &runtime,
   return result;
 }
 
-bool isJSPoint(jsi::Runtime &runtime, const jsi::Value &value) {
+inline bool isJSPoint(jsi::Runtime &runtime, const jsi::Value &value) {
   return value.isObject() &&
          value.asObject(runtime).hasProperty(runtime, "x") &&
          value.asObject(runtime).hasProperty(runtime, "y");
 }
 
-bool isIndexable(jsi::Runtime &runtime, const jsi::Value &value) {
+inline bool isIndexable(jsi::Runtime &runtime, const jsi::Value &value) {
   return value.isObject() && value.asObject(runtime).hasProperty(runtime, "0");
 }
 
-std::shared_ptr<SkRect> processRect(jsi::Runtime &runtime,
-                                    const jsi::Value &value) {
+inline std::shared_ptr<SkRect> processRect(jsi::Runtime &runtime,
+                                           const jsi::Value &value) {
   if (value.isObject()) {
     auto object = value.asObject(runtime);
     auto ptr = tryGetJsiObject<JsiSkRect>(runtime, object);
@@ -68,7 +68,7 @@ std::shared_ptr<SkRect> processRect(jsi::Runtime &runtime,
   return nullptr;
 }
 
-SkPoint processPoint(jsi::Runtime &runtime, const jsi::Value &value) {
+inline SkPoint processPoint(jsi::Runtime &runtime, const jsi::Value &value) {
   if (value.isObject()) {
     auto object = value.asObject(runtime);
     if (object.hasProperty(runtime, "x") && object.hasProperty(runtime, "y")) {
@@ -78,11 +78,11 @@ SkPoint processPoint(jsi::Runtime &runtime, const jsi::Value &value) {
     }
   }
   throw std::runtime_error("Couldn't read point value");
-};
+}
 
 // TODO: return the SkRRect directly
-std::shared_ptr<SkRRect> processRRect(jsi::Runtime &runtime,
-                                      const jsi::Value &value) {
+inline std::shared_ptr<SkRRect> processRRect(jsi::Runtime &runtime,
+                                             const jsi::Value &value) {
   if (value.isObject()) {
     auto object = value.asObject(runtime);
     auto ptr = tryGetJsiObject<JsiSkRRect>(runtime, object);
@@ -119,8 +119,8 @@ std::shared_ptr<SkRRect> processRRect(jsi::Runtime &runtime,
 }
 
 // Return SkPath instead of shared_ptr<SkPath>
-std::shared_ptr<SkPath> processPath(jsi::Runtime &runtime,
-                                    const jsi::Value &value) {
+inline std::shared_ptr<SkPath> processPath(jsi::Runtime &runtime,
+                                           const jsi::Value &value) {
   if (value.isString()) {
     auto pathString = value.getString(runtime).utf8(runtime);
     SkPath result;

package/cpp/api/recorder/DrawingCtx.h

@@ -52,7 +52,7 @@ struct Composers {
 
 class DrawingCtx {
 public:
-  DrawingCtx(SkCanvas *canvas) : canvas(canvas) {
+  explicit DrawingCtx(SkCanvas *canvas) : canvas(canvas) {
     SkPaint paint;
     paint.setAntiAlias(true);
     paints.push_back(paint);

package/cpp/api/recorder/ImageFit.h

@@ -18,14 +18,14 @@ struct FitRects {
   SkRect dst;
 };
 
-SkRect inscribe(SkSize size, SkRect rect) {
+inline SkRect inscribe(SkSize size, SkRect rect) {
   auto halfWidthDelta = (rect.width() - size.width()) / 2.0;
   auto halfHeightDelta = (rect.height() - size.height()) / 2.0;
   return SkRect::MakeXYWH(rect.x() + halfWidthDelta, rect.y() + halfHeightDelta,
                           size.width(), size.height());
 }
 
-SkMatrix rect2rect(SkRect src, SkRect dst) {
+inline SkMatrix rect2rect(SkRect src, SkRect dst) {
   auto sx = dst.width() / src.width();
   auto sy = dst.height() / src.height();
   auto tx = dst.x() - src.x() * sx;
@@ -36,9 +36,12 @@ SkMatrix rect2rect(SkRect src, SkRect dst) {
   return m3;
 }
 
-SkSize size(double width, double height) { return SkSize::Make(width, height); }
+inline SkSize size(double width, double height) {
+  return SkSize::Make(width, height);
+}
 
-FitSizes applyBoxFit(const std::string fit, SkSize input, SkSize output) {
+inline FitSizes applyBoxFit(const std::string fit, SkSize input,
+                            SkSize output) {
   SkSize src = size(0, 0);
   SkSize dst = size(0, 0);
 
@@ -96,7 +99,7 @@ FitSizes applyBoxFit(const std::string fit, SkSize input, SkSize output) {
   return {.src = src, .dst = dst};
 }
 
-FitRects fitRects(const std::string &fit, SkRect rect, SkRect rect2) {
+inline FitRects fitRects(const std::string &fit, SkRect rect, SkRect rect2) {
   auto sizes = applyBoxFit(fit, size(rect.width(), rect.height()),
                            size(rect2.width(), rect2.height()));
 

package/cpp/api/recorder/JsiRecorder.h

@@ -24,7 +24,7 @@ class JsiRecorder
 public:
   static constexpr const char *CLASS_NAME = "Recorder";
 
-  JsiRecorder(std::shared_ptr<RNSkPlatformContext> context)
+  explicit JsiRecorder(std::shared_ptr<RNSkPlatformContext> context)
       : JsiSkWrappingSharedPtrNativeObject<JsiRecorder, Recorder>(
             std::move(context), std::make_shared<Recorder>()) {
     getObject()->_context = getContext();
@@ -70,18 +70,7 @@ public:
       throw jsi::JSError(runtime, "Invalid Picture object provided to play()");
     }
 
-    // Create a new picture recorder to record into
-    SkPictureRecorder pictureRecorder;
-    SkISize size = SkISize::Make(2'000'000, 2'000'000);
-    SkRect rect = SkRect::Make(size);
-    auto canvas = pictureRecorder.beginRecording(rect, nullptr);
-
-    // Play the recorded commands into the canvas
-    DrawingCtx ctx(canvas);
-    getObject()->play(&ctx);
-
-    // Finish recording and get the new picture
-    auto newPicture = pictureRecorder.finishRecordingAsPicture();
+    auto newPicture = getObject()->makePicture();
 
     // Update the existing JsiSkPicture object with the new SkPicture
     // This reuses the existing JavaScript object instead of creating a new one
@@ -95,24 +84,12 @@ public:
 
   JSI_HOST_FUNCTION(applyUpdates) {
     auto values = arguments[0].asObject(runtime).asArray(runtime);
-    auto size = values.size(runtime);
-    auto recorder = getObject();
-    for (int i = 0; i < size; i++) {
-      auto sharedValue = values.getValueAtIndex(runtime, i).asObject(runtime);
-      auto name = "variable" + std::to_string(i);
-      // Look up the conversion functions for this name
-      auto it = recorder->variables.find(name);
-      if (it != recorder->variables.end()) {
-        // Execute each conversion function in the vector
-        const auto &conversionFunctions = it->second;
-        for (const auto &conversionFunc : conversionFunctions) {
-          conversionFunc(runtime, sharedValue);
-        }
-      }
-    }
+    getObject()->applyUpdates(runtime, values);
     return jsi::Value::undefined();
   }
 
+  JSI_HOST_FUNCTION(getId) { return jsi::Value(getObject()->id); }
+
   JSI_HOST_FUNCTION(saveGroup) {
     const jsi::Value *value = count > 0 ? &arguments[0] : nullptr;
     getObject()->saveGroup(runtime, value);
@@ -377,11 +354,17 @@ public:
     installHostMethod(runtime, prototype, "applyUpdates",
                       &JsiRecorder::applyUpdates);
     installHostMethod(runtime, prototype, "reset", &JsiRecorder::reset);
+    installHostMethod(runtime, prototype, "getId", &JsiRecorder::getId);
   }
 
-  // This has no basis in reality but since since these are private long-lived
-  // objects, we think it is more than fine.
-  size_t getMemoryPressure() override { return 5 * 1024 * 1024; }
+  // The recorder itself is a small command list. The resources it references
+  // (images, pictures, paths) report their own size through their wrappers
+  // and the pictures produced by play() report theirs. Do not put a made-up
+  // number here: a new recorder is created on every React commit, and the
+  // wrapper is disposed as soon as the view takes ownership of the recording
+  // (see NativeReanimatedContainer), so the charge would never drive a
+  // collection anyway.
+  size_t getMemoryPressure() override { return kMinMemoryPressure; }
 
   static const jsi::HostFunctionType
   createCtor(std::shared_ptr<RNSkPlatformContext> context) {

package/cpp/api/recorder/Paint.h

@@ -18,9 +18,9 @@ struct TransformProps {
 };
 
 // TODO: can we avoid a copy here?
-SkMatrix processTransform(std::optional<SkMatrix> &matrix,
-                          std::optional<SkM44> &transform,
-                          std::optional<SkPoint> &origin) {
+inline SkMatrix processTransform(std::optional<SkMatrix> &matrix,
+                                 std::optional<SkM44> &transform,
+                                 std::optional<SkPoint> &origin) {
   SkMatrix m3;
   if (matrix.has_value()) {
     m3 = matrix.value();

package/cpp/api/recorder/RNRecorder.h

@@ -1,14 +1,19 @@
 #pragma once
 
 #include <algorithm>
+#include <atomic>
 #include <cmath>
+#include <cstdint>
 #include <memory>
+#include <mutex>
 #include <optional>
 #include <string>
 #include <vector>
 
 #include <jsi/jsi.h>
 
+#include "include/core/SkPictureRecorder.h"
+
 #include "ColorFilters.h"
 #include "Command.h"
 #include "Convertor.h"
@@ -26,6 +31,11 @@ class Recorder {
 private:
   using CommandList = std::vector<std::unique_ptr<Command>>;
 
+  static double nextId() {
+    static std::atomic<uint64_t> counter{0};
+    return static_cast<double>(++counter);
+  }
+
   struct PendingGroup {
     GroupCommand *group;
     float zIndex;
@@ -35,6 +45,12 @@ private:
   CommandList commands;
   std::vector<CommandList *> commandStack;
 
+  // Once a view owns the recording, the Reanimated mapper writes the shared
+  // values into the commands (applyUpdates, UI thread) while the view replays
+  // them (play, main thread). Both hold this lock; nothing else does, so it
+  // never nests with the view's lock.
+  std::mutex _commandsMutex;
+
   CommandList &currentCommands() { return *commandStack.back(); }
 
   void pushCommand(std::unique_ptr<Command> command) {
@@ -94,6 +110,11 @@ public:
   std::shared_ptr<RNSkPlatformContext> _context;
   Variables variables;
 
+  // Unique per recording. The Reanimated mapper tags its updates with it so a
+  // mapper that outlives its recording (stopMapper() is asynchronous) cannot
+  // write into the recording that replaced it.
+  const double id = nextId();
+
   Recorder() { commandStack.push_back(&commands); }
   ~Recorder() {
     if (!_context || commands.empty()) {
@@ -382,10 +403,45 @@ public:
   }
 
   void play(DrawingCtx *ctx) {
+    std::lock_guard<std::mutex> lock(_commandsMutex);
     for (const auto &cmd : commands) {
       playCommand(ctx, cmd.get());
     }
   }
+
+  /**
+   * Plays the recording into a picture. The cull rect is deliberately huge:
+   * a recording is not tied to a view size.
+   */
+  sk_sp<SkPicture> makePicture() {
+    SkPictureRecorder pictureRecorder;
+    SkISize size = SkISize::Make(2'000'000, 2'000'000);
+    SkRect rect = SkRect::Make(size);
+    auto canvas = pictureRecorder.beginRecording(rect, nullptr);
+    DrawingCtx ctx(canvas);
+    play(&ctx);
+    return pictureRecorder.finishRecordingAsPicture();
+  }
+
+  /**
+   * Reads the current value of each shared value (in the order they were
+   * registered as variable0, variable1, ...) on the calling runtime and
+   * writes it into the recorded commands.
+   */
+  void applyUpdates(jsi::Runtime &runtime, const jsi::Array &values) {
+    std::lock_guard<std::mutex> lock(_commandsMutex);
+    auto size = values.size(runtime);
+    for (size_t i = 0; i < size; i++) {
+      auto sharedValue = values.getValueAtIndex(runtime, i).asObject(runtime);
+      auto name = "variable" + std::to_string(i);
+      auto it = variables.find(name);
+      if (it != variables.end()) {
+        for (const auto &conversionFunc : it->second) {
+          conversionFunc(runtime, sharedValue);
+        }
+      }
+    }
+  }
 };
 
 inline void Recorder::playCommand(DrawingCtx *ctx, Command *cmd) {

package/cpp/api/third_party/base64.cpp

@@ -4,7 +4,7 @@
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
-#include "base64.h"
+#include "api/third_party/base64.h"
 
 #include <cstdint>
 

package/cpp/jsi/JSICache.cpp

@@ -1,5 +1,6 @@
 #include "JSICache.h"
 
+#include <algorithm>
 #include <iterator>
 #include <memory>
 #include <stdexcept>
@@ -96,4 +97,26 @@ jsi::Object &JSICache::setPrototype(PrototypeKey key, jsi::Object prototype) {
   return it->second;
 }
 
+jsi::Value JSICache::lockWrapper(jsi::Runtime &runtime,
+                                 const void *nativeObject) {
+  auto it = _wrappers.find(nativeObject);
+  if (it == _wrappers.end()) {
+    return jsi::Value::undefined();
+  }
+  return it->second.lock(runtime);
+}
+
+void JSICache::setWrapper(jsi::Runtime &runtime, const void *nativeObject,
+                          const jsi::Object &wrapper) {
+  _wrappers.insert_or_assign(nativeObject, jsi::WeakObject(runtime, wrapper));
+  if (_wrappers.size() < _pruneWrappersAt) {
+    return;
+  }
+  for (auto it = _wrappers.begin(); it != _wrappers.end();) {
+    it = it->second.lock(runtime).isUndefined() ? _wrappers.erase(it)
+                                                : std::next(it);
+  }
+  _pruneWrappersAt = std::max(kMinPruneWrappersAt, _wrappers.size() * 2);
+}
+
 } // namespace RNJsi

package/cpp/jsi/JSICache.h

@@ -13,7 +13,8 @@ namespace jsi = facebook::jsi;
 
 /**
  * Per-runtime store for JSI values that native code wants to keep across
- * calls (currently: the prototype object of every NativeObject class).
+ * calls: the prototype object of every NativeObject class, and the JS
+ * wrapper of every native object that has one on the runtime.
  *
  * Ownership model (borrowed from react-native-nitro-modules' JSICache):
  *
@@ -72,6 +73,26 @@ public:
    */
   jsi::Object &setPrototype(PrototypeKey key, jsi::Object prototype);
 
+  /**
+   * Returns the JS wrapper stored for `nativeObject` on this runtime, or
+   * undefined if none was stored or the wrapper has been collected.
+   *
+   * The key is the native object's address. A live wrapper keeps its native
+   * object alive (the object is the wrapper's NativeState), so as long as
+   * the entry locks it still belongs to that object. Once the wrapper has
+   * been collected the entry is stale and is skipped or replaced, so an
+   * address reused by a new object can never resolve to the old wrapper.
+   */
+  jsi::Value lockWrapper(jsi::Runtime &runtime, const void *nativeObject);
+
+  /**
+   * Stores `wrapper` as the JS wrapper of `nativeObject` on this runtime.
+   * Only a weak reference is kept: the wrapper stays collectable, and the
+   * native object is released when it goes away.
+   */
+  void setWrapper(jsi::Runtime &runtime, const void *nativeObject,
+                  const jsi::Object &wrapper);
+
   JSICache() = default;
   ~JSICache() override = default;
   JSICache(const JSICache &) = delete;
@@ -81,6 +102,12 @@ private:
   static std::shared_ptr<JSICache> getOrCreateOnGlobal(jsi::Runtime &runtime);
 
   std::unordered_map<PrototypeKey, jsi::Object> _prototypes;
+  // Native object -> its wrapper on this runtime. Entries of collected
+  // wrappers are pruned in setWrapper once the map has doubled since the
+  // last pruning, so it stays proportional to the number of live wrappers.
+  std::unordered_map<const void *, jsi::WeakObject> _wrappers;
+  size_t _pruneWrappersAt = kMinPruneWrappersAt;
+  static constexpr size_t kMinPruneWrappersAt = 64;
 
   // Runtime -> cache. Weak on purpose: the runtime's global owns the cache.
   static std::mutex _registryMutex;

package/cpp/jsi/NativeObject.h

@@ -210,12 +210,12 @@ public:
             if (instance == nullptr) {
               throw jsi::JSError(rt, "Invalid boxed native object state");
             }
-            // Unboxing creates a *view* of the object on the target runtime.
-            // Keep the runtime the object was originally created on: async
-            // native code (e.g. GPUDevice error/lost events) delivers into
-            // the creation runtime, and rebinding it to a worklet runtime
-            // would invoke main-runtime jsi::Functions on the wrong runtime
-            // and thread.
+            // Unboxing hands back the wrapper cached for the target runtime,
+            // creating it on first use. Keep the runtime the object was
+            // originally created on: async native code (e.g. GPUDevice
+            // error/lost events) delivers into the creation runtime, and
+            // rebinding it to a worklet runtime would invoke main-runtime
+            // jsi::Functions on the wrong runtime and thread.
             auto *originalRuntime = instance->getCreationRuntime();
             auto value = Derived::create(rt, instance);
             if (originalRuntime != nullptr) {
@@ -262,10 +262,37 @@ public:
   }
 
   /**
-   * Create a JS object with native state attached.
+   * Returns the JS wrapper of `instance` on `runtime`, creating it on first
+   * use.
+   *
+   * A native object has at most one live wrapper per runtime. The wrapper is
+   * cached (weakly, so it stays collectable) in the runtime's JSICache, and
+   * converting the same object again (returning it from another native
+   * call, unboxing it in a worklet on every frame, ...) hands back that
+   * wrapper instead of a new one. Each wrapper reports the native memory the
+   * object owns to the GC of its runtime through setExternalMemoryPressure,
+   * so the memory is charged exactly once per runtime that can reach the
+   * object, however often it is converted; charging every conversion used
+   * to multiply the amount by the number of captures in a worklet until
+   * Hermes hit its max heap size. The hint is refreshed on every round trip
+   * for objects whose size changes after creation (path and paragraph
+   * builders).
    */
   static jsi::Value create(jsi::Runtime &runtime,
                            std::shared_ptr<Derived> instance) {
+    auto &cache = JSICache::get(runtime);
+    const void *key = instance.get();
+
+    auto existing = cache.lockWrapper(runtime, key);
+    if (existing.isObject()) {
+      auto pressure = instance->getMemoryPressure();
+      if (pressure > 0) {
+        existing.getObject(runtime).setExternalMemoryPressure(runtime,
+                                                              pressure);
+      }
+      return existing;
+    }
+
     // Store creation runtime for logging etc.
     instance->setCreationRuntime(&runtime);
 
@@ -290,9 +317,11 @@ public:
       obj.setExternalMemoryPressure(runtime, pressure);
     }
 
+    cache.setWrapper(runtime, key, obj);
     return std::move(obj);
   }
 
+public:
   /**
    * Get the native state from a JS value.
    * Throws if the value doesn't have the expected native state.

package/cpp/jsi/ViewProperty.cpp

@@ -0,0 +1,23 @@
+// The recorder headers depend on the include order established by
+// JsiSkApi.h, so the probe lives here rather than in ViewProperty.h (which
+// every platform view includes on its own).
+#include "api/JsiSkApi.h"
+
+#include "jsi/ViewProperty.h"
+
+#include "api/JsiSkPicture.h"
+#include "api/recorder/JsiRecorder.h"
+
+namespace RNJsi {
+
+ViewProperty::ViewProperty(jsi::Runtime &runtime, const jsi::Value &value) {
+  if (auto picture =
+          RNSkia::tryGetJsiObject<RNSkia::JsiSkPicture>(runtime, value)) {
+    _value = picture->getObject();
+  } else if (auto recorder =
+                 RNSkia::tryGetJsiObject<RNSkia::JsiRecorder>(runtime, value)) {
+    _value = recorder->getObject();
+  }
+}
+
+} // namespace RNJsi

package/cpp/jsi/ViewProperty.h

@@ -4,28 +4,49 @@
 #include <jsi/jsi.h>
 #include <memory>
 #include <string>
+#include <utility>
 #include <variant>
 
-#include "api/JsiSkPicture.h"
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "include/core/SkPicture.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+class Recorder;
+}
 
 namespace RNJsi {
 namespace jsi = facebook::jsi;
 
 class ViewProperty {
 public:
-  ViewProperty(jsi::Runtime &runtime, const jsi::Value &value) {
-    auto jsiPicture =
-        RNSkia::tryGetJsiObject<RNSkia::JsiSkPicture>(runtime, value);
-    if (jsiPicture) {
-      _value = jsiPicture->getObject();
-    }
-  }
+  /**
+   * Probes the JS value for the native objects a view can display (a picture
+   * or a recorder); anything else yields an empty property. Defined in
+   * ViewProperty.cpp: the recorder headers depend on the include order
+   * established by JsiSkApi.h, which this header (included by every platform
+   * view) must not pull in.
+   */
+  ViewProperty(jsi::Runtime &runtime, const jsi::Value &value);
 
-  bool isNull() { return std::holds_alternative<std::nullptr_t>(_value); }
+  bool isPicture() { return std::holds_alternative<sk_sp<SkPicture>>(_value); }
+
+  bool isRecorder() {
+    return std::holds_alternative<std::shared_ptr<RNSkia::Recorder>>(_value);
+  }
 
   sk_sp<SkPicture> getPicture() { return std::get<sk_sp<SkPicture>>(_value); }
 
+  std::shared_ptr<RNSkia::Recorder> getRecorder() {
+    return std::get<std::shared_ptr<RNSkia::Recorder>>(_value);
+  }
+
 private:
-  std::variant<std::nullptr_t, sk_sp<SkPicture>> _value = nullptr;
+  std::variant<std::nullptr_t, sk_sp<SkPicture>,
+               std::shared_ptr<RNSkia::Recorder>>
+      _value = nullptr;
 };
 } // namespace RNJsi

package/cpp/rnskia/RNDawnContext.h

@@ -112,7 +112,7 @@ public:
     int height = static_cast<int>(IOSurfaceGetHeight(ioSurface));
 #else
     wgpu::SharedTextureMemoryAHardwareBufferDescriptor platformDesc;
-    auto ahb = (AHardwareBuffer *)buffer;
+    auto ahb = reinterpret_cast<AHardwareBuffer *>(buffer);
     platformDesc.handle = ahb;
     AHardwareBuffer_Desc adesc;
     AHardwareBuffer_describe(ahb, &adesc);
@@ -270,6 +270,39 @@ public:
         textureRef);
   }
 
+  // Create an SkSurface that draws straight into a WebGPU texture (zero-copy).
+  // The texture must have RenderAttachment usage; give it TextureBinding too
+  // to sample it from WebGPU (e.g. as a three.js texture) after each flush.
+  // The surface retains the texture for its lifetime.
+  sk_sp<SkSurface> MakeSurfaceFromTexture(wgpu::Texture texture) {
+    if (!texture) {
+      return nullptr;
+    }
+    if (!(texture.GetUsage() & wgpu::TextureUsage::RenderAttachment)) {
+      throw std::runtime_error(
+          "MakeSurfaceFromTexture: the texture needs RenderAttachment usage");
+    }
+
+    skgpu::graphite::BackendTexture backendTexture =
+        skgpu::graphite::BackendTextures::MakeDawn(texture.Get());
+
+    struct TextureRef {
+      wgpu::Texture texture;
+    };
+    auto textureRef = new TextureRef{texture};
+
+    // The color type is derived from the texture format.
+    return SkSurfaces::WrapBackendTexture(
+        getRecorder(), backendTexture,
+        nullptr, // colorspace
+        nullptr, // surfaceProps
+        [](void *context) {
+          auto ref = static_cast<TextureRef *>(context);
+          delete ref;
+        },
+        textureRef);
+  }
+
   // Create a WebGPU texture from an SkImage
   // Returns a texture with CopySrc and TextureBinding usage
   wgpu::Texture MakeTextureFromImage(sk_sp<SkImage> image) {