react-native-wgpu 0.5.13 → 0.5.14

package/cpp/rnwgpu/api/GPUTexture.h

@@ -1,162 +0,0 @@
-#pragma once
-
-#include <algorithm>
-#include <memory>
-#include <string>
-
-#include "Unions.h"
-
-#include "NativeObject.h"
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "GPUTextureView.h"
-#include "GPUTextureViewDescriptor.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-class GPUTexture : public NativeObject<GPUTexture> {
-public:
-  static constexpr const char *CLASS_NAME = "GPUTexture";
-
-  explicit GPUTexture(wgpu::Texture instance, std::string label,
-                      bool reportsMemoryPressure = true)
-      : NativeObject(CLASS_NAME), _instance(instance), _label(label),
-        _reportsMemoryPressure(reportsMemoryPressure) {}
-
-public:
-  std::string getBrand() { return CLASS_NAME; }
-
-  std::shared_ptr<GPUTextureView> createView(
-      std::optional<std::shared_ptr<GPUTextureViewDescriptor>> descriptor);
-  void destroy();
-
-  uint32_t getWidth();
-  uint32_t getHeight();
-  uint32_t getDepthOrArrayLayers();
-  uint32_t getMipLevelCount();
-  uint32_t getSampleCount();
-  wgpu::TextureDimension getDimension();
-  wgpu::TextureFormat getFormat();
-  double getUsage();
-
-  std::string getLabel() { return _label; }
-  void setLabel(const std::string &label) {
-    _label = label;
-    _instance.SetLabel(_label.c_str());
-  }
-
-  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installGetter(runtime, prototype, "__brand", &GPUTexture::getBrand);
-    installMethod(runtime, prototype, "createView", &GPUTexture::createView);
-    installMethod(runtime, prototype, "destroy", &GPUTexture::destroy);
-    installGetter(runtime, prototype, "width", &GPUTexture::getWidth);
-    installGetter(runtime, prototype, "height", &GPUTexture::getHeight);
-    installGetter(runtime, prototype, "depthOrArrayLayers",
-                  &GPUTexture::getDepthOrArrayLayers);
-    installGetter(runtime, prototype, "mipLevelCount",
-                  &GPUTexture::getMipLevelCount);
-    installGetter(runtime, prototype, "sampleCount",
-                  &GPUTexture::getSampleCount);
-    installGetter(runtime, prototype, "dimension", &GPUTexture::getDimension);
-    installGetter(runtime, prototype, "format", &GPUTexture::getFormat);
-    installGetter(runtime, prototype, "usage", &GPUTexture::getUsage);
-    installGetterSetter(runtime, prototype, "label", &GPUTexture::getLabel,
-                        &GPUTexture::setLabel);
-  }
-
-  inline const wgpu::Texture get() { return _instance; }
-
-  size_t getMemoryPressure() override {
-    if (!_reportsMemoryPressure) {
-      return sizeof(GPUTexture);
-    }
-    // Calculate approximate memory usage based on texture properties
-    uint32_t width = getWidth();
-    uint32_t height = getHeight();
-    uint32_t depthOrArrayLayers = getDepthOrArrayLayers();
-    uint32_t mipLevelCount = getMipLevelCount();
-    uint32_t sampleCount = getSampleCount();
-
-    // Estimate bytes per pixel based on format
-    // This is a simplified estimate - actual values depend on the specific
-    // format
-    size_t bytesPerPixel = 4; // Default to RGBA8 format
-    wgpu::TextureFormat format = getFormat();
-    switch (format) {
-    case wgpu::TextureFormat::R8Unorm:
-    case wgpu::TextureFormat::R8Snorm:
-    case wgpu::TextureFormat::R8Uint:
-    case wgpu::TextureFormat::R8Sint:
-    case wgpu::TextureFormat::Stencil8:
-      bytesPerPixel = 1;
-      break;
-    case wgpu::TextureFormat::R16Uint:
-    case wgpu::TextureFormat::R16Sint:
-    case wgpu::TextureFormat::R16Float:
-    case wgpu::TextureFormat::RG8Unorm:
-    case wgpu::TextureFormat::RG8Snorm:
-    case wgpu::TextureFormat::RG8Uint:
-    case wgpu::TextureFormat::RG8Sint:
-    case wgpu::TextureFormat::Depth16Unorm:
-      bytesPerPixel = 2;
-      break;
-    case wgpu::TextureFormat::RGBA8Unorm:
-    case wgpu::TextureFormat::RGBA8UnormSrgb:
-    case wgpu::TextureFormat::RGBA8Snorm:
-    case wgpu::TextureFormat::RGBA8Uint:
-    case wgpu::TextureFormat::RGBA8Sint:
-    case wgpu::TextureFormat::BGRA8Unorm:
-    case wgpu::TextureFormat::BGRA8UnormSrgb:
-    case wgpu::TextureFormat::RGB10A2Unorm:
-    case wgpu::TextureFormat::R32Float:
-    case wgpu::TextureFormat::R32Uint:
-    case wgpu::TextureFormat::R32Sint:
-    case wgpu::TextureFormat::RG16Uint:
-    case wgpu::TextureFormat::RG16Sint:
-    case wgpu::TextureFormat::RG16Float:
-    case wgpu::TextureFormat::Depth24Plus:
-    case wgpu::TextureFormat::Depth24PlusStencil8:
-    case wgpu::TextureFormat::Depth32Float:
-      bytesPerPixel = 4;
-      break;
-    case wgpu::TextureFormat::RG32Float:
-    case wgpu::TextureFormat::RG32Uint:
-    case wgpu::TextureFormat::RG32Sint:
-    case wgpu::TextureFormat::RGBA16Uint:
-    case wgpu::TextureFormat::RGBA16Sint:
-    case wgpu::TextureFormat::RGBA16Float:
-    case wgpu::TextureFormat::Depth32FloatStencil8:
-      bytesPerPixel = 8;
-      break;
-    case wgpu::TextureFormat::RGBA32Float:
-    case wgpu::TextureFormat::RGBA32Uint:
-    case wgpu::TextureFormat::RGBA32Sint:
-      bytesPerPixel = 16;
-      break;
-    default:
-      bytesPerPixel = 4; // Safe default
-      break;
-    }
-
-    // Calculate total memory for all mip levels
-    size_t totalMemory = 0;
-    for (uint32_t mip = 0; mip < mipLevelCount; ++mip) {
-      uint32_t mipWidth = std::max(1u, width >> mip);
-      uint32_t mipHeight = std::max(1u, height >> mip);
-      totalMemory += static_cast<size_t>(mipWidth) * mipHeight *
-                     depthOrArrayLayers * bytesPerPixel * sampleCount;
-    }
-
-    return totalMemory;
-  }
-
-private:
-  wgpu::Texture _instance;
-  std::string _label;
-  bool _reportsMemoryPressure = true;
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUTextureView.h

