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

third_party/WebKit/Source/platform/heap/HeapPage.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 249 matching lines @@
     explicit FreeListEntry(size_t size)
         : HeapObjectHeader(size, gcInfoIndexForFreeListHeader)
         , m_next(nullptr)
     {
 #if ENABLE(ASSERT)
         ASSERT(size >= sizeof(HeapObjectHeader));
         zapMagic();
 #endif
     }
 
-    Address address() { return reinterpret_cast<Address>(this); }
+    Address getAddress() { return reinterpret_cast<Address>(this); }
 
     NO_SANITIZE_ADDRESS
     void unlink(FreeListEntry** prevNext)
     {
         *prevNext = m_next;
         m_next = nullptr;
     }
 
     NO_SANITIZE_ADDRESS
     void link(FreeListEntry** prevNext)
@@ skipping 118 matching lines @@
         size_t freeSize = 0;
     };
 
     virtual void takeSnapshot(WebMemoryAllocatorDump*, ThreadState::GCSnapshotInfo&, HeapSnapshotInfo&) = 0;
 #if ENABLE(ASSERT)
     virtual bool contains(Address) = 0;
 #endif
     virtual size_t size() = 0;
     virtual bool isLargeObjectPage() { return false; }
 
-    Address address() { return reinterpret_cast<Address>(this); }
+    Address getAddress() { return reinterpret_cast<Address>(this); }
     PageMemory* storage() const { return m_storage; }
     BaseHeap* heap() const { return m_heap; }
     bool orphaned() { return !m_heap; }
     bool terminating() { return m_terminating; }
     void setTerminating() { m_terminating = true; }
 
     // Returns true if this page has been swept by the ongoing lazy sweep.
     bool hasBeenSwept() const { return m_swept; }
 
     void markAsSwept()
@@ skipping 23 matching lines @@
     bool m_swept;
     friend class BaseHeap;
 };
 
 class NormalPage final : public BasePage {
 public:
     NormalPage(PageMemory*, BaseHeap*);
 
     Address payload()
     {
-        return address() + pageHeaderSize();
+        return getAddress() + pageHeaderSize();
     }
     size_t payloadSize()
     {
         return (blinkPagePayloadSize() - pageHeaderSize()) & ~allocationMask;
     }
     Address payloadEnd() { return payload() + payloadSize(); }
     bool containedInObjectPayload(Address address)
     {
         return payload() <= address && address < payloadEnd();
     }
@@ skipping 83 matching lines @@
     {
         // Compute the amount of padding we have to add to a header to make
         // the size of the header plus the padding a multiple of 8 bytes.
         size_t paddingSize = (sizeof(LargeObjectPage) + allocationGranularity - (sizeof(HeapObjectHeader) % allocationGranularity)) % allocationGranularity;
         return sizeof(LargeObjectPage) + paddingSize;
     }
     bool isLargeObjectPage() override { return true; }
 
     HeapObjectHeader* heapObjectHeader()
     {
-        Address headerAddress = address() + pageHeaderSize();
+        Address headerAddress = getAddress() + pageHeaderSize();
         return reinterpret_cast<HeapObjectHeader*>(headerAddress);
     }
 
 #ifdef ANNOTATE_CONTIGUOUS_CONTAINER
     void setIsVectorBackingPage() { m_isVectorBackingPage = true; }
     bool isVectorBackingPage() const { return m_isVectorBackingPage; }
 #endif
 
 private:
 
@@ skipping 318 matching lines @@
         SET_MEMORY_ACCESSIBLE(result, allocationSize - sizeof(HeapObjectHeader));
         ASSERT(findPageFromAddress(headerAddress + allocationSize - 1));
         return result;
     }
     return outOfLineAllocate(allocationSize, gcInfoIndex);
 }
 
 } // namespace blink
 
 #endif // HeapPage_h