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

Source/platform/heap/HeapTest.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 244 matching lines @@
             ThreadState::resumeThreads();
         }
     }
 
 private:
     ThreadState* m_state;
     SafePointScope m_safePointScope;
     bool m_parkedAllThreads; // False if we fail to park all threads
 };
 
-#define DEFINE_VISITOR_METHODS(Type)                                       \
-    virtual void mark(const Type* object, TraceCallback callback) override \
-    {                                                                      \
-        if (object)                                                        \
-            m_count++;                                                     \
-    }                                                                      \
-    virtual bool isMarked(const Type*) override { return false; }          \
-    virtual bool ensureMarked(const Type* objectPointer) override          \
-    {                                                                      \
-        return ensureMarked(objectPointer);                                \
+#define DEFINE_VISITOR_METHODS(Type)                               \
+    void mark(const Type* object, TraceCallback callback) override \
+    {                                                              \
+        if (object)                                                \
+            m_count++;                                             \
+    }                                                              \
+    bool isMarked(const Type*) override { return false; }          \
+    bool ensureMarked(const Type* objectPointer) override          \
+    {                                                              \
+        return ensureMarked(objectPointer);                        \
     }
 
 class CountingVisitor : public Visitor {
 public:
     CountingVisitor()
         : Visitor(Visitor::ThreadLocalMarking)
         , m_count(0)
     {
     }
 
-    virtual void mark(const void* object, TraceCallback) override
+    void mark(const void* object, TraceCallback) override
     {
         if (object)
             m_count++;
     }
 
-    virtual void markHeader(HeapObjectHeader* header, TraceCallback callback) override
+    void markHeader(HeapObjectHeader* header, TraceCallback callback) override
     {
         ASSERT(header->payload());
         m_count++;
     }
 
-    virtual void registerDelayedMarkNoTracing(const void*) override { }
-    virtual void registerWeakMembers(const void*, const void*, WeakCallback) override { }
-    virtual void registerWeakTable(const void*, EphemeronCallback, EphemeronCallback) override { }
+    void registerDelayedMarkNoTracing(const void*) override { }
+    void registerWeakMembers(const void*, const void*, WeakCallback) override { }
+    void registerWeakTable(const void*, EphemeronCallback, EphemeronCallback) override { }
 #if ENABLE(ASSERT)
-    virtual bool weakTableRegistered(const void*) override { return false; }
+    bool weakTableRegistered(const void*) override { return false; }
 #endif
-    virtual void registerWeakCellWithCallback(void**, WeakCallback) override { }
-    virtual bool ensureMarked(const void* objectPointer) override
+    void registerWeakCellWithCallback(void**, WeakCallback) override { }
+    bool ensureMarked(const void* objectPointer) override
     {
         if (!objectPointer || HeapObjectHeader::fromPayload(objectPointer)->isMarked())
             return false;
         markNoTracing(objectPointer);
         return true;
     }
 
     size_t count() { return m_count; }
     void reset() { m_count = 0; }
 
@@ skipping 49 matching lines @@
 
 static const size_t classMagic = 0xABCDDBCA;
 
 class HeapTestSubClass : public HeapTestOtherSuperClass, public HeapTestSuperClass {
 public:
     static HeapTestSubClass* create()
     {
         return new HeapTestSubClass();
     }
 
-    virtual ~HeapTestSubClass()
+    ~HeapTestSubClass() override
     {
         EXPECT_EQ(classMagic, m_magic);
         ++s_destructorCalls;
     }
 
     static int s_destructorCalls;
 
 private:
 
     HeapTestSubClass() : m_magic(classMagic) { }
@@ skipping 107 matching lines @@
 };
 
 class ThreadedHeapTester : public ThreadedTesterBase {
 public:
     static void test()
     {
         ThreadedTesterBase::test(new ThreadedHeapTester);
     }
 
 protected:
-    virtual void runThread() override
+    void runThread() override
     {
         ThreadState::attach();
 
         int gcCount = 0;
         while (!done()) {
             ThreadState::current()->safePoint(ThreadState::NoHeapPointersOnStack);
             {
                 Persistent<IntWrapper> wrapper;
 
                 typedef CrossThreadPersistent<IntWrapper> GlobalIntWrapperPersistent;
@@ skipping 31 matching lines @@
 };
 
 class ThreadedWeaknessTester : public ThreadedTesterBase {
 public:
     static void test()
     {
         ThreadedTesterBase::test(new ThreadedWeaknessTester);
     }
 
 private:
-    virtual void runThread() override
+    void runThread() override
     {
         ThreadState::attach();
 
         int gcCount = 0;
         while (!done()) {
             ThreadState::current()->safePoint(ThreadState::NoHeapPointersOnStack);
             {
                 Persistent<HeapHashMap<ThreadMarker, WeakMember<IntWrapper>>> weakMap = new HeapHashMap<ThreadMarker, WeakMember<IntWrapper>>;
                 PersistentHeapHashMap<ThreadMarker, WeakMember<IntWrapper>> weakMap2;
 
@@ skipping 73 matching lines @@
 
     private:
         explicit PersistentChain(int count)
         {
             m_refCountedChain = adoptRef(RefCountedChain::create(count));
         }
 
         RefPtr<RefCountedChain> m_refCountedChain;
     };
 
-    virtual void runThread() override
+    void runThread() override
     {
         ThreadState::attach();
 
         PersistentChain::create(100);
 
         // Upon thread detach, GCs will run until all persistents have been
         // released. We verify that the draining of persistents proceeds
         // as expected by dropping one Persistent<> per GC until there
         // are none left.
         ThreadState::detach();
@@ skipping 338 matching lines @@
     static int s_destructorCalls;
 
 private:
     RefCountedAndGarbageCollected2()
     {
     }
 };
 
 int RefCountedAndGarbageCollected2::s_destructorCalls = 0;
 
-#define DEFINE_VISITOR_METHODS(Type)                                       \
-    virtual void mark(const Type* object, TraceCallback callback) override \
-    {                                                                      \
-        mark(object);                                                      \
-    }                                                                      \
+#define DEFINE_VISITOR_METHODS(Type)                               \
+    void mark(const Type* object, TraceCallback callback) override \
+    {                                                              \
+        mark(object);                                              \
+    }                                                              \
 
 class RefCountedGarbageCollectedVisitor : public CountingVisitor {
 public:
     RefCountedGarbageCollectedVisitor(int expected, void** objects)
         : m_count(0)
         , m_expectedCount(expected)
         , m_expectedObjects(objects)
     {
     }
 
     void mark(const void* ptr) { markNoTrace(ptr); }
 
     virtual void markNoTrace(const void* ptr)
     {
         if (!ptr)
             return;
         if (m_count < m_expectedCount)
             EXPECT_TRUE(expectedObject(ptr));
         else
             EXPECT_FALSE(expectedObject(ptr));
         m_count++;
     }
 
-    virtual void mark(const void* ptr, TraceCallback) override
+    void mark(const void* ptr, TraceCallback) override
     {
         mark(ptr);
     }
 
-    virtual void markHeader(HeapObjectHeader* header, TraceCallback callback) override
+    void markHeader(HeapObjectHeader* header, TraceCallback callback) override
     {
         mark(header->payload());
     }
 
     bool validate() { return m_count >= m_expectedCount; }
     void reset() { m_count = 0; }
 
 private:
     bool expectedObject(const void* ptr)
     {
@@ skipping 378 matching lines @@
 
 int SubData::s_aliveCount = 0;
 
 class SubClass : public SuperClass {
 public:
     static PassRefPtrWillBeRawPtr<SubClass> create(PassRefPtrWillBeRawPtr<PointsBack> pointsBack)
     {
         return adoptRefWillBeNoop(new SubClass(pointsBack));
     }
 
-    virtual ~SubClass()
+    ~SubClass() override
     {
         --s_aliveCount;
     }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         visitor->trace(m_data);
         SuperClass::trace(visitor);
     }
 
@@ skipping 549 matching lines @@
     SimpleFinalizedEagerObjectBase() { }
 };
 
 class SimpleFinalizedEagerObject : public SimpleFinalizedEagerObjectBase {
 public:
     static SimpleFinalizedEagerObject* create()
     {
         return new SimpleFinalizedEagerObject();
     }
 
-    virtual ~SimpleFinalizedEagerObject()
+    ~SimpleFinalizedEagerObject() override
     {
         ++s_destructorCalls;
     }
 
     static int s_destructorCalls;
 private:
     SimpleFinalizedEagerObject() { }
 };
 
 template<typename T>
@@ skipping 4259 matching lines @@
 {
     Persistent<ClassWithMember> object = ClassWithMember::create();
     EXPECT_EQ(0, object->traceCount());
     TestMixinAllocatingObject* mixin = TestMixinAllocatingObject::create(object.get());
     EXPECT_TRUE(mixin);
     EXPECT_GT(object->traceCount(), 0);
     EXPECT_GT(mixin->traceCount(), 0);
 }
 
 } // namespace blink