Remove attrNodeListMap.

Source/core/dom/ElementRareData.h

 /*
  * Copyright (C) 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2008 David Smith <catfish.man@gmail.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  *
  */
 
 #ifndef ElementRareData_h
 #define ElementRareData_h
 
 #include "core/animation/ActiveAnimations.h"
 #include "core/dom/DatasetDOMStringMap.h"
-#include "core/dom/NamedNodeMap.h"
 #include "core/dom/NodeRareData.h"
 #include "core/dom/PseudoElement.h"
 #include "core/dom/custom/CustomElementDefinition.h"
 #include "core/dom/shadow/ElementShadow.h"
 #include "core/html/ClassList.h"
 #include "core/html/ime/InputMethodContext.h"
 #include "core/rendering/style/StyleInheritedData.h"
 #include "platform/heap/Handle.h"
 #include "wtf/OwnPtr.h"
 
 namespace WebCore {
 
+class AttrData;
 class HTMLElement;
+class NamedNodeMap;
 
 class ElementRareData : public NodeRareData {
 public:
     static ElementRareData* create(RenderObject* renderer)
     {
         return new ElementRareData(renderer);
     }
 
     ~ElementRareData();
 
@@ skipping 20 matching lines @@
 
     void clearShadow() { m_shadow = nullptr; }
     ElementShadow* shadow() const { return m_shadow.get(); }
     ElementShadow& ensureShadow()
     {
         if (!m_shadow)
             m_shadow = ElementShadow::create();
         return *m_shadow;
     }
 
-    NamedNodeMap* attributeMap() const { return m_attributeMap.get(); }
-    void setAttributeMap(PassOwnPtrWillBeRawPtr<NamedNodeMap> attributeMap) { m_attributeMap = attributeMap; }
-
     RenderStyle* computedStyle() const { return m_computedStyle.get(); }
     void setComputedStyle(PassRefPtr<RenderStyle> computedStyle) { m_computedStyle = computedStyle; }
     void clearComputedStyle() { m_computedStyle = nullptr; }
 
     ClassList* classList() const { return m_classList.get(); }
     void setClassList(PassOwnPtrWillBeRawPtr<ClassList> classList) { m_classList = classList; }
     void clearClassListValueForQuirksMode()
     {
         if (!m_classList)
             return;
@@ skipping 22 matching lines @@
             m_inputMethodContext = InputMethodContext::create(element);
         return *m_inputMethodContext;
     }
 
     bool hasPseudoElements() const;
     void clearPseudoElements();
 
     void setCustomElementDefinition(PassRefPtr<CustomElementDefinition> definition) { m_customElementDefinition = definition; }
     CustomElementDefinition* customElementDefinition() const { return m_customElementDefinition.get(); }
 
+    AttrData& ensureAttrData();
+    AttrData* attrData() { return m_attrData.get(); }

[esprehn, 2014/06/17 08:27:05]

const

+
     void traceAfterDispatch(Visitor*);
 
 private:
     short m_tabindex;
 
     LayoutSize m_minimumSizeForResizing;
     IntSize m_savedLayerScrollOffset;
 
     OwnPtrWillBeMember<DatasetDOMStringMap> m_dataset;
     OwnPtrWillBeMember<ClassList> m_classList;
     OwnPtrWillBeMember<ElementShadow> m_shadow;
-    OwnPtrWillBeMember<NamedNodeMap> m_attributeMap;
+    OwnPtrWillBeMember<AttrData> m_attrData;
     OwnPtrWillBeMember<InputMethodContext> m_inputMethodContext;
     OwnPtrWillBeMember<ActiveAnimations> m_activeAnimations;
     OwnPtrWillBeMember<InlineCSSStyleDeclaration> m_cssomWrapper;
 
     RefPtr<RenderStyle> m_computedStyle;
     RefPtr<CustomElementDefinition> m_customElementDefinition;
 
     RefPtrWillBeMember<PseudoElement> m_generatedBefore;
     RefPtrWillBeMember<PseudoElement> m_generatedAfter;
     RefPtrWillBeMember<PseudoElement> m_backdrop;
@@ skipping 71 matching lines @@
     default:
         return 0;
     }
 }
 
 inline void ElementRareData::resetStyleState()
 {
     clearElementFlag(StyleAffectedByEmpty);
 }
 
+class AttrData : public NoBaseWillBeGarbageCollected<AttrData> {

[haraken, 2014/06/17 02:07:02]

This is something like we're introducing another RareData to the
ElementRareData. Although I agree that it makes sense to pack Attr objects and a
NamedNodeMap together (since they are likely to be used at the same time), it's
also true that this adds another complexity to the ElementRareData.

I'm not quite sure if it's worth making this change. Once Erik implements the
fixed-point algorithm of weak collections, we can just keep using the current
AttrNodeList as is. That seems better to me.

[esprehn, 2014/06/17 08:27:05]

We really should put these in separate files, but it's fine to put it here for
now since they're all here already.

+    DECLARE_EMPTY_DESTRUCTOR_WILL_BE_REMOVED(AttrData);
+public:
+    static PassOwnPtrWillBeRawPtr<AttrData> create();
+    void trace(Visitor*);
+
+    WillBeHeapVector<RefPtrWillBeMember<Attr> >& ensureAttrNodeList();
+    WillBeHeapVector<RefPtrWillBeMember<Attr> >* attrNodeList() { return m_attrNodeList.get(); }

[esprehn, 2014/06/17 08:27:05]

const

+    void removeAttrNodeList();
+
+    NamedNodeMap* attributeMap() const { return m_attributeMap.get(); }
+    void setAttributeMap(PassOwnPtrWillBeRawPtr<NamedNodeMap>);
+
+private:
+    AttrData();
+
+    OwnPtrWillBeMember<WillBeHeapVector<RefPtrWillBeMember<Attr> > > m_attrNodeList;
+    OwnPtrWillBeMember<NamedNodeMap> m_attributeMap;
+};
+
 } // namespace
 
 #endif // ElementRareData_h