@@ -1,44 +0,0 @@
-#pragma once
-
-#include <string>
-
-#include "Unions.h"
-
-#include "NativeObject.h"
-
-#include "webgpu/webgpu_cpp.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-class GPUTextureView : public NativeObject<GPUTextureView> {
-public:
-  static constexpr const char *CLASS_NAME = "GPUTextureView";
-
-  explicit GPUTextureView(wgpu::TextureView instance, std::string label)
-      : NativeObject(CLASS_NAME), _instance(instance), _label(label) {}
-
-public:
-  std::string getBrand() { return CLASS_NAME; }
-
-  std::string getLabel() { return _label; }
-  void setLabel(const std::string &label) {
-    _label = label;
-    _instance.SetLabel(_label.c_str());
-  }
-
-  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installGetter(runtime, prototype, "__brand", &GPUTextureView::getBrand);
-    installGetterSetter(runtime, prototype, "label", &GPUTextureView::getLabel,
-                        &GPUTextureView::setLabel);
-  }
-
-  inline const wgpu::TextureView get() { return _instance; }
-
-private:
-  wgpu::TextureView _instance;
-  std::string _label;
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUUncapturedErrorEvent.h

@@ -1,71 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-#include <variant>
-
-#include "JSIConverter.h"
-#include "NativeObject.h"
-
-#include "GPUInternalError.h"
-#include "GPUOutOfMemoryError.h"
-#include "GPUValidationError.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-using GPUErrorVariant = std::variant<std::shared_ptr<GPUValidationError>,
-                                     std::shared_ptr<GPUOutOfMemoryError>,
-                                     std::shared_ptr<GPUInternalError>>;
-
-class GPUUncapturedErrorEvent : public NativeObject<GPUUncapturedErrorEvent> {
-public:
-  static constexpr const char *CLASS_NAME = "GPUUncapturedErrorEvent";
-
-  explicit GPUUncapturedErrorEvent(GPUErrorVariant error)
-      : NativeObject(CLASS_NAME), _error(std::move(error)) {}
-
-public:
-  std::string getBrand() { return CLASS_NAME; }
-  std::string getType() { return "uncapturederror"; }
-
-  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installGetter(runtime, prototype, "__brand",
-                  &GPUUncapturedErrorEvent::getBrand);
-    installGetter(runtime, prototype, "type",
-                  &GPUUncapturedErrorEvent::getType);
-
-    // Custom getter for error that handles the variant conversion
-    auto errorGetter = jsi::Function::createFromHostFunction(
-        runtime, jsi::PropNameID::forUtf8(runtime, "get_error"), 0,
-        [](jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
-           size_t count) -> jsi::Value {
-          auto native = GPUUncapturedErrorEvent::fromValue(rt, thisVal);
-          return std::visit(
-              [&rt](auto &&err) -> jsi::Value {
-                using T = std::decay_t<decltype(err)>;
-                return JSIConverter<T>::toJSI(rt, err);
-              },
-              native->_error);
-        });
-
-    auto objectCtor = runtime.global().getPropertyAsObject(runtime, "Object");
-    auto defineProperty =
-        objectCtor.getPropertyAsFunction(runtime, "defineProperty");
-
-    jsi::Object descriptor(runtime);
-    descriptor.setProperty(runtime, "get", errorGetter);
-    descriptor.setProperty(runtime, "enumerable", true);
-    descriptor.setProperty(runtime, "configurable", true);
-
-    defineProperty.call(runtime, prototype,
-                        jsi::String::createFromUtf8(runtime, "error"),
-                        descriptor);
-  }
-
-private:
-  GPUErrorVariant _error;
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUValidationError.h

