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

src/heap/memory-reducer.cc

 // Copyright 2015 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/heap/memory-reducer.h"
 
 #include "src/flags.h"
 #include "src/heap/heap.h"
 #include "src/utils.h"
 #include "src/v8.h"
 
 namespace v8 {
 namespace internal {
 
 const int MemoryReducer::kLongDelayMs = 5000;
 const int MemoryReducer::kShortDelayMs = 500;
 const int MemoryReducer::kMaxNumberOfGCs = 3;
 
+MemoryReducer::TimerTask::TimerTask(MemoryReducer* memory_reducer)
+    : CancelableTask(memory_reducer->heap()->isolate()),
+      memory_reducer_(memory_reducer) {}
 
-void MemoryReducer::TimerTask::Run() {
-  if (heap_is_torn_down_) return;
+
+void MemoryReducer::TimerTask::RunInternal() {
   Heap* heap = memory_reducer_->heap();
   Event event;
   event.type = kTimer;
   event.time_ms = heap->MonotonicallyIncreasingTimeInMs();
   event.low_allocation_rate = heap->HasLowAllocationRate();
   event.can_start_incremental_gc =
       heap->incremental_marking()->IsStopped() &&
       heap->incremental_marking()->CanBeActivated();
   memory_reducer_->NotifyTimer(event);
 }
 
 
 void MemoryReducer::NotifyTimer(const Event& event) {
   DCHECK(nullptr != pending_task_);
   DCHECK_EQ(kTimer, event.type);
   DCHECK_EQ(kWait, state_.action);
-  pending_task_ = nullptr;
   state_ = Step(state_, event);
   if (state_.action == kRun) {
     DCHECK(heap()->incremental_marking()->IsStopped());
     DCHECK(FLAG_incremental_marking);
     heap()->StartIdleIncrementalMarking();
     if (FLAG_trace_gc_verbose) {
       PrintIsolate(heap()->isolate(), "Memory reducer: started GC #%d\n",
                    state_.started_gcs);
     }
   } else if (state_.action == kWait) {
@@ skipping 115 matching lines @@
   return State(kDone, 0, 0);  // Make the compiler happy.
 }
 
 
 void MemoryReducer::ScheduleTimer(double delay_ms) {
   DCHECK(delay_ms > 0);
   // Leave some room for precision error in task scheduler.
   const double kSlackMs = 100;
   v8::Isolate* isolate = reinterpret_cast<v8::Isolate*>(heap()->isolate());
   DCHECK(nullptr == pending_task_);
-  pending_task_ = new MemoryReducer::TimerTask(this);
+  auto timer_task = new MemoryReducer::TimerTask(this);
   V8::GetCurrentPlatform()->CallDelayedOnForegroundThread(
-      isolate, pending_task_, (delay_ms + kSlackMs) / 1000.0);
-}
-
-
-void MemoryReducer::ClearTask(v8::Task* task) {
-  if (pending_task_ == task) {
-    pending_task_ = nullptr;
-  }
+      isolate, timer_task, (delay_ms + kSlackMs) / 1000.0);
 }
 
 
 void MemoryReducer::TearDown() {
-  if (pending_task_ != nullptr) {
-    pending_task_->NotifyHeapTearDown();
-    pending_task_ = nullptr;
-  }
   state_ = State(kDone, 0, 0);
 }
 
 }  // internal
 }  // v8