Remove attrNodeListMap.

Source/core/dom/Element.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Peter Kelly (pmk@post.com)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012, 2013 Apple Inc. All rights reserved.
  *           (C) 2007 Eric Seidel (eric@webkit.org)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 96 matching lines @@
 #include "wtf/text/CString.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/TextPosition.h"
 
 namespace WebCore {
 
 using namespace HTMLNames;
 using namespace XMLNames;
 
 typedef WillBeHeapVector<RefPtrWillBeMember<Attr> > AttrNodeList;
-typedef WillBePersistentHeapHashMap<RawPtrWillBeWeakMember<Element>, OwnPtrWillBeMember<AttrNodeList> > AttrNodeListMap;
-
-static AttrNodeListMap& attrNodeListMap()
-{
-    DEFINE_STATIC_LOCAL(AttrNodeListMap, map, ());
-    return map;
-}
-
-static AttrNodeList* attrNodeListForElement(Element* element)
-{
-    if (!element->hasSyntheticAttrChildNodes())
-        return 0;
-    ASSERT(attrNodeListMap().contains(element));
-    return attrNodeListMap().get(element);
-}
-
-static AttrNodeList& ensureAttrNodeListForElement(Element* element)
-{
-    if (element->hasSyntheticAttrChildNodes()) {
-        ASSERT(attrNodeListMap().contains(element));
-        return *attrNodeListMap().get(element);
-    }
-    ASSERT(!attrNodeListMap().contains(element));
-    element->setHasSyntheticAttrChildNodes(true);
-    AttrNodeListMap::AddResult result = attrNodeListMap().add(element, adoptPtrWillBeNoop(new AttrNodeList));
-    return *result.storedValue->value;
-}
-
-static void removeAttrNodeListForElement(Element* element)
-{
-    ASSERT(element->hasSyntheticAttrChildNodes());
-    ASSERT(attrNodeListMap().contains(element));
-    attrNodeListMap().remove(element);
-    element->setHasSyntheticAttrChildNodes(false);
-}
 
 static Attr* findAttrNodeInList(const AttrNodeList& attrNodeList, const QualifiedName& name)
 {
     AttrNodeList::const_iterator end = attrNodeList.end();
     for (AttrNodeList::const_iterator it = attrNodeList.begin(); it != end; ++it) {
         if ((*it)->qualifiedName() == name)
             return it->get();
     }
     return 0;
 }
@@ skipping 185 matching lines @@
 void Element::setBooleanAttribute(const QualifiedName& name, bool value)
 {
     if (value)
         setAttribute(name, emptyAtom);
     else
         removeAttribute(name);
 }
 
 NamedNodeMap* Element::attributes() const
 {
-    ElementRareData& rareData = const_cast<Element*>(this)->ensureElementRareData();
-    if (NamedNodeMap* attributeMap = rareData.attributeMap())
+    AttrData& attrData = const_cast<Element*>(this)->ensureElementRareData().ensureAttrData();
+    if (NamedNodeMap* attributeMap = attrData.attributeMap())
         return attributeMap;
 
-    rareData.setAttributeMap(NamedNodeMap::create(const_cast<Element*>(this)));
-    return rareData.attributeMap();
+    attrData.setAttributeMap(NamedNodeMap::create(const_cast<Element*>(this)));
+    return attrData.attributeMap();
 }
 
 ActiveAnimations* Element::activeAnimations() const
 {
     if (hasRareData())
         return elementRareData()->activeAnimations();
     return 0;
 }
 
 ActiveAnimations& Element::ensureActiveAnimations()
@@ skipping 1485 matching lines @@
         if (result.length() > 0)
             result.appendLiteral("; ");
         result.appendLiteral("class=");
         result.append(s);
     }
 
     strncpy(buffer, result.toString().utf8().data(), length - 1);
 }
 #endif
 
-const WillBeHeapVector<RefPtrWillBeMember<Attr> >& Element::attrNodeList()
+WillBeHeapVector<RefPtrWillBeMember<Attr> >* Element::attrNodeList()
+{
+    return hasRareData() && elementRareData()->attrData() ? elementRareData()->attrData()->attrNodeList() : 0;

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

This would be better as:

if (!hasRareData())
  return 0;
if (AttrData* data = elementRareData()->attrData())
  return data->attrNodeList();
return 0;

+}
+
+WillBeHeapVector<RefPtrWillBeMember<Attr> >& Element::ensureAttrNodeList()
+{
+    setHasSyntheticAttrChildNodes(true);

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

You can remove this bitfield now. hasSyntheticAttrChildNodes should check
hasRareData() && elementRareData()->attrData()->attrNodeList()

+    return ensureElementRareData().ensureAttrData().ensureAttrNodeList();
+}
+
+void Element::removeAttrNodeList()
 {
     ASSERT(hasSyntheticAttrChildNodes());
-    return *attrNodeListForElement(this);
+    if (hasRareData() && elementRareData()->attrData())
+        elementRareData()->attrData()->removeAttrNodeList();
+    setHasSyntheticAttrChildNodes(false);
 }
 
 PassRefPtrWillBeRawPtr<Attr> Element::setAttributeNode(Attr* attrNode, ExceptionState& exceptionState)
 {
     if (!attrNode) {
         exceptionState.throwDOMException(TypeMismatchError, ExceptionMessages::argumentNullOrIncorrectType(1, "Attr"));
         return nullptr;
     }
 
     RefPtrWillBeRawPtr<Attr> oldAttrNode = attrIfExists(attrNode->qualifiedName());
@@ skipping 30 matching lines @@
             // all but Gecko (and, arguably, the DOM Level1 spec text.)
             // Consider switching.
             oldAttrNode = Attr::create(document(), attrNode->qualifiedName(), attr.value());
         }
     }
 
     setAttributeInternal(index, attrNode->qualifiedName(), attrNode->value(), NotInSynchronizationOfLazyAttribute);
 
     attrNode->attachToElement(this, localName);
     treeScope().adoptIfNeeded(*attrNode);
