react-native-webgpu 0.15.2 → 0.16.1

package/android/src/main/java/com/webgpu/WebGPUView.java

@@ -2,6 +2,7 @@ package com.webgpu;
 
 import android.content.Context;
 import android.os.Build;
+import android.util.Log;
 import android.view.Surface;
 import android.view.View;
 
@@ -10,6 +11,7 @@ import com.facebook.react.uimanager.ThemedReactContext;
 import com.facebook.react.views.view.ReactViewGroup;
 
 public class WebGPUView extends ReactViewGroup implements WebGPUAPI {
+  private static final String TAG = "WebGPUView";
 
   // Backing view kinds, see updateView().
   private static final int KIND_SURFACE_VIEW = 0;
@@ -17,16 +19,22 @@ public class WebGPUView extends ReactViewGroup implements WebGPUAPI {
   private static final int KIND_HARDWARE_BUFFER_VIEW = 2;
 
   private int mContextId;
+  // Props. opaque is applied in place, and so is zOrderOnTop where Android
+  // allows it (see setZOrderOnTop); surfaceType is read once, when the
+  // backing view is created (see updateView()).
   private boolean mOpaque = true;
   private String mSurfaceType = "auto";
   private boolean mZOrderOnTop = false;
-  private int mAppliedKind = -1;
-  private boolean mAppliedZOrderOnTop;
   private WebGPUModule mModule;
+  // The backing view, created by the first prop transaction and kept, with
+  // the kind it was created with. The kind is -1 until then: it is what
+  // tells a mounted canvas apart.
   private View mView = null;
+  private int mKind = -1;
   // Only a SurfaceView votes: a TextureView or HardwareBufferView is
   // composited into the window, which votes for it.
-  private final SurfaceFrameRateVote mFrameRateVote = new SurfaceFrameRateVote(this);
+  private final SurfaceFrameRateVote mFrameRateVote = new SurfaceFrameRateVote(
+    this, idleAfterNanos -> releaseFrameRateVoteIfIdle(mContextId, idleAfterNanos));
 
   WebGPUView(Context context) {
     super(context);
@@ -54,12 +62,52 @@ public class WebGPUView extends ReactViewGroup implements WebGPUAPI {
     mOpaque = value;
   }
 
+  // The backing view is chosen from the props of the first transaction and
+  // kept (see updateView()). React calls a setter again only when its prop
+  // changed, so a call on a mounted canvas is a change: the setters below
+  // apply it in place where the view can take it, else they ignore it and
+  // say so (a canvas that needs another backing view is remounted, with a
+  // new key). The JS side warns about the same changes in development (see
+  // Canvas.tsx), mirroring these rules.
+
   public void setSurfaceType(String value) {
+    if (mKind != -1) {
+      warnIgnoredOnceMounted("android.surfaceType");
+      return;
+    }
     mSurfaceType = value;
   }
 
   public void setZOrderOnTop(boolean value) {
+    if (mKind == -1) {
+      mZOrderOnTop = value;
+      return;
+    }
+    // Only a SurfaceView has a z-order of its own: elsewhere the prop never
+    // applied, and the change is moot.
+    if (mKind != KIND_SURFACE_VIEW) {
+      return;
+    }
+    if (!zOrderChangesInPlace()) {
+      warnIgnoredOnceMounted("android.zOrderOnTop");
+      return;
+    }
     mZOrderOnTop = value;
+    ((WebGPUSurfaceView) mView).setZOrderOnTop(value);
+  }
+
+  private void warnIgnoredOnceMounted(String prop) {
+    Log.w(TAG, "Ignoring a change of " + prop + " on a mounted canvas: the backing view"
+        + " is chosen when the canvas mounts. Remount the canvas (give it a new key)"
+        + " to change it.");
+  }
+
+  // SurfaceView.setZOrderOnTop() moves a live surface since Android 11, for
+  // an app targeting it; before that, the surface reads it when it is
+  // created (see updateView()).
+  private boolean zOrderChangesInPlace() {
+    return Build.VERSION.SDK_INT >= Build.VERSION_CODES.R
+        && getContext().getApplicationInfo().targetSdkVersion >= Build.VERSION_CODES.R;
   }
 
   // Resolve the backing view from the props. "auto" picks SurfaceView for an
@@ -83,41 +131,44 @@ public class WebGPUView extends ReactViewGroup implements WebGPUAPI {
   }
 
   // Apply the complete prop transaction once, after contextId and all rendering
-  // options have arrived. Only a change of backing view (or of zOrderOnTop,
-  // which a SurfaceView must know before it attaches) replaces the child;
-  // opacity is applied in place.
+  // options have arrived. The first one creates the backing view, which is
+  // then kept: a SurfaceView must know its z-order before it attaches (before
+  // Android 11), and replacing a backing view on screen hands the canvas from
+  // one view to another, which no release of Android does without a frame of
+  // nothing, or of black, in between (the two views are composited by
+  // different frames). A canvas that needs another backing view is remounted
+  // instead. Later transactions apply the opacity in place (the setters decide
+  // what else is taken); WebGPUHardwareBufferView always composites with
+  // alpha, so there it is a no-op.
   public void updateView() {
+    if (mKind != -1) {
+      if (mKind == KIND_TEXTURE_VIEW) {
+        ((WebGPUTextureView) mView).setOpaque(mOpaque);
+      } else if (mKind == KIND_SURFACE_VIEW) {
+        ((WebGPUSurfaceView) mView).setOpaque(mOpaque);
+      }
+      return;
+    }
     int kind = resolveKind();
     boolean zOrderOnTop = kind == KIND_SURFACE_VIEW && mZOrderOnTop;
-    if (mView == null || kind != mAppliedKind || zOrderOnTop != mAppliedZOrderOnTop) {
-      if (mView != null) {
-        removeView(mView);
-      }
-      mAppliedKind = kind;
-      mAppliedZOrderOnTop = zOrderOnTop;
-      Context ctx = getContext();
-      switch (kind) {
-        case KIND_HARDWARE_BUFFER_VIEW:
-          mView = new WebGPUHardwareBufferView(ctx, this);
-          break;
-        case KIND_TEXTURE_VIEW:
-          mView = new WebGPUTextureView(ctx, this, mOpaque);
-          break;
-        default:
-          mView = new WebGPUSurfaceView(ctx, this, zOrderOnTop, mOpaque);
-          break;
-      }
-      addView(mView);
-      // ReactViewGroup.requestLayout() is a deliberate no-op, so addView outside
-      // the layout pass never lays the child out; do it by hand or the new view
-      // stays 0x0 and never gets a surface.
-      layoutChild();
-    } else if (kind == KIND_TEXTURE_VIEW) {
-      ((WebGPUTextureView) mView).setOpaque(mOpaque);
-    } else if (kind == KIND_SURFACE_VIEW) {
-      ((WebGPUSurfaceView) mView).setOpaque(mOpaque);
+    mKind = kind;
+    Context ctx = getContext();
+    switch (kind) {
+      case KIND_HARDWARE_BUFFER_VIEW:
+        mView = new WebGPUHardwareBufferView(ctx, this);
+        break;
+      case KIND_TEXTURE_VIEW:
+        mView = new WebGPUTextureView(ctx, this, mOpaque);
+        break;
+      default:
+        mView = new WebGPUSurfaceView(ctx, this, zOrderOnTop, mOpaque);
+        break;
     }
-    // WebGPUHardwareBufferView always composites with alpha; opacity is a no-op.
+    addView(mView);
+    // ReactViewGroup.requestLayout() is a deliberate no-op, so addView outside
+    // the layout pass never lays the child out; do it by hand or the new view
+    // stays 0x0 and never gets a surface.
+    layoutChild();
   }
 
   private void layoutChild() {
@@ -137,7 +188,7 @@ public class WebGPUView extends ReactViewGroup implements WebGPUAPI {
     float density = getResources().getDisplayMetrics().density;
     float width = getWidth() / density;
     float height = getHeight() / density;
-    boolean votesFrameRate = mAppliedKind == KIND_SURFACE_VIEW;
+    boolean votesFrameRate = mKind == KIND_SURFACE_VIEW;
     if (votesFrameRate) {
       mFrameRateVote.attach(surface);
     }
@@ -160,12 +211,12 @@ public class WebGPUView extends ReactViewGroup implements WebGPUAPI {
   }
 
   /**
-   * Called from native (SurfaceInfo::presentFrame) on the thread that
-   * presented a frame to the surface, only for a SurfaceView.
+   * Called from native (AnimationReporter in cpp-adapter.cpp) on the thread
+   * that presents to the surface, once per animation, only for a SurfaceView.
    */
   @DoNotStrip
-  void onFramePresented() {
-    mFrameRateVote.onFramePresented();
+  void onAnimating() {
+    mFrameRateVote.onAnimating();
   }
 
   @Override
@@ -182,15 +233,15 @@ public class WebGPUView extends ReactViewGroup implements WebGPUAPI {
     onViewDestroyed(mContextId);
   }
 
-  // reportPresents asks native to call onFramePresented() for each frame
-  // presented to this surface.
+  // reportAnimation asks native to call onAnimating() when frames start being
+  // presented to this surface back to back.
   @DoNotStrip
   private native void onSurfaceCreate(
     Surface surface,
     int contextId,
     float width,
     float height,
-    boolean reportPresents
+    boolean reportAnimation
   );
 
   @DoNotStrip
@@ -207,4 +258,8 @@ public class WebGPUView extends ReactViewGroup implements WebGPUAPI {
   @DoNotStrip
   private native void onViewDestroyed(int contextId);
 
+  // See SurfaceFrameRateVote.AnimationSource.
+  @DoNotStrip
+  private native long releaseFrameRateVoteIfIdle(int contextId, long idleAfterNanos);
+
 }

package/apple/ApplePlatformContext.h

@@ -2,6 +2,7 @@
 
 #include "PlatformContext.h"
 #include <functional>
+#include <memory>
 #include <string>
 
 namespace rnwgpu {

package/cpp/jsi/JSICache.cpp

@@ -2,8 +2,10 @@
 
 #include <algorithm>
 #include <iterator>
+#include <memory>
 #include <stdexcept>
 #include <string>
+#include <unordered_map>
 #include <utility>
 
 namespace rnwgpu {

package/cpp/jsi/NativeObject.h

@@ -14,6 +14,7 @@
 #include <typeindex>
 #include <unordered_map>
 #include <utility>
+#include <vector>
 
 #include "EnforceRange.h"
 #include "JSICache.h"
@@ -178,6 +179,14 @@ private:
  *   getters and Proxy traps of unrelated objects never run.
  * - box(value): wraps the object into a BoxedWebGPUObject, branded with its
  *   class name, for unbox() on the target runtime.
+ * - installConstructors(): installs the constructor of every WebGPU class on
+ *   the calling runtime, skipping the ones already there, so `instanceof`
+ *   works against any class on that runtime, including classes no object of
+ *   which was ever created there or crossed into it (unboxing installs only
+ *   the class of the object that crosses). installWebGPU() calls it. The
+ *   class list belongs to the API layer (RNWebGPUManager::installConstructors)
+ *   and is handed in at construction: every API class includes this header,
+ *   which therefore cannot include them back.
  *
  * One instance is installed on the main runtime as
  * globalThis.__webgpuWorkletHelpers and captured by the serializer's
@@ -188,8 +197,26 @@ private:
  */
 class WebGPUWorkletHelpers : public jsi::HostObject {
 public:
+  using InstallConstructors = void (*)(jsi::Runtime &);
+
+  explicit WebGPUWorkletHelpers(InstallConstructors installConstructors)
+      : _installConstructors(installConstructors) {}
+
   jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override {
     auto propName = name.utf8(runtime);
+    if (propName == "installConstructors") {
+      auto install = _installConstructors;
+      return jsi::Function::createFromHostFunction(
+          runtime, name, 0,
+          [install](jsi::Runtime &rt, const jsi::Value & /*thisVal*/,
+                    const jsi::Value * /*args*/,
+                    size_t /*count*/) -> jsi::Value {
+            if (install != nullptr) {
+              install(rt);
+            }
+            return jsi::Value::undefined();
+          });
+    }
     if (propName == "isNativeObject") {
       return jsi::Function::createFromHostFunction(
           runtime, name, 1,
@@ -229,11 +256,15 @@ public:
   std::vector<jsi::PropNameID>
   getPropertyNames(jsi::Runtime &runtime) override {
     std::vector<jsi::PropNameID> names;
-    names.reserve(2);
+    names.reserve(3);
     names.push_back(jsi::PropNameID::forUtf8(runtime, "isNativeObject"));
     names.push_back(jsi::PropNameID::forUtf8(runtime, "box"));
+    names.push_back(jsi::PropNameID::forUtf8(runtime, "installConstructors"));
     return names;
   }
+
+private:
+  InstallConstructors _installConstructors;
 };
 
 /**
@@ -377,6 +408,9 @@ public:
    * The constructor throws if called directly (these objects are only
    * created internally by the native code).
    *
+   * Idempotent per runtime: once the global exists there, later calls return
+   * without touching it, so the constructor object keeps its identity.
+   *
    * Also registers this class with NativeObjectRegistry so that
    * BoxedWebGPUObject::unbox() can rebuild its objects on secondary runtimes.
    */
@@ -393,10 +427,9 @@ public:
             if (instance == nullptr) {
               throw jsi::JSError(rt, "Invalid boxed native object state");
             }
-            // The constructor makes `instanceof` work on this runtime too.
-            if (!rt.global().hasProperty(rt, Derived::CLASS_NAME)) {
-              Derived::installConstructor(rt);
-            }
+            // The constructor makes `instanceof` work on this runtime too
+            // (a no-op once it is installed there).
+            Derived::installConstructor(rt);
             // 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 (GPUDevice error/lost
@@ -414,6 +447,14 @@ public:
 
     installPrototype(runtime);
 
+    // Once per runtime. installWebGPU() runs this at the top of every worklet
+    // invocation, and reinstalling would replace the global with a new
+    // function object each time (`const C = GPUBuffer; C === GPUBuffer`
+    // would be false).
+    if (runtime.global().hasProperty(runtime, Derived::CLASS_NAME)) {
+      return;
+    }
+
     auto *prototype = getCachedPrototype(runtime);
     if (prototype == nullptr) {
       return;
@@ -640,19 +681,26 @@ protected:
                 rt, std::move(result));
           }
         });
+    defineGetter(runtime, prototype, name, getterFunc);
+  }
 
-    // Use Object.defineProperty to create a proper getter
-    auto objectCtor = runtime.global().getPropertyAsObject(runtime, "Object");
-    auto defineProperty =
-        objectCtor.getPropertyAsFunction(runtime, "defineProperty");
-
-    jsi::Object descriptor(runtime);
-    descriptor.setProperty(runtime, "get", getterFunc);
-    descriptor.setProperty(runtime, "enumerable", true);
-    descriptor.setProperty(runtime, "configurable", true);
-
-    defineProperty.call(runtime, prototype,
-                        jsi::String::createFromUtf8(runtime, name), descriptor);
+  /**
+   * Install a getter whose native implementation builds the JS value itself,
+   * from the calling jsi::Runtime: for values no JSIConverter produces (null
+   * or a BigInt, say).
+   */
+  static void installGetter(jsi::Runtime &runtime, jsi::Object &prototype,
+                            const char *name,
+                            jsi::Value (Derived::*getter)(jsi::Runtime &)) {
+    auto getterFunc = jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forUtf8(runtime, std::string("get_") + name),
+        0,
+        [getter](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+          auto native = Derived::fromValue(rt, thisVal);
+          return (native.get()->*getter)(rt);
+        });
+    defineGetter(runtime, prototype, name, getterFunc);
   }
 
   /**
@@ -757,6 +805,22 @@ protected:
   }
 
 private:
+  // Use Object.defineProperty to create a proper getter
+  static void defineGetter(jsi::Runtime &runtime, jsi::Object &prototype,
+                           const char *name, const jsi::Function &getterFunc) {
+    auto objectCtor = runtime.global().getPropertyAsObject(runtime, "Object");
+    auto defineProperty =
+        objectCtor.getPropertyAsFunction(runtime, "defineProperty");
+
+    jsi::Object descriptor(runtime);
+    descriptor.setProperty(runtime, "get", getterFunc);
+    descriptor.setProperty(runtime, "enumerable", true);
+    descriptor.setProperty(runtime, "configurable", true);
+
+    defineProperty.call(runtime, prototype,
+                        jsi::String::createFromUtf8(runtime, name), descriptor);
+  }
+
   // Helper to call a method that takes the calling jsi::Runtime as its first
   // parameter, with JSI argument conversion for the rest and JSI conversion of
   // the result.

package/cpp/rnwgpu/RNWebGPUManager.cpp

@@ -22,6 +22,8 @@
 #include "GPUError.h"
 #include "GPUExternalTexture.h"
 #include "GPUInternalError.h"
+#include "GPUNativeBufferExternalTexture.h"
+#include "GPUNativeBufferTexture.h"
 #include "GPUOutOfMemoryError.h"
 #include "GPUPipelineLayout.h"
 #include "GPUQuerySet.h"
@@ -85,43 +87,7 @@ RNWebGPUManager::RNWebGPUManager(
                                    RNWebGPU::create(*_jsRuntime, rnWebGPU));
 
   // Install constructors for instanceof support
-  GPU::installConstructor(*_jsRuntime);
-  GPUAdapter::installConstructor(*_jsRuntime);
-  GPUAdapterInfo::installConstructor(*_jsRuntime);
-  GPUBindGroup::installConstructor(*_jsRuntime);
-  GPUBindGroupLayout::installConstructor(*_jsRuntime);
-  GPUBuffer::installConstructor(*_jsRuntime);
-  GPUCanvasContext::installConstructor(*_jsRuntime);
-  GPUCommandBuffer::installConstructor(*_jsRuntime);
-  GPUCommandEncoder::installConstructor(*_jsRuntime);
-  GPUCompilationInfo::installConstructor(*_jsRuntime);
-  GPUCompilationMessage::installConstructor(*_jsRuntime);
-  GPUComputePassEncoder::installConstructor(*_jsRuntime);
-  GPUComputePipeline::installConstructor(*_jsRuntime);
-  GPUDevice::installConstructor(*_jsRuntime);
-  GPUDeviceLostInfo::installConstructor(*_jsRuntime);
-  GPUError::installConstructor(*_jsRuntime);
-  GPUExternalTexture::installConstructor(*_jsRuntime);
-  GPUInternalError::installConstructor(*_jsRuntime);
-  GPUOutOfMemoryError::installConstructor(*_jsRuntime);
-  GPUValidationError::installConstructor(*_jsRuntime);
-  GPUUncapturedErrorEvent::installConstructor(*_jsRuntime);
-  GPUPipelineLayout::installConstructor(*_jsRuntime);
-  GPUQuerySet::installConstructor(*_jsRuntime);
-  GPUQueue::installConstructor(*_jsRuntime);
-  GPURenderBundle::installConstructor(*_jsRuntime);
-  GPURenderBundleEncoder::installConstructor(*_jsRuntime);
-  GPURenderPassEncoder::installConstructor(*_jsRuntime);
-  GPURenderPipeline::installConstructor(*_jsRuntime);
-  GPUSampler::installConstructor(*_jsRuntime);
-  GPUSharedFence::installConstructor(*_jsRuntime);
-  GPUSharedTextureMemory::installConstructor(*_jsRuntime);
-  GPUShaderModule::installConstructor(*_jsRuntime);
-  GPUSupportedLimits::installConstructor(*_jsRuntime);
-  GPUTexture::installConstructor(*_jsRuntime);
-  GPUTextureView::installConstructor(*_jsRuntime);
-  VideoFrame::installConstructor(*_jsRuntime);
-  VideoPlayer::installConstructor(*_jsRuntime);
+  installConstructors(*_jsRuntime);
 
   // Install constant objects as plain JS objects with own properties
   _jsRuntime->global().setProperty(*_jsRuntime, "GPUBufferUsage",
@@ -140,14 +106,58 @@ RNWebGPUManager::RNWebGPUManager(
   installWebGPUWorkletHelpers(*_jsRuntime);
 }
 
+void RNWebGPUManager::installConstructors(jsi::Runtime &runtime) {
+  GPU::installConstructor(runtime);
+  GPUAdapter::installConstructor(runtime);
+  GPUAdapterInfo::installConstructor(runtime);
+  GPUBindGroup::installConstructor(runtime);
+  GPUBindGroupLayout::installConstructor(runtime);
+  GPUBuffer::installConstructor(runtime);
+  GPUCanvasContext::installConstructor(runtime);
+  GPUCommandBuffer::installConstructor(runtime);
+  GPUCommandEncoder::installConstructor(runtime);
+  GPUCompilationInfo::installConstructor(runtime);
+  GPUCompilationMessage::installConstructor(runtime);
+  GPUComputePassEncoder::installConstructor(runtime);
+  GPUComputePipeline::installConstructor(runtime);
+  GPUDevice::installConstructor(runtime);
+  GPUDeviceLostInfo::installConstructor(runtime);
+  GPUError::installConstructor(runtime);
+  GPUExternalTexture::installConstructor(runtime);
+  GPUNativeBufferExternalTexture::installConstructor(runtime);
+  GPUNativeBufferTexture::installConstructor(runtime);
+  GPUInternalError::installConstructor(runtime);
+  GPUOutOfMemoryError::installConstructor(runtime);
+  GPUValidationError::installConstructor(runtime);
+  GPUUncapturedErrorEvent::installConstructor(runtime);
+  GPUPipelineLayout::installConstructor(runtime);
+  GPUQuerySet::installConstructor(runtime);
+  GPUQueue::installConstructor(runtime);
+  GPURenderBundle::installConstructor(runtime);
+  GPURenderBundleEncoder::installConstructor(runtime);
+  GPURenderPassEncoder::installConstructor(runtime);
+  GPURenderPipeline::installConstructor(runtime);
+  GPUSampler::installConstructor(runtime);
+  GPUSharedFence::installConstructor(runtime);
+  GPUSharedTextureMemory::installConstructor(runtime);
+  GPUShaderModule::installConstructor(runtime);
+  GPUSupportedLimits::installConstructor(runtime);
+  GPUTexture::installConstructor(runtime);
+  GPUTextureView::installConstructor(runtime);
+  VideoFrame::installConstructor(runtime);
+  VideoPlayer::installConstructor(runtime);
+}
+
 void RNWebGPUManager::installWebGPUWorkletHelpers(jsi::Runtime &runtime) {
-  // The serializer worklets capture this object by closure; worklets passes a
-  // HostObject to every runtime by reference, so installing it here, on the
-  // main runtime, is enough (see WebGPUWorkletHelpers).
+  // The serializer worklets and installWebGPU() capture this object by
+  // closure; worklets passes a HostObject to every runtime by reference, so
+  // installing it here, on the main runtime, is enough (see
+  // WebGPUWorkletHelpers).
   runtime.global().setProperty(
       runtime, "__webgpuWorkletHelpers",
       jsi::Object::createFromHostObject(
-          runtime, std::make_shared<WebGPUWorkletHelpers>()));
+          runtime, std::make_shared<WebGPUWorkletHelpers>(
+                       &RNWebGPUManager::installConstructors)));
 }
 
 void RNWebGPUManager::flushPendingSurfaceTransition(

package/cpp/rnwgpu/RNWebGPUManager.h

@@ -35,6 +35,16 @@ public:
    */
   static void installWebGPUWorkletHelpers(jsi::Runtime &runtime);
 
+  /**
+   * Installs the constructor of every WebGPU API class on `runtime` (see
+   * NativeObject::installConstructor), skipping the ones already there. Runs
+   * on the main runtime at startup and, through
+   * __webgpuWorkletHelpers.installConstructors(), on every runtime that calls
+   * installWebGPU(). RNWebGPU itself is not part of it: that global is the
+   * module instance, main runtime only.
+   */
+  static void installConstructors(jsi::Runtime &runtime);
+
   /**
    * Applies a surface attach latched by the platform UI thread (see
    * SurfaceInfo::applyPendingAttach) from the JS thread. Surface attaches are

package/cpp/rnwgpu/SurfaceRegistry.h

@@ -59,7 +59,7 @@ struct Size {
 using NativeSurfaceReleaser = std::function<void(void *)>;
 
 #if defined(__ANDROID__)
-// --- AHB-pool presentation mode (WebGPUHardwareBufferView)
+// --- AHB-pool presentation mode (WebGPUNativeBufferView)
 // -----------------------------
 //
 // A third presentation backend (besides the on-screen wgpu::Surface swapchain
@@ -71,7 +71,7 @@ using NativeSurfaceReleaser = std::function<void(void *)>;
 // like the swapchain, so the canvas texture always matches the app's other
 // attachments (e.g. its depth texture).
 
-#define RNWGPU_LOG_TAG "WebGPUHardwareBufferView"
+#define RNWGPU_LOG_TAG "WebGPUNativeBufferView"
 // Failure / anomaly reporting only (never per-frame).
 #define RNWGPU_POOL_WARN(...)                                                  \
   __android_log_print(ANDROID_LOG_WARN, RNWGPU_LOG_TAG, __VA_ARGS__)
@@ -435,7 +435,7 @@ public:
   bool hasNativeSurface() {
     std::shared_lock<std::shared_mutex> lock(_mutex);
 #if defined(__ANDROID__)
-    // A WebGPUHardwareBufferView in pool mode owns presentation the same way a
+    // A WebGPUNativeBufferView in pool mode owns presentation the same way a
     // surface-backed view does, and retires the entry on its own teardown.
     if (_poolMode.load()) {
       return true;
@@ -725,7 +725,7 @@ private:
     {
       std::unique_lock<std::shared_mutex> lock(_mutex);
 #if defined(__ANDROID__)
-      // Leaving pool mode (the WebGPUHardwareBufferView detached): drop the
+      // Leaving pool mode (the WebGPUNativeBufferView detached): drop the
       // pool. A configured context keeps rendering into the offscreen
       // fallback, exactly like the surface path.
       if (_poolMode.load()) {