[heap] Make the current GCCallbackFlags are part of {Heap}.

src/heap/heap.h

 // 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.
 
 #ifndef V8_HEAP_HEAP_H_
 #define V8_HEAP_HEAP_H_
 
 #include <cmath>
 #include <map>
 
@@ skipping 1344 matching lines @@
   // ===========================================================================
   // Incremental marking API. ==================================================
   // ===========================================================================
 
   // Start incremental marking and ensure that idle time handler can perform
   // incremental steps.
   void StartIdleIncrementalMarking();
 
   // Starts incremental marking assuming incremental marking is currently
   // stopped.
-  void StartIncrementalMarking(int gc_flags,
-                               const GCCallbackFlags gc_callback_flags,
+  void StartIncrementalMarking(int gc_flags = kNoGCFlags,
+                               const GCCallbackFlags gc_callback_flags =
+                                   GCCallbackFlags::kNoGCCallbackFlags,
                                const char* reason = nullptr);
 
   // Performs incremental marking steps of step_size_in_bytes as long as
   // deadline_ins_ms is not reached. step_size_in_bytes can be 0 to compute
   // an estimate increment. Returns the remaining time that cannot be used
   // for incremental marking anymore because a single step would exceed the
   // deadline.
   double AdvanceIncrementalMarking(
       intptr_t step_size_in_bytes, double deadline_in_ms,
       IncrementalMarking::StepActions step_actions);
@@ skipping 293 matching lines @@
   ROOT_LIST(ROOT_ACCESSOR)
 #undef ROOT_ACCESSOR
 
   int current_gc_flags() { return current_gc_flags_; }
 
   void set_current_gc_flags(int flags) {
     current_gc_flags_ = flags;
     DCHECK(!ShouldFinalizeIncrementalMarking() ||
            !ShouldAbortIncrementalMarking());
   }
 

[Hannes Payer (out of office), 2015/08/25 09:21:20]

The local variable is just used within heap. The getter/setter are not needed.

[Michael Lippautz, 2015/08/25 10:33:39]

Done.

+  GCCallbackFlags current_gc_callback_flags() {
+    return current_gc_callback_flags_;
+  }
+
+  void set_current_gc_callback_flags(GCCallbackFlags callback_flags) {
+    current_gc_callback_flags_ = callback_flags;
+  }
+
   inline bool ShouldReduceMemory() const {
     return current_gc_flags_ & kReduceMemoryFootprintMask;
   }
 
   inline bool ShouldAbortIncrementalMarking() const {
     return current_gc_flags_ & kAbortIncrementalMarkingMask;
   }
 
   inline bool ShouldFinalizeIncrementalMarking() const {
     return current_gc_flags_ & kFinalizeIncrementalMarkingMask;
@@ skipping 648 matching lines @@
   // Shared state read by the scavenge collector and set by ScavengeObject.
   PromotionQueue promotion_queue_;
 
   // Flag is set when the heap has been configured.  The heap can be repeatedly
   // configured through the API until it is set up.
   bool configured_;
 
   // Currently set GC flags that are respected by all GC components.
   int current_gc_flags_;
 
+  // Currently set GC callback flags that are used to pass information between
+  // the embedder and V8's GC.
+  GCCallbackFlags current_gc_callback_flags_;
+
   ExternalStringTable external_string_table_;
 
   VisitorDispatchTable<ScavengingCallback> scavenging_visitors_table_;
 
   MemoryChunk* chunks_queued_for_free_;
 
   base::Semaphore pending_unmap_job_semaphore_;
 
   base::Mutex relocation_mutex_;
 
@@ skipping 404 matching lines @@
   DisallowHeapAllocation no_allocation;  // i.e. no gc allowed.
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(PathTracer);
 };
 #endif  // DEBUG
 }
 }  // namespace v8::internal
 
 #endif  // V8_HEAP_HEAP_H_