@@ -1,32 +0,0 @@
-#pragma once
-
-#include <string>
-
-#include "NativeObject.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-class GPUValidationError : public NativeObject<GPUValidationError> {
-public:
-  static constexpr const char *CLASS_NAME = "GPUValidationError";
-
-  explicit GPUValidationError(std::string message)
-      : NativeObject(CLASS_NAME), _message(std::move(message)) {}
-
-public:
-  std::string getBrand() { return CLASS_NAME; }
-  std::string getMessage() { return _message; }
-
-  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installGetter(runtime, prototype, "__brand", &GPUValidationError::getBrand);
-    installGetter(runtime, prototype, "message",
-                  &GPUValidationError::getMessage);
-  }
-
-private:
-  std::string _message;
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/ImageBitmap.h

@@ -1,48 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "NativeObject.h"
-#include "PlatformContext.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-class ImageBitmap : public NativeObject<ImageBitmap> {
-public:
-  static constexpr const char *CLASS_NAME = "ImageBitmap";
-
-  explicit ImageBitmap(ImageData &imageData)
-      : NativeObject(CLASS_NAME), _imageData(imageData) {}
-
-  size_t getWidth() { return _imageData.width; }
-
-  size_t getHeight() { return _imageData.height; }
-
-  void *getData() { return _imageData.data.data(); }
-
-  size_t getSize() { return _imageData.data.size(); }
-
-  void close() {
-    _imageData.data.clear();
-    _imageData.data.shrink_to_fit();
-    _imageData.width = 0;
-    _imageData.height = 0;
-  }
-
-  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installGetter(runtime, prototype, "width", &ImageBitmap::getWidth);
-    installGetter(runtime, prototype, "height", &ImageBitmap::getHeight);
-    installMethod(runtime, prototype, "close", &ImageBitmap::close);
-  }
-
-  size_t getMemoryPressure() override { return getSize(); }
-
-private:
-  ImageData _imageData;
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/RNWebGPU.h

