Oilpan: Fix compile of GC_PROFILING build, and remove object graph dumper.

Source/platform/heap/Heap.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 1409 matching lines @@
         visitor->markHeader(header, gcInfo->m_trace);
     }
 }
 
 void NormalPage::checkAndMarkPointer(Visitor* visitor, Address address)
 {
     ASSERT(contains(address));
     HeapObjectHeader* header = findHeaderFromAddress(address);
     if (!header || header->isDead())
         return;
-#if ENABLE(GC_PROFILING)
-    visitor->setHostInfo(&address, "stack");
-#endif
     markPointer(visitor, header);
 }
 
 void NormalPage::markOrphaned()
 {
     // Zap the payload with a recognizable value to detect any incorrect
     // cross thread pointer usage.
 #if defined(ADDRESS_SANITIZER)
     // This needs to zap poisoned memory as well.
     // Force unpoison memory before memset.
@@ skipping 162 matching lines @@
             ASAN_UNPOISON_MEMORY_REGION(header->payload(), header->payloadSize());
     }
 }
 #endif
 
 void LargeObjectPage::checkAndMarkPointer(Visitor* visitor, Address address)
 {
     ASSERT(contains(address));
     if (!containedInObjectPayload(address) || heapObjectHeader()->isDead())
         return;
-#if ENABLE(GC_PROFILING)
-    visitor->setHostInfo(&address, "stack");
-#endif
     markPointer(visitor, heapObjectHeader());
 }
 
 void LargeObjectPage::markOrphaned()
 {
     // Zap the payload with a recognizable value to detect any incorrect
     // cross thread pointer usage.
     memset(payload(), orphanedZapValue, payloadSize());
     BasePage::markOrphaned();
 }
@@ skipping 206 matching lines @@
 }
 
 #if ENABLE(GC_PROFILING)
 const GCInfo* Heap::findGCInfo(Address address)
 {
     return ThreadState::findGCInfoFromAllThreads(address);
 }
 #endif
 
 #if ENABLE(GC_PROFILING)
-void Heap::dumpPathToObjectOnNextGC(void* p)
-{
-    MarkingVisitor<Visitor::GlobalMarking> visitor;
-    visitor->dumpPathToObjectOnNextGC(p);
-}
-
 String Heap::createBacktraceString()
 {
     int framesToShow = 3;
     int stackFrameSize = 16;
     ASSERT(stackFrameSize >= framesToShow);
     using FramePointer = void*;
     FramePointer* stackFrame = static_cast<FramePointer*>(alloca(sizeof(FramePointer) * stackFrameSize));
     WTFGetBacktrace(stackFrame, &stackFrameSize);
 
     StringBuilder builder;
@@ skipping 31 matching lines @@
     ASSERT(!Heap::orphanedPagePool()->contains(object));
     CallbackStack::Item* slot = s_markingStack->allocateEntry();
     *slot = CallbackStack::Item(object, callback);
 }
 
 bool Heap::popAndInvokeTraceCallback(Visitor* visitor)
 {
     CallbackStack::Item* item = s_markingStack->pop();
     if (!item)
         return false;
-
-#if ENABLE(GC_PROFILING)
-    visitor->setHostInfo(item->object(), classOf(item->object()));
-#endif
     item->call(visitor);
     return true;
 }
 
 void Heap::pushPostMarkingCallback(void* object, TraceCallback callback)
 {
     ASSERT(ThreadState::current()->isInGC());
 
     // Trace should never reach an orphaned page.
     ASSERT(!Heap::orphanedPagePool()->contains(object));
@@ skipping 103 matching lines @@
         return;
 
     if (state->isMainThread())
         ScriptForbiddenScope::enter();
 
     TRACE_EVENT2("blink_gc", "Heap::collectGarbage",
         "lazySweeping", gcType == ThreadState::GCWithoutSweep,
         "gcReason", gcReasonString(reason));
     TRACE_EVENT_SCOPED_SAMPLING_STATE("blink_gc", "BlinkGC");
     double timeStamp = WTF::currentTimeMS();
-#if ENABLE(GC_PROFILING)
-    gcScope.visitor()->objectGraph().clear();
-#endif
 
     // Disallow allocation during garbage collection (but not during the
     // finalization that happens when the gcScope is torn down).
     ThreadState::NoAllocationScope noAllocationScope(state);
 
     preGC();
 
     StackFrameDepthScope stackDepthScope;
 
     size_t totalObjectSize = Heap::allocatedObjectSize() + Heap::markedObjectSize();
@@ skipping 12 matching lines @@
     postMarkingProcessing(gcScope.visitor());
     globalWeakProcessing(gcScope.visitor());
 
     // Now we can delete all orphaned pages because there are no dangling
     // pointers to the orphaned pages.  (If we have such dangling pointers,
     // we should have crashed during marking before getting here.)
     orphanedPagePool()->decommitOrphanedPages();
 
     postGC(gcType);
 
-#if ENABLE(GC_PROFILING)
-    gcScope.visitor()->reportStats();
-#endif
-
     double markingTimeInMilliseconds = WTF::currentTimeMS() - timeStamp;
     s_estimatedMarkingTimePerByte = totalObjectSize ? (markingTimeInMilliseconds / 1000 / totalObjectSize) : 0;
 
     Platform::current()->histogramCustomCounts("BlinkGC.CollectGarbage", markingTimeInMilliseconds, 0, 10 * 1000, 50);
     Platform::current()->histogramCustomCounts("BlinkGC.TotalObjectSpace", Heap::allocatedObjectSize() / 1024, 0, 4 * 1024 * 1024, 50);
     Platform::current()->histogramCustomCounts("BlinkGC.TotalAllocatedSpace", Heap::allocatedSpace() / 1024, 0, 4 * 1024 * 1024, 50);
     Platform::current()->histogramEnumeration("BlinkGC.GCReason", reason, NumberOfGCReason);
     Heap::reportMemoryUsageHistogram();
     WTF::Partitions::reportMemoryUsageHistogram();
 
@@ skipping 268 matching lines @@
 size_t Heap::s_allocatedObjectSize = 0;
 size_t Heap::s_allocatedSpace = 0;
 size_t Heap::s_markedObjectSize = 0;
 // We don't want to use 0 KB for the initial value because it may end up
 // triggering the first GC of some thread too prematurely.
 size_t Heap::s_estimatedLiveObjectSize = 512 * 1024;
 size_t Heap::s_externalObjectSizeAtLastGC = 0;
 double Heap::s_estimatedMarkingTimePerByte = 0.0;
 
 } // namespace blink