Oilpan: Move the EventListener hierarchy to Oilpan's heap

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 45 matching lines @@
         , end(end)
     {
     }
 
     const AtomicString& eventType;
     size_t& iterator;
     size_t& end;
 };
 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;
 };
 
 // This is the base class for all DOM event targets. To make your class an
 // EventTarget, follow these steps:
 // - Make your IDL interface inherit from EventTarget.
 //   Optionally add "attribute EventHandler onfoo;" attributes.
 // - Inherit from EventTargetWithInlineData (only in rare cases should you use
 //   EventTarget directly); or, if you want YourClass to be inherited from
@@ skipping 33 matching lines @@
     void deref() { derefEventTarget(); }
 #endif
 
     virtual const AtomicString& interfaceName() const = 0;
     virtual ExecutionContext* executionContext() const = 0;
 
     virtual Node* toNode();
     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>);
 
     // dispatchEventForBindings is intended to only be called from
     // javascript originated calls. This method will validate and may adjust
     // the Event object before dispatching.
     bool dispatchEventForBindings(PassRefPtrWillBeRawPtr<Event>, ExceptionState&);
     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*);
 
     DEFINE_INLINE_VIRTUAL_TRACE() { }
 
     virtual bool keepEventInNode(Event*) { return false; }
 
 protected:
     EventTarget();
@@ skipping 13 matching lines @@
 
     LocalDOMWindow* executingWindow();
     void fireEventListeners(Event*, EventTargetData*, EventListenerVector&);
     void countLegacyEvents(const AtomicString& legacyTypeName, EventListenerVector*, EventListenerVector*);
 
     bool clearAttributeEventListener(const AtomicString& eventType);
 
     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;
 };
 
 // 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 {
 public:
     GC_PLUGIN_IGNORE("491488")
     void* operator new(size_t size)
     {
         // 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);
     }
+
+    DEFINE_INLINE_VIRTUAL_TRACE()
+    {
+        EventTargetWithInlineData::trace(visitor);
+    }
 };
 #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.
 #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) { \
         if (Node* node = eventTarget.toNode()) \
             return node->document().getWindowAttributeEventListener(EventTypeNames::attribute); \
         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 { \
             ASSERT(eventTarget.toDOMWindow()); \
             eventTarget.setAttributeEventListener(EventTypeNames::attribute, listener); \
         } \
     }
 
 #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); \
     }
 
 inline bool EventTarget::hasEventListeners() const
 {
     // FIXME: We should have a const version of eventTargetData.
     if (const EventTargetData* d = const_cast<EventTarget*>(this)->eventTargetData())
         return !d->eventListenerMap.isEmpty();
@@ skipping 33 matching lines @@
     using baseClass::deref; \
 private: \
     void refEventTarget() final { ref(); } \
     void derefEventTarget() final { deref(); } \
     typedef int thisIsHereToForceASemiColonAfterThisEventTargetMacro
 #define REFCOUNTED_EVENT_TARGET(baseClass) DEFINE_EVENT_TARGET_REFCOUNTING(RefCounted<baseClass>)
 #define REFCOUNTED_GARBAGE_COLLECTED_EVENT_TARGET(baseClass) DEFINE_EVENT_TARGET_REFCOUNTING(RefCountedGarbageCollected<baseClass>)
 #endif // ENABLE(OILPAN)
 
 #endif // EventTarget_h