[heap] Ensure progress when incrementally marking wrappers

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 1119 matching lines @@
   if (state_ == SWEEPING) {
     TRACE_GC(heap_->tracer(), GCTracer::Scope::MC_INCREMENTAL_SWEEPING);
     FinalizeSweeping();
   }
 
   size_t bytes_processed = 0;
   if (state_ == MARKING) {
     const bool incremental_wrapper_tracing =
         FLAG_incremental_marking_wrappers &&
         heap_->local_embedder_heap_tracer()->InUse();
-    const bool process_wrappers =
-        incremental_wrapper_tracing &&
-        (heap_->local_embedder_heap_tracer()
-             ->RequiresImmediateWrapperProcessing() ||
-         heap_->mark_compact_collector()->marking_deque()->IsEmpty());
+    const bool v8_marking_deque_empty =
+        heap_->mark_compact_collector()->marking_deque()->IsEmpty();
+    const bool process_wrappers = incremental_wrapper_tracing &&
+                                  (heap_->local_embedder_heap_tracer()
+                                       ->RequiresImmediateWrapperProcessing() ||
+                                   v8_marking_deque_empty);
     bool wrapper_work_left = incremental_wrapper_tracing;
     if (!process_wrappers) {
       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);
+      if (v8_marking_deque_empty)
+        heap_->local_embedder_heap_tracer()->NotifyV8MarkingDequeWasEmpty();
       wrapper_work_left = heap_->local_embedder_heap_tracer()->Trace(
           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()) {
@@ skipping 33 matching lines @@
   idle_marking_delay_counter_++;
 }
 
 
 void IncrementalMarking::ClearIdleMarkingDelayCounter() {
   idle_marking_delay_counter_ = 0;
 }
 
 }  // namespace internal
 }  // namespace v8