Oilpan: add assert to verify eager finalization.

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 1110 matching lines @@
         return NormalPage3HeapIndex;
     return NormalPage4HeapIndex;
 }
 
 inline bool Heap::isNormalHeapIndex(int index)
 {
     return index >= NormalPage1HeapIndex && index <= NormalPage4HeapIndex;
 }
 
 #if ENABLE_LAZY_SWEEPING
+#define DECLARE_EAGER_FINALIZATION_OPERATOR_NEW() \
+public:                                           \
+    GC_PLUGIN_IGNORE("491488")                    \
+    void* operator new(size_t size)               \
+    {                                             \
+        return allocateObject(size, true);        \
+    }
+#define EAGERLY_FINALIZE_WILL_BE_REMOVED()
+#if ENABLE(ASSERT)
+class VerifyEagerFinalization {
+public:
+    ~VerifyEagerFinalization()
+    {
+        // If this assert triggers, the class annotated as eagerly
+        // finalized ended up not being allocated on the heap
+        // set aside for eager finalization. The reason is most
+        // likely that the effective 'operator new' overload for
+        // this class' leftmost base is for a class that is not
+        // eagerly finalized. Declaring and defining an 'operator new'
+        // for this class is what's required -- consider using
+        // DECLARE_EAGER_FINALIZATION_OPERATOR_NEW().
+        ASSERT(ThreadState::current()->isEagerlySweeping());

[haraken, 2015/06/03 03:52:35]

Instead of introducing isEagerlySweeping(), you might want to check that the
index of the heap page that this object belongs to is EagerHeapPageIndex.

[sof, 2015/06/03 11:35:16]

That gets us there also and with less noise; done.

+    }
+};
+#define EAGERLY_FINALIZE()                             \
+private:                                               \
+    VerifyEagerFinalization m_verifyEagerFinalization; \
+public:                                                \
+    typedef int IsEagerlyFinalizedMarker
+#else
 #define EAGERLY_FINALIZE() typedef int IsEagerlyFinalizedMarker
-#define EAGERLY_FINALIZE_WILL_BE_REMOVED()
+#endif
 #else
+#define DECLARE_EAGER_FINALIZATION_OPERATOR_NEW()
 #define EAGERLY_FINALIZE()
 // TODO(Oilpan): define in terms of Oilpan's EAGERLY_FINALIZE() once lazy
 // sweeping is enabled non-Oilpan.
 #define EAGERLY_FINALIZE_WILL_BE_REMOVED()
 #endif
 
 NO_SANITIZE_ADDRESS inline
 size_t HeapObjectHeader::size() const
 {
     size_t result = m_encoded & headerSizeMask;
@@ skipping 152 matching lines @@
     size_t copySize = previousHeader->payloadSize();
     if (copySize > size)
         copySize = size;
     memcpy(address, previous, copySize);
     return address;
 }
 
 } // namespace blink
 
 #endif // Heap_h