Update heap/ classes to use OVERRIDE / FINAL when needed

Source/heap/Heap.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 1172 matching lines @@
     {
         ASSERT(header);
         ASSERT(objectPointer);
         if (header->isMarked())
             return;
         header->mark();
         if (callback)
             Heap::pushTraceCallback(const_cast<void*>(objectPointer), callback);
     }
 
-    virtual void mark(HeapObjectHeader* header, TraceCallback callback)
+    virtual void mark(HeapObjectHeader* header, TraceCallback callback) OVERRIDE
     {
         // We need both the HeapObjectHeader and FinalizedHeapObjectHeader
         // version to correctly find the payload.
         visitHeader(header, header->payload(), callback);
     }
 
-    virtual void mark(FinalizedHeapObjectHeader* header, TraceCallback callback)
+    virtual void mark(FinalizedHeapObjectHeader* header, TraceCallback callback) OVERRIDE
     {
         // We need both the HeapObjectHeader and FinalizedHeapObjectHeader
         // version to correctly find the payload.
         visitHeader(header, header->payload(), callback);
     }
 
-    virtual void mark(const void* objectPointer, TraceCallback callback)
+    virtual void mark(const void* objectPointer, TraceCallback callback) OVERRIDE
     {
         if (!objectPointer)
             return;
         FinalizedHeapObjectHeader* header = FinalizedHeapObjectHeader::fromPayload(objectPointer);
         visitHeader(header, header->payload(), callback);
     }
 
-    virtual void registerWeakMembers(const void* containingObject, WeakPointerCallback callback)
+    virtual void registerWeakMembers(const void* containingObject, WeakPointerCallback callback) OVERRIDE
     {
         Heap::pushWeakPointerCallback(const_cast<void*>(containingObject), callback);
     }
 
-    virtual bool isMarked(const void* objectPointer)
+    virtual bool isMarked(const void* objectPointer) OVERRIDE
     {
         return FinalizedHeapObjectHeader::fromPayload(objectPointer)->isMarked();
     }
 
     // This macro defines the necessary visitor methods for typed heaps
-#define DEFINE_VISITOR_METHODS(Type)                                     \
-    virtual void mark(const Type* objectPointer, TraceCallback callback) \
-    {                                                                    \
-        if (!objectPointer)                                              \
-            return;                                                      \
-        HeapObjectHeader* header =                                       \
-            HeapObjectHeader::fromPayload(objectPointer);                \
-        visitHeader(header, header->payload(), callback);                \
-    }                                                                    \
-    virtual bool isMarked(const Type* objectPointer)                     \
-    {                                                                    \
-        return HeapObjectHeader::fromPayload(objectPointer)->isMarked(); \
+#define DEFINE_VISITOR_METHODS(Type)                                              \
+    virtual void mark(const Type* objectPointer, TraceCallback callback) OVERRIDE \
+    {                                                                             \
+        if (!objectPointer)                                                       \
+            return;                                                               \
+        HeapObjectHeader* header =                                                \
+            HeapObjectHeader::fromPayload(objectPointer);                         \
+        visitHeader(header, header->payload(), callback);                         \
+    }                                                                             \
+    virtual bool isMarked(const Type* objectPointer) OVERRIDE                     \
+    {                                                                             \
+        return HeapObjectHeader::fromPayload(objectPointer)->isMarked();          \
     }
 
     FOR_EACH_TYPED_HEAP(DEFINE_VISITOR_METHODS)
 #undef DEFINE_VISITOR_METHODS
 };
 
 void Heap::init()
 {
     ThreadState::init();
     CallbackStack::init(&s_markingStack);
@@ skipping 118 matching lines @@
 
 // Force template instantiations for the types that we need.
 template class HeapPage<FinalizedHeapObjectHeader>;
 template class HeapPage<HeapObjectHeader>;
 template class ThreadHeap<FinalizedHeapObjectHeader>;
 template class ThreadHeap<HeapObjectHeader>;
 
 CallbackStack* Heap::s_markingStack;
 CallbackStack* Heap::s_weakCallbackStack;
 }