Remove Element#attributes.

sky/engine/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 31 matching lines @@
 #include "core/css/resolver/StyleResolver.h"
 #include "core/dom/Attr.h"
 #include "core/dom/ClientRect.h"
 #include "core/dom/ClientRectList.h"
 #include "core/dom/ElementDataCache.h"
 #include "core/dom/ElementRareData.h"
 #include "core/dom/ElementTraversal.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/MutationObserverInterestGroup.h"
 #include "core/dom/MutationRecord.h"
-#include "core/dom/NamedNodeMap.h"
 #include "core/dom/NodeRenderStyle.h"
 #include "core/dom/RenderTreeBuilder.h"
 #include "core/dom/SelectorQuery.h"
 #include "core/dom/StyleEngine.h"
 #include "core/dom/Text.h"
 #include "core/dom/custom/CustomElement.h"
 #include "core/dom/custom/CustomElementRegistrationContext.h"
 #include "core/dom/shadow/InsertionPoint.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/editing/FrameSelection.h"
@@ skipping 25 matching lines @@
 #include "platform/UserGestureIndicator.h"
 #include "platform/scroll/ScrollableArea.h"
 #include "wtf/BitVector.h"
 #include "wtf/HashFunctions.h"
 #include "wtf/text/CString.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/TextPosition.h"
 
 namespace blink {
 
-typedef Vector<RefPtr<Attr> > AttrNodeList;
-
-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)->name() == name.localName())
-            return it->get();
-    }
-    return 0;
-}
-
 PassRefPtr<Element> Element::create(const QualifiedName& tagName, Document* document)
 {
     return adoptRef(new Element(tagName, document, CreateElement));
 }
 
 Element::Element(const QualifiedName& tagName, Document* document, ConstructionType type)
     : ContainerNode(document, type)
     , m_tagName(tagName)
 {
     ScriptWrappable::init(this);
 }
 
 Element::~Element()
 {
     ASSERT(needsAttach());
 
 #if !ENABLE(OILPAN)
     if (hasRareData())
         elementRareData()->clearShadow();
 
     if (isCustomElement())
         CustomElement::wasDestroyed(this);
-
-    if (hasSyntheticAttrChildNodes())
-        detachAllAttrNodesFromElement();
 #endif
 }
 
 inline ElementRareData* Element::elementRareData() const
 {
     ASSERT(hasRareData());
     return static_cast<ElementRareData*>(rareData());
 }
 
 inline ElementRareData& Element::ensureElementRareData()
@@ skipping 106 matching lines @@
 }
 
 void Element::setBooleanAttribute(const QualifiedName& name, bool value)
 {
     if (value)
         setAttribute(name, emptyAtom);
     else
         removeAttribute(name);
 }
 
-NamedNodeMap* Element::attributesForBindings() const
-{
-    ElementRareData& rareData = const_cast<Element*>(this)->ensureElementRareData();
-    if (NamedNodeMap* attributeMap = rareData.attributeMap())
-        return attributeMap;
-
-    rareData.setAttributeMap(NamedNodeMap::create(const_cast<Element*>(this)));
-    return rareData.attributeMap();
-}
-
 ActiveAnimations* Element::activeAnimations() const
 {
     if (hasRareData())
         return elementRareData()->activeAnimations();
     return 0;
 }
 
 ActiveAnimations& Element::ensureActiveAnimations()
 {
     ElementRareData& rareData = ensureElementRareData();
@@ skipping 943 matching lines @@
         if (result.length() > 0)
             result.appendLiteral("; ");
         result.appendLiteral("class=");
         result.append(s);
     }
 
     strncpy(buffer, result.toString().utf8().data(), length - 1);
 }
 #endif
 
