[Oilpan]: Make StylePropertySet fully garbage collected.

Source/core/dom/ElementData.h

 /*
  * 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 15 matching lines @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef ElementData_h
 #define ElementData_h
 
 #include "core/dom/Attribute.h"
 #include "core/dom/SpaceSplitString.h"
+#include "platform/heap/Handle.h"
 #include "wtf/text/AtomicString.h"
 
 namespace WebCore {
 
 class Attr;
 class ShareableElementData;
 class StylePropertySet;
 class UniqueElementData;
 
 // ElementData represents very common, but not necessarily unique to an element,
 // data such as attributes, inline style, and parsed class names and ids.
-class ElementData : public RefCounted<ElementData> {
-    WTF_MAKE_FAST_ALLOCATED;
+class ElementData : public RefCountedWillBeGarbageCollectedFinalized<ElementData> {
+    WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED;
 public:
+#if ENABLE(OILPAN)
+    // Override GarbageCollectedFinalized's finalizeGarbageCollectedObject to
+    // dispatch to the correct subclass' destructor.
+    void finalizeGarbageCollectedObject();
+#else
     // Override RefCounted's deref() to ensure operator delete is called on
     // the appropriate subclass type.
     void deref();
+#endif
 
     void clearClass() const { m_classNames.clear(); }
     void setClass(const AtomicString& className, bool shouldFoldCase) const { m_classNames.set(className, shouldFoldCase); }
     const SpaceSplitString& classNames() const { return m_classNames; }
 
     const AtomicString& idForStyleResolution() const { return m_idForStyleResolution; }
     void setIdForStyleResolution(const AtomicString& newId) const { m_idForStyleResolution = newId; }
 
     const StylePropertySet* inlineStyle() const { return m_inlineStyle.get(); }
 
     const StylePropertySet* presentationAttributeStyle() const;
 
     // This is not a trivial getter and its return value should be cached for performance.
     size_t length() const;
     bool isEmpty() const { return !length(); }
 
     const Attribute& attributeItem(unsigned index) const;
     const Attribute* getAttributeItem(const QualifiedName&) const;
     size_t getAttributeItemIndex(const QualifiedName&, bool shouldIgnoreCase = false) const;
     size_t getAttributeItemIndex(const AtomicString& name, bool shouldIgnoreAttributeCase) const;
     size_t getAttrIndex(Attr*) const;
 
     bool hasID() const { return !m_idForStyleResolution.isNull(); }
     bool hasClass() const { return !m_classNames.isNull(); }
 
     bool isEquivalent(const ElementData* other) const;
 
     bool isUnique() const { return m_isUnique; }
 
+    void traceAfterDispatch(Visitor*);
+    void trace(Visitor*);
+
 protected:
     ElementData();
     explicit ElementData(unsigned arraySize);
     ElementData(const ElementData&, bool isUnique);
 
     // Keep the type in a bitfield instead of using virtual destructors to avoid adding a vtable.
     unsigned m_isUnique : 1;
     unsigned m_arraySize : 28;
     mutable unsigned m_presentationAttributeStyleIsDirty : 1;
     mutable unsigned m_styleAttributeIsDirty : 1;
     mutable unsigned m_animatedSVGAttributesAreDirty : 1;
 
-    mutable RefPtr<StylePropertySet> m_inlineStyle;
+    mutable RefPtrWillBeMember<StylePropertySet> m_inlineStyle;
     mutable SpaceSplitString m_classNames;
     mutable AtomicString m_idForStyleResolution;
 
 private:
     friend class Element;
     friend class ShareableElementData;
     friend class UniqueElementData;
     friend class SVGElement;
 
+#if !ENABLE(OILPAN)
     void destroy();
+#endif
 
     const Attribute* attributeBase() const;
     const Attribute* getAttributeItem(const AtomicString& name, bool shouldIgnoreAttributeCase) const;
     size_t getAttributeItemIndexSlowCase(const AtomicString& name, bool shouldIgnoreAttributeCase) const;
 
-    PassRefPtr<UniqueElementData> makeUniqueCopy() const;
+    PassRefPtrWillBeRawPtr<UniqueElementData> makeUniqueCopy() const;
 };
 
 #if COMPILER(MSVC)
 #pragma warning(push)
 #pragma warning(disable: 4200) // Disable "zero-sized array in struct/union" warning
 #endif
 
 // SharableElementData is managed by ElementDataCache and is produced by
 // the parser during page load for elements that have identical attributes. This
 // is a memory optimization since it's very common for many elements to have
 // duplicate sets of attributes (ex. the same classes).
 class ShareableElementData FINAL : public ElementData {
 public:
-    static PassRefPtr<ShareableElementData> createWithAttributes(const Vector<Attribute>&);
+    static PassRefPtrWillBeRawPtr<ShareableElementData> createWithAttributes(const Vector<Attribute>&);
 
     explicit ShareableElementData(const Vector<Attribute>&);
     explicit ShareableElementData(const UniqueElementData&);
     ~ShareableElementData();
 
+    void traceAfterDispatch(Visitor* visitor) { ElementData::traceAfterDispatch(visitor); }
+
+    void* operator new(std::size_t, void* location)

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

Why is this needed? Can you add a comment?

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

Sure. I will add a comment. This is needed because ShareableElementData and
UniqueElementData are not allocated with a fixed size. Instead the allocated
memory size is computed based on the number of attributes. This requires us to
call Heap::allocate directly with the size and subsequently call placement new
with the allocated memory address.
We don't normally support this pattern for objects and so haven't defined the
placement new operator on garbage collected objects by default. If we see this
pattern enough we will come up with a generic solution for it.

+    {
+        return location;
+    }
+
     Attribute m_attributeArray[0];
 };
 
 #if COMPILER(MSVC)
 #pragma warning(pop)
 #endif
 
 // UniqueElementData is created when an element needs to mutate its attributes
 // or gains presentation attribute style (ex. width="10"). It does not need to
 // be created to fill in values in the ElementData that are derived from
 // attributes. For example populating the m_inlineStyle from the style attribute
 // doesn't require a UniqueElementData as all elements with the same style
 // attribute will have the same inline style.
 class UniqueElementData FINAL : public ElementData {
 public:
-    static PassRefPtr<UniqueElementData> create();
-    PassRefPtr<ShareableElementData> makeShareableCopy() const;
+    static PassRefPtrWillBeRawPtr<UniqueElementData> create();
+    PassRefPtrWillBeRawPtr<ShareableElementData> makeShareableCopy() const;
 
     // These functions do no error/duplicate checking.
     void addAttribute(const QualifiedName&, const AtomicString&);
     void removeAttribute(size_t index);
 
     Attribute& attributeItem(unsigned index);
     Attribute* getAttributeItem(const QualifiedName&);
 
     UniqueElementData();
     explicit UniqueElementData(const ShareableElementData&);
     explicit UniqueElementData(const UniqueElementData&);
 
+    void traceAfterDispatch(Visitor*);
+
     // FIXME: We might want to support sharing element data for elements with
     // presentation attribute style. Lots of table cells likely have the same
     // attributes. Most modern pages don't use presentation attributes though
     // so this might not make sense.
-    mutable RefPtr<StylePropertySet> m_presentationAttributeStyle;
+    mutable RefPtrWillBeMember<StylePropertySet> m_presentationAttributeStyle;
     Vector<Attribute, 4> m_attributeVector;
 };
 
+#if !ENABLE(OILPAN)
 inline void ElementData::deref()
 {
     if (!derefBase())
         return;
     destroy();
 }
+#endif
 
 inline size_t ElementData::length() const
 {
     if (isUnique())
         return static_cast<const UniqueElementData*>(this)->m_attributeVector.size();
     return m_arraySize;
 }
 
 inline const StylePropertySet* ElementData::presentationAttributeStyle() const
 {
@@ skipping 87 matching lines @@
 }
 
 inline Attribute& UniqueElementData::attributeItem(unsigned index)
 {
     return m_attributeVector.at(index);
 }
 
 } // namespace WebCore
 
 #endif // ElementData_h