-    ensureAttrNodeListForElement(this).append(attrNode);
+    ensureAttrNodeList().append(attrNode);
 
     return oldAttrNode.release();
 }
 
 PassRefPtrWillBeRawPtr<Attr> Element::setAttributeNodeNS(Attr* attr, ExceptionState& exceptionState)
 {
     return setAttributeNode(attr, exceptionState);
 }
 
 PassRefPtrWillBeRawPtr<Attr> Element::removeAttributeNode(Attr* attr, ExceptionState& exceptionState)
@@ skipping 830 matching lines @@
     if (isSVGElement())
         return !toSVGElement(this)->isAnimatableAttribute(name);
 
     return true;
 }
 #endif
 
 #ifdef DUMP_NODE_STATISTICS
 bool Element::hasNamedNodeMap() const
 {
-    return hasRareData() && elementRareData()->attributeMap();
+    return hasRareData() && elementRareData()->attrData() && elementRareData()->attrData()->attributeMap();

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

ditto

 }
 #endif
 
 inline void Element::updateName(const AtomicString& oldName, const AtomicString& newName)
 {
     if (!inDocument() || isInShadowTree())
         return;
 
     if (oldName == newName)
         return;
@@ skipping 194 matching lines @@
 
 void Element::setSavedLayerScrollOffset(const IntSize& size)
 {
     if (size.isZero() && !hasRareData())
         return;
     ensureElementRareData().setSavedLayerScrollOffset(size);
 }
 
 PassRefPtrWillBeRawPtr<Attr> Element::attrIfExists(const QualifiedName& name)
 {
-    if (AttrNodeList* attrNodeList = attrNodeListForElement(this))
+    if (AttrNodeList* attrNodeList = this->attrNodeList())

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

Rename the |attrNodeList| variable to something else and remove this-> ? Ditto
for other parts in this file.

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

list = ...

         return findAttrNodeInList(*attrNodeList, name);
     return nullptr;
 }
 
 PassRefPtrWillBeRawPtr<Attr> Element::ensureAttr(const QualifiedName& name)
 {
-    AttrNodeList& attrNodeList = ensureAttrNodeListForElement(this);
+    AttrNodeList& attrNodeList = ensureAttrNodeList();
     RefPtrWillBeRawPtr<Attr> attrNode = findAttrNodeInList(attrNodeList, name);
     if (!attrNode) {
         attrNode = Attr::create(*this, name);
         treeScope().adoptIfNeeded(*attrNode);
         attrNodeList.append(attrNode);
     }
     return attrNode.release();
 }
 
 void Element::detachAttrNodeFromElementWithValue(Attr* attrNode, const AtomicString& value)
 {
     ASSERT(hasSyntheticAttrChildNodes());
     attrNode->detachFromElementWithValue(value);
 
-    AttrNodeList* attrNodeList = attrNodeListForElement(this);
+    AttrNodeList* attrNodeList = this->attrNodeList();
     for (unsigned i = 0; i < attrNodeList->size(); ++i) {
         if (attrNodeList->at(i)->qualifiedName() == attrNode->qualifiedName()) {
             attrNodeList->remove(i);
             if (attrNodeList->isEmpty())
-                removeAttrNodeListForElement(this);
+                removeAttrNodeList();
             return;
         }
     }
     ASSERT_NOT_REACHED();
 }
 
 void Element::detachAllAttrNodesFromElement()
 {
-    AttrNodeList* attrNodeList = attrNodeListForElement(this);
+    AttrNodeList* attrNodeList = this->attrNodeList();
     ASSERT(attrNodeList);
 
     AttributeIteratorAccessor attributes = attributesIterator();
     AttributeConstIterator end = attributes.end();
     for (AttributeConstIterator it = attributes.begin(); it != end; ++it) {
         if (RefPtrWillBeRawPtr<Attr> attrNode = findAttrNodeInList(*attrNodeList, it->name()))
             attrNode->detachFromElementWithValue(it->value());
     }
 
-    removeAttrNodeListForElement(this);
+    removeAttrNodeList();
 }
 
 void Element::willRecalcStyle(StyleRecalcChange)
 {
     ASSERT(hasCustomStyleCallbacks());
 }
 
 void Element::didRecalcStyle(StyleRecalcChange)
 {
     ASSERT(hasCustomStyleCallbacks());
@@ skipping 288 matching lines @@
 
 void Element::trace(Visitor* visitor)
 {
     if (hasRareData())
         visitor->trace(elementRareData());
 
     ContainerNode::trace(visitor);
 }
 
 } // namespace WebCore