-Vector<RefPtr<Attr> >* Element::attrNodeList()
-{
-    return hasRareData() ? elementRareData()->attrNodeList() : 0;
-}
-
-Vector<RefPtr<Attr> >& Element::ensureAttrNodeList()
-{
-    setHasSyntheticAttrChildNodes(true);
-    return ensureElementRareData().ensureAttrNodeList();
-}
-
-void Element::removeAttrNodeList()
-{
-    ASSERT(hasSyntheticAttrChildNodes());
-    if (hasRareData())
-        elementRareData()->removeAttrNodeList();
-    setHasSyntheticAttrChildNodes(false);
-}
-
 void Element::parseAttribute(const QualifiedName& name, const AtomicString& value)
 {
     if (name == HTMLNames::tabindexAttr) {
         int tabindex = 0;
         if (value.isEmpty()) {
             clearTabIndexExplicitlyIfNeeded();
             if (treeScope().adjustedFocusedElement() == this) {
                 // We might want to call blur(), but it's dangerous to dispatch
                 // events here.
                 document().setNeedsFocusedElementCheck();
@@ skipping 23 matching lines @@
     ASSERT_WITH_SECURITY_IMPLICATION(index < attributes.size());
 
     QualifiedName name = attributes[index].name();
     AtomicString valueBeingRemoved = attributes[index].value();
 
     if (!inSynchronizationOfLazyAttribute) {
         if (!valueBeingRemoved.isNull())
             willModifyAttribute(name, valueBeingRemoved, nullAtom);
     }
 
-    if (RefPtr<Attr> attrNode = attrIfExists(name))
-        attrNode->detachFromElement();
-
     attributes.remove(index);
 
     if (!inSynchronizationOfLazyAttribute)
         attributeChanged(name, nullAtom);
 }
 
 void Element::appendAttributeInternal(const QualifiedName& name, const AtomicString& value, SynchronizationOfLazyAttribute inSynchronizationOfLazyAttribute)
 {
     if (!inSynchronizationOfLazyAttribute)
         willModifyAttribute(name, nullAtom, value);
@@ skipping 17 matching lines @@
     removeAttributeInternal(index, NotInSynchronizationOfLazyAttribute);
 }
 
 Vector<RefPtr<Attr>> Element::getAttributes()
 {
     if (!elementData())
         return Vector<RefPtr<Attr>>();
     synchronizeAllAttributes();
     Vector<RefPtr<Attr>> attributes;
     for (const Attribute& attribute : elementData()->attributes())
-        attributes.append(ensureAttr(attribute.name()));
+        attributes.append(Attr::create(attribute.name(), attribute.value()));
     return attributes;
 }
 
-PassRefPtr<Attr> Element::getAttributeNode(const AtomicString& localName)
-{
-    if (!elementData())
-        return nullptr;
-    synchronizeAttribute(localName);
-    const Attribute* attribute = elementData()->attributes().find(localName);
-    if (!attribute)
-        return nullptr;
-    return ensureAttr(attribute->name());
-}
-
 void Element::focus(bool restorePreviousSelection, FocusType type)
 {
     if (!inDocument())
         return;
 
     if (document().focusedElement() == this)
         return;
 
     if (!document().isActive())
         return;
@@ skipping 248 matching lines @@
     } while (n && value.isNull());
 
     return value;
 }
 
 Locale& Element::locale() const
 {
     return document().getCachedLocale(computeInheritedLanguage());
 }
 
-void Element::normalizeAttributes()
-{
-    if (!hasAttributes())
-        return;
-    Vector<RefPtr<Attr> >* attrNodes = attrNodeList();
-    if (!attrNodes)
-        return;
-    // Copy the Attr Vector because Node::normalize() can fire synchronous JS
-    // events (e.g. DOMSubtreeModified) and a JS listener could add / remove
-    // attributes while we are iterating.
-    Vector<RefPtr<Attr> > attrNodesCopy(*attrNodes);
-    for (size_t i = 0; i < attrNodesCopy.size(); ++i)
-        attrNodesCopy[i]->normalize();
-}
-
 bool Element::matches(const String& selectors, ExceptionState& exceptionState)
 {
     SelectorQuery* selectorQuery = document().selectorQueryCache().add(AtomicString(selectors), document(), exceptionState);
     if (!selectorQuery)
         return false;
     return selectorQuery->matches(*this);
 }
 
 DOMTokenList& Element::classList()
 {
@@ skipping 94 matching lines @@
         case SpellcheckAttributeFalse:
             return false;
         case SpellcheckAttributeDefault:
             break;
         }
     }
 
     return true;
 }
 
-#ifdef DUMP_NODE_STATISTICS
-bool Element::hasNamedNodeMap() const
-{
-    return hasRareData() && elementRareData()->attributeMap();
-}
-#endif
-
 inline void Element::updateId(const AtomicString& oldId, const AtomicString& newId)
 {
     if (!isInTreeScope())
         return;
 
     if (oldId == newId)
         return;
 
     updateId(treeScope(), oldId, newId);
 }
@@ skipping 67 matching lines @@
     return hasRareData() ? elementRareData()->savedLayerScrollOffset() : IntSize();
 }
 
 void Element::setSavedLayerScrollOffset(const IntSize& size)
 {
     if (size.isZero() && !hasRareData())
         return;
     ensureElementRareData().setSavedLayerScrollOffset(size);
 }
 
-PassRefPtr<Attr> Element::attrIfExists(const QualifiedName& name)
-{
-    if (AttrNodeList* attrNodeList = this->attrNodeList())
-        return findAttrNodeInList(*attrNodeList, name);
-    return nullptr;
-}
-
-PassRefPtr<Attr> Element::ensureAttr(const QualifiedName& name)
-{
-    AttrNodeList& attrNodeList = ensureAttrNodeList();
-    RefPtr<Attr> attrNode = findAttrNodeInList(attrNodeList, name);
-    if (!attrNode) {
-        attrNode = Attr::create(*this, name);
-        treeScope().adoptIfNeeded(*attrNode);
-        attrNodeList.append(attrNode);
-    }
-    return attrNode.release();
-}
-
-void Element::detachAllAttrNodesFromElement()
-{
-    AttrNodeList* list = this->attrNodeList();
-    ASSERT(list);
-
-    for (unsigned i = 0; i < list->size(); ++i)
-        list->at(i)->detachFromElement();
-    removeAttrNodeList();
-}
-
 void Element::willRecalcStyle(StyleRecalcChange)
 {
     ASSERT(hasCustomStyleCallbacks());
 }
 
 void Element::didRecalcStyle(StyleRecalcChange)
 {
     ASSERT(hasCustomStyleCallbacks());
 }
 
 
 PassRefPtr<RenderStyle> Element::customStyleForRenderer()
 {
     ASSERT(hasCustomStyleCallbacks());
     return nullptr;
 }
 
 void Element::cloneAttributesFromElement(const Element& other)
 {
-    if (hasSyntheticAttrChildNodes())
-        detachAllAttrNodesFromElement();
-
     other.synchronizeAllAttributes();
     if (!other.m_elementData) {
         m_elementData.clear();
         return;
     }
 
     const AtomicString& oldID = getIdAttribute();
     const AtomicString& newID = other.getIdAttribute();
 
     if (!oldID.isNull() || !newID.isNull())
@@ skipping 200 matching lines @@
 {
 #if ENABLE(OILPAN)
     if (hasRareData())
         visitor->trace(elementRareData());
     visitor->trace(m_elementData);
 #endif
     ContainerNode::trace(visitor);
 }
 
 } // namespace blink