Oilpan: Move the EventListener hierarchy to Oilpan's heap

Source/core/events/EventTarget.h

Index: Source/core/events/EventTarget.h
diff --git a/Source/core/events/EventTarget.h b/Source/core/events/EventTarget.h
index 423015163d4b1137aea235cd58d5d82c78ab57b9..bca1c6ca6a5c4cbdaa9567e750d084ba2a20da83 100644
--- a/Source/core/events/EventTarget.h
+++ b/Source/core/events/EventTarget.h
@@ -63,12 +63,15 @@ struct FiringEventIterator {
 };
 typedef Vector<FiringEventIterator, 1> FiringEventIteratorVector;
 
-struct CORE_EXPORT EventTargetData {
-    WTF_MAKE_NONCOPYABLE(EventTargetData); WTF_MAKE_FAST_ALLOCATED(EventTargetData);
+class CORE_EXPORT EventTargetData final : public NoBaseWillBeGarbageCollectedFinalized<EventTargetData> {
+    WTF_MAKE_NONCOPYABLE(EventTargetData);
+    WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED(EventTargetData);
 public:
     EventTargetData();
     ~EventTargetData();
 
+    DECLARE_TRACE();
+
     EventListenerMap eventListenerMap;
     OwnPtr<FiringEventIteratorVector> firingEventIterators;
 };
@@ -122,8 +125,8 @@ public:
     virtual LocalDOMWindow* toDOMWindow();
     virtual MessagePort* toMessagePort();
 
-    virtual bool addEventListener(const AtomicString& eventType, PassRefPtr<EventListener>, bool useCapture);
-    virtual bool removeEventListener(const AtomicString& eventType, PassRefPtr<EventListener>, bool useCapture);
+    virtual bool addEventListener(const AtomicString& eventType, PassRefPtrWillBeRawPtr<EventListener>, bool useCapture);
+    virtual bool removeEventListener(const AtomicString& eventType, PassRefPtrWillBeRawPtr<EventListener>, bool useCapture);
     virtual void removeAllEventListeners();
 
     bool dispatchEvent(PassRefPtrWillBeRawPtr<Event>);
@@ -135,13 +138,13 @@ public:
     virtual void uncaughtExceptionInEventHandler();
 
     // Used for legacy "onEvent" attribute APIs.
-    bool setAttributeEventListener(const AtomicString& eventType, PassRefPtr<EventListener>);
+    bool setAttributeEventListener(const AtomicString& eventType, PassRefPtrWillBeRawPtr<EventListener>);
     EventListener* getAttributeEventListener(const AtomicString& eventType);
 
     bool hasEventListeners() const;
     bool hasEventListeners(const AtomicString& eventType) const;
     bool hasCapturingEventListeners(const AtomicString& eventType);
-    const EventListenerVector& getEventListeners(const AtomicString& eventType);
+    EventListenerVector* getEventListeners(const AtomicString& eventType);
     Vector<AtomicString> eventTypes();
 
     bool fireEventListeners(Event*);
@@ -175,10 +178,22 @@ private:
     friend class EventListenerIterator;
 };
 
-class CORE_EXPORT EventTargetWithInlineData : public EventTarget {
+// EventTargetData is a GCed object, so it should not be used as a part of
+// object. However, we intentionally use it as a part of object for performance,
+// assuming that no one extracts a pointer of
+// EventTargetWithInlineData::m_eventTargetData and store it to a Member etc.
+class GC_PLUGIN_IGNORE("513199") CORE_EXPORT EventTargetWithInlineData : public EventTarget {
+public:
+    DEFINE_INLINE_VIRTUAL_TRACE()
+    {
+        visitor->trace(m_eventTargetData);
+        EventTarget::trace(visitor);
+    }
+
 protected:
     EventTargetData* eventTargetData() final { return &m_eventTargetData; }
     EventTargetData& ensureEventTargetData() final { return m_eventTargetData; }
+
 private:
     EventTargetData m_eventTargetData;
 };
@@ -204,6 +219,11 @@ public:
         // EventTarget is not eagerly finalized.
         return allocateObject(size, IsEagerlyFinalizedType<T>::value);
     }
