Replacing the OVERRIDE with override in third_party/WebKit/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 214 matching lines @@
 };
 
 static void getHeapStats(HeapStats* stats)
 {
     TestGCScope scope(ThreadState::NoHeapPointersOnStack);
     EXPECT_TRUE(scope.allThreadsParked());
     Heap::getStats(stats);
 }
 
 #define DEFINE_VISITOR_METHODS(Type)                                       \
-    virtual void mark(const Type* object, TraceCallback callback) OVERRIDE \
+    virtual void mark(const Type* object, TraceCallback callback) override \
     {                                                                      \
         if (object)                                                        \
             m_count++;                                                     \
     }                                                                      \
-    virtual bool isMarked(const Type*) OVERRIDE { return false; }
+    virtual bool isMarked(const Type*) override { return false; }
 
 class CountingVisitor : public Visitor {
 public:
     CountingVisitor()
         : m_count(0)
     {
     }
 
-    virtual void mark(const void* object, TraceCallback) OVERRIDE
+    virtual void mark(const void* object, TraceCallback) override
     {
         if (object)
             m_count++;
     }
 
-    virtual void mark(HeapObjectHeader* header, TraceCallback callback) OVERRIDE
+    virtual void mark(HeapObjectHeader* header, TraceCallback callback) override
     {
         ASSERT(header->payload());
         m_count++;
     }
 
-    virtual void mark(FinalizedHeapObjectHeader* header, TraceCallback callback) OVERRIDE
+    virtual void mark(FinalizedHeapObjectHeader* header, TraceCallback callback) override
     {
         ASSERT(header->payload());
         m_count++;
     }
 
-    virtual void registerDelayedMarkNoTracing(const void*) OVERRIDE { }
-    virtual void registerWeakMembers(const void*, const void*, WeakPointerCallback) OVERRIDE { }
-    virtual void registerWeakTable(const void*, EphemeronCallback, EphemeronCallback) OVERRIDE { }
+    virtual void registerDelayedMarkNoTracing(const void*) override { }
+    virtual void registerWeakMembers(const void*, const void*, WeakPointerCallback) override { }
+    virtual void registerWeakTable(const void*, EphemeronCallback, EphemeronCallback) override { }
 #if ENABLE(ASSERT)
-    virtual bool weakTableRegistered(const void*) OVERRIDE { return false; }
+    virtual bool weakTableRegistered(const void*) override { return false; }
 #endif
-    virtual void registerWeakCell(void**, WeakPointerCallback) OVERRIDE { }
-    virtual bool isMarked(const void*) OVERRIDE { return false; }
+    virtual void registerWeakCell(void**, WeakPointerCallback) override { }
+    virtual bool isMarked(const void*) override { return false; }
 
     FOR_EACH_TYPED_HEAP(DEFINE_VISITOR_METHODS)
 
     size_t count() { return m_count; }
     void reset() { m_count = 0; }
 
 private:
     size_t m_count;
 };
 
