Oilpan: introduce eager finalization.

Source/core/events/EventTarget.h

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  *           (C) 2007, 2008 Nikolas Zimmermann <zimmermann@kde.org>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ skipping 178 matching lines @@
 // Base class for classes that wish to inherit from RefCountedGarbageCollected (in non-Oilpan world) and
 // EventTargetWithInlineData (in both worlds). For details about how to use this class template, see the comments for
 // EventTargetWithInlineData above.
 //
 // This class template exists to circumvent Oilpan's "leftmost class rule", where the Oilpan classes must come first in
 // the base class list to avoid memory offset adjustment. In non-Oilpan world, RefCountedGarbageCollected<T> must come
 // first, but in Oilpan world EventTargetWithInlineData needs to come first. This class templates does the required
 // #if-switch here, in order to avoid a lot of "#if ENABLE(OILPAN)"-s sprinkled in the derived classes.
 #if ENABLE(OILPAN)
 template <typename T>
-class RefCountedGarbageCollectedEventTargetWithInlineData : public EventTargetWithInlineData { };
+class RefCountedGarbageCollectedEventTargetWithInlineData : public EventTargetWithInlineData {
+public:
+    GC_PLUGIN_IGNORE("491488")
+    void* operator new(size_t size)

[haraken, 2015/06/01 08:42:52]

I'm OK with this approach, but it's error-prone that we sometimes have to
override 'new' to allocate objects on the eager sweep heap as intended. We
should have a verification system for this.

- One way to do this would be to use a GC plugin, as you suggested.

- Another way would be to do the verification at runtime, like this:

#define EAGERLY_FINALIZE() \
  EagerlySweptDestructor m_destructor;

class EagerlySweptDestructor {
  ~EagerlySweptDestructor() {
    ASSERT(isSweepingEagerHeap());
  }
};

- Having both verifications sounds much better :)

[haraken, 2015/06/01 09:12:58]

You can implement the verirication(s) in a follow-up even if you want.

[sof, 2015/06/01 14:51:36]

Will followup, at least for the latter one.

+    {
+        // If T is eagerly finalized, it needs to be allocated accordingly.
+        // Redefinition of the operator is needed to accomplish that, as otherwise
+        // it would be allocated using GarbageCollected<EventTarget>'s operator new.
+        // EventTarget is not eagerly finalized.
+        return allocateObject(size, IsEagerlyFinalizedType<T>::value);
+    }
+};
 #else
 template <typename T>
 class RefCountedGarbageCollectedEventTargetWithInlineData : public RefCountedGarbageCollected<T>, public EventTargetWithInlineData {
 public:
     DEFINE_INLINE_VIRTUAL_TRACE() { EventTargetWithInlineData::trace(visitor); }
 };
 #endif
 
 // FIXME: These macros should be split into separate DEFINE and DECLARE
 // macros to avoid causing so many header includes.
@@ skipping 85 matching lines @@
 #define DEFINE_EVENT_TARGET_REFCOUNTING_WILL_BE_REMOVED(baseClass) DEFINE_EVENT_TARGET_REFCOUNTING(baseClass)
 
 #endif // ENABLE(OILPAN)
 
 // Use this macro if your EventTarget subclass is also a subclass of WTF::RefCounted.
 // A ref-counted class that uses a different method of refcounting should use DEFINE_EVENT_TARGET_REFCOUNTING directly.
 // Both of these macros are meant to be placed just before the "public:" section of the class declaration.
 #define REFCOUNTED_EVENT_TARGET(className) DEFINE_EVENT_TARGET_REFCOUNTING_WILL_BE_REMOVED(RefCounted<className>)
 
 #endif // EventTarget_h