Add {CancelableTaskManager} to handle {Cancelable} concurrent tasks.

src/heap/incremental-marking-job.cc

 // Copyright 2012 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/incremental-marking-job.h"
 
 #include "src/base/platform/time.h"
 #include "src/heap/heap-inl.h"
 #include "src/heap/heap.h"
 #include "src/heap/incremental-marking.h"
@@ skipping 73 matching lines @@
     heap->TryFinalizeIdleIncrementalMarking(remaining_idle_time_in_ms);
   }
   return incremental_marking->IsStopped() ? kDone : kMoreWork;
 }
 
 
 void IncrementalMarkingJob::IdleTask::RunInternal(double deadline_in_seconds) {
   double deadline_in_ms =
       deadline_in_seconds *
       static_cast<double>(base::Time::kMillisecondsPerSecond);
-  Heap* heap = isolate_->heap();
+  Heap* heap = isolate()->heap();
   double start_ms = heap->MonotonicallyIncreasingTimeInMs();
   job_->NotifyIdleTask();
   job_->NotifyIdleTaskProgress();
   if (Step(heap, deadline_in_ms) == kMoreWork) {
     job_->ScheduleIdleTask(heap);
   }
   if (FLAG_trace_idle_notification) {
     double current_time_ms = heap->MonotonicallyIncreasingTimeInMs();
     double idle_time_in_ms = deadline_in_ms - start_ms;
     double deadline_difference = deadline_in_ms - current_time_ms;
-    PrintIsolate(isolate_, "%8.0f ms: ", isolate_->time_millis_since_init());
+    PrintIsolate(isolate(), "%8.0f ms: ", isolate()->time_millis_since_init());
     PrintF(
         "Idle task: requested idle time %.2f ms, used idle time %.2f "
         "ms, deadline usage %.2f ms\n",
         idle_time_in_ms, idle_time_in_ms - deadline_difference,
         deadline_difference);
   }
 }
 
 
 void IncrementalMarkingJob::DelayedTask::Step(Heap* heap) {
   const int kIncrementalMarkingDelayMs = 50;
   double deadline =
       heap->MonotonicallyIncreasingTimeInMs() + kIncrementalMarkingDelayMs;
   heap->incremental_marking()->AdvanceIncrementalMarking(
       0, deadline, i::IncrementalMarking::StepActions(
                        i::IncrementalMarking::NO_GC_VIA_STACK_GUARD,
                        i::IncrementalMarking::FORCE_MARKING,
                        i::IncrementalMarking::FORCE_COMPLETION));
   heap->FinalizeIncrementalMarkingIfComplete(
       "Incremental marking task: finalize incremental marking");
 }
 
 
 void IncrementalMarkingJob::DelayedTask::RunInternal() {
-  Heap* heap = isolate_->heap();
+  Heap* heap = isolate()->heap();
   job_->NotifyDelayedTask();
   IncrementalMarking* incremental_marking = heap->incremental_marking();
   if (!incremental_marking->IsStopped()) {
     if (job_->ShouldForceMarkingStep()) {
       Step(heap);
     }
     // The Step() above could have finished incremental marking.
     if (!incremental_marking->IsStopped()) {
       job_->ScheduleDelayedTask(heap);
     }
   }
 }
 
 }  // namespace internal
 }  // namespace v8