[Oilpan]: Make StylePropertySet fully garbage collected.

Source/core/dom/ElementData.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 20 matching lines @@
 #include "config.h"
 #include "core/dom/ElementData.h"
 
 #include "core/css/StylePropertySet.h"
 #include "core/dom/Attr.h"
 #include "core/dom/QualifiedName.h"
 #include "wtf/Vector.h"
 
 namespace WebCore {
 
-struct SameSizeAsElementData : public RefCounted<SameSizeAsElementData> {
+struct SameSizeAsElementData : public RefCountedWillBeGarbageCollectedFinalized<SameSizeAsElementData> {
     unsigned bitfield;
-    void* refPtrs[3];
+    void* pointers[3];
 };
 
 COMPILE_ASSERT(sizeof(ElementData) == sizeof(SameSizeAsElementData), element_attribute_data_should_stay_small);
 
 static size_t sizeForShareableElementDataWithAttributeCount(unsigned count)
 {
     return sizeof(ShareableElementData) + sizeof(Attribute) * count;
 }
 
 ElementData::ElementData()
@@ skipping 19 matching lines @@
     , m_arraySize(isUnique ? 0 : other.length())
     , m_presentationAttributeStyleIsDirty(other.m_presentationAttributeStyleIsDirty)
     , m_styleAttributeIsDirty(other.m_styleAttributeIsDirty)
     , m_animatedSVGAttributesAreDirty(other.m_animatedSVGAttributesAreDirty)
     , m_classNames(other.m_classNames)
     , m_idForStyleResolution(other.m_idForStyleResolution)
 {
     // NOTE: The inline style is copied by the subclass copy constructor since we don't know what to do with it here.
 }
 
+#if ENABLE(OILPAN)
+void ElementData::finalizeGarbageCollectedObject()
+{
+    if (m_isUnique)
+        static_cast<UniqueElementData*>(this)->~UniqueElementData();
+    else
+        static_cast<ShareableElementData*>(this)->~ShareableElementData();
+}
+#else
 void ElementData::destroy()
 {
     if (m_isUnique)
         delete static_cast<UniqueElementData*>(this);
     else
         delete static_cast<ShareableElementData*>(this);
 }
+#endif
 
-PassRefPtr<UniqueElementData> ElementData::makeUniqueCopy() const
+PassRefPtrWillBeRawPtr<UniqueElementData> ElementData::makeUniqueCopy() const
 {
     if (isUnique())
-        return adoptRef(new UniqueElementData(static_cast<const UniqueElementData&>(*this)));
-    return adoptRef(new UniqueElementData(static_cast<const ShareableElementData&>(*this)));
+        return adoptRefWillBeNoop(new UniqueElementData(static_cast<const UniqueElementData&>(*this)));
+    return adoptRefWillBeNoop(new UniqueElementData(static_cast<const ShareableElementData&>(*this)));
 }
 
 bool ElementData::isEquivalent(const ElementData* other) const
 {
     if (!other)
         return isEmpty();
 
     unsigned length = this->length();
     if (length != other->length())
         return false;
@@ skipping 34 matching lines @@
             // FIXME: Would be faster to do this comparison without calling toString, which
             // generates a temporary string by concatenation. But this branch is only reached
             // if the attribute name has a prefix, which is rare in HTML.
             if (equalPossiblyIgnoringCase(name, attribute.name().toString(), shouldIgnoreAttributeCase))
                 return i;
         }
     }
     return kNotFound;
 }
 
