Fix virtual/override/final usage in Source/platform/.

Source/platform/heap/Heap.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 431 matching lines @@
     size_t payloadSize()
     {
         return (blinkPagePayloadSize() - pageHeaderSize()) & ~allocationMask;
     }
     Address payloadEnd() { return payload() + payloadSize(); }
     bool containedInObjectPayload(Address address)
     {
         return payload() <= address && address < payloadEnd();
     }
 
-    virtual size_t objectPayloadSizeForTesting() override;
-    virtual bool isEmpty() override;
-    virtual void removeFromHeap() override;
-    virtual void sweep() override;
-    virtual void makeConsistentForGC() override;
-    virtual void makeConsistentForMutator() override;
+    size_t objectPayloadSizeForTesting() override;
+    bool isEmpty() override;
+    void removeFromHeap() override;
+    void sweep() override;
+    void makeConsistentForGC() override;
+    void makeConsistentForMutator() override;
 #if defined(ADDRESS_SANITIZER)
-    virtual void poisonObjects(ThreadState::ObjectsToPoison, ThreadState::Poisoning) override;
+    void poisonObjects(ThreadState::ObjectsToPoison, ThreadState::Poisoning) override;
 #endif
-    virtual void checkAndMarkPointer(Visitor*, Address) override;
-    virtual void markOrphaned() override;
+    void checkAndMarkPointer(Visitor*, Address) override;
+    void markOrphaned() override;
 
     void takeSnapshot(String dumpBaseName, size_t pageIndex, size_t* outFreeSize, size_t* outFreeCount) override;
 #if ENABLE(GC_PROFILING)
     const GCInfo* findGCInfo(Address) override;
     void snapshot(TracedValue*, ThreadState::SnapshotInfo*) override;
     void incrementMarkedObjectsAge() override;
     void countMarkedObjects(ClassAgeCountsMap&) override;
     void countObjectsToSweep(ClassAgeCountsMap&) override;
 #endif
 #if ENABLE(ASSERT) || ENABLE(GC_PROFILING)
     // Returns true for the whole blinkPageSize page that the page is on, even
     // for the header, and the unmapped guard page at the start. That ensures
     // the result can be used to populate the negative page cache.
-    virtual bool contains(Address) override;
+    bool contains(Address) override;
 #endif
-    virtual size_t size() override { return blinkPageSize; }
+    size_t size() override { return blinkPageSize; }
     static size_t pageHeaderSize()
     {
         // 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(NormalPage) + allocationGranularity - (sizeof(HeapObjectHeader) % allocationGranularity)) % allocationGranularity;
         return sizeof(NormalPage) + paddingSize;
     }
 
 
     NormalPageHeap* heapForNormalPage();
@@ skipping 18 matching lines @@
     LargeObjectPage(PageMemory*, BaseHeap*, size_t);
 
     Address payload() { return heapObjectHeader()->payload(); }
     size_t payloadSize() { return m_payloadSize; }
     Address payloadEnd() { return payload() + payloadSize(); }
     bool containedInObjectPayload(Address address)
     {
         return payload() <= address && address < payloadEnd();
     }
 
-    virtual size_t objectPayloadSizeForTesting() override;
-    virtual bool isEmpty() override;
-    virtual void removeFromHeap() override;
-    virtual void sweep() override;
-    virtual void makeConsistentForGC() override;
-    virtual void makeConsistentForMutator() override;
+    size_t objectPayloadSizeForTesting() override;
+    bool isEmpty() override;
+    void removeFromHeap() override;
+    void sweep() override;
+    void makeConsistentForGC() override;
+    void makeConsistentForMutator() override;
 #if defined(ADDRESS_SANITIZER)
-    virtual void poisonObjects(ThreadState::ObjectsToPoison, ThreadState::Poisoning) override;
+    void poisonObjects(ThreadState::ObjectsToPoison, ThreadState::Poisoning) override;
 #endif
-    virtual void checkAndMarkPointer(Visitor*, Address) override;
-    virtual void markOrphaned() override;
+    void checkAndMarkPointer(Visitor*, Address) override;
+    void markOrphaned() override;
 
     void takeSnapshot(String dumpBaseName, size_t pageIndex, size_t* outFreeSize, size_t* outFreeCount) override;
 #if ENABLE(GC_PROFILING)
     const GCInfo* findGCInfo(Address) override;
     void snapshot(TracedValue*, ThreadState::SnapshotInfo*) override;
     void incrementMarkedObjectsAge() override;
     void countMarkedObjects(ClassAgeCountsMap&) override;
     void countObjectsToSweep(ClassAgeCountsMap&) override;
 #endif
 #if ENABLE(ASSERT) || ENABLE(GC_PROFILING)
     // Returns true for any address that is on one of the pages that this
     // large object uses. That ensures that we can use a negative result to
     // populate the negative page cache.