@@ skipping 174 matching lines @@
 };
 
 class ThreadedHeapTester : public ThreadedTesterBase {
 public:
     static void test()
     {
         ThreadedTesterBase::test(new ThreadedHeapTester);
     }
 
 protected:
-    virtual void runThread() OVERRIDE
+    virtual void runThread() override
     {
         ThreadState::attach();
 
         int gcCount = 0;
         while (!done()) {
             ThreadState::current()->safePoint(ThreadState::NoHeapPointersOnStack);
             {
                 Persistent<IntWrapper> wrapper;
 
                 typedef Persistent<IntWrapper, GlobalPersistents> GlobalIntWrapperPersistent;
@@ skipping 27 matching lines @@
 };
 
 class ThreadedWeaknessTester : public ThreadedTesterBase {
 public:
     static void test()
     {
         ThreadedTesterBase::test(new ThreadedWeaknessTester);
     }
 
 private:
-    virtual void runThread() OVERRIDE
+    virtual 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 183 matching lines @@
     static Foo* create(Bar* bar)
     {
         return new Foo(bar);
     }
 
     static Foo* create(Foo* foo)
     {
         return new Foo(foo);
     }
 
-    virtual void trace(Visitor* visitor) OVERRIDE
+    virtual void trace(Visitor* visitor) override
     {
         if (m_pointsToFoo)
             visitor->mark(static_cast<Foo*>(m_bar));
         else
             visitor->mark(m_bar);
     }
 
 private:
     Foo(Bar* bar)
         : Bar()
@@ skipping 13 matching lines @@
     bool m_pointsToFoo;
 };
 
 class Bars : public Bar {
 public:
     static Bars* create()
     {
         return new Bars();
     }
 
-    virtual void trace(Visitor* visitor) OVERRIDE
+    virtual void trace(Visitor* visitor) override
     {
         for (unsigned i = 0; i < m_width; i++)
             visitor->trace(m_bars[i]);
     }
 
     unsigned getWidth() const
     {
         return m_width;
     }
 
@@ skipping 101 matching lines @@
 
 private:
     RefCountedAndGarbageCollected2()
     {
     }
 };
 
 int RefCountedAndGarbageCollected2::s_destructorCalls = 0;
 
 #define DEFINE_VISITOR_METHODS(Type)                                       \
-    virtual void mark(const Type* object, TraceCallback callback) OVERRIDE \
+    virtual 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
+    virtual void mark(const void* ptr, TraceCallback) override
     {
         mark(ptr);
     }
 
-    virtual void mark(HeapObjectHeader* header, TraceCallback callback) OVERRIDE
+    virtual void mark(HeapObjectHeader* header, TraceCallback callback) override
     {
         mark(header->payload());
     }
 
-    virtual void mark(FinalizedHeapObjectHeader* header, TraceCallback callback) OVERRIDE
+    virtual void mark(FinalizedHeapObjectHeader* header, TraceCallback callback) override
     {
         mark(header->payload());
     }
 
     bool validate() { return m_count >= m_expectedCount; }
     void reset() { m_count = 0; }
 
     FOR_EACH_TYPED_HEAP(DEFINE_VISITOR_METHODS)
 
 private:
@@ skipping 13 matching lines @@
 
 #undef DEFINE_VISITOR_METHODS
 
 class Weak : public Bar {
 public:
     static Weak* create(Bar* strong, Bar* weak)
     {
         return new Weak(strong, weak);
     }
 
-    virtual void trace(Visitor* visitor) OVERRIDE
+    virtual void trace(Visitor* visitor) override
     {
         visitor->trace(m_strongBar);
         visitor->registerWeakMembers(this, zapWeakMembers);
     }
 
     static void zapWeakMembers(Visitor* visitor, void* self)
     {
         reinterpret_cast<Weak*>(self)->zapWeakMembers(visitor);
     }
 
@@ skipping 18 matching lines @@
     Bar* m_weakBar;
 };
 
 class WithWeakMember : public Bar {
 public:
     static WithWeakMember* create(Bar* strong, Bar* weak)
     {
         return new WithWeakMember(strong, weak);
     }
 
-    virtual void trace(Visitor* visitor) OVERRIDE
+    virtual void trace(Visitor* visitor) override
     {
         visitor->trace(m_strongBar);
         visitor->trace(m_weakBar);
     }
 
     bool strongIsThere() { return !!m_strongBar; }
     bool weakIsThere() { return !!m_weakBar; }
 
 private:
     WithWeakMember(Bar* strongBar, Bar* weakBar)
@@ skipping 4397 matching lines @@
 TEST(HeapTest, NonNodeAllocatingNodeInDestructor)
 {
     new NonNodeAllocatingNodeInDestructor();
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(10, (*NonNodeAllocatingNodeInDestructor::s_node)->value());
     delete NonNodeAllocatingNodeInDestructor::s_node;
     NonNodeAllocatingNodeInDestructor::s_node = 0;
 }
 
 } // namespace blink