Move Partition Allocator into Chromium base.

third_party/WebKit/Source/platform/PartitionAllocMemoryDumpProvider.cpp

 // Copyright 2015 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/PartitionAllocMemoryDumpProvider.h"
 
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/heap_profiler_allocation_context.h"
 #include "base/trace_event/heap_profiler_allocation_context_tracker.h"
 #include "base/trace_event/heap_profiler_allocation_register.h"
@@ skipping 20 matching lines @@
 const char kPartitionsDumpName[] = "partitions";
 
 std::string getPartitionDumpName(const char* partitionName) {
   return base::StringPrintf("%s/%s/%s", kPartitionAllocDumpName,
                             kPartitionsDumpName, partitionName);
 }
 
 // This class is used to invert the dependency of PartitionAlloc on the
 // PartitionAllocMemoryDumpProvider. This implements an interface that will
 // be called with memory statistics for each bucket in the allocator.
-class PartitionStatsDumperImpl final : public PartitionStatsDumper {
+class PartitionStatsDumperImpl final : public WTF::PartitionStatsDumper {
   DISALLOW_NEW();
   WTF_MAKE_NONCOPYABLE(PartitionStatsDumperImpl);
 
  public:
   PartitionStatsDumperImpl(
       base::trace_event::ProcessMemoryDump* memoryDump,
       base::trace_event::MemoryDumpLevelOfDetail levelOfDetail)
       : m_memoryDump(memoryDump), m_uid(0), m_totalActiveBytes(0) {}
 
   // PartitionStatsDumper implementation.
   void partitionDumpTotals(const char* partitionName,
-                           const PartitionMemoryStats*) override;
-  void partitionsDumpBucketStats(const char* partitionName,
-                                 const PartitionBucketMemoryStats*) override;
+                           const WTF::PartitionMemoryStats*) override;
+  void partitionsDumpBucketStats(
+      const char* partitionName,
+      const WTF::PartitionBucketMemoryStats*) override;
 
   size_t totalActiveBytes() const { return m_totalActiveBytes; }
 
  private:
   base::trace_event::ProcessMemoryDump* m_memoryDump;
   unsigned long m_uid;
   size_t m_totalActiveBytes;
 };
 
 void PartitionStatsDumperImpl::partitionDumpTotals(
     const char* partitionName,
-    const PartitionMemoryStats* memoryStats) {
+    const WTF::PartitionMemoryStats* memoryStats) {
   m_totalActiveBytes += memoryStats->totalActiveBytes;
   std::string dumpName = getPartitionDumpName(partitionName);
   base::trace_event::MemoryAllocatorDump* allocatorDump =
       m_memoryDump->CreateAllocatorDump(dumpName);
   allocatorDump->AddScalar("size", "bytes", memoryStats->totalResidentBytes);
   allocatorDump->AddScalar("allocated_objects_size", "bytes",
                            memoryStats->totalActiveBytes);
   allocatorDump->AddScalar("virtual_size", "bytes",
                            memoryStats->totalMmappedBytes);
   allocatorDump->AddScalar("virtual_committed_size", "bytes",
                            memoryStats->totalCommittedBytes);
   allocatorDump->AddScalar("decommittable_size", "bytes",
                            memoryStats->totalDecommittableBytes);
   allocatorDump->AddScalar("discardable_size", "bytes",
                            memoryStats->totalDiscardableBytes);
 }
 
 void PartitionStatsDumperImpl::partitionsDumpBucketStats(
     const char* partitionName,
-    const PartitionBucketMemoryStats* memoryStats) {
+    const WTF::PartitionBucketMemoryStats* memoryStats) {
   ASSERT(memoryStats->isValid);
   std::string dumpName = getPartitionDumpName(partitionName);
   if (memoryStats->isDirectMap)
     dumpName.append(base::StringPrintf("/directMap_%lu", ++m_uid));
   else
     dumpName.append(base::StringPrintf(
         "/bucket_%u", static_cast<unsigned>(memoryStats->bucketSlotSize)));
 
   base::trace_event::MemoryAllocatorDump* allocatorDump =
       m_memoryDump->CreateAllocatorDump(dumpName);
@@ skipping 80 matching lines @@
 
 PartitionAllocMemoryDumpProvider::~PartitionAllocMemoryDumpProvider() {}
 
 void PartitionAllocMemoryDumpProvider::OnHeapProfilingEnabled(bool enabled) {
   if (enabled) {
     {
       MutexLocker locker(m_allocationRegisterMutex);
       if (!m_allocationRegister)
         m_allocationRegister.reset(new base::trace_event::AllocationRegister());
     }
-    PartitionAllocHooks::setAllocationHook(reportAllocation);
-    PartitionAllocHooks::setFreeHook(reportFree);
+    WTF::PartitionAllocHooks::setAllocationHook(reportAllocation);
+    WTF::PartitionAllocHooks::setFreeHook(reportFree);
   } else {
-    PartitionAllocHooks::setAllocationHook(nullptr);
-    PartitionAllocHooks::setFreeHook(nullptr);
+    WTF::PartitionAllocHooks::setAllocationHook(nullptr);
+    WTF::PartitionAllocHooks::setFreeHook(nullptr);
   }
   m_isHeapProfilingEnabled = enabled;
 }
 
 void PartitionAllocMemoryDumpProvider::insert(void* address,
                                               size_t size,
                                               const char* typeName) {
   base::trace_event::AllocationContext context =
       base::trace_event::AllocationContextTracker::GetInstanceForCurrentThread()
           ->GetContextSnapshot();
   context.type_name = typeName;
   MutexLocker locker(m_allocationRegisterMutex);
   if (m_allocationRegister)
     m_allocationRegister->Insert(address, size, context);
 }
 
 void PartitionAllocMemoryDumpProvider::remove(void* address) {
   MutexLocker locker(m_allocationRegisterMutex);
   if (m_allocationRegister)
     m_allocationRegister->Remove(address);
 }
 
 }  // namespace blink