Oilpan: Remove RefCountedGarbageCollectedEventTargetWithInlineData

third_party/WebKit/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 65 matching lines @@
     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
-//   RefCountedGarbageCollected<YourClass> in addition to EventTargetWithInlineData,
-//   inherit from RefCountedGarbageCollectedEventTargetWithInlineData<YourClass>.
+// - Inherit from EventTargetWithInlineData (only in rare cases
+//   should you use EventTarget directly).
 // - In your class declaration, EventTargetWithInlineData (or
-//   RefCountedGarbageCollectedEventTargetWithInlineData<>) must come first in
+//   EventTargetWithInlineData) must come first in

[sof, 2016/04/11 10:43:46]

remove "(or EventTargetWithInlineData)"

 //   the base class list. If your class is non-final, classes inheriting from
 //   your class need to come first, too.
 // - Figure out if you now need to inherit from ActiveDOMObject as well.
 // - In your class declaration, you will typically use
 //   REFCOUNTED_EVENT_TARGET(YourClass) if YourClass is a RefCounted<>,
 //   or REFCOUNTED_GARBAGE_COLLECTED_EVENT_TARGET(OtherRefCounted<YourClass>)
 //   if YourClass uses a different kind of reference counting template such as
 //   RefCountedGarbageCollected<YourClass>.
 // - Make sure to include this header file in your .h file, or you will get
 //   very strange compiler errors.
 // - If you added an onfoo attribute, use DEFINE_ATTRIBUTE_EVENT_LISTENER(foo)
 //   in your class declaration.
 // - Override EventTarget::interfaceName() and getExecutionContext(). The former
 //   will typically return EventTargetNames::YourClassName. The latter will
 //   return ActiveDOMObject::executionContext (if you are an ActiveDOMObject)
 //   or the document you're in.
 // - Your trace() method will need to call EventTargetWithInlineData::trace
-//   or RefCountedGarbageCollectedEventTargetWithInlineData<YourClass>::trace,
+//   or EventTargetWithInlineData::trace,

[sof, 2016/04/11 10:43:46]

remove line.

 //   depending on the base class of your class.
+// - EventTargets do not support EAGERLY_FINALIZE. You need to use
+//   a pre-finalizer instead.

[haraken, 2016/04/11 08:32:20]

Note: This fact is checked by a runtime verification.

 //
 // Optionally, add a FooEvent.idl class, but that's outside the scope of this
 // comment (and much more straightforward).
 class CORE_EXPORT EventTarget : public GarbageCollectedFinalized<EventTarget>, public ScriptWrappable {
     DEFINE_WRAPPERTYPEINFO();
 public:
     virtual ~EventTarget();
 
 #if !ENABLE(OILPAN)
     void ref() { refEventTarget(); }
@@ skipping 83 matching lines @@
     }
 
 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:
-    DEFINE_INLINE_VIRTUAL_TRACE()
-    {
-        static_assert(!IsEagerlyFinalizedType<T>::value, "EventTargets do not support eager finalization.");
-        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 this->getAttributeEventListener(EventTypeNames::attribute); } \
     void setOn##attribute(EventListener* listener) { this->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, EventListener* listener) { eventTarget.setAttributeEventListener(EventTypeNames::attribute, listener); } \
 
@@ skipping 62 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