fix: perform microtask checkpoint before MicrotaskRunner destruction

shell/browser/javascript_environment.cc

@@ -333,11 +333,13 @@ void JavascriptEnvironment::CreateMicrotasksRunner() {
 
 void JavascriptEnvironment::DestroyMicrotasksRunner() {
   DCHECK(microtasks_runner_);
+  microtasks_runner_->PerformCheckpoint();
   {
     v8::HandleScope scope(isolate_);
     gin_helper::CleanedUpAtExit::DoCleanup();
   }
   base::CurrentThread::Get()->RemoveTaskObserver(microtasks_runner_.get());
+  microtasks_runner_.reset();
 }
 
 }  // namespace electron

shell/browser/microtasks_runner.cc

@@ -14,25 +14,28 @@
 
 MicrotasksRunner::MicrotasksRunner(v8::Isolate* isolate) : isolate_(isolate) {}
 
-void MicrotasksRunner::WillProcessTask(const base::PendingTask& pending_task,
-                                       bool was_blocked_or_low_priority) {}
-
-void MicrotasksRunner::DidProcessTask(const base::PendingTask& pending_task) {
-  v8::Isolate::Scope scope(isolate_);
+void MicrotasksRunner::PerformCheckpoint() {
   // In the browser process we follow Node.js microtask policy of kExplicit
   // and let the MicrotaskRunner which is a task observer for chromium UI thread
   // scheduler run the microtask checkpoint. This worked fine because Node.js
   // also runs microtasks through its task queue, but after
   // https://github.com/electron/electron/issues/20013 Node.js now performs its
   // own microtask checkpoint and it may happen is some situations that there is
   // contention for performing checkpoint between Node.js and chromium, ending
-  // up Node.js dealying its callbacks. To fix this, now we always lets Node.js
+  // up Node.js delaying its callbacks. To fix this, now we always let Node.js
   // handle the checkpoint in the browser process.
-  {
-    v8::HandleScope handle_scope(isolate_);
-    node::CallbackScope microtasks_scope(isolate_, v8::Object::New(isolate_),
-                                         {0, 0});
-  }
+  // node::CallbackScope performs the checkpoint when it goes out of scope.
+  v8::Isolate::Scope scope(isolate_);
+  v8::HandleScope handle_scope(isolate_);
+  node::CallbackScope microtasks_scope(isolate_, v8::Object::New(isolate_),
+                                       {0, 0});
+}
+
+void MicrotasksRunner::WillProcessTask(const base::PendingTask& pending_task,
+                                       bool was_blocked_or_low_priority) {}
+
+void MicrotasksRunner::DidProcessTask(const base::PendingTask& pending_task) {
+  PerformCheckpoint();
 }
 
 }  // namespace electron

shell/browser/microtasks_runner.h

@@ -24,6 +24,8 @@ class MicrotasksRunner : public base::TaskObserver {
  public:
   explicit MicrotasksRunner(v8::Isolate* isolate);
 
+  void PerformCheckpoint();
+
   // base::TaskObserver
   void WillProcessTask(const base::PendingTask& pending_task,
                        bool was_blocked_or_low_priority) override;