Don't run the second pass of the pending phantom callbacks if the heap has been torn down.

src/global-handles.cc

 // Copyright 2009 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 
 #include "src/api.h"
 #include "src/global-handles.h"
 
 #include "src/vm-state-inl.h"
@@ skipping 477 matching lines @@
     block_ = block_->next_used();
   }
 
  private:
   NodeBlock* block_;
   int index_;
 
   DISALLOW_COPY_AND_ASSIGN(NodeIterator);
 };
 
-class GlobalHandles::PendingPhantomCallbacksSecondPassTask : public v8::Task {
+class GlobalHandles::PendingPhantomCallbacksSecondPassTask
+    : public v8::internal::CancelableTask {
  public:
   // Takes ownership of the contents of pending_phantom_callbacks, leaving it in
   // the same state it would be after a call to Clear().
   PendingPhantomCallbacksSecondPassTask(
       List<PendingPhantomCallback>* pending_phantom_callbacks, Isolate* isolate)
-      : isolate_(isolate) {
+      : CancelableTask(isolate) {
     pending_phantom_callbacks_.Swap(pending_phantom_callbacks);
   }
 
-  ~PendingPhantomCallbacksSecondPassTask() override {}
-
-  void Run() override {
+  void RunInternal() override {
     InvokeSecondPassPhantomCallbacks(&pending_phantom_callbacks_, isolate_);
   }
 
  private:
   List<PendingPhantomCallback> pending_phantom_callbacks_;
-  Isolate* isolate_;
 
   DISALLOW_COPY_AND_ASSIGN(PendingPhantomCallbacksSecondPassTask);
 };
 
 
 GlobalHandles::GlobalHandles(Isolate* isolate)
     : isolate_(isolate),
       number_of_global_handles_(0),
       first_block_(NULL),
       first_used_block_(NULL),
@@ skipping 311 matching lines @@
       // Skip callbacks that have already been processed once.
       if (callback->node() == nullptr) continue;
       callback->Invoke(isolate());
       freed_nodes++;
     }
   }
   if (pending_phantom_callbacks_.length() > 0) {
     if (synchronous_second_pass) {
       InvokeSecondPassPhantomCallbacks(&pending_phantom_callbacks_, isolate());
     } else {
-      auto* task = new PendingPhantomCallbacksSecondPassTask(
+      auto task = new PendingPhantomCallbacksSecondPassTask(
           &pending_phantom_callbacks_, isolate());
       V8::GetCurrentPlatform()->CallOnForegroundThread(
           reinterpret_cast<v8::Isolate*>(isolate()), task);
     }
   }
   pending_phantom_callbacks_.Clear();
   return freed_nodes;
 }
 
 
@@ skipping 408 matching lines @@
   blocks_[block][offset] = object;
   if (isolate->heap()->InNewSpace(object)) {
     new_space_indices_.Add(size_);
   }
   *index = size_++;
 }
 
 
 }  // namespace internal
 }  // namespace v8