Start incremental marking in long idle notification for background tab

src/heap/memory-reducer.h

 // 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.
 
 #ifndef V8_HEAP_memory_reducer_H
 #define V8_HEAP_memory_reducer_H
 
 #include "include/v8-platform.h"
 #include "src/base/macros.h"
 
@@ skipping 30 matching lines @@
 // DONE -> WAIT 0 (now_ms + long_delay_ms) happens:
 //     - on context disposal,
 //     - at the end of mark-compact GC initiated by the mutator.
 // This signals that there is potential garbage to be collected.
 //
 // WAIT n x -> WAIT n (now_ms + long_delay_ms) happens:
 //     - on mark-compact GC initiated by the mutator,
 //     - in the timer callback if the mutator allocation rate is high or
 //       incremental GC is in progress.
 //
+// WAIT n x -> WAIT (n+1) happens:
+//     - on background idle notification, which signals that we can start
+//       incremental marking even if the allocation rate is high.
+// The MemoryReducer starts incremental marking on this transition but still
+// has a pending timer task.
+//
+// WAIT n x -> DONE happens:
+//     - in the timer callback if n >= kMaxNumberOfGCs.
+//
 // WAIT n x -> RUN (n+1) happens:
 //     - in the timer callback if the mutator allocation rate is low
 //       and now_ms >= x and there is no incremental GC in progress.
 // The MemoryReducer starts incremental marking on this transition.
 //
 // RUN n -> DONE happens:
 //     - at end of the incremental GC initiated by the MemoryReducer if
 //       (n > 1 and there is no more garbage to be collected) or
 //       n == kMaxNumberOfGCs.
 // RUN n -> WAIT n (now_ms + short_delay_ms) happens:
@@ skipping 13 matching lines @@
           next_gc_start_ms(next_gc_start_ms) {}
     Action action;
     int started_gcs;
     double next_gc_start_ms;
   };
 
   enum EventType {
     kTimer,
     kMarkCompact,
     kContextDisposed,
+    kBackgroundIdleNotification
   };
 
   struct Event {
     EventType type;
     double time_ms;
     bool low_allocation_rate;
     bool next_gc_likely_to_collect_more;
     bool can_start_incremental_gc;
   };
 
   explicit MemoryReducer(Heap* heap) : heap_(heap), state_(kDone, 0, 0.0) {}
   // Callbacks.
   void NotifyTimer(const Event& event);
   void NotifyMarkCompact(const Event& event);
-  void NotifyScavenge(const Event& event);
   void NotifyContextDisposed(const Event& event);
+  void NotifyBackgroundIdleNotification(const Event& event);
   // The step function that computes the next state from the current state and
   // the incoming event.
   static State Step(const State& state, const Event& event);
   // Posts a timer task that will call NotifyTimer after the given delay.
   void ScheduleTimer(double delay_ms);
 
   static const int kLongDelayMs;
   static const int kShortDelayMs;
   static const int kMaxNumberOfGCs;
 
@@ skipping 16 matching lines @@
   Heap* heap_;
   State state_;
 
   DISALLOW_COPY_AND_ASSIGN(MemoryReducer);
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HEAP_memory_reducer_H