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<YourClass> (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
 //   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<YourClass>::trace,
 //   depending on the base class of your class.
 //
 // 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)
@@ skipping 68 matching lines @@
 
     bool clearAttributeEventListener(const AtomicString& eventType);
 
     friend class EventListenerIterator;
 };
 
 // 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.
+template <typename T>
 class GC_PLUGIN_IGNORE("513199") CORE_EXPORT EventTargetWithInlineData : public EventTarget {

[haraken, 2016/04/06 11:23:56]

tasak@ told me that this doesn't work because of MSVC's bug:
https://bugs.chromium.org/p/chromium/issues/detail?id=491995

In short, the issue will be gone if we remove the template<typename T>. So I'll
replace an EAGERLY_FINALIZE with a pre-finalizer in the EventTarget hierarchy
and thus remove the template<typename T>.

 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);
+        visitor->trace(m_eventTargetData);
+        EventTarget::trace(visitor);
     }
+
+protected:
+    EventTargetData* eventTargetData() final { return &m_eventTargetData; }
+    EventTargetData& ensureEventTargetData() final { return m_eventTargetData; }
+
+private:
+    EventTargetData m_eventTargetData;
 };
-#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 63 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