+void ElementData::trace(Visitor* visitor)
+{
+    if (m_isUnique)
+        static_cast<UniqueElementData*>(this)->traceAfterDispatch(visitor);

[esprehn, 2014/05/14 20:25:27]

What is traceAfterDispatch? what is dispatch? Why does trace() sometimes need to
call traceAfterDispatch, and sometimes need to call trace?

[wibling-chromium, 2014/05/15 13:15:18]

This is a common pattern we use when objects don't have a vtable. Ideally we
want to use a virtual dispatch, but that will add an extra word of memory to
each object. To avoid this we do this manual dispatch to the subclass'
traceAfterDispatch method which then does the actual tracing.

+    else
+        static_cast<ShareableElementData*>(this)->traceAfterDispatch(visitor);
+}
+
+void ElementData::traceAfterDispatch(Visitor* visitor)
+{
+    visitor->trace(m_inlineStyle);
+}
+
 ShareableElementData::ShareableElementData(const Vector<Attribute>& attributes)
     : ElementData(attributes.size())
 {
     for (unsigned i = 0; i < m_arraySize; ++i)
         new (&m_attributeArray[i]) Attribute(attributes[i]);
 }
 
 ShareableElementData::~ShareableElementData()
 {
     for (unsigned i = 0; i < m_arraySize; ++i)
         m_attributeArray[i].~Attribute();
 }
 
 ShareableElementData::ShareableElementData(const UniqueElementData& other)
     : ElementData(other, false)
 {
     ASSERT(!other.m_presentationAttributeStyle);
 
     if (other.m_inlineStyle) {
         m_inlineStyle = other.m_inlineStyle->immutableCopyIfNeeded();
     }
 
     for (unsigned i = 0; i < m_arraySize; ++i)
         new (&m_attributeArray[i]) Attribute(other.m_attributeVector.at(i));
 }
 
-PassRefPtr<ShareableElementData> ShareableElementData::createWithAttributes(const Vector<Attribute>& attributes)
+PassRefPtrWillBeRawPtr<ShareableElementData> ShareableElementData::createWithAttributes(const Vector<Attribute>& attributes)
 {
+#if ENABLE(OILPAN)
+    void* slot = Heap::allocate<ElementData>(sizeForShareableElementDataWithAttributeCount(attributes.size()));
+#else
     void* slot = WTF::fastMalloc(sizeForShareableElementDataWithAttributeCount(attributes.size()));
-    return adoptRef(new (slot) ShareableElementData(attributes));
+#endif
+    return adoptRefWillBeNoop(new (slot) ShareableElementData(attributes));
 }
 
 UniqueElementData::UniqueElementData()
 {
 }
 
 UniqueElementData::UniqueElementData(const UniqueElementData& other)
     : ElementData(other, true)
     , m_presentationAttributeStyle(other.m_presentationAttributeStyle)
     , m_attributeVector(other.m_attributeVector)
 {
     m_inlineStyle = other.m_inlineStyle ? other.m_inlineStyle->mutableCopy() : nullptr;
 }
 
 UniqueElementData::UniqueElementData(const ShareableElementData& other)
     : ElementData(other, true)
 {
     // An ShareableElementData should never have a mutable inline StylePropertySet attached.
     ASSERT(!other.m_inlineStyle || !other.m_inlineStyle->isMutable());
     m_inlineStyle = other.m_inlineStyle;
 
     unsigned length = other.length();
     m_attributeVector.reserveCapacity(length);
     for (unsigned i = 0; i < length; ++i)
         m_attributeVector.uncheckedAppend(other.m_attributeArray[i]);
 }
 
-PassRefPtr<UniqueElementData> UniqueElementData::create()
+PassRefPtrWillBeRawPtr<UniqueElementData> UniqueElementData::create()
 {
-    return adoptRef(new UniqueElementData);
+    return adoptRefWillBeNoop(new UniqueElementData);
 }
 
-PassRefPtr<ShareableElementData> UniqueElementData::makeShareableCopy() const
+PassRefPtrWillBeRawPtr<ShareableElementData> UniqueElementData::makeShareableCopy() const
 {
+#if ENABLE(OILPAN)
+    void* slot = Heap::allocate<ElementData>(sizeForShareableElementDataWithAttributeCount(m_attributeVector.size()));
+#else
     void* slot = WTF::fastMalloc(sizeForShareableElementDataWithAttributeCount(m_attributeVector.size()));
-    return adoptRef(new (slot) ShareableElementData(*this));
+#endif
+    return adoptRefWillBeNoop(new (slot) ShareableElementData(*this));
 }
 
 Attribute* UniqueElementData::getAttributeItem(const QualifiedName& name)
 {
     unsigned length = this->length();
     for (unsigned i = 0; i < length; ++i) {
         if (m_attributeVector.at(i).name().matches(name))
             return &m_attributeVector.at(i);
     }
     return 0;
 }
 
+void UniqueElementData::traceAfterDispatch(Visitor* visitor)
+{
+    visitor->trace(m_presentationAttributeStyle);
+    ElementData::traceAfterDispatch(visitor);
+}
+
 } // namespace WebCore