[oilpan] Add checks to new operator

Source/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 424 matching lines @@
 // Forward declaration.
 template<typename T> class Persistent;
 
 // Base class for the transition period. Provides new and delete
 // operators for allocation on the heap as well as finalization
 // behavior.
 template<typename T>
 class HeapAllocatedFinalized : public HeapAllocated<T> {
     WTF_MAKE_NONCOPYABLE(HeapAllocatedFinalized);
 
+    // If this assert fails then you are inheriting this method instead of

[Mads Ager (chromium), 2013/06/11 06:42:43]

This comment seems to belong on the inherited new operator in the public section
below. Then this macro should have a comment about when to use it similar to the
one for OVERRIDE_NEW_ALL_SUBCLASSES_HAVE_DYNAMIC_ACCEPT.

+    // overriding it. This may be an issue because the inherited class
+    // specialization (T) is used to find the finalizer. This may mean that the
+    // wrong method is used in the allocateFinalized specialization below and
+    // the wrong accept method may be used to visit the method if there is a GC
+    // before the new object has been adopted.
+#define OVERRIDE_NEW(subClass)                                          \
+    void* operator new(size_t size)                                     \
+    {                                                                   \
+        ASSERT(size == sizeof(class subClass));                         \
+        return Heap::allocateFinalized<subClass>(size);                 \
+    }
+
+// Only use this for classes where we know that accept(Visitor*) is dynamic,
+// ie. it is virtual or uses a type field that is immediately initialized
+// in the constuctors. Similarly the finalizer must be the same for all
+// subclasses.
+#define OVERRIDE_NEW_ALL_SUBCLASSES_HAVE_DYNAMIC_ACCEPT(subClass)       \
+    void* operator new(size_t size)                                     \
+    {                                                                   \
+        return Heap::allocateFinalized<subClass>(size);                 \
+    }
+
 public:
     // Override new to pass the finalizer.
     void* operator new(size_t size)
     {
+        // If this assert fails you probably need to use OVERRIDE_NEW
+        // (see above).
+        ASSERT(size == sizeof(T));
         return Heap::allocateFinalized<T>(size);
     }
 
     // Finalize is called when the object is freed from the heap. Finalize
     // can be overridden to support calling the destructor of a subclass.
     // This is similar to the way deref is overridden to call delete on
     // the correct subtype.
     void finalize()
     {
         static_cast<T*>(this)->~T();
@@ skipping 152 matching lines @@
     // You can't mark an object that isn't in the heap.
     ASSERT(contains(header));
     // End of object should also be in the heap.
     ASSERT(contains(header->payloadEnd() - 1));
     header->mark();
 }
 
 } // namespace WebCore
 
 #endif