react-native-webgpu 0.15.2 → 0.16.0

package/android/CMakeLists.txt

@@ -46,6 +46,8 @@ add_library(${PACKAGE_NAME} SHARED
     ../cpp/rnwgpu/api/GPUSharedFence.cpp
     ../cpp/rnwgpu/api/GPUSharedTextureMemory.cpp
     ../cpp/rnwgpu/api/GPUExternalTexture.cpp
+    ../cpp/rnwgpu/api/GPUNativeBufferWrapper.cpp
+    ../cpp/rnwgpu/api/NativeFrameImport.cpp
     ../cpp/rnwgpu/api/GPURenderBundleEncoder.cpp
     ../cpp/rnwgpu/api/GPURenderPassEncoder.cpp
     ../cpp/rnwgpu/api/GPURenderPipeline.cpp
@@ -96,6 +98,8 @@ if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
             log
             jnigraphics
             android
+            # sync_merge, for the one fence endAccess() returns
+            sync
             fbjni::fbjni
             ReactAndroid::jsi
             ReactAndroid::reactnative
@@ -108,6 +112,7 @@ else()
         log
         jnigraphics
         android
+        sync
         fbjni::fbjni
         ReactAndroid::jsi
         ReactAndroid::reactnativejni

package/android/cpp/cpp-adapter.cpp

@@ -1,7 +1,11 @@
 #include <unistd.h>
 
+#include <atomic>
+#include <chrono>
+#include <cstdint>
 #include <cstring>
 #include <memory>
+#include <mutex>
 #include <string>
 #include <unordered_map>
 #include <utility>
@@ -160,10 +164,10 @@ namespace {
 
 // Weak handle on a Java view and one of its no-argument methods, for native
 // threads to call into it: the fence waiter wakes a WebGPUHardwareBufferView
-// when a frame is ready, the presenting thread reports each frame a
-// SurfaceView shows. Holding the view weakly means a view that RN has dropped
-// is not kept alive by a SurfaceInfo that outlives it (the registry keeps the
-// SurfaceInfo until onDropViewInstance).
+// when a frame is ready, the presenting thread tells a SurfaceView it is
+// animating (AnimationReporter). Holding the view weakly means a view that RN
+// has dropped is not kept alive by a SurfaceInfo that outlives it (the
+// registry keeps the SurfaceInfo until onDropViewInstance).
 struct WeakViewCall {
   jweak view = nullptr;
   jmethodID method = nullptr;
@@ -203,11 +207,84 @@ struct WeakViewCall {
   }
 };
 
+// Tells a SurfaceView it starts animating, for its refresh rate vote
+// (WebGPUView.onAnimating), from the frames presented to its surface. A call
+// into Java on the render path costs a JNI transition and attaches a presenting
+// thread the JVM doesn't know for the length of the call, so there is one call
+// per animation: the first frame presented right after its predecessor calls,
+// the frames after it only record the time. The view polls that time from the
+// main thread (releaseIfIdle) and, once the animation has stopped, takes its
+// vote back and re-arms the call for the next animation. Lock-free, since it
+// runs on every present.
+class AnimationReporter {
+public:
+  AnimationReporter(JNIEnv *env, jobject view)
+      : _onAnimating(env, view, "onAnimating") {}
+
+  void onFramePresented() {
+    const int64_t now = nowNanos();
+    const int64_t previous = _lastPresent.exchange(now);
+    if (now - previous > kAnimatingIntervalNanos) {
+      return;
+    }
+    _lastAnimating.store(now);
+    if (!_reported.exchange(true)) {
+      _onAnimating();
+    }
+  }
+
+  // Main thread. Returns how much longer the animation must stay stopped
+  // before it counts as idle, or 0 once it has: the next animating frame then
+  // calls into Java again.
+  int64_t releaseIfIdle(int64_t idleAfterNanos) {
+    const int64_t idle = nowNanos() - _lastAnimating.load();
+    if (idle < idleAfterNanos) {
+      return idleAfterNanos - idle;
+    }
+    _reported.store(false);
+    return 0;
+  }
+
+private:
+  // Presents this close together are an animation (faster than 40 fps).
+  static constexpr int64_t kAnimatingIntervalNanos = 25'000'000;
+
+  static int64_t nowNanos() {
+    return std::chrono::duration_cast<std::chrono::nanoseconds>(
+               std::chrono::steady_clock::now().time_since_epoch())
+        .count();
+  }
+
+  WeakViewCall _onAnimating;
+  // INT64_MIN / 2 rather than a sentinel: the first present is never "right
+  // after" it, and the subtractions above don't overflow.
+  std::atomic<int64_t> _lastPresent{INT64_MIN / 2};
+  std::atomic<int64_t> _lastAnimating{INT64_MIN / 2};
+  // Java has been told about the current animation.
+  std::atomic<bool> _reported{false};
+};
+
+// The reporters by contextId, for WebGPUView.releaseFrameRateVoteIfIdle. The
+// surface callbacks and the idle check all run on the main thread; the lock
+// only guards against a caller that doesn't.
+std::mutex animationReportersMutex;
+std::unordered_map<int, std::shared_ptr<AnimationReporter>> animationReporters;
+
+void setAnimationReporter(int contextId,
+                          std::shared_ptr<AnimationReporter> reporter) {
+  std::lock_guard<std::mutex> lock(animationReportersMutex);
+  if (reporter) {
+    animationReporters[contextId] = std::move(reporter);
+  } else {
+    animationReporters.erase(contextId);
+  }
+}
+
 } // namespace
 
 extern "C" JNIEXPORT void JNICALL Java_com_webgpu_WebGPUView_onSurfaceCreate(
     JNIEnv *env, jobject thiz, jobject jSurface, jint contextId, jfloat width,
-    jfloat height, jboolean reportPresents) {
+    jfloat height, jboolean reportAnimation) {
   if (manager == nullptr) {
     return;
   }
@@ -228,13 +305,15 @@ extern "C" JNIEXPORT void JNICALL Java_com_webgpu_WebGPUView_onSurfaceCreate(
       surface, [](void *nativeSurface) {
         ANativeWindow_release(static_cast<ANativeWindow *>(nativeSurface));
       });
-  // A SurfaceView asks to hear about each presented frame, for its refresh
-  // rate vote (WebGPUView.onFramePresented).
-  if (reportPresents) {
-    auto reporter =
-        std::make_shared<WeakViewCall>(env, thiz, "onFramePresented");
-    info->setFramePresentedCallback([reporter]() { (*reporter)(); });
+  // A SurfaceView asks to hear when it animates, for its refresh rate vote
+  // (WebGPUView.onAnimating).
+  if (reportAnimation) {
+    auto reporter = std::make_shared<AnimationReporter>(env, thiz);
+    setAnimationReporter(contextId, reporter);
+    info->setFramePresentedCallback(
+        [reporter]() { reporter->onFramePresented(); });
   } else {
+    setAnimationReporter(contextId, nullptr);
     info->setFramePresentedCallback(nullptr);
   }
   // The attach is adopted at the next frame boundary by the rendering thread;
@@ -246,6 +325,7 @@ extern "C" JNIEXPORT void JNICALL Java_com_webgpu_WebGPUView_onSurfaceCreate(
 extern "C" JNIEXPORT void JNICALL
 Java_com_webgpu_WebGPUView_switchToOffscreenSurface(JNIEnv *env, jobject thiz,
                                                     jint contextId) {
+  setAnimationReporter(contextId, nullptr);
   auto &registry = rnwgpu::SurfaceRegistry::getInstance();
   if (auto info = registry.getSurfaceInfo(contextId)) {
     info->setFramePresentedCallback(nullptr);
@@ -253,12 +333,30 @@ Java_com_webgpu_WebGPUView_switchToOffscreenSurface(JNIEnv *env, jobject thiz,
   }
 }
 
+// See AnimationReporter::releaseIfIdle; 0 when the surface reports nothing.
+extern "C" JNIEXPORT jlong JNICALL
+Java_com_webgpu_WebGPUView_releaseFrameRateVoteIfIdle(JNIEnv *env, jobject thiz,
+                                                      jint contextId,
+                                                      jlong idleAfterNanos) {
+  std::shared_ptr<AnimationReporter> reporter;
+  {
+    std::lock_guard<std::mutex> lock(animationReportersMutex);
+    auto it = animationReporters.find(contextId);
+    if (it == animationReporters.end()) {
+      return 0;
+    }
+    reporter = it->second;
+  }
+  return static_cast<jlong>(reporter->releaseIfIdle(idleAfterNanos));
+}
+
 extern "C" JNIEXPORT void JNICALL Java_com_webgpu_WebGPUView_onViewDestroyed(
     JNIEnv *env, jobject thiz, jint contextId) {
   // The view dies with its Canvas (contextIds are never reused), so view
   // teardown retires the registry entry. The JS-side cleanup
   // (RNWebGPU.destroyContext) only handles entries that never had a native
   // surface; see RNWebGPU::destroyContext for the ownership split.
+  setAnimationReporter(contextId, nullptr);
   auto &registry = rnwgpu::SurfaceRegistry::getInstance();
   if (auto info = registry.getSurfaceInfo(contextId)) {
     info->setFramePresentedCallback(nullptr);

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

@@ -24,134 +24,146 @@ import androidx.annotation.Nullable;
  * drops back to a few redraws a second: a layer with a vote counts as active
  * for SurfaceFlinger even when it no longer draws.
  *
- * attach() and detach() run on the main thread with the surface callbacks;
- * onFramePresented() runs on whichever thread presents (the JS thread, the
- * Reanimated UI runtime or a worklet runtime), so the state is locked.
+ * Native code tells onAnimating() once per animation, on the thread that
+ * presents (the JS thread, the Reanimated UI runtime or a worklet runtime),
+ * and the vote is cast right there, with no hop to a main thread that may be
+ * busy. The rate is resolved ahead of time on the main thread, where the
+ * view's display can be read. The idle check runs on the main thread and asks
+ * native code how long ago the canvas last animated; once it has stopped, it
+ * takes the vote back and native code calls onAnimating() again at the next
+ * animation. The lock only guards the state: the binder calls
+ * (Surface.setFrameRate) are made outside it.
  */
 final class SurfaceFrameRateVote {
   private static final String TAG = "SurfaceFrameRateVote";
 
-  // Presents this close together are an animation (faster than 40 fps). The
-  // threshold is absolute rather than relative to the current refresh rate,
-  // so that a canvas that only manages 60 fps at 120 Hz keeps its vote rather
-  // than oscillating between the two rates. A canvas that redraws a few times
-  // a second never votes.
-  private static final long ANIMATING_INTERVAL_NANOS = 25_000_000L;
-
-  // The vote is taken back once the canvas has not animated (no two presents
-  // within ANIMATING_INTERVAL_NANOS) for this long. Measured from the last
-  // back-to-back present rather than the last present, so that a canvas that
-  // slows down to a few redraws a second lets the vote lapse like one that
-  // stops drawing.
-  private static final long IDLE_AFTER_NANOS = 500_000_000L;
+  // The vote is taken back once the canvas has not animated for this long,
+  // whether it stops drawing or drops back to a few redraws a second. Native
+  // code decides what animating means (presents faster than 40 fps, see
+  // AnimationReporter in cpp-adapter.cpp). The threshold is absolute rather
+  // than relative to the current refresh rate, so that a canvas that only
+  // manages 60 fps at 120 Hz keeps its vote rather than oscillating between
+  // the two rates. A canvas that redraws a few times a second never votes.
+  static final long IDLE_AFTER_NANOS = 500_000_000L;
+
+  /** Native side of the vote, see AnimationReporter in cpp-adapter.cpp. */
+  interface AnimationSource {
+    /**
+     * How much longer the canvas must stay still before it counts as idle,
+     * or 0 once it does, in which case the next animation calls
+     * onAnimating() again. Main thread.
+     */
+    long releaseIfIdle(long idleAfterNanos);
+  }
 
   private final View mView;
+  private final AnimationSource mSource;
   private final Handler mHandler = new Handler(Looper.getMainLooper());
   private final Runnable mIdleCheck = this::checkIdle;
 
   @Nullable
   private Surface mSurface;
   private boolean mVoting = false;
-  private boolean mIdleCheckPending = false;
-  // 0 before the first present on the surface.
-  private long mLastPresentNanos = 0;
-  // The last present that followed its predecessor within
-  // ANIMATING_INTERVAL_NANOS; 0 until the first.
-  private long mLastAnimatingNanos = 0;
+  // The rate to ask for, resolved on the main thread; 0 when unknown, in
+  // which case animations don't vote until the next idle check resolves it.
+  private float mRefreshRate = 0f;
 
   /** The view the surface belongs to; its display decides the rate to ask for. */
-  SurfaceFrameRateVote(View view) {
+  SurfaceFrameRateVote(View view, AnimationSource source) {
     mView = view;
+    mSource = source;
   }
 
   /** The surface was created: it is voted on until detach(). Main thread. */
-  synchronized void attach(Surface surface) {
+  void attach(Surface surface) {
     detach();
     if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
       return;
     }
-    mSurface = surface;
+    float refreshRate = resolveMaxRefreshRate();
+    synchronized (this) {
+      mSurface = surface;
+      mRefreshRate = refreshRate;
+    }
   }
 
-  /** A frame was presented on the surface. Any thread. */
-  synchronized void onFramePresented() {
-    if (mSurface == null) {
-      return;
-    }
-    long now = System.nanoTime();
-    boolean animating = mLastPresentNanos != 0 && now - mLastPresentNanos <= ANIMATING_INTERVAL_NANOS;
-    mLastPresentNanos = now;
-    if (animating) {
-      mLastAnimatingNanos = now;
-      if (!mVoting) {
-        vote();
+  /**
+   * The canvas started animating (presenting frames back to back). Called
+   * once per animation, on the presenting thread.
+   */
+  void onAnimating() {
+    Surface surface;
+    float refreshRate;
+    synchronized (this) {
+      if (mSurface == null) {
+        return;
       }
+      surface = mSurface;
+      refreshRate = mRefreshRate;
+      mVoting = refreshRate > 0;
     }
-    if (mVoting && !mIdleCheckPending) {
-      scheduleIdleCheck(IDLE_AFTER_NANOS);
+    // Whether it votes or not, the idle check re-arms native code once the
+    // animation stops.
+    mHandler.postDelayed(mIdleCheck, IDLE_AFTER_NANOS / 1_000_000);
+    if (refreshRate > 0) {
+      // This form only switches when the display can do so seamlessly, like
+      // the vote the window casts for its own views: a canvas animation is
+      // not worth a blank screen. Surface.setFrameRate is thread-safe.
+      setFrameRate(surface, refreshRate);
     }
   }
 
   /** The surface is going away (it is still valid here) or the view left its window. Main thread. */
-  synchronized void detach() {
-    if (mSurface == null) {
-      return;
+  void detach() {
+    Surface surface;
+    boolean voting;
+    synchronized (this) {
+      surface = mSurface;
+      voting = mVoting;
+      mSurface = null;
+      mVoting = false;
     }
-    withdraw();
     mHandler.removeCallbacks(mIdleCheck);
-    mIdleCheckPending = false;
-    mLastPresentNanos = 0;
-    mLastAnimatingNanos = 0;
-    mSurface = null;
-  }
-
-  private void vote() {
-    float refreshRate = resolveMaxRefreshRate();
-    if (refreshRate <= 0 || !mSurface.isValid()) {
-      return;
-    }
-    try {
-      // This form only switches when the display can do so seamlessly, like
-      // the vote the window casts for its own views: a canvas animation is
-      // not worth a blank screen. Surface.setFrameRate is thread-safe.
-      mSurface.setFrameRate(refreshRate, Surface.FRAME_RATE_COMPATIBILITY_DEFAULT);
-      mVoting = true;
-    } catch (RuntimeException e) {
-      Log.w(TAG, "Could not vote the refresh rate, leaving it to the display", e);
-      detach();
+    // A vote cast concurrently on the presenting thread may land after this;
+    // it dies with the surface, which is going away.
+    if (surface != null && voting) {
+      setFrameRate(surface, 0);
     }
   }
 
-  private void withdraw() {
-    if (!mVoting) {
+  private void checkIdle() {
+    long remainingNanos = mSource.releaseIfIdle(IDLE_AFTER_NANOS);
+    if (remainingNanos > 0) {
+      mHandler.postDelayed(mIdleCheck, (remainingNanos + 999_999) / 1_000_000);
       return;
     }
-    mVoting = false;
-    if (mSurface == null || !mSurface.isValid()) {
-      return;
+    // Native code is re-armed: the next onAnimating() can only come after
+    // this point, so it doesn't race with the withdrawal below.
+    float refreshRate = resolveMaxRefreshRate();
+    Surface surface;
+    boolean voting;
+    synchronized (this) {
+      surface = mSurface;
+      voting = mVoting;
+      mVoting = false;
+      if (surface != null) {
+        // Follows the display the view is on, for the next animation.
+        mRefreshRate = refreshRate;
+      }
     }
-    try {
-      mSurface.setFrameRate(0, Surface.FRAME_RATE_COMPATIBILITY_DEFAULT);
-    } catch (RuntimeException e) {
-      Log.w(TAG, "Could not withdraw the refresh rate vote", e);
+    if (surface != null && voting) {
+      setFrameRate(surface, 0);
     }
   }
 
-  private void scheduleIdleCheck(long delayNanos) {
-    mIdleCheckPending = true;
-    mHandler.postDelayed(mIdleCheck, (delayNanos + 999_999) / 1_000_000);
-  }
-
-  private synchronized void checkIdle() {
-    mIdleCheckPending = false;
-    if (!mVoting) {
+  private static void setFrameRate(Surface surface, float refreshRate) {
+    if (!surface.isValid()) {
       return;
     }
-    long idleNanos = System.nanoTime() - mLastAnimatingNanos;
-    if (idleNanos >= IDLE_AFTER_NANOS) {
-      withdraw();
-    } else {
-      scheduleIdleCheck(IDLE_AFTER_NANOS - idleNanos);
+    try {
+      surface.setFrameRate(refreshRate, Surface.FRAME_RATE_COMPATIBILITY_DEFAULT);
+    } catch (RuntimeException e) {
+      Log.w(TAG, "Could not set the surface's frame rate, leaving it to the display", e);
     }
   }
 

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

@@ -26,7 +26,8 @@ public class WebGPUView extends ReactViewGroup implements WebGPUAPI {
   private View mView = null;
   // 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);
@@ -160,12 +161,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 +183,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 +208,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"
@@ -640,19 +641,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 +765,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"
@@ -102,6 +104,8 @@ RNWebGPUManager::RNWebGPUManager(
   GPUDeviceLostInfo::installConstructor(*_jsRuntime);
   GPUError::installConstructor(*_jsRuntime);
   GPUExternalTexture::installConstructor(*_jsRuntime);
+  GPUNativeBufferExternalTexture::installConstructor(*_jsRuntime);
+  GPUNativeBufferTexture::installConstructor(*_jsRuntime);
   GPUInternalError::installConstructor(*_jsRuntime);
   GPUOutOfMemoryError::installConstructor(*_jsRuntime);
   GPUValidationError::installConstructor(*_jsRuntime);

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()) {