wip

Author: fraidev

src/binding.cc

@@ -3013,18 +3013,27 @@ v8::StartupData v8__SnapshotCreator__CreateBlob(
 }
 
 // Rust-side callbacks for trait-based CustomPlatform (PlatformImpl trait).
-// `this` is a pointer to the CustomPlatform instance, used by Rust to
-// recover the Box<dyn PlatformImpl> stored at the same offset.
+// Each callback corresponds to a C++ virtual method on TaskRunner or Platform.
+// `context` is a pointer to the Rust Box<dyn PlatformImpl>.
 extern "C" {
-void v8__Platform__CustomPlatform__BASE__onForegroundTaskPosted(
-    void* this_, void* isolate, double delay_in_seconds);
-void v8__Platform__CustomPlatform__BASE__onIsolateShutdown(void* this_,
-                                                           void* isolate);
-void v8__Platform__CustomPlatform__BASE__DROP(void* this_);
-}
-
-// TaskRunner wrapper that intercepts all PostTask* calls and dispatches
-// to the Rust PlatformImpl trait via the CustomPlatform context.
+void v8__Platform__CustomPlatform__BASE__PostTask(void* context,
+                                                   void* isolate);
+void v8__Platform__CustomPlatform__BASE__PostNonNestableTask(void* context,
+                                                              void* isolate);
+void v8__Platform__CustomPlatform__BASE__PostDelayedTask(
+    void* context, void* isolate, double delay_in_seconds);
+void v8__Platform__CustomPlatform__BASE__PostNonNestableDelayedTask(
+    void* context, void* isolate, double delay_in_seconds);
+void v8__Platform__CustomPlatform__BASE__PostIdleTask(void* context,
+                                                       void* isolate);
+void v8__Platform__CustomPlatform__BASE__NotifyIsolateShutdown(void* context,
+                                                                void* isolate);
+void v8__Platform__CustomPlatform__BASE__DROP(void* context);
+}
+
+// TaskRunner wrapper that intercepts all PostTask* virtual methods, forwards
+// tasks to the default platform's queue, and notifies Rust via the
+// corresponding PlatformImpl trait method.
 class CustomTaskRunner final : public v8::TaskRunner {
  public:
   CustomTaskRunner(std::shared_ptr<v8::TaskRunner> wrapped, void* context,
@@ -3043,20 +3052,20 @@ class CustomTaskRunner final : public v8::TaskRunner {
   void PostTaskImpl(std::unique_ptr<v8::Task> task,
                     const v8::SourceLocation& location) override {
     wrapped_->PostTask(std::move(task), location);
-    v8__Platform__CustomPlatform__BASE__onForegroundTaskPosted(
-        context_, static_cast<void*>(isolate_), 0.0);
+    v8__Platform__CustomPlatform__BASE__PostTask(
+        context_, static_cast<void*>(isolate_));
   }
   void PostNonNestableTaskImpl(std::unique_ptr<v8::Task> task,
                                const v8::SourceLocation& location) override {
     wrapped_->PostNonNestableTask(std::move(task), location);
-    v8__Platform__CustomPlatform__BASE__onForegroundTaskPosted(
-        context_, static_cast<void*>(isolate_), 0.0);
+    v8__Platform__CustomPlatform__BASE__PostNonNestableTask(
+        context_, static_cast<void*>(isolate_));
   }
   void PostDelayedTaskImpl(std::unique_ptr<v8::Task> task,
                            double delay_in_seconds,
                            const v8::SourceLocation& location) override {
     wrapped_->PostDelayedTask(std::move(task), delay_in_seconds, location);
-    v8__Platform__CustomPlatform__BASE__onForegroundTaskPosted(
+    v8__Platform__CustomPlatform__BASE__PostDelayedTask(
         context_, static_cast<void*>(isolate_),
         delay_in_seconds > 0 ? delay_in_seconds : 0.0);
   }
@@ -3065,15 +3074,15 @@ class CustomTaskRunner final : public v8::TaskRunner {
       const v8::SourceLocation& location) override {
     wrapped_->PostNonNestableDelayedTask(std::move(task), delay_in_seconds,
                                          location);
-    v8__Platform__CustomPlatform__BASE__onForegroundTaskPosted(
+    v8__Platform__CustomPlatform__BASE__PostNonNestableDelayedTask(
         context_, static_cast<void*>(isolate_),
         delay_in_seconds > 0 ? delay_in_seconds : 0.0);
   }
   void PostIdleTaskImpl(std::unique_ptr<v8::IdleTask> task,
                         const v8::SourceLocation& location) override {
     wrapped_->PostIdleTask(std::move(task), location);
-    v8__Platform__CustomPlatform__BASE__onForegroundTaskPosted(
-        context_, static_cast<void*>(isolate_), 0.0);
+    v8__Platform__CustomPlatform__BASE__PostIdleTask(
+        context_, static_cast<void*>(isolate_));
   }
 
  private:
@@ -3082,8 +3091,9 @@ class CustomTaskRunner final : public v8::TaskRunner {
   v8::Isolate* isolate_;
 };
 
-// Generic Platform subclass that delegates virtual method overrides to a
-// Rust PlatformImpl trait object, following the inspector API pattern.
+// Platform subclass that overrides GetForegroundTaskRunner to wrap each
+// isolate's runner with a CustomTaskRunner, and intercepts
+// NotifyIsolateShutdown. Follows the inspector API pattern.
 class CustomPlatform : public v8::platform::DefaultPlatform {
   using IdleTaskSupport = v8::platform::IdleTaskSupport;
 
@@ -3124,7 +3134,7 @@ class CustomPlatform : public v8::platform::DefaultPlatform {
         }
       }
     }
-    v8__Platform__CustomPlatform__BASE__onIsolateShutdown(
+    v8__Platform__CustomPlatform__BASE__NotifyIsolateShutdown(
         context_, static_cast<void*>(isolate));
     DefaultPlatform::NotifyIsolateShutdown(isolate);
   }

src/platform.rs

@@ -68,58 +68,132 @@ pub struct Platform(Opaque);
 /// Trait for customizing platform behavior, following the same pattern as
 /// [`V8InspectorClientImpl`](crate::inspector::V8InspectorClientImpl).
 ///
-/// Implement this trait to receive callbacks for platform virtual method
-/// overrides. The C++ `CustomPlatform` base class delegates to these methods.
-/// All methods have default no-op implementations; override only what you need.
+/// Implement this trait to receive callbacks for overridden C++ virtual
+/// methods on the `DefaultPlatform` and its per-isolate `TaskRunner`.
 ///
-/// Implementations must be `Send + Sync` as callbacks may fire from any thread.
+/// The C++ `CustomPlatform` wraps each isolate's `TaskRunner` so that
+/// every `PostTask` / `PostDelayedTask` / etc. call is forwarded to the
+/// default implementation *and* notifies Rust through the corresponding
+/// trait method.
+///
+/// All methods have default no-op implementations; override only what
+/// you need.
+///
+/// Implementations must be `Send + Sync` as callbacks may fire from any
+/// thread.
 #[allow(unused_variables)]
 pub trait PlatformImpl: Send + Sync {
-  /// Called when a foreground task has been posted for the given isolate.
+  // ---- TaskRunner virtual methods ----
+
+  /// Called when `TaskRunner::PostTask` is invoked for the given isolate.
+  ///
+  /// The task itself has already been forwarded to the default platform's
+  /// queue and will be executed by `PumpMessageLoop`. This callback is a
+  /// notification that a new task is available.
+  ///
+  /// May be called from ANY thread (V8 background threads, etc.).
+  fn post_task(&self, isolate_ptr: *mut std::ffi::c_void) {}
+
+  /// Called when `TaskRunner::PostNonNestableTask` is invoked.
   ///
-  /// This corresponds to intercepted calls on the isolate's `TaskRunner`
-  /// (`PostTask`, `PostDelayedTask`, `PostIdleTask`, etc.).
+  /// Same semantics as [`post_task`](Self::post_task).
+  fn post_non_nestable_task(&self, isolate_ptr: *mut std::ffi::c_void) {}
+
+  /// Called when `TaskRunner::PostDelayedTask` is invoked.
   ///
-  /// `isolate_ptr` is the raw `v8::Isolate*` pointer of the target isolate.
-  /// `delay_in_seconds` is 0.0 for immediate tasks, or the delay before the
-  /// task should be executed. For delayed tasks, the embedder should schedule
-  /// a wake-up after the given delay (e.g. via a timer in tokio).
+  /// The task has been forwarded to the default runner's delayed queue.
+  /// `delay_in_seconds` is the delay before the task should execute.
+  /// Embedders should schedule a wake-up after this delay.
   ///
-  /// This may be called from ANY thread (V8 background threads, etc.).
-  fn on_foreground_task_posted(
+  /// May be called from ANY thread.
+  fn post_delayed_task(
     &self,
     isolate_ptr: *mut std::ffi::c_void,
     delay_in_seconds: f64,
   ) {
   }
 
-  /// Called when an isolate is about to be shut down.
+  /// Called when `TaskRunner::PostNonNestableDelayedTask` is invoked.
   ///
-  /// This corresponds to the `NotifyIsolateShutdown` virtual method.
-  /// The default `DefaultPlatform` cleanup runs after this callback returns.
-  fn on_isolate_shutdown(&self, isolate_ptr: *mut std::ffi::c_void) {}
+  /// Same semantics as [`post_delayed_task`](Self::post_delayed_task).
+  fn post_non_nestable_delayed_task(
+    &self,
+    isolate_ptr: *mut std::ffi::c_void,
+    delay_in_seconds: f64,
+  ) {
+  }
+
+  /// Called when `TaskRunner::PostIdleTask` is invoked.
+  ///
+  /// Same semantics as [`post_task`](Self::post_task).
+  fn post_idle_task(&self, isolate_ptr: *mut std::ffi::c_void) {}
+
+  // ---- Platform virtual methods ----
+
+  /// Called when `Platform::NotifyIsolateShutdown` is invoked.
+  ///
+  /// The default `DefaultPlatform` cleanup runs after this callback
+  /// returns.
+  fn notify_isolate_shutdown(&self, isolate_ptr: *mut std::ffi::c_void) {}
 }
 
 // FFI callbacks called from C++ CustomPlatform/CustomTaskRunner.
 // `context` is a raw pointer to a `Box<dyn PlatformImpl>`.
 
 #[unsafe(no_mangle)]
-unsafe extern "C" fn v8__Platform__CustomPlatform__BASE__onForegroundTaskPosted(
+unsafe extern "C" fn v8__Platform__CustomPlatform__BASE__PostTask(
+  context: *mut std::ffi::c_void,
+  isolate: *mut std::ffi::c_void,
+) {
+  let imp = unsafe { &*(context as *const Box<dyn PlatformImpl>) };
+  imp.post_task(isolate);
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn v8__Platform__CustomPlatform__BASE__PostNonNestableTask(
+  context: *mut std::ffi::c_void,
+  isolate: *mut std::ffi::c_void,
+) {
+  let imp = unsafe { &*(context as *const Box<dyn PlatformImpl>) };
+  imp.post_non_nestable_task(isolate);
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn v8__Platform__CustomPlatform__BASE__PostDelayedTask(
   context: *mut std::ffi::c_void,
   isolate: *mut std::ffi::c_void,
   delay_in_seconds: f64,
 ) {
   let imp = unsafe { &*(context as *const Box<dyn PlatformImpl>) };
-  imp.on_foreground_task_posted(isolate, delay_in_seconds);
+  imp.post_delayed_task(isolate, delay_in_seconds);
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn v8__Platform__CustomPlatform__BASE__PostNonNestableDelayedTask(
+  context: *mut std::ffi::c_void,
+  isolate: *mut std::ffi::c_void,
+  delay_in_seconds: f64,
+) {
+  let imp = unsafe { &*(context as *const Box<dyn PlatformImpl>) };
+  imp.post_non_nestable_delayed_task(isolate, delay_in_seconds);
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn v8__Platform__CustomPlatform__BASE__PostIdleTask(
+  context: *mut std::ffi::c_void,
+  isolate: *mut std::ffi::c_void,
+) {
+  let imp = unsafe { &*(context as *const Box<dyn PlatformImpl>) };
+  imp.post_idle_task(isolate);
 }
 
 #[unsafe(no_mangle)]
-unsafe extern "C" fn v8__Platform__CustomPlatform__BASE__onIsolateShutdown(
+unsafe extern "C" fn v8__Platform__CustomPlatform__BASE__NotifyIsolateShutdown(
   context: *mut std::ffi::c_void,
   isolate: *mut std::ffi::c_void,
 ) {
   let imp = unsafe { &*(context as *const Box<dyn PlatformImpl>) };
-  imp.on_isolate_shutdown(isolate);
+  imp.notify_isolate_shutdown(isolate);
 }
 
 #[unsafe(no_mangle)]