Introduce EmbedderReachableReferenceReporter

src/heap/incremental-marking.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.h"
 
 #include "src/code-stubs.h"
 #include "src/compilation-cache.h"
 #include "src/conversions.h"
 #include "src/heap/gc-idle-time-handler.h"
@@ skipping 551 matching lines @@
 
   is_compacting_ = !FLAG_never_compact &&
                    heap_->mark_compact_collector()->StartCompaction(
                        MarkCompactCollector::INCREMENTAL_COMPACTION);
 
   state_ = MARKING;
 
   if (heap_->UsingEmbedderHeapTracer()) {
     TRACE_GC(heap()->tracer(),
              GCTracer::Scope::MC_INCREMENTAL_WRAPPER_PROLOGUE);
-    heap_->mark_compact_collector()->embedder_heap_tracer()->TracePrologue();
+    heap_->embedder_heap_tracer()->TracePrologue(
+        heap_->embedder_reachable_reference_reporter());
   }
 
   RecordWriteStub::Mode mode = is_compacting_
                                    ? RecordWriteStub::INCREMENTAL_COMPACTION
                                    : RecordWriteStub::INCREMENTAL;
 
   PatchIncrementalMarkingRecordWriteStubs(heap_, mode);
 
   heap_->mark_compact_collector()->EnsureMarkingDequeIsCommittedAndInitialize(
       MarkCompactCollector::kMaxMarkingDequeSize);
@@ skipping 206 matching lines @@
     // Map retaining is needed for perfromance, not correctness,
     // so we can do it only once at the beginning of the finalization.
     RetainMaps();
   }
   ProcessWeakCells();
 
   int marking_progress =
       abs(old_marking_deque_top -
           heap_->mark_compact_collector()->marking_deque()->top());
 
-  marking_progress +=
-      static_cast<int>(heap_->mark_compact_collector()->wrappers_to_trace());
+  marking_progress += static_cast<int>(heap_->wrappers_to_trace());
 
   double end = heap_->MonotonicallyIncreasingTimeInMs();
   double delta = end - start;
   heap_->tracer()->AddMarkingTime(delta);
   if (FLAG_trace_incremental_marking) {
     heap()->isolate()->PrintWithTimestamp(
         "[IncrementalMarking] Finalize incrementally round %d, "
         "spent %d ms, marking progress %d.\n",
         static_cast<int>(delta), incremental_marking_finalization_rounds_,
         marking_progress);
@@ skipping 408 matching lines @@
     TRACE_GC(heap_->tracer(), GCTracer::Scope::MC_INCREMENTAL_SWEEPING);
     FinalizeSweeping();
   }
 
   intptr_t bytes_processed = 0;
   if (state_ == MARKING) {
     const bool incremental_wrapper_tracing =
         FLAG_incremental_marking_wrappers && heap_->UsingEmbedderHeapTracer();
     const bool process_wrappers =
         incremental_wrapper_tracing &&
-        (heap_->mark_compact_collector()
-             ->RequiresImmediateWrapperProcessing() ||
+        (heap_->RequiresImmediateWrapperProcessing() ||
          heap_->mark_compact_collector()->marking_deque()->IsEmpty());
     bool wrapper_work_left = incremental_wrapper_tracing;
     if (!process_wrappers) {
       if (step_origin == StepOrigin::kV8 &&
           bytes_marked_ahead_of_schedule_ >= bytes_to_process) {
         // Steps performed in tasks have put us ahead of schedule.
         // We skip processing of marking dequeue here and thus
         // shift marking time from inside V8 to standalone tasks.
         bytes_marked_ahead_of_schedule_ -= bytes_to_process;
       } else {
         bytes_processed = ProcessMarkingDeque(bytes_to_process);
         if (step_origin == StepOrigin::kTask) {
           bytes_marked_ahead_of_schedule_ += bytes_processed;
         }
       }
     } else {
       const double wrapper_deadline =
           heap_->MonotonicallyIncreasingTimeInMs() + kStepSizeInMs;
       TRACE_GC(heap()->tracer(),
                GCTracer::Scope::MC_INCREMENTAL_WRAPPER_TRACING);
-      heap_->mark_compact_collector()->RegisterWrappersWithEmbedderHeapTracer();
-      wrapper_work_left =
-          heap_->mark_compact_collector()
-              ->embedder_heap_tracer()
-              ->AdvanceTracing(wrapper_deadline,
-                               EmbedderHeapTracer::AdvanceTracingActions(
-                                   EmbedderHeapTracer::ForceCompletionAction::
-                                       DO_NOT_FORCE_COMPLETION));
+      heap_->RegisterWrappersWithEmbedderHeapTracer();
+      wrapper_work_left = heap_->embedder_heap_tracer()->AdvanceTracing(
+          wrapper_deadline, EmbedderHeapTracer::AdvanceTracingActions(
+                                EmbedderHeapTracer::ForceCompletionAction::
+                                    DO_NOT_FORCE_COMPLETION));
     }
 
     if (heap_->mark_compact_collector()->marking_deque()->IsEmpty() &&
         !wrapper_work_left) {
       if (completion == FORCE_COMPLETION ||
           IsIdleMarkingDelayCounterLimitReached()) {
         if (!finalize_marking_completed_) {
           FinalizeMarking(action);
         } else {
           MarkingComplete(action);
@@ skipping 54 matching lines @@
   idle_marking_delay_counter_++;
 }
 
 
 void IncrementalMarking::ClearIdleMarkingDelayCounter() {
   idle_marking_delay_counter_ = 0;
 }
 
 }  // namespace internal
 }  // namespace v8