-    virtual bool contains(Address) override;
+    bool contains(Address) override;
 #endif
     virtual size_t size()
     {
         return pageHeaderSize() +  sizeof(HeapObjectHeader) + m_payloadSize;
     }
     static size_t pageHeaderSize()
     {
         // 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;
     }
-    virtual bool isLargeObjectPage() override { return true; }
+    bool isLargeObjectPage() override { return true; }
 
     HeapObjectHeader* heapObjectHeader()
     {
         Address headerAddress = address() + pageHeaderSize();
         return reinterpret_cast<HeapObjectHeader*>(headerAddress);
     }
 
 #ifdef ANNOTATE_CONTIGUOUS_CONTAINER
     void setIsVectorBackingPage() { m_isVectorBackingPage = true; }
     bool isVectorBackingPage() const { return m_isVectorBackingPage; }
@@ skipping 159 matching lines @@
 
 class PLATFORM_EXPORT NormalPageHeap final : public BaseHeap {
 public:
     NormalPageHeap(ThreadState*, int);
     void addToFreeList(Address address, size_t size)
     {
         ASSERT(findPageFromAddress(address));
         ASSERT(findPageFromAddress(address + size - 1));
         m_freeList.addToFreeList(address, size);
     }
-    virtual void clearFreeLists() override;
+    void clearFreeLists() override;
 #if ENABLE(ASSERT)
-    virtual bool isConsistentForGC() override;
+    bool isConsistentForGC() override;
     bool pagesToBeSweptContains(Address);
 #endif
     void takeFreelistSnapshot(const String& dumpBaseName) override;
 #if ENABLE(GC_PROFILING)
     void snapshotFreeList(TracedValue&) override;
 #endif
 
     Address allocateObject(size_t allocationSize, size_t gcInfoIndex);
 
     void freePage(NormalPage*);
 
     bool coalesce();
     void promptlyFreeObject(HeapObjectHeader*);
     bool expandObject(HeapObjectHeader*, size_t);
     bool shrinkObject(HeapObjectHeader*, size_t);
     void decreasePromptlyFreedSize(size_t size) { m_promptlyFreedSize -= size; }
 
 private:
     void allocatePage();
-    virtual Address lazySweepPages(size_t, size_t gcInfoIndex) override;
+    Address lazySweepPages(size_t, size_t gcInfoIndex) override;
     Address outOfLineAllocate(size_t allocationSize, size_t gcInfoIndex);
     Address currentAllocationPoint() const { return m_currentAllocationPoint; }
     size_t remainingAllocationSize() const { return m_remainingAllocationSize; }
     bool hasCurrentAllocationArea() const { return currentAllocationPoint() && remainingAllocationSize(); }
     void setAllocationPoint(Address, size_t);
     void updateRemainingAllocationSize();
     Address allocateFromFreeList(size_t, size_t gcInfoIndex);
 
     FreeList m_freeList;
     Address m_currentAllocationPoint;
     size_t m_remainingAllocationSize;
     size_t m_lastRemainingAllocationSize;
 
     // The size of promptly freed objects in the heap.
     size_t m_promptlyFreedSize;
 
 #if ENABLE(GC_PROFILING)
     size_t m_cumulativeAllocationSize;
     size_t m_allocationCount;
     size_t m_inlineAllocationCount;
 #endif
 };
 
 class LargeObjectHeap final : public BaseHeap {
 public:
     LargeObjectHeap(ThreadState*, int);
     Address allocateLargeObjectPage(size_t, size_t gcInfoIndex);
     void freeLargeObjectPage(LargeObjectPage*);
 #if ENABLE(ASSERT)
-    virtual bool isConsistentForGC() override { return true; }
+    bool isConsistentForGC() override { return true; }
 #endif
 private:
     Address doAllocateLargeObjectPage(size_t, size_t gcInfoIndex);
-    virtual Address lazySweepPages(size_t, size_t gcInfoIndex) override;
+    Address lazySweepPages(size_t, size_t gcInfoIndex) override;
 };
 
 // Mask an address down to the enclosing oilpan heap base page.  All oilpan heap
 // pages are aligned at blinkPageBase plus an OS page size.
 // FIXME: Remove PLATFORM_EXPORT once we get a proper public interface to our
 // typed heaps.  This is only exported to enable tests in HeapTest.cpp.
 PLATFORM_EXPORT inline BasePage* pageFromObject(const void* object)
 {
     Address address = reinterpret_cast<Address>(const_cast<void*>(object));
     BasePage* page = reinterpret_cast<BasePage*>(blinkPageAddress(address) + WTF::kSystemPageSize);
@@ skipping 580 matching lines @@
     size_t copySize = previousHeader->payloadSize();
     if (copySize > size)
         copySize = size;
     memcpy(address, previous, copySize);
     return address;
 }
 
 } // namespace blink
 
 #endif // Heap_h