@@ -1,241 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-
-#include "NativeObject.h"
-
-#include "ArrayBuffer.h"
-#include "Canvas.h"
-#include "GPU.h"
-#include "GPUCanvasContext.h"
-#include "ImageBitmap.h"
-#include "PlatformContext.h"
-#include "VideoFrame.h"
-#include "VideoPlayer.h"
-
-#include <ReactCommon/CallInvoker.h>
-
-#include "JSIConverter.h"
-#include "Promise.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-struct Blob {
-  std::string blobId;
-  double size;
-  double offset;
-  std::string type;
-  std::string name;
-};
-
-// JSIConverter specialization must be declared before use
-template <> struct JSIConverter<std::shared_ptr<Blob>> {
-  static std::shared_ptr<Blob>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    if (!outOfBounds && arg.isObject()) {
-      auto result = std::make_unique<Blob>();
-      auto val = arg.asObject(runtime);
-      if (val.hasProperty(runtime, "_data")) {
-        auto value = val.getPropertyAsObject(runtime, "_data");
-        result->blobId = JSIConverter<std::string>::fromJSI(
-            runtime, value.getProperty(runtime, "blobId"), false);
-        result->size = JSIConverter<double>::fromJSI(
-            runtime, value.getProperty(runtime, "size"), false);
-        result->offset = JSIConverter<double>::fromJSI(
-            runtime, value.getProperty(runtime, "offset"), false);
-      }
-      return result;
-    } else {
-      throw std::runtime_error("Invalid Blob::fromJSI()");
-    }
-  }
-  static jsi::Value toJSI(jsi::Runtime &runtime, std::shared_ptr<Blob> arg) {
-    throw std::runtime_error("Invalid Blob::toJSI()");
-  }
-};
-
-class RNWebGPU : public NativeObject<RNWebGPU> {
-public:
-  static constexpr const char *CLASS_NAME = "RNWebGPU";
-
-  explicit RNWebGPU(std::shared_ptr<GPU> gpu,
-                    std::shared_ptr<PlatformContext> platformContext,
-                    std::shared_ptr<facebook::react::CallInvoker> callInvoker)
-      : NativeObject(CLASS_NAME), _gpu(gpu), _platformContext(platformContext),
-        _callInvoker(callInvoker) {}
-
-  std::shared_ptr<GPU> getGPU() { return _gpu; }
-
-  bool getFabric() { return true; }
-
-  std::shared_ptr<GPUCanvasContext>
-  MakeWebGPUCanvasContext(int contextId, float width, float height) {
-    auto ctx =
-        std::make_shared<GPUCanvasContext>(_gpu, contextId, width, height);
-    return ctx;
-  }
-
-  jsi::Value createImageBitmap(jsi::Runtime &runtime,
-                               const jsi::Value & /*thisVal*/,
-                               const jsi::Value *args, size_t count) {
-    if (count < 1) {
-      throw jsi::JSError(runtime,
-                         "createImageBitmap requires a Blob or ArrayBuffer "
-                         "argument");
-    }
-
-    auto platformContext = _platformContext;
-    auto callInvoker = _callInvoker;
-
-    // Check if the argument is an ArrayBuffer or ArrayBufferView
-    // (TypedArray / DataView). Only a real buffer source is run through the
-    // ArrayBuffer converter, which validates byteOffset/byteLength against the
-    // backing buffer and throws on an out-of-bounds (or spoofed) view. Anything
-    // else (e.g. a Blob) is left to the fall-through path below, so its errors
-    // are not misreported as bounds errors here.
-    if (args[0].isObject()) {
-      auto obj = args[0].getObject(runtime);
-
-      bool isBufferSource = obj.isArrayBuffer(runtime);
-      if (!isBufferSource && obj.hasProperty(runtime, "buffer")) {
-        auto bufferProp = obj.getProperty(runtime, "buffer");
-        isBufferSource = bufferProp.isObject() &&
-                         bufferProp.getObject(runtime).isArrayBuffer(runtime);
-      }
-
-      if (isBufferSource) {
-        // Bounds violations propagate out of fromJSI so the call rejects
-        // rather than reading out of bounds below.
-        auto buffer = JSIConverter<std::shared_ptr<ArrayBuffer>>::fromJSI(
-            runtime, args[0], false);
-        std::span<const uint8_t> data{buffer->data(), buffer->size()};
-
-        // Copy bytes on the JS thread: the ArrayBuffer pointer is into
-        // JS-owned memory that can be GC'd
-        std::vector<uint8_t> dataCopy(data.begin(), data.end());
-
-        return Promise::createPromise(
-            runtime,
-            [platformContext, callInvoker, dataCopy = std::move(dataCopy)](
-                jsi::Runtime & /*runtime*/,
-                std::shared_ptr<Promise> promise) mutable {
-              platformContext->createImageBitmapFromDataAsync(
-                  dataCopy,
-                  [callInvoker, promise](ImageData imageData) {
-                    auto imageBitmap = std::make_shared<ImageBitmap>(imageData);
-                    callInvoker->invokeAsync([promise, imageBitmap]() {
-                      promise->resolve(
-                          JSIConverter<std::shared_ptr<ImageBitmap>>::toJSI(
-                              promise->runtime, imageBitmap));
-                    });
-                  },
-                  [callInvoker, promise](std::string error) {
-                    callInvoker->invokeAsync(
-                        [promise, error]() { promise->reject(error); });
-                  });
-            });
-      }
-    }
-
-    // Fall through to existing Blob path
-    auto blob =
-        JSIConverter<std::shared_ptr<Blob>>::fromJSI(runtime, args[0], false);
-    std::string blobId = blob->blobId;
-    double offset = blob->offset;
-    double size = blob->size;
-
-    return Promise::createPromise(
-        runtime,
-        [platformContext, callInvoker, blobId, offset,
-         size](jsi::Runtime & /*runtime*/, std::shared_ptr<Promise> promise) {
-          platformContext->createImageBitmapAsync(
-              blobId, offset, size,
-              [callInvoker, promise](ImageData imageData) {
-                auto imageBitmap = std::make_shared<ImageBitmap>(imageData);
-                callInvoker->invokeAsync([promise, imageBitmap]() {
-                  promise->resolve(
-                      JSIConverter<std::shared_ptr<ImageBitmap>>::toJSI(
-                          promise->runtime, imageBitmap));
-                });
-              },
-              [callInvoker, promise](std::string error) {
-                callInvoker->invokeAsync(
-                    [promise, error]() { promise->reject(error); });
-              });
-        });
-  }
-
-  std::shared_ptr<VideoFrame> loadVideoFrame(std::string path) {
-    auto frame = _platformContext->loadVideoFrame(path);
-    return std::make_shared<VideoFrame>(std::move(frame));
-  }
-
-  std::shared_ptr<VideoFrame> createTestVideoFrame(double width, double height) {
-    auto frame = _platformContext->createTestVideoFrame(
-        static_cast<uint32_t>(width), static_cast<uint32_t>(height));
-    return std::make_shared<VideoFrame>(std::move(frame));
-  }
-
-  // Wrap a CVPixelBufferRef / AHardwareBuffer* pointer (typed as void* via
-  // BigInt on the JS side) into one of our VideoFrames. The native side
-  // CFRetains / acquires so the caller can release immediately.
-  std::shared_ptr<VideoFrame> createVideoFrameFromNativeBuffer(void *pointer) {
-    auto handle = _platformContext->wrapNativeBuffer(pointer);
-    return std::make_shared<VideoFrame>(std::move(handle));
-  }
-
-  std::shared_ptr<VideoPlayer>
-  createVideoPlayer(std::string path, std::optional<std::string> pixelFormat) {
-    auto format = (pixelFormat && pixelFormat.value() == "nv12")
-                      ? VideoPixelFormat::NV12
-                      : VideoPixelFormat::BGRA8;
-    auto impl = _platformContext->createVideoPlayer(path, format);
-    return std::make_shared<VideoPlayer>(std::move(impl));
-  }
-
-  std::string writeTestVideoFile() {
-    return _platformContext->writeTestVideoFile();
-  }
-
-  std::shared_ptr<Canvas> getNativeSurface(int contextId) {
-    auto &registry = rnwgpu::SurfaceRegistry::getInstance();
-    auto info = registry.getSurfaceInfo(contextId);
-    if (info == nullptr) {
-      return std::make_shared<Canvas>(nullptr, 0, 0);
-    }
-    auto nativeInfo = info->getNativeInfo();
-    return std::make_shared<Canvas>(nativeInfo.nativeSurface, nativeInfo.width,
-                                    nativeInfo.height);
-  }
-
-  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installGetter(runtime, prototype, "fabric", &RNWebGPU::getFabric);
-    installGetter(runtime, prototype, "gpu", &RNWebGPU::getGPU);
-    installMethod(runtime, prototype, "createImageBitmap",
-                  &RNWebGPU::createImageBitmap);
-    installMethod(runtime, prototype, "getNativeSurface",
-                  &RNWebGPU::getNativeSurface);
-    installMethod(runtime, prototype, "MakeWebGPUCanvasContext",
-                  &RNWebGPU::MakeWebGPUCanvasContext);
-    installMethod(runtime, prototype, "loadVideoFrame",
-                  &RNWebGPU::loadVideoFrame);
-    installMethod(runtime, prototype, "createTestVideoFrame",
-                  &RNWebGPU::createTestVideoFrame);
-    installMethod(runtime, prototype, "createVideoFrameFromNativeBuffer",
-                  &RNWebGPU::createVideoFrameFromNativeBuffer);
-    installMethod(runtime, prototype, "createVideoPlayer",
-                  &RNWebGPU::createVideoPlayer);
-    installMethod(runtime, prototype, "writeTestVideoFile",
-                  &RNWebGPU::writeTestVideoFile);
-  }
-
-private:
-  std::shared_ptr<GPU> _gpu;
-  std::shared_ptr<PlatformContext> _platformContext;
-  std::shared_ptr<facebook::react::CallInvoker> _callInvoker;
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/RnFeatures.h

