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 482 matching lines @@
   int index_;
 
   DISALLOW_COPY_AND_ASSIGN(NodeIterator);
 };
 
 class GlobalHandles::PendingPhantomCallbacksSecondPassTask : public v8::Task {
  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(
+      GlobalHandles* global_handles,
       List<PendingPhantomCallback>* pending_phantom_callbacks, Isolate* isolate)
-      : isolate_(isolate) {
+      : global_handles_(global_handles),
+        isolate_(isolate),
+        heap_is_torn_down_(false) {
     pending_phantom_callbacks_.Swap(pending_phantom_callbacks);
   }
 
-  ~PendingPhantomCallbacksSecondPassTask() override {}
+  ~PendingPhantomCallbacksSecondPassTask() override {
+    if (!heap_is_torn_down_) {
+      global_handles_->ClearPhantomCallbacksTask(this);
+    }
+  }
 
   void Run() override {
-    InvokeSecondPassPhantomCallbacks(&pending_phantom_callbacks_, isolate_);
+    if (!heap_is_torn_down_) {
+      InvokeSecondPassPhantomCallbacks(&pending_phantom_callbacks_, isolate_);
+    }
   }
 
+  void NotifyHeapTearDown() { heap_is_torn_down_ = true; }
+
  private:
+  GlobalHandles* global_handles_;
   List<PendingPhantomCallback> pending_phantom_callbacks_;
   Isolate* isolate_;
+  bool heap_is_torn_down_;
 
   DISALLOW_COPY_AND_ASSIGN(PendingPhantomCallbacksSecondPassTask);
 };
 
 
 GlobalHandles::GlobalHandles(Isolate* isolate)
     : isolate_(isolate),
       number_of_global_handles_(0),
       first_block_(NULL),
       first_used_block_(NULL),
       first_free_(NULL),
       post_gc_processing_count_(0),
-      object_group_connections_(kObjectGroupConnectionsCapacity) {}
+      object_group_connections_(kObjectGroupConnectionsCapacity),
+      phantom_callbacks_task_(nullptr) {}
 
 
 GlobalHandles::~GlobalHandles() {
   NodeBlock* block = first_block_;
   while (block != NULL) {
     NodeBlock* tmp = block->next();
     delete block;
     block = tmp;
   }
   first_block_ = NULL;
@@ skipping 280 matching lines @@
     } else {
       node->set_in_new_space_list(false);
       isolate_->heap()->IncrementNodesDiedInNewSpace();
     }
   }
   new_space_nodes_.Rewind(last);
   new_space_nodes_.Trim();
 }
 
 
+void GlobalHandles::ClearPhantomCallbacksTask(
+    PendingPhantomCallbacksSecondPassTask* task) {
+  if (phantom_callbacks_task_ == task) {
+    phantom_callbacks_task_ = nullptr;
+  }
+}
+
+
 int GlobalHandles::DispatchPendingPhantomCallbacks(
     bool synchronous_second_pass) {
   int freed_nodes = 0;
   {
     // The initial pass callbacks must simply clear the nodes.
     for (auto i = pending_phantom_callbacks_.begin();
          i != pending_phantom_callbacks_.end(); ++i) {
       auto callback = i;
       // 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(
-          &pending_phantom_callbacks_, isolate());
+      phantom_callbacks_task_ = new PendingPhantomCallbacksSecondPassTask(
+          this, &pending_phantom_callbacks_, isolate());
       V8::GetCurrentPlatform()->CallOnForegroundThread(
-          reinterpret_cast<v8::Isolate*>(isolate()), task);
+          reinterpret_cast<v8::Isolate*>(isolate()), phantom_callbacks_task_);

[jochen (gone - plz use gerrit), 2015/07/20 09:58:17]

there could be more than one task, no?

maybe it's worthwhile to pull out a base class of tasks that run on the
foreground thread, and have a set<> of pending tasks e.g. on Heap or on Isolate

[epertoso, 2015/07/20 13:14:21]

Done.

     }
   }
   pending_phantom_callbacks_.Clear();
   return freed_nodes;
 }
 
 
 void GlobalHandles::PendingPhantomCallback::Invoke(Isolate* isolate) {
   Data::Callback* callback_addr = nullptr;
   if (node_ != nullptr) {
@@ skipping 231 matching lines @@
 void GlobalHandles::RemoveImplicitRefGroups() {
   for (int i = 0; i < implicit_ref_groups_.length(); i++) {
     delete implicit_ref_groups_.at(i);
   }
   implicit_ref_groups_.Clear();
   implicit_ref_connections_.Clear();
 }
 
 
 void GlobalHandles::TearDown() {
+  if (phantom_callbacks_task_) {
+    phantom_callbacks_task_->NotifyHeapTearDown();
+  }
   // TODO(1428): invoke weak callbacks.
 }
 
 
 void GlobalHandles::ComputeObjectGroupsAndImplicitReferences() {
   if (object_group_connections_.length() == 0) {
     for (int i = 0; i < retainer_infos_.length(); ++i)
       retainer_infos_[i].info->Dispose();
     retainer_infos_.Clear();
     implicit_ref_connections_.Clear();
@@ skipping 154 matching lines @@
   blocks_[block][offset] = object;
   if (isolate->heap()->InNewSpace(object)) {
     new_space_indices_.Add(size_);
   }
   *index = size_++;
 }
 
 
 }  // namespace internal
 }  // namespace v8