clean up

Author: fraidev

src/binding.cc

@@ -3025,8 +3025,6 @@ 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);
 }
 
@@ -3091,35 +3089,22 @@ class CustomTaskRunner final : public v8::TaskRunner {
 };
 
 // Platform subclass that overrides GetForegroundTaskRunner to wrap each
-// isolate's runner with a CustomTaskRunner, and intercepts
-// NotifyIsolateShutdown. Follows the inspector API pattern.
+// Platform subclass that wraps each isolate's TaskRunner to notify Rust
+// when foreground tasks are posted. Follows the inspector API pattern.
+//
+// NotifyIsolateShutdown is NOT intercepted here because it is not virtual
+// on DefaultPlatform — V8's free function does static_cast<DefaultPlatform*>
+// and calls it directly, bypassing any override. Isolate cleanup must be
+// handled on the Rust side (e.g. in the isolate's Drop impl).
 class CustomPlatform : public v8::platform::DefaultPlatform {
   using IdleTaskSupport = v8::platform::IdleTaskSupport;
 
-  // Magic value used to identify CustomPlatform instances at runtime.
-  // v8::platform::NotifyIsolateShutdown does static_cast<DefaultPlatform*>
-  // which bypasses our non-virtual NotifyIsolateShutdown, so the FFI
-  // wrapper needs to detect CustomPlatform and dispatch correctly.
-  static constexpr uint64_t kMagic = 0x4375'7374'506C'6174;  // "CustPlat"
-
  public:
   CustomPlatform(int thread_pool_size, IdleTaskSupport idle_task_support,
                  void* context)
       : DefaultPlatform(thread_pool_size, idle_task_support),
-        magic_(kMagic),
         context_(context) {}
 
-  static bool IsCustomPlatform(v8::Platform* platform) {
-    auto* dp = static_cast<DefaultPlatform*>(platform);
-    auto* maybe_custom = static_cast<CustomPlatform*>(dp);
-    return maybe_custom->magic_ == kMagic;
-  }
-
-  static CustomPlatform* Cast(v8::Platform* platform) {
-    return static_cast<CustomPlatform*>(
-        static_cast<DefaultPlatform*>(platform));
-  }
-
   // SAFETY: The platform is single-owner (via unique_ptr). The destructor
   // runs after all isolates have been disposed and no more task runner
   // callbacks can fire, so DROP does not race with other callbacks.
@@ -3143,25 +3128,6 @@ class CustomPlatform : public v8::platform::DefaultPlatform {
     return custom;
   }
 
-  // NotifyIsolateShutdown is not virtual on DefaultPlatform, so this
-  // hides the base method. This works because callers always go through
-  // the CustomPlatform* type (via the platform shared_ptr).
-  void NotifyIsolateShutdown(v8::Isolate* isolate) {
-    {
-      std::lock_guard<std::mutex> lock(mutex_);
-      for (auto it = runners_.begin(); it != runners_.end();) {
-        if (it->first.first == isolate) {
-          it = runners_.erase(it);
-        } else {
-          ++it;
-        }
-      }
-    }
-    v8__Platform__CustomPlatform__BASE__NotifyIsolateShutdown(
-        context_, static_cast<void*>(isolate));
-    DefaultPlatform::NotifyIsolateShutdown(isolate);
-  }
-
   // Disable thread-isolated allocations (same as UnprotectedDefaultPlatform).
   // Required when isolates may be created on threads other than the one that
   // called v8::V8::Initialize (e.g. worker threads in Deno).
@@ -3170,7 +3136,6 @@ class CustomPlatform : public v8::platform::DefaultPlatform {
   }
 
  private:
-  uint64_t magic_;
   void* context_;
   std::mutex mutex_;
   // weak_ptr so runners are kept alive only while V8 holds a reference.
@@ -3265,15 +3230,7 @@ void v8__Platform__RunIdleTasks(v8::Platform* platform, v8::Isolate* isolate,
 
 void v8__Platform__NotifyIsolateShutdown(v8::Platform* platform,
                                          v8::Isolate* isolate) {
-  // v8::platform::NotifyIsolateShutdown does static_cast<DefaultPlatform*>
-  // and calls the non-virtual NotifyIsolateShutdown, which would bypass
-  // CustomPlatform's override. Dispatch to CustomPlatform directly when
-  // applicable so the Rust callback fires.
-  if (CustomPlatform::IsCustomPlatform(platform)) {
-    CustomPlatform::Cast(platform)->NotifyIsolateShutdown(isolate);
-  } else {
-    v8::platform::NotifyIsolateShutdown(platform, isolate);
-  }
+  v8::platform::NotifyIsolateShutdown(platform, isolate);
 }
 
 void v8__Platform__DELETE(v8::Platform* self) { delete self; }

src/platform.rs

@@ -127,14 +127,6 @@ pub trait PlatformImpl: Send + Sync {
   ///
   /// 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.
@@ -187,15 +179,6 @@ unsafe extern "C" fn v8__Platform__CustomPlatform__BASE__PostIdleTask(
   imp.post_idle_task(isolate);
 }
 
-#[unsafe(no_mangle)]
-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.notify_isolate_shutdown(isolate);
-}
-
 #[unsafe(no_mangle)]
 unsafe extern "C" fn v8__Platform__CustomPlatform__BASE__DROP(
   context: *mut std::ffi::c_void,