@@ -1,53 +0,0 @@
-#pragma once
-
-#include <string>
-#include <unordered_set>
-#include <vector>
-
-#include "webgpu/webgpu_cpp.h"
-
-namespace rnwgpu {
-
-// Umbrella feature name owned by react-native-wgpu. Backed by a
-// platform-specific pair of Dawn features. The prefix is intentional: this
-// string is not part of the WebGPU spec, it is our API surface for the
-// "import a native surface as a sampleable texture" capability.
-inline constexpr const char *kRnNativeTextureFeature =
-    "rnwebgpu/native-texture";
-
-// Dawn features that back the umbrella on the current platform. Empty on
-// platforms where the capability is not available, in which case the umbrella
-// behaves as a no-op (it won't appear in adapter.features and asking for it
-// in requiredFeatures expands to nothing).
-inline std::vector<wgpu::FeatureName> rnNativeTextureBackingFeatures() {
-#if defined(__APPLE__)
-  return {wgpu::FeatureName::SharedTextureMemoryIOSurface,
-          wgpu::FeatureName::SharedFenceMTLSharedEvent};
-#elif defined(__ANDROID__)
-  return {wgpu::FeatureName::SharedTextureMemoryAHardwareBuffer,
-          wgpu::FeatureName::SharedFenceSyncFD};
-#else
-  return {};
-#endif
-}
-
-// If every Dawn feature backing the umbrella is in `enabled`, add the
-// umbrella name to `out`. Used by adapter.features / device.features so JS
-// callers can see (and call .has on) the same name they pass in.
-inline void
-maybeSynthesizeRnNativeTextureFeature(
-    const std::unordered_set<wgpu::FeatureName> &enabled,
-    std::unordered_set<std::string> &out) {
-  auto backing = rnNativeTextureBackingFeatures();
-  if (backing.empty()) {
-    return;
-  }
-  for (auto f : backing) {
-    if (enabled.find(f) == enabled.end()) {
-      return;
-    }
-  }
-  out.insert(kRnNativeTextureFeature);
-}
-
-} // namespace rnwgpu