Change PartitionAlloc to Chromium naming style.

third_party/WebKit/Source/wtf/allocator/Partitions.h

 /*
  * 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 58 matching lines @@
     return m_layoutAllocator.root();
   }
 
   static size_t currentDOMMemoryUsage() {
     NOTREACHED();
     return 0;
   }
 
   static size_t totalSizeOfCommittedPages() {
     size_t totalSize = 0;
-    totalSize += m_fastMallocAllocator.root()->totalSizeOfCommittedPages;
-    totalSize += m_bufferAllocator.root()->totalSizeOfCommittedPages;
-    totalSize += m_layoutAllocator.root()->totalSizeOfCommittedPages;
+    totalSize += m_fastMallocAllocator.root()->total_size_of_committed_pages;
+    totalSize += m_bufferAllocator.root()->total_size_of_committed_pages;
+    totalSize += m_layoutAllocator.root()->total_size_of_committed_pages;
     return totalSize;
   }
 
   static void decommitFreeableMemory();
 
   static void reportMemoryUsageHistogram();
 
   static void dumpMemoryStats(bool isLightDump, base::PartitionStatsDumper*);
 
   ALWAYS_INLINE static void* bufferMalloc(size_t n, const char* typeName) {
-    return partitionAllocGeneric(bufferPartition(), n, typeName);
+    return PartitionAllocGeneric(bufferPartition(), n, typeName);
   }
   ALWAYS_INLINE static void* bufferRealloc(void* p,
                                            size_t n,
                                            const char* typeName) {
-    return partitionReallocGeneric(bufferPartition(), p, n, typeName);
+    return PartitionReallocGeneric(bufferPartition(), p, n, typeName);
   }
   ALWAYS_INLINE static void bufferFree(void* p) {
-    partitionFreeGeneric(bufferPartition(), p);
+    PartitionFreeGeneric(bufferPartition(), p);
   }
   ALWAYS_INLINE static size_t bufferActualSize(size_t n) {
-    return partitionAllocActualSize(bufferPartition(), n);
+    return PartitionAllocActualSize(bufferPartition(), n);
   }
   static void* fastMalloc(size_t n, const char* typeName) {
-    return partitionAllocGeneric(Partitions::fastMallocPartition(), n,
+    return PartitionAllocGeneric(Partitions::fastMallocPartition(), n,
                                  typeName);
   }
   static void* fastZeroedMalloc(size_t n, const char* typeName) {
     void* result = fastMalloc(n, typeName);
     memset(result, 0, n);
     return result;
   }
   static void* fastRealloc(void* p, size_t n, const char* typeName) {
-    return partitionReallocGeneric(Partitions::fastMallocPartition(), p, n,
+    return PartitionReallocGeneric(Partitions::fastMallocPartition(), p, n,
                                    typeName);
   }
   static void fastFree(void* p) {
-    partitionFreeGeneric(Partitions::fastMallocPartition(), p);
+    PartitionFreeGeneric(Partitions::fastMallocPartition(), p);
   }
 
   static void handleOutOfMemory();
 
  private:
   static base::subtle::SpinLock s_initializationLock;
   static bool s_initialized;
 
   // We have the following four partitions.
   //   - LayoutObject partition: A partition to allocate LayoutObjects.
@@ skipping 12 matching lines @@
   static base::SizeSpecificPartitionAllocator<1024> m_layoutAllocator;
   static ReportPartitionAllocSizeFunction m_reportSizeFunction;
 };
 
 using base::kGenericMaxDirectMapped;
 using base::kPageAllocationGranularity;
 using base::kPageAllocationGranularityBaseMask;
 using base::kPageAllocationGranularityOffsetMask;
 using base::kSystemPageSize;
 
-using base::allocPages;
-using base::decommitSystemPages;
-using base::discardSystemPages;
-using base::partitionFree;
-using base::freePages;
-using base::getAllocPageErrorCode;
-using base::recommitSystemPages;
-using base::roundDownToSystemPage;
-using base::roundUpToSystemPage;
-using base::setSystemPagesAccessible;
-using base::setSystemPagesInaccessible;
+using base::AllocPages;
+using base::DecommitSystemPages;
+using base::DiscardSystemPages;
+using base::PartitionFree;
+using base::FreePages;
+using base::GetAllocPageErrorCode;
+using base::RecommitSystemPages;
+using base::RoundDownToSystemPage;
+using base::RoundUpToSystemPage;
+using base::SetSystemPagesAccessible;
+using base::SetSystemPagesInaccessible;
 
 using base::PageAccessible;
 using base::PageInaccessible;
 using base::PartitionStatsDumper;
 using base::PartitionMemoryStats;
 using base::PartitionBucketMemoryStats;
 using base::PartitionAllocHooks;
 
 }  // namespace WTF
 
 #endif  // Partitions_h