Fix compilation of heap compaction debug diagnostics code.

third_party/WebKit/Source/platform/heap/HeapCompact.cpp

 // Copyright 2016 The Chromium 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 "platform/heap/HeapCompact.h"
 
 #include "platform/Histogram.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/heap/Heap.h"
 #include "platform/heap/SparseHeapBitmap.h"
@@ skipping 148 matching lines @@
     DCHECK(relocatable_pages_.Contains(from_page));
 #endif
     MovableReference* slot = reinterpret_cast<MovableReference*>(it->value);
     auto interior = interior_fixups_.find(slot);
     if (interior != interior_fixups_.end()) {
       MovableReference* slot_location =
           reinterpret_cast<MovableReference*>(interior->value);
       if (!slot_location) {
         interior_fixups_.Set(slot, to);
       } else {
-        LOG_HEAP_COMPACTION("Redirected slot: %p => %p\n", slot, slotLocation);
+        LOG_HEAP_COMPACTION("Redirected slot: %p => %p\n", slot, slot_location);
         slot = slot_location;
       }
     }
     // If the slot has subsequently been updated, a prefinalizer or
     // a destructor having mutated and expanded/shrunk the collection,
     // do not update and relocate the slot -- |from| is no longer valid
     // and referenced.
     //
     // The slot's contents may also have been cleared during weak processing;
     // no work to be done in that case either.
@@ skipping 33 matching lines @@
     if (!size)
       size = HeapObjectHeader::FromPayload(to)->PayloadSize();
     RelocateInteriorFixups(from, to, size);
   }
 
 #if DEBUG_HEAP_COMPACTION
   void dumpDebugStats() {
     LOG_HEAP_COMPACTION(
         "Fixups: pages=%u objects=%u callbacks=%u interior-size=%zu"
         " interiors-f=%u\n",
-        m_relocatablePages.size(), m_fixups.size(), m_fixupCallbacks.size(),
-        m_interiors ? m_interiors->intervalCount() : 0,
-        m_interiorFixups.size());
+        relocatable_pages_.size(), fixups_.size(), fixup_callbacks_.size(),
+        interiors_ ? interiors_->IntervalCount() : 0, interior_fixups_.size());
   }
 #endif
 
  private:
   MovableObjectFixups() {}
 
   // Tracking movable and updatable references. For now, we keep a
   // map which for each movable object, recording the slot that
   // points to it. Upon moving the object, that slot needs to be
   // updated.
@@ skipping 52 matching lines @@
 bool HeapCompact::ShouldCompact(ThreadState* state,
                                 BlinkGC::GCType gc_type,
                                 BlinkGC::GCReason reason) {
 #if !ENABLE_HEAP_COMPACTION
   return false;
 #else
   if (!RuntimeEnabledFeatures::heapCompactionEnabled())
     return false;
 
   LOG_HEAP_COMPACTION("shouldCompact(): gc=%s count=%zu free=%zu\n",
-                      ThreadState::gcReasonString(reason),
-                      m_gcCountSinceLastCompaction, m_freeListSize);
+                      ThreadState::GcReasonString(reason),
+                      gc_count_since_last_compaction_, free_list_size_);
   gc_count_since_last_compaction_++;
   // It is only safe to compact during non-conservative GCs.
   // TODO: for the main thread, limit this further to only idle GCs.
   if (reason != BlinkGC::kIdleGC && reason != BlinkGC::kPreciseGC &&
       reason != BlinkGC::kForcedGC)
     return false;
 
   // If the GCing thread requires a stack scan, do not compact.
   // Why? Should the stack contain an iterator pointing into its
   // associated backing store, its references wouldn't be