+
+    DEFINE_INLINE_VIRTUAL_TRACE()
+    {
+        EventTargetWithInlineData::trace(visitor);
+    }
 };
 #else
 template <typename T>
@@ -217,15 +237,15 @@ public:
 // macros to avoid causing so many header includes.
 #define DEFINE_ATTRIBUTE_EVENT_LISTENER(attribute) \
     EventListener* on##attribute() { return getAttributeEventListener(EventTypeNames::attribute); } \
-    void setOn##attribute(PassRefPtr<EventListener> listener) { setAttributeEventListener(EventTypeNames::attribute, listener); } \
+    void setOn##attribute(PassRefPtrWillBeRawPtr<EventListener> listener) { setAttributeEventListener(EventTypeNames::attribute, listener); } \
 
 #define DEFINE_STATIC_ATTRIBUTE_EVENT_LISTENER(attribute) \
     static EventListener* on##attribute(EventTarget& eventTarget) { return eventTarget.getAttributeEventListener(EventTypeNames::attribute); } \
-    static void setOn##attribute(EventTarget& eventTarget, PassRefPtr<EventListener> listener) { eventTarget.setAttributeEventListener(EventTypeNames::attribute, listener); } \
+    static void setOn##attribute(EventTarget& eventTarget, PassRefPtrWillBeRawPtr<EventListener> listener) { eventTarget.setAttributeEventListener(EventTypeNames::attribute, listener); } \
 
 #define DEFINE_WINDOW_ATTRIBUTE_EVENT_LISTENER(attribute) \
     EventListener* on##attribute() { return document().getWindowAttributeEventListener(EventTypeNames::attribute); } \
-    void setOn##attribute(PassRefPtr<EventListener> listener) { document().setWindowAttributeEventListener(EventTypeNames::attribute, listener); } \
+    void setOn##attribute(PassRefPtrWillBeRawPtr<EventListener> listener) { document().setWindowAttributeEventListener(EventTypeNames::attribute, listener); } \
 
 #define DEFINE_STATIC_WINDOW_ATTRIBUTE_EVENT_LISTENER(attribute) \
     static EventListener* on##attribute(EventTarget& eventTarget) { \
@@ -234,7 +254,7 @@ public:
         ASSERT(eventTarget.toDOMWindow()); \
         return eventTarget.getAttributeEventListener(EventTypeNames::attribute); \
     } \
-    static void setOn##attribute(EventTarget& eventTarget, PassRefPtr<EventListener> listener) { \
+    static void setOn##attribute(EventTarget& eventTarget, PassRefPtrWillBeRawPtr<EventListener> listener) { \
         if (Node* node = eventTarget.toNode()) \
             node->document().setWindowAttributeEventListener(EventTypeNames::attribute, listener); \
         else { \
@@ -245,15 +265,15 @@ public:
 
 #define DEFINE_MAPPED_ATTRIBUTE_EVENT_LISTENER(attribute, eventName) \
     EventListener* on##attribute() { return getAttributeEventListener(EventTypeNames::eventName); } \
-    void setOn##attribute(PassRefPtr<EventListener> listener) { setAttributeEventListener(EventTypeNames::eventName, listener); } \
+    void setOn##attribute(PassRefPtrWillBeRawPtr<EventListener> listener) { setAttributeEventListener(EventTypeNames::eventName, listener); } \
 
 #define DECLARE_FORWARDING_ATTRIBUTE_EVENT_LISTENER(recipient, attribute) \
     EventListener* on##attribute(); \
-    void setOn##attribute(PassRefPtr<EventListener> listener);
+    void setOn##attribute(PassRefPtrWillBeRawPtr<EventListener> listener);
 
 #define DEFINE_FORWARDING_ATTRIBUTE_EVENT_LISTENER(type, recipient, attribute) \
     EventListener* type::on##attribute() { return recipient ? recipient->getAttributeEventListener(EventTypeNames::attribute) : 0; } \
-    void type::setOn##attribute(PassRefPtr<EventListener> listener) \
+    void type::setOn##attribute(PassRefPtrWillBeRawPtr<EventListener> listener) \
     { \
         if (recipient) \
             recipient->setAttributeEventListener(EventTypeNames::attribute, listener); \