Rename enums/functions that collide in chromium style in platform/

third_party/WebKit/Source/platform/heap/HeapPage.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 366 matching lines @@
     m_freeList.clear();
 }
 
 #if ENABLE(ASSERT)
 bool NormalPageHeap::isConsistentForGC()
 {
     // A thread heap is consistent for sweeping if none of the pages to be swept
     // contain a freelist block or the current allocation point.
     for (size_t i = 0; i < blinkPageSizeLog2; ++i) {
         for (FreeListEntry* freeListEntry = m_freeList.m_freeLists[i]; freeListEntry; freeListEntry = freeListEntry->next()) {
-            if (pagesToBeSweptContains(freeListEntry->address()))
+            if (pagesToBeSweptContains(freeListEntry->getAddress()))
                 return false;
         }
     }
     if (hasCurrentAllocationArea()) {
         if (pagesToBeSweptContains(currentAllocationPoint()))
             return false;
     }
     return true;
 }
 
@@ skipping 362 matching lines @@
         FreeListEntry* entry = m_freeList.m_freeLists[index];
         if (allocationSize > bucketSize) {
             // Final bucket candidate; check initial entry if it is able
             // to service this allocation. Do not perform a linear scan,
             // as it is considered too costly.
             if (!entry || entry->size() < allocationSize)
                 break;
         }
         if (entry) {
             entry->unlink(&m_freeList.m_freeLists[index]);
-            setAllocationPoint(entry->address(), entry->size());
+            setAllocationPoint(entry->getAddress(), entry->size());
             ASSERT(hasCurrentAllocationArea());
             ASSERT(remainingAllocationSize() >= allocationSize);
             m_freeList.m_biggestFreeListIndex = index;
             return allocateObject(allocationSize, gcInfoIndex);
         }
     }
     m_freeList.m_biggestFreeListIndex = index;
     return nullptr;
 }
 
@@ skipping 44 matching lines @@
 #endif
     ASSERT(gcInfoIndex > 0);
     HeapObjectHeader* header = new (NotNull, headerAddress) HeapObjectHeader(largeObjectSizeInHeader, gcInfoIndex);
     Address result = headerAddress + sizeof(*header);
     ASSERT(!(reinterpret_cast<uintptr_t>(result) & allocationMask));
     LargeObjectPage* largeObject = new (largeObjectAddress) LargeObjectPage(pageMemory, this, allocationSize);
     ASSERT(header->checkHeader());
 
     // Poison the object header and allocationGranularity bytes after the object
     ASAN_POISON_MEMORY_REGION(header, sizeof(*header));
-    ASAN_POISON_MEMORY_REGION(largeObject->address() + largeObject->size(), allocationGranularity);
+    ASAN_POISON_MEMORY_REGION(largeObject->getAddress() + largeObject->size(), allocationGranularity);
 
     largeObject->link(&m_firstPage);
 
     Heap::increaseAllocatedSpace(largeObject->size());
     threadState()->increaseAllocatedObjectSize(largeObject->size());
     return result;
 }
 
 void LargeObjectHeap::freeLargeObjectPage(LargeObjectPage* object)
 {
     ASAN_UNPOISON_MEMORY_REGION(object->payload(), object->payloadSize());
     object->heapObjectHeader()->finalize(object->payload(), object->payloadSize());
     Heap::decreaseAllocatedSpace(object->size());
 
     // Unpoison the object header and allocationGranularity bytes after the
     // object before freeing.
     ASAN_UNPOISON_MEMORY_REGION(object->heapObjectHeader(), sizeof(HeapObjectHeader));
-    ASAN_UNPOISON_MEMORY_REGION(object->address() + object->size(), allocationGranularity);
+    ASAN_UNPOISON_MEMORY_REGION(object->getAddress() + object->size(), allocationGranularity);
 
     if (object->terminating()) {
         ASSERT(ThreadState::current()->isTerminating());
         // The thread is shutting down and this page is being removed as a part
         // of the thread local GC.  In that case the object could be traced in
         // the next global GC if there is a dangling pointer from a live thread
         // heap to this dead thread heap.  To guard against this, we put the
         // page into the orphaned page pool and zap the page memory.  This
         // ensures that tracing the dangling pointer in the next global GC just
         // crashes instead of causing use-after-frees.  After the next global
@@ skipping 556 matching lines @@
     pageDump->addScalar("live_size", "bytes", liveSize);
     pageDump->addScalar("dead_size", "bytes", deadSize);
     pageDump->addScalar("free_size", "bytes", freeSize);
     heapInfo.freeSize += freeSize;
     heapInfo.freeCount += freeCount;
 }
 
 #if ENABLE(ASSERT)
 bool NormalPage::contains(Address addr)
 {
-    Address blinkPageStart = roundToBlinkPageStart(address());
-    ASSERT(blinkPageStart == address() - blinkGuardPageSize); // Page is at aligned address plus guard page size.
+    Address blinkPageStart = roundToBlinkPageStart(getAddress());
+    ASSERT(blinkPageStart == getAddress() - blinkGuardPageSize); // Page is at aligned address plus guard page size.
     return blinkPageStart <= addr && addr < blinkPageStart + blinkPageSize;
 }
 #endif
 
 NormalPageHeap* NormalPage::heapForNormalPage()
 {
     return static_cast<NormalPageHeap*>(heap());
 }
 
 LargeObjectPage::LargeObjectPage(PageMemory* storage, BaseHeap* heap, size_t payloadSize)
@@ skipping 97 matching lines @@
 
     pageDump->addScalar("live_count", "objects", liveCount);
     pageDump->addScalar("dead_count", "objects", deadCount);
     pageDump->addScalar("live_size", "bytes", liveSize);
     pageDump->addScalar("dead_size", "bytes", deadSize);
 }
 
 #if ENABLE(ASSERT)
 bool LargeObjectPage::contains(Address object)
 {
-    return roundToBlinkPageStart(address()) <= object && object < roundToBlinkPageEnd(address() + size());
+    return roundToBlinkPageStart(getAddress()) <= object && object < roundToBlinkPageEnd(getAddress() + size());
 }
 #endif
 
 void HeapDoesNotContainCache::flush()
 {
     if (m_hasEntries) {
         for (int i = 0; i < numberOfEntries; ++i)
             m_entries[i] = nullptr;
         m_hasEntries = false;
     }
@@ skipping 28 matching lines @@
 
     m_hasEntries = true;
     size_t index = hash(address);
     ASSERT(!(index & 1));
     Address cachePage = roundToBlinkPageStart(address);
     m_entries[index + 1] = m_entries[index];
     m_entries[index] = cachePage;
 }
 
 } // namespace blink