@@ skipping 21 matching lines @@
 #else
   return force_compaction_gc_ || (gc_count_since_last_compaction_ >
                                       kGCCountSinceLastCompactionThreshold &&
                                   free_list_size_ > kFreeListSizeThreshold);
 #endif
 #endif
 }
 
 void HeapCompact::Initialize(ThreadState* state) {
   DCHECK(RuntimeEnabledFeatures::heapCompactionEnabled());
-  LOG_HEAP_COMPACTION("Compacting: free=%zu\n", m_freeListSize);
+  LOG_HEAP_COMPACTION("Compacting: free=%zu\n", free_list_size_);
   do_compact_ = true;
   freed_pages_ = 0;
   freed_size_ = 0;
   fixups_.reset();
   gc_count_since_last_compaction_ = 0;
   force_compaction_gc_ = false;
 }
 
 void HeapCompact::RegisterMovingObjectReference(MovableReference* slot) {
   if (!do_compact_)
@@ skipping 20 matching lines @@
   LOG_HEAP_FREELIST("Arena residencies: {");
 #endif
   for (int i = BlinkGC::kVector1ArenaIndex; i <= BlinkGC::kHashTableArenaIndex;
        ++i) {
     NormalPageArena* arena =
         static_cast<NormalPageArena*>(thread_state->Arena(i));
     size_t arena_size = arena->ArenaSize();
     size_t free_list_size = arena->FreeListSize();
     total_arena_size += arena_size;
     total_free_list_size += free_list_size;
-    LOG_HEAP_FREELIST("%d: [%zu, %zu], ", i, arenaSize, freeListSize);
+    LOG_HEAP_FREELIST("%d: [%zu, %zu], ", i, arena_size, free_list_size);
     // TODO: be more discriminating and consider arena
     // load factor, effectiveness of past compactions etc.
     if (!arena_size)
       continue;
     // Mark the arena as compactable.
     compactable_arenas_ |= (0x1u << (BlinkGC::kVector1ArenaIndex + i));
   }
-  LOG_HEAP_FREELIST("}\nTotal = %zu, Free = %zu\n", totalArenaSize,
-                    totalFreeListSize);
+  LOG_HEAP_FREELIST("}\nTotal = %zu, Free = %zu\n", total_arena_size,
+                    total_free_list_size);
 
   // TODO(sof): consider smoothing the reported sizes.
   free_list_size_ = total_free_list_size;
 }
 
 void HeapCompact::FinishedArenaCompaction(NormalPageArena* arena,
                                           size_t freed_pages,
                                           size_t freed_size) {
   if (!do_compact_)
     return;
@@ skipping 13 matching lines @@
 
   if (!start_compaction_time_ms_)
     start_compaction_time_ms_ = WTF::CurrentTimeMS();
 }
 
 void HeapCompact::FinishThreadCompaction() {
   if (!do_compact_)
     return;
 
 #if DEBUG_HEAP_COMPACTION
-  if (m_fixups)
-    m_fixups->dumpDebugStats();
+  if (fixups_)
+    fixups_->dumpDebugStats();
 #endif
   fixups_.reset();
   do_compact_ = false;
 
   double time_for_heap_compaction =
       WTF::CurrentTimeMS() - start_compaction_time_ms_;
   DEFINE_THREAD_SAFE_STATIC_LOCAL(
       CustomCountHistogram, time_for_heap_compaction_histogram,
       new CustomCountHistogram("BlinkGC.TimeForHeapCompaction", 1, 10 * 1000,
                                50));
   time_for_heap_compaction_histogram.Count(time_for_heap_compaction);
   start_compaction_time_ms_ = 0;
 
   DEFINE_THREAD_SAFE_STATIC_LOCAL(
       CustomCountHistogram, object_size_freed_by_heap_compaction,
       new CustomCountHistogram("BlinkGC.ObjectSizeFreedByHeapCompaction", 1,
                                4 * 1024 * 1024, 50));
   object_size_freed_by_heap_compaction.Count(freed_size_ / 1024);
 
 #if DEBUG_LOG_HEAP_COMPACTION_RUNNING_TIME
   LOG_HEAP_COMPACTION_INTERNAL(
       "Compaction stats: time=%gms, pages freed=%zu, size=%zu\n",
-      timeForHeapCompaction, m_freedPages, m_freedSize);
+      time_for_heap_compaction, freed_pages_, freed_size_);
 #else
   LOG_HEAP_COMPACTION("Compaction stats: freed pages=%zu size=%zu\n",
-                      m_freedPages, m_freedSize);
+                      freed_pages_, freed_size_);
 #endif
 }
 
 void HeapCompact::AddCompactingPage(BasePage* page) {
   DCHECK(do_compact_);
   DCHECK(IsCompactingArena(page->Arena()->ArenaIndex()));
   Fixups().AddCompactingPage(page);
 }
 
 bool HeapCompact::ScheduleCompactionGCForTesting(bool value) {
   bool current = force_compaction_gc_;
   force_compaction_gc_ = value;
   return current;
 }
 
 }  // namespace blink