CMakeLists.txt

@@SET(WebCore_SOURCES

    dom/ActiveDOMObject.cpp

    dom/Attr.cpp

525 dom/Attribute.cpp

    dom/BeforeTextInsertedEvent.cpp

    dom/BeforeUnloadEvent.cpp

    dom/CDATASection.cpp

Source/WebCore/ChangeLog

2012-04-13  Andreas Kling  <kling@webkit.org>

        Optimize Element attribute storage for the common case (no Attr objects.)

        <http://webkit.org/b/83440>

        Reviewed by NOBODY (OOPS!).

        Reduce Attribute to its smallest possible size; a qname/value pair.

        They are no-longer ref-counted, which allows us to store them in Vectors.

        Refactored the Attr object to go with the new Attribute:

        Attr now wraps either {element, qname} or {qname, value}. The latter is for

        the case where a standalone Attr object is instantiated via DOM APIs.

        ElementAttributeData.cpp manages a map of pair<element, qname> => Attr.

        Each Element (well, ElementAttributeData) keeps track of how many Attr

        objects are pointing to it. This is so we can avoid hash lookups during

        common operations in the typical case where you have zero Attrs.

        * CMakeLists.txt:

        * GNUmakefile.list.am:

        * Target.pri:

        * WebCore.gypi:

        * WebCore.vcproj/WebCore.vcproj:

        * WebCore.xcodeproj/project.pbxproj:

        * dom/Attr.cpp:

        (WebCore::Attr::Attr):

        (WebCore):

        (WebCore::Attr::create):

        (WebCore::Attr::~Attr):

        (WebCore::Attr::createTextChild):

        (WebCore::Attr::setPrefix):

        (WebCore::Attr::setValue):

        (WebCore::Attr::cloneNode):

        (WebCore::Attr::childrenChanged):

        (WebCore::Attr::style):

        (WebCore::Attr::value):

        (WebCore::Attr::elementAttribute):

        (WebCore::Attr::detachFromElementWithValue):

        (WebCore::Attr::attachToElement):

        * dom/Attr.h:

        (WebCore):

        (Attr):

        (WebCore::Attr::qualifiedName):

        (WebCore::Attr::localName):

        (WebCore::Attr::namespaceURI):

        (WebCore::Attr::prefix):

        * dom/Attribute.cpp: Removed.

        * dom/Attribute.h:

        (WebCore::Attribute::Attribute):

        (Attribute):

        * dom/Document.cpp:

        (WebCore::Document::importNode):

        (WebCore::Document::createAttributeNS):

        * dom/Element.cpp:

        (WebCore::Element::~Element):

        (WebCore::Element::takeAttribute):

        (WebCore):

        (WebCore::Element::removeAttribute):

        (WebCore::Element::setAttributeInternal):

        (WebCore::Element::parserSetAttributes):

        (WebCore::Element::setAttributeNode):

        (WebCore::Element::removeAttributeNode):

        (WebCore::Element::normalizeAttributes):

        (WebCore::Element::didRemoveAttribute):

        (WebCore::Element::getAttr):

        (WebCore::Element::getOrCreateAttr):

        * dom/Element.h:

        (Element):

        (WebCore::Element::getAttributeItemIndex):

        * dom/ElementAttributeData.cpp:

        (WebCore):

        (WebCore::attrMap):

        (WebCore::ElementAttributeData::getAttr):

        (WebCore::ElementAttributeData::getOrCreateAttr):

        (WebCore::ElementAttributeData::setAttr):

        (WebCore::ElementAttributeData::removeAttr):

        (WebCore::AttributeVector::removeAttribute):

        (WebCore::ElementAttributeData::~ElementAttributeData):

        (WebCore::ElementAttributeData::addAttribute):

        (WebCore::ElementAttributeData::removeAttribute):

        (WebCore::ElementAttributeData::isEquivalent):

        (WebCore::ElementAttributeData::detachAttributesFromElement):

        (WebCore::ElementAttributeData::getAttributeItemIndexSlowCase):

        (WebCore::ElementAttributeData::setAttributes):

        (WebCore::ElementAttributeData::clearAttributes):

        (WebCore::ElementAttributeData::replaceAttribute):

        (WebCore::ElementAttributeData::getAttributeNode):

        * dom/ElementAttributeData.h:

        (WebCore):

        (WebCore::AttributeVector::AttributeVector):

        (WebCore::AttributeVector::attributeItem):

        (AttributeVector):

        (WebCore::AttributeVector::getAttributeItem):

        (WebCore::AttributeVector::getAttributeItemIndex):

        (WebCore::AttributeVector::insertAttribute):

        (ElementAttributeData):

        (WebCore::ElementAttributeData::hasAttrs):

        (WebCore::ElementAttributeData::didAddAttr):

        (WebCore::ElementAttributeData::didRemoveAttr):

        (WebCore::ElementAttributeData::ElementAttributeData):

        (WebCore::ElementAttributeData::attributeVector):

        (WebCore::ElementAttributeData::removeAttribute):

        (WebCore::ElementAttributeData::getAttributeItem):

        (WebCore::ElementAttributeData::getAttributeItemIndex):

        * dom/NamedNodeMap.cpp:

        (WebCore::NamedNodeMap::getNamedItem):

        (WebCore::NamedNodeMap::getNamedItemNS):

        (WebCore::NamedNodeMap::removeNamedItem):

        (WebCore::NamedNodeMap::removeNamedItemNS):

        (WebCore::NamedNodeMap::item):

        * dom/Node.cpp:

        (WebCore::Node::compareDocumentPosition):

        * html/parser/HTMLConstructionSite.cpp:

        (WebCore::HTMLConstructionSite::insertHTMLHtmlStartTagBeforeHTML):

        (WebCore::HTMLConstructionSite::mergeAttributesFromTokenIntoElement):

        (WebCore::HTMLConstructionSite::insertScriptElement):

        (WebCore::HTMLConstructionSite::createElement):

        (WebCore::HTMLConstructionSite::createHTMLElement):

        (WebCore::HTMLConstructionSite::createHTMLElementFromSavedElement):

        * html/parser/HTMLToken.h:

        (WebCore::AtomicHTMLToken::AtomicHTMLToken):

        * html/parser/HTMLTreeBuilder.cpp:

        (WebCore::HTMLTreeBuilder::processFakeStartTag):

        (WebCore::HTMLTreeBuilder::attributesForIsindexInput):

        (WebCore::HTMLTreeBuilder::processIsindexStartTagForInBody):

        (WebCore):

        (WebCore::HTMLTreeBuilder::processStartTagForInBody):

        * html/parser/HTMLTreeBuilder.h:

        * html/parser/TextDocumentParser.cpp:

        (WebCore::TextDocumentParser::insertFakePreElement):

        * page/PageSerializer.cpp:

        (WebCore::SerializerMarkupAccumulator::appendCustomAttributes):

        * svg/SVGFitToViewBox.cpp:

        * svg/properties/SVGAnimatedPropertySynchronizer.h:

        * xml/XMLErrors.cpp:

        (WebCore::createXHTMLParserErrorHeader):

        (WebCore::XMLErrors::insertErrorMessageBlock):

        * xml/XPathNodeSet.cpp:

        (WebCore::XPath::NodeSet::traversalSort):

        * xml/XPathStep.cpp:

        (WebCore::XPath::Step::nodesInAxis):

        * xml/parser/MarkupTokenBase.h:

        (WebCore::AtomicMarkupTokenBase::AtomicMarkupTokenBase):

        (WebCore::AtomicMarkupTokenBase::getAttributeItem):

        (WebCore::AtomicMarkupTokenBase::attributes):

        (AtomicMarkupTokenBase):

        (WebCore::::initializeAttributes):

        * xml/parser/XMLToken.h:

        (WebCore::AtomicXMLToken::AtomicXMLToken):

        * xml/parser/XMLTreeBuilder.cpp:

        (WebCore::XMLTreeBuilder::processNamespaces):

        (WebCore::XMLTreeBuilder::processAttributes):

2012-04-13  Andreas Kling  <kling@webkit.org>

        Optimize Element attribute storage for the common case (no Attr objects.)

        <http://webkit.org/b/83440>

        Reviewed by NOBODY (OOPS!).

        Reduce Attribute to its smallest possible size; a qname/value pair.

        They are no-longer ref-counted, which allows us to store them in Vectors.

        Refactored the Attr object to go with the new Attribute:

        Attr now wraps either {element, qname} or {qname, value}. The latter is for

        the case where a standalone Attr object is instantiated via DOM APIs.

        ElementAttributeData.cpp manages a map of pair<element, qname> => Attr.

        Each Element (well, ElementAttributeData) keeps track of how many Attr

        objects are pointing to it. This is so we can avoid hash lookups during

        common operations in the typical case where you have zero Attrs.

        * CMakeLists.txt:

        * GNUmakefile.list.am:

        * Target.pri:

        * WebCore.gypi:

        * WebCore.vcproj/WebCore.vcproj:

        * WebCore.xcodeproj/project.pbxproj:

        * dom/Attr.cpp:

        (WebCore::Attr::Attr):

        (WebCore):

        (WebCore::Attr::create):

        (WebCore::Attr::~Attr):

        (WebCore::Attr::createTextChild):

        (WebCore::Attr::setPrefix):

        (WebCore::Attr::setValue):

        (WebCore::Attr::cloneNode):

        (WebCore::Attr::childrenChanged):

        (WebCore::Attr::style):

        (WebCore::Attr::value):

        (WebCore::Attr::elementAttribute):

        (WebCore::Attr::detachWithValue):

        (WebCore::Attr::attachToElement):

        * dom/Attr.h:

        (WebCore):

        (Attr):

        (WebCore::Attr::qualifiedName):

        (WebCore::Attr::localName):

        (WebCore::Attr::namespaceURI):

        (WebCore::Attr::prefix):

        * dom/Attribute.cpp: Removed.

        * dom/Attribute.h:

        (WebCore::Attribute::Attribute):

        (Attribute):

        * dom/Document.cpp:

        (WebCore::Document::importNode):

        (WebCore::Document::createAttributeNS):

        * dom/Element.cpp:

        (WebCore::Element::~Element):

        (WebCore::Element::takeAttribute):

        (WebCore):

        (WebCore::Element::removeAttribute):

        (WebCore::Element::setAttributeInternal):

        (WebCore::Element::parserSetAttributes):

        (WebCore::Element::setAttributeNode):

        (WebCore::Element::removeAttributeNode):

        (WebCore::Element::normalizeAttributes):

        (WebCore::Element::didRemoveAttribute):

        (WebCore::Element::getAttr):

        (WebCore::Element::getOrCreateAttr):

        * dom/Element.h:

        (Element):

        (WebCore::Element::getAttributeItemIndex):

        * dom/ElementAttributeData.cpp:

        (WebCore):

        (WebCore::attrMap):

        (WebCore::ElementAttributeData::getAttr):

        (WebCore::ElementAttributeData::getOrCreateAttr):

        (WebCore::ElementAttributeData::setAttr):

        (WebCore::ElementAttributeData::removeAttr):

        (WebCore::AttributeVector::removeAttribute):

        (WebCore::ElementAttributeData::~ElementAttributeData):

        (WebCore::ElementAttributeData::addAttribute):

        (WebCore::ElementAttributeData::removeAttribute):

        (WebCore::ElementAttributeData::isEquivalent):

        (WebCore::ElementAttributeData::detachAttributesFromElement):

        (WebCore::ElementAttributeData::getAttributeItemIndexSlowCase):

        (WebCore::ElementAttributeData::setAttributes):

        (WebCore::ElementAttributeData::clearAttributes):

        (WebCore::ElementAttributeData::replaceAttribute):

        (WebCore::ElementAttributeData::getAttributeNode):

        * dom/ElementAttributeData.h:

        (WebCore):

        (WebCore::AttributeVector::AttributeVector):

        (WebCore::AttributeVector::attributeItem):

        (AttributeVector):

        (WebCore::AttributeVector::getAttributeItem):

        (WebCore::AttributeVector::getAttributeItemIndex):

        (WebCore::AttributeVector::insertAttribute):

        (ElementAttributeData):

        (WebCore::ElementAttributeData::hasAttrs):

        (WebCore::ElementAttributeData::didAddAttr):

        (WebCore::ElementAttributeData::didRemoveAttr):

        (WebCore::ElementAttributeData::ElementAttributeData):

        (WebCore::ElementAttributeData::attributeVector):

        (WebCore::ElementAttributeData::removeAttribute):

        (WebCore::ElementAttributeData::getAttributeItem):

        (WebCore::ElementAttributeData::getAttributeItemIndex):

        * dom/NamedNodeMap.cpp:

        (WebCore::NamedNodeMap::getNamedItem):

        (WebCore::NamedNodeMap::getNamedItemNS):

        (WebCore::NamedNodeMap::removeNamedItem):

        (WebCore::NamedNodeMap::removeNamedItemNS):

        (WebCore::NamedNodeMap::item):

        * dom/Node.cpp:

        (WebCore::Node::compareDocumentPosition):

        * html/parser/HTMLConstructionSite.cpp:

        (WebCore::HTMLConstructionSite::insertHTMLHtmlStartTagBeforeHTML):

        (WebCore::HTMLConstructionSite::mergeAttributesFromTokenIntoElement):

        (WebCore::HTMLConstructionSite::insertScriptElement):

        (WebCore::HTMLConstructionSite::createElement):

        (WebCore::HTMLConstructionSite::createHTMLElement):

        (WebCore::HTMLConstructionSite::createHTMLElementFromSavedElement):

        * html/parser/HTMLToken.h:

        (WebCore::AtomicHTMLToken::AtomicHTMLToken):

        * html/parser/HTMLTreeBuilder.cpp:

        (WebCore::HTMLTreeBuilder::processFakeStartTag):

        (WebCore::HTMLTreeBuilder::attributesForIsindexInput):

        (WebCore::HTMLTreeBuilder::processIsindexStartTagForInBody):

        (WebCore):

        (WebCore::HTMLTreeBuilder::processStartTagForInBody):

        * html/parser/HTMLTreeBuilder.h:

        * html/parser/TextDocumentParser.cpp:

        (WebCore::TextDocumentParser::insertFakePreElement):

        * page/PageSerializer.cpp:

        (WebCore::SerializerMarkupAccumulator::appendCustomAttributes):

        * svg/SVGFitToViewBox.cpp:

        * svg/properties/SVGAnimatedPropertySynchronizer.h:

        * xml/XMLErrors.cpp:

        (WebCore::createXHTMLParserErrorHeader):

        (WebCore::XMLErrors::insertErrorMessageBlock):

        * xml/XPathNodeSet.cpp:

        (WebCore::XPath::NodeSet::traversalSort):

        * xml/XPathStep.cpp:

        (WebCore::XPath::Step::nodesInAxis):

        * xml/parser/MarkupTokenBase.h:

        (WebCore::AtomicMarkupTokenBase::AtomicMarkupTokenBase):

        (WebCore::AtomicMarkupTokenBase::getAttributeItem):

        (WebCore::AtomicMarkupTokenBase::attributes):

        (AtomicMarkupTokenBase):

        (WebCore::::initializeAttributes):

        * xml/parser/XMLToken.h:

        (WebCore::AtomicXMLToken::AtomicXMLToken):

        * xml/parser/XMLTreeBuilder.cpp:

        (WebCore::XMLTreeBuilder::processNamespaces):

        (WebCore::XMLTreeBuilder::processAttributes):

2012-04-12  Alec Flett  <alecflett@chromium.org>

        IndexedDB: Attributes for a cursor "run past the end" should be undefined.

Source/WebCore/GNUmakefile.list.am

@@webcore_sources += \

	Source/WebCore/dom/ActiveDOMObject.h \

	Source/WebCore/dom/Attr.cpp \

	Source/WebCore/dom/Attr.h \

1727 Source/WebCore/dom/Attribute.cpp \

	Source/WebCore/dom/Attribute.h \

	Source/WebCore/dom/BeforeLoadEvent.h \

	Source/WebCore/dom/BeforeTextInsertedEvent.cpp \

Source/WebCore/Target.pri

@@SOURCES += \

    css/WebKitCSSTransformValue.cpp \

    dom/ActiveDOMObject.cpp \

    dom/Attr.cpp \

502 dom/Attribute.cpp \

    dom/BeforeTextInsertedEvent.cpp \

    dom/BeforeUnloadEvent.cpp \

    dom/CDATASection.cpp \

Source/WebCore/WebCore.gypi

        'webcore_dom_files': [

            'dom/ActiveDOMObject.cpp',

            'dom/Attr.cpp',

5115 'dom/Attribute.cpp',

            'dom/BeforeLoadEvent.h',

            'dom/BeforeTextInsertedEvent.cpp',

            'dom/BeforeTextInsertedEvent.h',

Source/WebCore/WebCore.vcproj/WebCore.vcproj

				>

			</File>

			<File

				RelativePath="..\dom\Attribute.cpp"

				>

				<FileConfiguration

					Name="Debug|Win32"

					ExcludedFromBuild="true"

					>

					<Tool

						Name="VCCLCompilerTool"

					/>

				</FileConfiguration>

				<FileConfiguration

					Name="Release|Win32"

					ExcludedFromBuild="true"

					>

					<Tool

						Name="VCCLCompilerTool"

					/>

				</FileConfiguration>

				<FileConfiguration

					Name="Debug_Cairo_CFLite|Win32"

					ExcludedFromBuild="true"

					>

					<Tool

						Name="VCCLCompilerTool"

					/>

				</FileConfiguration>

				<FileConfiguration

					Name="Release_Cairo_CFLite|Win32"

					ExcludedFromBuild="true"

					>

					<Tool

						Name="VCCLCompilerTool"

					/>

				</FileConfiguration>

				<FileConfiguration

					Name="Debug_All|Win32"

					ExcludedFromBuild="true"

					>

					<Tool

						Name="VCCLCompilerTool"

					/>

				</FileConfiguration>

				<FileConfiguration

					Name="Production|Win32"

					ExcludedFromBuild="true"

					>

					<Tool

						Name="VCCLCompilerTool"

					/>

				</FileConfiguration>

			</File>

			<File

				RelativePath="..\dom\Attribute.h"

				>

			</File>

Source/WebCore/WebCore.xcodeproj/project.pbxproj

		A8C4A80709D563270003AC8D /* Element.h in Headers */ = {isa = PBXBuildFile; fileRef = A8C4A7F509D563270003AC8D /* Element.h */; settings = {ATTRIBUTES = (Private, ); }; };

		A8C4A80809D563270003AC8D /* Element.cpp in Sources */ = {isa = PBXBuildFile; fileRef = A8C4A7F609D563270003AC8D /* Element.cpp */; };

		A8C4A80B09D563270003AC8D /* Attribute.h in Headers */ = {isa = PBXBuildFile; fileRef = A8C4A7F909D563270003AC8D /* Attribute.h */; settings = {ATTRIBUTES = (Private, ); }; };

4158 A8C4A80C09D563270003AC8D /* Attribute.cpp in Sources */ = {isa = PBXBuildFile; fileRef = A8C4A7FA09D563270003AC8D /* Attribute.cpp */; };

		A8C4A80D09D563270003AC8D /* Attr.h in Headers */ = {isa = PBXBuildFile; fileRef = A8C4A7FB09D563270003AC8D /* Attr.h */; settings = {ATTRIBUTES = (Private, ); }; };

		A8C4A80E09D563270003AC8D /* Attr.cpp in Sources */ = {isa = PBXBuildFile; fileRef = A8C4A7FC09D563270003AC8D /* Attr.cpp */; };

		A8CB413E0E8633FD0032C4F0 /* DashArray.h in Headers */ = {isa = PBXBuildFile; fileRef = A8CB41020E85B8A50032C4F0 /* DashArray.h */; settings = {ATTRIBUTES = (Private, ); }; };

		A8C4A7F509D563270003AC8D /* Element.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = Element.h; sourceTree = "<group>"; };

		A8C4A7F609D563270003AC8D /* Element.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = Element.cpp; sourceTree = "<group>"; };

		A8C4A7F909D563270003AC8D /* Attribute.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = Attribute.h; sourceTree = "<group>"; };

11064 A8C4A7FA09D563270003AC8D /* Attribute.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = Attribute.cpp; sourceTree = "<group>"; };

		A8C4A7FB09D563270003AC8D /* Attr.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = Attr.h; sourceTree = "<group>"; };

		A8C4A7FC09D563270003AC8D /* Attr.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = Attr.cpp; sourceTree = "<group>"; };

		A8CB41020E85B8A50032C4F0 /* DashArray.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DashArray.h; sourceTree = "<group>"; };

				A8C4A7FC09D563270003AC8D /* Attr.cpp */,

				A8C4A7FB09D563270003AC8D /* Attr.h */,

				93EEC1E509C2877700C515D1 /* Attr.idl */,

20917 A8C4A7FA09D563270003AC8D /* Attribute.cpp */,

				A8C4A7F909D563270003AC8D /* Attribute.h */,

				BC9462D7107A7B4C00857193 /* BeforeLoadEvent.h */,

				BC9462CB107A7A3900857193 /* BeforeLoadEvent.idl */,

				E1CDE92015018ED000862CC5 /* AsyncFileStream.cpp in Sources */,

				89D08D9F12228451001241DF /* AsyncFileSystem.cpp in Sources */,

				A8C4A80E09D563270003AC8D /* Attr.cpp in Sources */,

25162 A8C4A80C09D563270003AC8D /* Attribute.cpp in Sources */,

				FD315FF612B0267600C1A359 /* AudioBasicProcessorNode.cpp in Sources */,

				FD315FF812B0267600C1A359 /* AudioBuffer.cpp in Sources */,

				FD315FFB12B0267600C1A359 /* AudioBufferSourceNode.cpp in Sources */,

Source/WebCore/dom/Attr.cpp

 *           (C) 1999 Antti Koivisto (koivisto@kde.org)

 *           (C) 2001 Peter Kelly (pmk@post.com)

 *           (C) 2001 Dirk Mueller (mueller@kde.org)

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

@@namespace WebCore {

using namespace HTMLNames;

39 ~~inline~~ Attr::Attr(Element* element, Docume~~nt* document, PassRefPtr<Attribute> attribute~~)

40 : ContainerNode(document)

39Attr::Attr(Element* element, const QualifiedName& name)

40 : ContainerNode(element->document())

4141 , m_element(element)

42 , m_attribute(attribute)

    , m_name(name)

    , m_ignoreChildrenChanged(0)

    , m_specified(true)

{

}

Attr::Attr(Document* document, const QualifiedName& name, const AtomicString& value)

    : ContainerNode(document)

    , m_element(0)

    , m_name(name)

    , m_value(value)

    , m_ignoreChildrenChanged(0)

    , m_specified(true)

{

46 ASSERT(!m_attribute->attr());

47 m_attribute->bindAttr(this);

4856}

4957

50 PassRefPtr<Attr> Attr::create(Element* element, Document* document, PassRefPtr<Attribute> attribute)

PassRefPtr<Attr> Attr::create(Element* element, const QualifiedName& name)

{

    RefPtr<Attr> attr = adoptRef(new Attr(element, name));

    attr->createTextChild();

    return attr.release();

}

PassRefPtr<Attr> Attr::create(Document* document, const QualifiedName& name, const AtomicString& value)

5166{

52 RefPtr<Attr> attr = adoptRef(new Attr(~~element,~~ document, ~~attrib~~ute));

67 RefPtr<Attr> attr = adoptRef(new Attr(document, name, value));

    attr->createTextChild();

    return attr.release();

}

Attr::~Attr()

{

59 ASSERT(m_attribute->attr() == this);

60 m_attribute->unbindAttr(this);

}

void Attr::createTextChild()

{

    ASSERT(refCount());

66 if (!~~m_attribute->~~value().isEmpty()) {

67 RefPtr<Text> textNode = document()->createTextNode(~~m_attribute->~~value().string());

79 if (!value().isEmpty()) {

80 RefPtr<Text> textNode = document()->createTextNode(value().string());

        // This does everything appendChild() would do in this situation (assuming m_ignoreChildrenChanged was set),

        // but much more efficiently.

@@void Attr::createTextChild()

    }

}

String Attr::nodeName() const

{

    return name();

}

Node::NodeType Attr::nodeType() const

{

    return ATTRIBUTE_NODE;

}

const AtomicString& Attr::localName() const

{

    return m_attribute->localName();

}

const AtomicString& Attr::namespaceURI() const

{

    return m_attribute->namespaceURI();

}

const AtomicString& Attr::prefix() const

{

    return m_attribute->prefix();

}

void Attr::setPrefix(const AtomicString& prefix, ExceptionCode& ec)

{

    ec = 0;

@@void Attr::setPrefix(const AtomicString& prefix, ExceptionCode& ec)

        return;

    }

115 m_attribute->setPrefix(prefix.isEmpty() ? AtomicString() : prefix);

116 }

103 const AtomicString& newPrefix = prefix.isEmpty() ? nullAtom : prefix;

117104

String Attr::nodeValue() const

{

    return value();

    if (Attribute* attribute = elementAttribute())

        attribute->setPrefix(newPrefix);

    m_name.setPrefix(newPrefix);

}

void Attr::setValue(const AtomicString& value)

@@void Attr::setValue(const AtomicString& value)

    EventQueueScope scope;

    m_ignoreChildrenChanged++;

    removeChildren();

128 m_attribute->setValue(value);

    if (m_element)

        elementAttribute()->setValue(value);

    else

        m_value = value;

    createTextChild();

    m_ignoreChildrenChanged--;

132 invalidateNodeListsCacheAfterAttributeChanged(m_~~attribute->~~name());

122 invalidateNodeListsCacheAfterAttributeChanged(m_name);

}

void Attr::setValue(const AtomicString& value, ExceptionCode&)

{

    if (m_element)

138 m_element->willModifyAttribute(m_~~attribute->n~~ame(), ~~m_attribute~~->value(), value);

128 m_element->willModifyAttribute(qualifiedName(), this->value(), value);

    setValue(value);

    if (m_element)

143 m_element->didModifyAttribute(~~m_a~~ttribute~~.get~~());

133 m_element->didModifyAttribute(elementAttribute());

}

void Attr::setNodeValue(const String& v, ExceptionCode& ec)

@@void Attr::setNodeValue(const String& v, ExceptionCode& ec)

PassRefPtr<Node> Attr::cloneNode(bool /*deep*/)

{

153 RefPtr<Attr> clone = adoptRef(new Attr(0, document(), m_~~attribute->clon~~e()));

143 RefPtr<Attr> clone = adoptRef(new Attr(document(), qualifiedName(), value()));

    cloneChildNodes(clone.get());

    return clone.release();

}

@@void Attr::childrenChanged(bool, Node*, Node*, int)

    if (m_ignoreChildrenChanged > 0)

        return;

175 invalidateNodeListsCacheAfterAttributeChanged(m_~~attribute->n~~ame());

165 invalidateNodeListsCacheAfterAttributeChanged(qualifiedName());

    // FIXME: We should include entity references in the value

@@void Attr::childrenChanged(bool, Node*, Node*, int)

    AtomicString newValue = valueBuilder.toString();

    if (m_element)

187 m_element->willModifyAttribute(m_attribute->name(), m_attribute->value(), newValue);

        m_element->willModifyAttribute(qualifiedName(), value(), newValue);

    if (m_element)

        elementAttribute()->setValue(newValue);

    else

        m_value = newValue;

188183

189 m_attribute->setValue(newValue);

190184 if (m_element)

191 m_element->attributeChanged(~~m_a~~ttribute~~.get~~());

185 m_element->attributeChanged(elementAttribute());

}

bool Attr::isId() const

@@CSSStyleDeclaration* Attr::style()

    if (!m_element->isStyledElement())

        return 0;

    m_style = StylePropertySet::create();

205 static_cast<StyledElement*>(m_element)->collectStyleForAttribute(~~m_a~~ttribute~~.get~~(), m_style.get());

199 static_cast<StyledElement*>(m_element)->collectStyleForAttribute(elementAttribute(), m_style.get());

    return m_style->ensureCSSStyleDeclaration();

}

const AtomicString& Attr::value() const

{

    if (m_element)

        return m_element->getAttributeItem(qualifiedName())->value();

    return m_value;

}

Attribute* Attr::elementAttribute()

{

    if (!m_element || !m_element->attributeData())

        return 0;

    return m_element->getAttributeItem(qualifiedName());

}

void Attr::detachFromElementWithValue(const AtomicString& value)

{

    ASSERT(m_element);  

    ASSERT(m_value.isNull());

    m_element->attributeData()->removeAttr(m_element, qualifiedName());

    m_value = value;

    m_element = 0;

}

void Attr::attachToElement(Element* element)

{

    ASSERT(!m_element);

    m_element = element;

    m_value = nullAtom;

}

209233}

Source/WebCore/dom/Attr.h

1

/*

 * Copyright (C) 1999 Lars Knoll (knoll@kde.org)

 *           (C) 1999 Antti Koivisto (koivisto@kde.org)

#define Attr_h

#include "ContainerNode.h"

29 #include "~~Attribut~~e.h"

30#include "QualifiedName.h"

namespace WebCore {

@@class StylePropertySet;

// Attr can have Text and EntityReference children

// therefore it has to be a fullblown Node. The plan

// is to dynamically allocate a textchild and store the

39 // resulting nodevalue in the Attribute upon

40// resulting nodevalue in the attribute upon

// destruction. however, this is not yet implemented.

class Attr : public ContainerNode {

43 friend class AttributeVector;

44 friend class ElementAttributeData;

4544public:

46 static PassRefPtr<Attr> create(Element*, Document*, PassRefPtr<Attribute>);

45 static PassRefPtr<Attr> create(Element*, const QualifiedName&);

46 static PassRefPtr<Attr> create(Document*, const QualifiedName&, const AtomicString& value);

    virtual ~Attr();

    String name() const { return qualifiedName().toString(); }

    bool specified() const { return m_specified; }

    Element* ownerElement() const { return m_element; }

53 const AtomicString& value() const ~~{ return m_attribute->value(); }~~

53 const AtomicString& value() const;

    void setValue(const AtomicString&, ExceptionCode&);

    void setValue(const AtomicString&);

57 Attribute* attr() const { return m_attribute.get(); }

58 const QualifiedName& qualifiedName() const { return m_attribute->name(); }

57 const QualifiedName& qualifiedName() const { return m_name; }

    bool isId() const;

@@public:

    void setSpecified(bool specified) { m_specified = specified; }

    void attachToElement(Element*);

    void detachFromElementWithValue(const AtomicString&);

6668private:

67 Attr(Element*, Document*, PassRefPtr<Attribute>);

69 Attr(Element*, const QualifiedName&);

70 Attr(Document*, const QualifiedName&, const AtomicString& value);

    void createTextChild();

71 virtual String nodeName() const;

72 virtual NodeType nodeType() const;

74 virtual String nodeName() const OVERRIDE { return name(); }

75 virtual NodeType nodeType() const OVERRIDE { return ATTRIBUTE_NODE; }

7376

    const AtomicString& localName() const;

    const AtomicString& namespaceURI() const;

    const AtomicString& prefix() const;

    const AtomicString& localName() const { return m_name.localName(); }

    const AtomicString& namespaceURI() const { return m_name.namespaceURI(); }

    const AtomicString& prefix() const { return m_name.prefix(); }

    virtual void setPrefix(const AtomicString&, ExceptionCode&);

80 virtual String nodeValue() const;

83 virtual String nodeValue() const OVERRIDE { return value(); }

    virtual void setNodeValue(const String&, ExceptionCode&);

    virtual PassRefPtr<Node> cloneNode(bool deep);

@@private:

    virtual const AtomicString& virtualLocalName() const { return localName(); }

    virtual const AtomicString& virtualNamespaceURI() const { return namespaceURI(); }

    Attribute* elementAttribute();

    // Attr wraps either an element/name, or a name/value pair (when it's a standalone Node.)

    // Note that m_name is always set, but m_element/m_value may be null.

93100 Element* m_element;

94 RefPtr<Attribute> m_attribute;

    QualifiedName m_name;

    AtomicString m_value;

    RefPtr<StylePropertySet> m_style;

    unsigned m_ignoreChildrenChanged : 31;

    bool m_specified : 1;

Source/WebCore/dom/Attribute.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)

 * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.

 *

 * 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.

 */

#include "config.h"

#include "Attribute.h"

#include "Attr.h"

#include "Element.h"

#include <wtf/HashMap.h>

#include <wtf/UnusedParam.h>

namespace WebCore {

typedef HashMap<Attribute*, Attr*> AttributeAttrMap;

static AttributeAttrMap& attributeAttrMap()

{

    DEFINE_STATIC_LOCAL(AttributeAttrMap, map, ());

    return map;

}

PassRefPtr<Attribute> Attribute::clone() const

{

    return adoptRef(new Attribute(m_name, m_value));

}

Attr* Attribute::attr() const

{

    if (m_hasAttr) {

        ASSERT(attributeAttrMap().contains(const_cast<Attribute*>(this)));

        return attributeAttrMap().get(const_cast<Attribute*>(this));

    }

    ASSERT(!attributeAttrMap().contains(const_cast<Attribute*>(this)));

    return 0;

}

PassRefPtr<Attr> Attribute::createAttrIfNeeded(Element* e)

{

    RefPtr<Attr> r;

    if (m_hasAttr) {

        ASSERT(attributeAttrMap().contains(this));

        r = attributeAttrMap().get(this);

    } else {

        ASSERT(!attributeAttrMap().contains(this));

        r = Attr::create(e, e->document(), this); // This will end up calling Attribute::bindAttr.

        ASSERT(attributeAttrMap().contains(this));

    }

    return r.release();

}

void Attribute::bindAttr(Attr* attr)

{

    ASSERT(!m_hasAttr);

    ASSERT(!attributeAttrMap().contains(this));

    attributeAttrMap().set(this, attr);

    m_hasAttr = true;

}

void Attribute::unbindAttr(Attr* attr)

{

    ASSERT(m_hasAttr);

    ASSERT(attributeAttrMap().contains(this));

    ASSERT_UNUSED(attr, attributeAttrMap().get(this) == attr);

    attributeAttrMap().remove(this);

    m_hasAttr = false;

}

} // namespace WebCore

Source/WebCore/dom/Attribute.h

 *           (C) 1999 Antti Koivisto (koivisto@kde.org)

 *           (C) 2001 Peter Kelly (pmk@post.com)

 *           (C) 2001 Dirk Mueller (mueller@kde.org)

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

namespace WebCore {

class Attr;

class Element;

// This has no counterpart in DOM.

// It is an internal representation of the node value of an Attr.

// The actual Attr with its value as a Text child is allocated only if needed.

38 class Attribute : public RefCounted<Attribute> {

39 friend class Attr;

35class Attribute {

4036public:

41 static PassRefPtr<Attribute> create(const QualifiedName& name, const AtomicString& value)

37 Attribute()

38 : m_name(nullAtom, nullAtom, nullAtom)

4239 {

43 return adoptRef(new Attribute(name, value));

4440 }

45 static PassRefPtr<Attribute> create(const AtomicString& name, const AtomicString& value)

    Attribute(const QualifiedName& name, const AtomicString& value)

        : m_name(name)

        , m_value(value)

    {

    }

    Attribute(const AtomicString& name, const AtomicString& value)

        : m_name(nullAtom, name, nullAtom)

        , m_value(value)

4651 {

47 return adoptRef(new Attribute(name, value));

    }

    const AtomicString& value() const { return m_value; }

    const AtomicString& prefix() const { return m_name.prefix(); }

    const AtomicString& localName() const { return m_name.localName(); }

    const AtomicString& namespaceURI() const { return m_name.namespaceURI(); }

54

58

5559 const QualifiedName& name() const { return m_name; }

    
    Attr* attr() const;

    PassRefPtr<Attr> createAttrIfNeeded(Element*);

    bool isNull() const { return m_value.isNull(); }

    bool isEmpty() const { return m_value.isEmpty(); }

62

63 PassRefPtr<Attribute> clone() const;

    void setValue(const AtomicString& value) { m_value = value; }

    void setPrefix(const AtomicString& prefix) { m_name.setPrefix(prefix); }

@@public:

    void parserSetName(const QualifiedName& name) { m_name = name; }

private:

    Attribute(const QualifiedName& name, const AtomicString& value)

        : m_hasAttr(false)

        , m_name(name)

        , m_value(value)

    {

    }

    Attribute(const AtomicString& name, const AtomicString& value)

        : m_hasAttr(false)

        , m_name(nullAtom, name, nullAtom)

        , m_value(value)

    {

    }

    void bindAttr(Attr*);

    void unbindAttr(Attr*);

    // This boolean will go into the spare 32-bits of padding from RefCounted in 64-bit.

    bool m_hasAttr;

    QualifiedName m_name;

    AtomicString m_value;

};

Source/WebCore/dom/Document.cpp

@@PassRefPtr<Node> Document::importNode(Node* importedNode, bool deep, ExceptionCo

        return newElement.release();

    }

    case ATTRIBUTE_NODE:

913 return Attr::create(0, this, static_cast<Attr*>(importedNode)->attr()->c~~lon~~e());

913 return Attr::create(this, QualifiedName(nullAtom, static_cast<Attr*>(importedNode)->name(), nullAtom), static_cast<Attr*>(importedNode)->value());

    case DOCUMENT_FRAGMENT_NODE: {

        if (importedNode->isShadowRoot()) {

            // ShadowRoot nodes should not be explicitly importable.

@@PassRefPtr<Attr> Document::createAttributeNS(const String& namespaceURI, const S

        return 0;

    }

4453 return Attr::create(0, this, ~~Attribute::create(~~qName, String~~Impl::empty~~()));

4453 return Attr::create(this, qName, emptyString());

}

#if ENABLE(SVG)

Source/WebCore/dom/Element.cpp

@@Element::~Element()

    if (shadowTree())

        rareData()->m_shadowTree.clear();

    if (m_attributeData)

130 m_attributeData->clearAttributes();

130 m_attributeData->clearAttributes(this);

}

inline ElementRareData* Element::rareData() const

@@void Element::copyNonAttributeProperties(const Element*)

{

}

PassRefPtr<Attr> Element::takeAttribute(size_t index)

{

    if (!attributeData())

        return 0;

    Attribute* attribute = attributeData()->attributeItem(index);

    RefPtr<Attr> attr = getAttr(attribute->name());

    if (attr)

        attr->detachFromElementWithValue(attribute->value());

    else

        attr = Attr::create(document(), attribute->name(), attribute->value());

    attributeData()->removeAttribute(index, this);

    return attr.release();

}

void Element::removeAttribute(const QualifiedName& name)

{

    if (!attributeData())

        return;

    
    if (RefPtr<Attr> attr = getAttr(name))

        attr->detachFromElementWithValue(attr->value());

    attributeData()->removeAttribute(name, this);

}

@@inline void Element::setAttributeInternal(size_t index, const QualifiedName& nam

    }

    if (!old) {

654 m_attributeData->addAttribute(Attribute~~::create~~(name, value), this, inUpdateStyleAttribute);

675 m_attributeData->addAttribute(Attribute(name, value), this, inUpdateStyleAttribute);

        return;

    }

    if (inUpdateStyleAttribute == NotInUpdateStyleAttribute)

659 willModifyAttribute(name, old ~~? old~~->value() ~~: nullAtom~~, value);

680 willModifyAttribute(name, old->value(), value);

660681

661 if (Attr* attrNode = ~~old->a~~ttr())

682 if (RefPtr<Attr> attrNode = getAttr(name))

        attrNode->setValue(value);

    else

        old->setValue(value);

@@static bool isAttributeToRemove(const QualifiedName& name, const AtomicString& v

    return (name.localName().endsWith(hrefAttr.localName()) || name == srcAttr || name == actionAttr) && protocolIsJavaScript(stripLeadingAndTrailingHTMLSpaces(value));       

}

743 void Element::parserSetAttributes(Pa~~ssOwnPtr<~~AttributeVector> attributeVector, FragmentScriptingPermission scriptingPermission)

764void Element::parserSetAttributes(const AttributeVector& attributeVector, FragmentScriptingPermission scriptingPermission)

{

    ASSERT(!inDocument());

    ASSERT(!parentNode());

    ASSERT(!m_attributeData);

750 if (!attributeVector)

771 if (attributeVector.isEmpty())

        return;

    createAttributeData();

754 m_attributeData->m_attributes.swap(*attributeVector);

775 m_attributeData->m_attributes = attributeVector;

    // If the element is created as result of a paste or drag-n-drop operation

    // we want to remove all the script and event handlers.

    if (scriptingPermission == FragmentScriptingNotAllowed) {

        unsigned i = 0;

        while (i < m_attributeData->length()) {

761 const QualifiedName& attributeName = m_attributeData->m_attributes[i]->name();

782 const QualifiedName& attributeName = m_attributeData->m_attributes[i].name();

            if (isEventHandlerAttribute(attributeName)) {

                m_attributeData->m_attributes.remove(i);

                continue;

            }

767 if (isAttributeToRemove(attributeName, m_attributeData->m_attributes[i]->value()))

768 m_attributeData->m_attributes[i]->setValue(nullAtom);

788 if (isAttributeToRemove(attributeName, m_attributeData->m_attributes[i].value()))

789 m_attributeData->m_attributes[i].setValue(nullAtom);

            i++;

        }

    }

    // Store the set of attributes that changed on the stack in case

    // attributeChanged mutates m_attributeData.

    Vector<RefPtr<Attribute> > attributes;

    m_attributeData->copyAttributesToVector(attributes);

    for (Vector<RefPtr<Attribute> >::iterator iter = attributes.begin(); iter != attributes.end(); ++iter)

        attributeChanged(iter->get());

    AttributeVector attributes = m_attributeData->attributeVector();

    for (unsigned i = 0; i < attributes.size(); ++i)

        attributeChanged(&attributes[i]);

}

bool Element::hasAttributes() const

@@PassRefPtr<Attr> Element::setAttributeNode(Attr* attr, ExceptionCode& ec)

    }

    ElementAttributeData* attributeData = ensureUpdatedAttributeData();

    Attribute* attribute = attr->attr();

    size_t index = attributeData->getAttributeItemIndex(attribute->name());

    Attribute* oldAttribute = index != notFound ? attributeData->attributeItem(index) : 0;

    if (oldAttribute == attribute)

        return attr; // we know about it already

    RefPtr<Attr> oldAttr = getAttr(attr->qualifiedName());

    if (oldAttr.get() == attr)

        return attr; // This Attr is already attached to the element.

    // INUSE_ATTRIBUTE_ERR: Raised if node is an Attr that is already an attribute of another Element object.

    // The DOM user must explicitly clone Attr nodes to re-use them in other elements.

@@PassRefPtr<Attr> Element::setAttributeNode(Attr* attr, ExceptionCode& ec)

        return 0;

    }

    RefPtr<Attr> oldAttr;

    if (oldAttribute) {

        oldAttr = oldAttribute->createAttrIfNeeded(this);

        attributeData->replaceAttribute(index, attribute, this);

    } else

        attributeData->addAttribute(attribute, this);

1426 size_t index = attributeData->getAttributeItemIndex(attr->qualifiedName());

1427 Attribute* oldAttribute = index != notFound ? attributeData->attributeItem(index) : 0;

14131428

    if (!oldAttribute) {

        attributeData->addAttribute(Attribute(attr->qualifiedName(), attr->value()), this);

        attributeData->setAttr(this, attr->qualifiedName(), attr);

        return 0;

    }

    if (oldAttr)

        oldAttr->detachFromElementWithValue(oldAttribute->value());

    else

        oldAttr = Attr::create(document(), oldAttribute->name(), oldAttribute->value());

    attributeData->replaceAttribute(index, Attribute(attr->name(), attr->value()), this);

    attributeData->setAttr(this, attr->qualifiedName(), attr);

    return oldAttr.release();

}

@@PassRefPtr<Attr> Element::removeAttributeNode(Attr* attr, ExceptionCode& ec)

        return 0;

    }

1445 return attributeData->takeAttribute(index, this);

    RefPtr<Attr> oldAttr = getOrCreateAttr(attr->qualifiedName());

    attributeData->removeAttribute(index, this);

    return oldAttr.release();

}

void Element::setAttributeNS(const AtomicString& namespaceURI, const AtomicString& qualifiedName, const AtomicString& value, ExceptionCode& ec, FragmentScriptingPermission scriptingPermission)

@@void Element::removeAttribute(const String& name)

    String localName = shouldIgnoreAttributeCase(this) ? name.lower() : name;

    size_t index = attributeData->getAttributeItemIndex(localName, false);

    if (index == notFound)

1476 return;

1506 return;

    attributeData->removeAttribute(index, this);

}

@@void Element::normalizeAttributes()

    if (!attributeData || attributeData->isEmpty())

        return;

    Vector<RefPtr<Attribute> > attributeVector;

    attributeData->copyAttributesToVector(attributeVector);

    size_t numAttrs = attributeVector.size();

    for (size_t i = 0; i < numAttrs; ++i) {

        if (Attr* attr = attributeVector[i]->attr())

    AttributeVector attributes = attributeData->attributeVector();

    for (size_t i = 0; i < attributes.size(); ++i) {

        if (RefPtr<Attr> attr = getAttr(attributes[i].name()))

            attr->normalize();

    }

}

@@void Element::didModifyAttribute(Attribute* attr)

    // Do not dispatch a DOMSubtreeModified event here; see bug 81141.

}

2028 void Element::didRemoveAttribute(A~~ttribut~~e* ~~attr~~)

2056void Element::didRemoveAttribute(const QualifiedName& name)

20292057{

    if (attr->isNull())

        return;

    AtomicString savedValue = attr->value();

    attr->setValue(nullAtom);

    attributeChanged(attr);

    attr->setValue(savedValue);

2058 Attribute dummyAttribute(name, nullAtom);

2059 attributeChanged(&dummyAttribute);

20372060

2038 InspectorInstrumentation::didRemoveDOMAttr(document(), this, ~~attr->~~name().localName());

2061 InspectorInstrumentation::didRemoveDOMAttr(document(), this, name.localName());

    dispatchSubtreeModifiedEvent();

}

@@void Element::setSavedLayerScrollOffset(const IntSize& size)

    ensureRareData()->m_savedLayerScrollOffset = size;

}

PassRefPtr<Attr> Element::getAttr(const QualifiedName& name)

{

    if (!attributeData())

        return 0;

    return attributeData()->getAttr(this, name);

}

PassRefPtr<Attr> Element::getOrCreateAttr(const QualifiedName& name)

{

    ASSERT(attributeData());

    return attributeData()->getOrCreateAttr(this, name);

}

20842120} // namespace WebCore

Source/WebCore/dom/Element.h

@@public:

    const AtomicString& getAttribute(const QualifiedName&) const;

    void setAttribute(const QualifiedName&, const AtomicString& value, EInUpdateStyleAttribute = NotInUpdateStyleAttribute);

    void removeAttribute(const QualifiedName&);

118 void removeAttribute(size_t index);

    // Typed getters and setters for language bindings.

    int getIntegralAttribute(const QualifiedName& attributeName) const;

@@public:

    size_t attributeCount() const;

    Attribute* attributeItem(unsigned index) const;

    Attribute* getAttributeItem(const QualifiedName&) const;

167 size_t getAttributeItemIndex(const QualifiedName& name) const { return attributeData()->getAttributeItemIndex(name); }

168 size_t getAttributeItemIndex(const String& name, bool shouldIgnoreAttributeCase) const { return attributeData()->getAttributeItemIndex(name, shouldIgnoreAttributeCase); }

    void scrollIntoView(bool alignToTop = true);

    void scrollIntoViewIfNeeded(bool centerIfNeeded = true);

@@public:

    void removeAttribute(const String& name);

    void removeAttributeNS(const String& namespaceURI, const String& localName);

202

203 PassRefPtr<Attr> takeAttribute(size_t index);

    PassRefPtr<Attr> getAttributeNode(const String& name);

    PassRefPtr<Attr> getAttributeNodeNS(const String& namespaceURI, const String& localName);

    PassRefPtr<Attr> setAttributeNode(Attr*, ExceptionCode&);

    PassRefPtr<Attr> setAttributeNodeNS(Attr*, ExceptionCode&);

    PassRefPtr<Attr> removeAttributeNode(Attr*, ExceptionCode&);

    PassRefPtr<Attr> getAttr(const QualifiedName&);

    PassRefPtr<Attr> getOrCreateAttr(const QualifiedName&);

    

    virtual CSSStyleDeclaration* style();

@@public:

    virtual void attributeChanged(Attribute*);

    // Only called by the parser immediately after element construction.

239 void parserSetAttributes(Pa~~ssOwnPtr<~~AttributeVector>, FragmentScriptingPermission);

247 void parserSetAttributes(const AttributeVector&, FragmentScriptingPermission);

    ElementAttributeData* attributeData() const { return m_attributeData.get(); }

    ElementAttributeData* ensureAttributeData() const;

@@public:

    void willRemoveAttribute(const QualifiedName&, const AtomicString& value);

    void didAddAttribute(Attribute*);

    void didModifyAttribute(Attribute*);

300 void didRemoveAttribute(A~~ttribut~~e*);

308 void didRemoveAttribute(const QualifiedName&);

    LayoutSize minimumSizeForResizing() const;

    void setMinimumSizeForResizing(const LayoutSize&);

Source/WebCore/dom/ElementAttributeData.cpp

#include "ElementAttributeData.h"

#include "CSSStyleSheet.h"

30#include "Attr.h"

#include "StyledElement.h"

namespace WebCore {

typedef HashMap<pair<Element*, QualifiedName>, RefPtr<Attr> > AttrMap;

static AttrMap& attrMap()

{

    DEFINE_STATIC_LOCAL(AttrMap, map, ());

    return map;

}

PassRefPtr<Attr> ElementAttributeData::getAttr(Element* element, const QualifiedName& name)

{

    if (!m_attrCount)

        return 0;

    return attrMap().get(std::make_pair(element, name)).get();

}

PassRefPtr<Attr> ElementAttributeData::getOrCreateAttr(Element* element, const QualifiedName& name)

{

    AttrMap::AddResult result = attrMap().add(std::make_pair(element, name), 0);

    if (result.isNewEntry) {

        result.iterator->second = Attr::create(element, name);

        setAttr(element, name, result.iterator->second.get());

    }

    return result.iterator->second.get();

}

void ElementAttributeData::setAttr(Element* element, const QualifiedName& name, Attr* attr)

{

    ASSERT(!attrMap().contains(std::make_pair(element, name)));

    attrMap().add(std::make_pair(element, name), attr);

    attr->attachToElement(element);

    didAddAttr();

}

void ElementAttributeData::removeAttr(Element* element, const QualifiedName& name)

{

    ASSERT(attrMap().contains(std::make_pair(element, name)));

    attrMap().remove(std::make_pair(element, name));

    didRemoveAttr();

}

void AttributeVector::removeAttribute(const QualifiedName& name)

{

    size_t index = getAttributeItemIndex(name);

    if (index == notFound)

        return;

    RefPtr<Attribute> attribute = at(index);

    if (Attr* attr = attribute->attr())

        attr->m_element = 0;

    remove(index);

}

ElementAttributeData::~ElementAttributeData()

{

48 detachAttributesFromElement();

}

void ElementAttributeData::setClass(const String& className, bool shouldFoldCase)

@@void ElementAttributeData::destroyInlineStyle(StyledElement* element)

    m_inlineStyleDecl = 0;

}

97 void ElementAttributeData::addAttribute(Pa~~ssRefPtr<~~Attribute> ~~prpA~~ttribute, Element* element, EInUpdateStyleAttribute inUpdateStyleAttribute)

133void ElementAttributeData::addAttribute(const Attribute& attribute, Element* element, EInUpdateStyleAttribute inUpdateStyleAttribute)

98134{

99 RefPtr<Attribute> attribute = prpAttribute;

100

101135 if (element && inUpdateStyleAttribute == NotInUpdateStyleAttribute)

102 element->willModifyAttribute(attribute->name(), nullAtom, attribute->value());

136 element->willModifyAttribute(attribute.name(), nullAtom, attribute.value());

103137

104138 m_attributes.append(attribute);

105 if (Attr* attr = attribute->attr())

106 attr->m_element = element;

107139

108140 if (element && inUpdateStyleAttribute == NotInUpdateStyleAttribute)

109 element->didAddAttribute(attribute~~.get(~~));

141 element->didAddAttribute(const_cast<Attribute*>(&attribute));

}

void ElementAttributeData::removeAttribute(size_t index, Element* element, EInUpdateStyleAttribute inUpdateStyleAttribute)

{

    ASSERT(index < length());

116 RefPtr<Attribute> attribute = m_attributes[index];

148 Attribute& attribute = m_attributes[index];

149 QualifiedName name = attribute.name();

117150

118151 if (element && inUpdateStyleAttribute == NotInUpdateStyleAttribute)

119 element->willRemoveAttribute(attribute->name(), attribute->value());

        element->willRemoveAttribute(name, attribute.value());

    if (RefPtr<Attr> attr = getAttr(element, name))

        attr->detachFromElementWithValue(attribute.value());

120156

121 if (Attr* attr = attribute->attr())

122 attr->m_element = 0;

    m_attributes.remove(index);

    if (element && inUpdateStyleAttribute == NotInUpdateStyleAttribute)

        element->didRemoveAttribute(attribute.get());

}

PassRefPtr<Attr> ElementAttributeData::takeAttribute(size_t index, Element* element)

{

    ASSERT(index < length());

    ASSERT(element);

    RefPtr<Attr> attr = m_attributes[index]->createAttrIfNeeded(element);

    removeAttribute(index, element);

    return attr.release();

160 element->didRemoveAttribute(name);

}

bool ElementAttributeData::isEquivalent(const ElementAttributeData* other) const

@@bool ElementAttributeData::isEquivalent(const ElementAttributeData* other) const

        return false;

    for (unsigned i = 0; i < len; i++) {

        Attribute* attr = attributeItem(i);

        Attribute* otherAttr = other->getAttributeItem(attr->name());

        if (!otherAttr || attr->value() != otherAttr->value())

173 Attribute* otherAttr = other->getAttributeItem(m_attributes[i].name());

174 if (!otherAttr || m_attributes[i].value() != otherAttr->value())

            return false;

    }

    return true;

}

158 void ElementAttributeData::detachAttributesFromElement()

181void ElementAttributeData::detachAttributesFromElement(Element* element)

159182{

    size_t size = m_attributes.size();

    for (size_t i = 0; i < size; i++) {

        if (Attr* attr = m_attributes[i]->attr())

            attr->m_element = 0;

    }

}

183 if (!m_attrCount)

184 return;

166185

void ElementAttributeData::copyAttributesToVector(Vector<RefPtr<Attribute> >& copy)

{

    copy = m_attributes;

    for (unsigned i = 0; i < m_attributes.size(); ++i) {

        if (RefPtr<Attr> attr = getAttr(element, m_attributes[i].name()))

            attr->detachFromElementWithValue(m_attributes[i].value());

    }

}

size_t ElementAttributeData::getAttributeItemIndexSlowCase(const String& name, bool shouldIgnoreAttributeCase) const

{

174 unsigned len = length();

175

176194 // Continue to checking case-insensitively and/or full namespaced names if necessary:

    for (unsigned i = 0; i < len; ++i) {

        const QualifiedName& attrName = m_attributes[i]->name();

        if (!attrName.hasPrefix()) {

            if (shouldIgnoreAttributeCase && equalIgnoringCase(name, attrName.localName()))

    for (unsigned i = 0; i < m_attributes.size(); ++i) {

        if (!m_attributes[i].name().hasPrefix()) {

            if (shouldIgnoreAttributeCase && equalIgnoringCase(name, m_attributes[i].localName()))

                return i;

        } else {

            // 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.

186 if (equalPossiblyIgnoringCase(name, attrName.toString(), shouldIgnoreAttributeCase))

203 if (equalPossiblyIgnoringCase(name, m_attributes[i].name().toString(), shouldIgnoreAttributeCase))

                return i;

        }

    }

@@void ElementAttributeData::setAttributes(const ElementAttributeData& other, Elem

    if (oldName || newName)

        element->updateName(oldName ? oldName->value() : nullAtom, newName ? newName->value() : nullAtom);

211 clearAttributes();

228 clearAttributes(element);

    unsigned newLength = other.length();

    m_attributes.resize(newLength);

    // FIXME: These loops can probably be combined.

    for (unsigned i = 0; i < newLength; i++)

217 m_attributes[i] = other.m_attributes[i]~~->clone()~~;

234 m_attributes[i] = other.m_attributes[i];

218235 for (unsigned i = 0; i < newLength; i++)

219 element->attributeChanged(m_attributes[i]~~.get()~~);

236 element->attributeChanged(&m_attributes[i]);

220237}

221238

222 void ElementAttributeData::clearAttributes()

239void ElementAttributeData::clearAttributes(Element* element)

223240{

224241 clearClass();

225 detachAttributesFromElement();

242 detachAttributesFromElement(element);

    m_attributes.clear();

}

229 void ElementAttributeData::replaceAttribute(size_t index, Pa~~ssRefPtr<~~Attribute> ~~prpA~~ttribute, Element* element)

246void ElementAttributeData::replaceAttribute(size_t index, const Attribute& attribute, Element* element)

{

    ASSERT(element);

    ASSERT(index < length());

    RefPtr<Attribute> attribute = prpAttribute;

    Attribute* old = m_attributes[index].get();

    element->willModifyAttribute(attribute->name(), old->value(), attribute->value());

    if (Attr* attr = old->attr())

        attr->m_element = 0;

251 element->willModifyAttribute(attribute.name(), m_attributes[index].value(), attribute.value());

241252 m_attributes[index] = attribute;

242 if (Attr* attr = attribute->attr())

243 attr->m_element = element;

    element->didModifyAttribute(const_cast<Attribute*>(&attribute));

}

PassRefPtr<Attr> ElementAttributeData::getAttributeNode(const String& name, bool shouldIgnoreAttributeCase, Element* element) const

{

    ASSERT(element);

    Attribute* attribute = getAttributeItem(name, shouldIgnoreAttributeCase);

    if (!attribute)

        return 0;

    return const_cast<ElementAttributeData*>(this)->getOrCreateAttr(element, attribute->name());

}

244264

245 element->didModifyAttribute(attribute.get());

PassRefPtr<Attr> ElementAttributeData::getAttributeNode(const QualifiedName& name, Element* element) const

{

    ASSERT(element);

    Attribute* attribute = getAttributeItem(name);

    if (!attribute)

        return 0;

    return const_cast<ElementAttributeData*>(this)->getOrCreateAttr(element, attribute->name());

246272}

247273

274

248275}

Source/WebCore/dom/ElementAttributeData.h

#ifndef ElementAttributeData_h

#define ElementAttributeData_h

29 #include "Attr.h"

#include "Attribute.h"

#include "SpaceSplitString.h"

#include "StylePropertySet.h"

namespace WebCore {

36class Attr;

3737class Element;

3838

class AttributeVector : public Vector<RefPtr<Attribute>, 4> {

    friend class ElementAttributeData;

39class AttributeVector : public Vector<Attribute, 4> {

4240public:

    static PassOwnPtr<AttributeVector> create()

    {

        return adoptPtr(new AttributeVector());

    }

41 AttributeVector() { }

4742

48 Attribute* attributeItem(unsigned index) const { return at(index)~~.get()~~; }

43 Attribute* attributeItem(unsigned index) const { return &const_cast<AttributeVector*>(this)->at(index); }

    Attribute* getAttributeItem(const QualifiedName&) const;

    size_t getAttributeItemIndex(const QualifiedName&) const;

    // Used during parsing: only inserts if not already there.

53 void insertAttribute(Pa~~ssRefPtr<~~Attribute~~> newAttribute~~);

48 void insertAttribute(const Attribute&);

5449 void removeAttribute(const QualifiedName&);

private:

    AttributeVector() { }

};

inline Attribute* AttributeVector::getAttributeItem(const QualifiedName& name) const

{

    size_t index = getAttributeItemIndex(name);

    if (index != notFound)

64 return at(index)~~.get()~~;

56 return &const_cast<AttributeVector*>(this)->at(index);

    return 0;

}

inline size_t AttributeVector::getAttributeItemIndex(const QualifiedName& name) const

{

    for (unsigned i = 0; i < size(); ++i) {

71 if (at(i)->name().matches(name))

63 if (at(i).name().matches(name))

            return i;

    }

    return notFound;

}

77 inline void AttributeVector::insertAttribute(Pa~~ssRefPtr<~~Attribute> newAttribute)

69inline void AttributeVector::insertAttribute(const Attribute& newAttribute)

7870{

79 if (!getAttributeItem(newAttribute->name()))

71 if (!getAttributeItem(newAttribute.name()))

        append(newAttribute);

}

@@public:

    size_t getAttributeItemIndex(const String& name, bool shouldIgnoreAttributeCase) const;

    // These functions do no error checking.

123 void addAttribute(Pa~~ssRefPtr<~~Attribute>, Element*, EInUpdateStyleAttribute = NotInUpdateStyleAttribute);

115 void addAttribute(const Attribute&, Element*, EInUpdateStyleAttribute = NotInUpdateStyleAttribute);

    void removeAttribute(const QualifiedName&, Element*);

    void removeAttribute(size_t index, Element*, EInUpdateStyleAttribute = NotInUpdateStyleAttribute);

    PassRefPtr<Attr> takeAttribute(size_t index, Element*);

@@public:

    bool isEquivalent(const ElementAttributeData* other) const;

    bool hasAttrs() const { return m_attrCount; }

    void didAddAttr() { m_attrCount++; }

    void didRemoveAttr() { m_attrCount--; }

    void setAttr(Element*, const QualifiedName&, Attr*);

    void removeAttr(Element*, const QualifiedName&);

    PassRefPtr<Attr> getAttr(Element*, const QualifiedName&);

    PassRefPtr<Attr> getOrCreateAttr(Element*, const QualifiedName&);

133134private:

134135 friend class Element;

136 friend class HTMLConstructionSite;

135137

136138 ElementAttributeData()

139 : m_attrCount(0)

    {

    }

140 void detachAttributesFromElement();

141 void copyAttributesToVector(Vector<RefPtr<Attribute> >&);

    AttributeVector attributeVector() const { return m_attributes; }

    void detachAttributesFromElement(Element*);

    Attribute* getAttributeItem(const String& name, bool shouldIgnoreAttributeCase) const;

    size_t getAttributeItemIndexSlowCase(const String& name, bool shouldIgnoreAttributeCase) const;

    void setAttributes(const ElementAttributeData& other, Element*);

145 void clearAttributes();

146 void replaceAttribute(size_t index, Pa~~ssRefPtr<~~Attribute>, Element*);

149 void clearAttributes(Element*);

150 void replaceAttribute(size_t index, const Attribute&, Element*);

    RefPtr<StylePropertySet> m_inlineStyleDecl;

    RefPtr<StylePropertySet> m_attributeStyle;

    SpaceSplitString m_classNames;

    AtomicString m_idForStyleResolution;

    AttributeVector m_attributes;

157

158 unsigned m_attrCount;

};

inline void ElementAttributeData::removeAttribute(const QualifiedName& name, Element* element)

@@inline void ElementAttributeData::removeAttribute(const QualifiedName& name, Ele

        return;

    removeAttribute(index, element);

}

inline PassRefPtr<Attr> ElementAttributeData::getAttributeNode(const String& name, bool shouldIgnoreAttributeCase, Element* element) const

{

    ASSERT(element);

    Attribute* attribute = getAttributeItem(name, shouldIgnoreAttributeCase);

    if (!attribute)

        return 0;

    return attribute->createAttrIfNeeded(element);

}

inline PassRefPtr<Attr> ElementAttributeData::getAttributeNode(const QualifiedName& name, Element* element) const

{

    ASSERT(element);

    Attribute* attribute = getAttributeItem(name);

    if (!attribute)

        return 0;

    return attribute->createAttrIfNeeded(element);

168 return;

}

inline Attribute* ElementAttributeData::getAttributeItem(const String& name, bool shouldIgnoreAttributeCase) const

{

    size_t index = getAttributeItemIndex(name, shouldIgnoreAttributeCase);

    if (index != notFound)

186 return m_attributes[index]~~.get()~~;

175 return &const_cast<ElementAttributeData*>(this)->m_attributes[index];

    return 0;

}

@@inline size_t ElementAttributeData::getAttributeItemIndex(const String& name, bo

    // Optimize for the case where the attribute exists and its name exactly matches.

    for (unsigned i = 0; i < len; ++i) {

        const QualifiedName& attrName = m_attributes[i]->name();

        if (!attrName.hasPrefix()) {

            if (name == attrName.localName())

188 if (!m_attributes[i].name().hasPrefix()) {

189 if (name == m_attributes[i].localName())

                return i;

        } else

            doSlowCheck = true;

Source/WebCore/dom/NamedNodeMap.cpp

@@void NamedNodeMap::deref()

PassRefPtr<Node> NamedNodeMap::getNamedItem(const String& name) const

{

55 return m_element~~->attributeData()~~->getAttributeNode(name~~, shouldIgnoreAttributeCase(m_element), m_element~~);

55 return m_element->getAttributeNode(name);

}

PassRefPtr<Node> NamedNodeMap::getNamedItemNS(const String& namespaceURI, const String& localName) const

{

60 return m_element->~~attributeData()->~~getAttributeNode~~(QualifiedName(nullAtom, localName,~~ namespaceURI)~~, m_e~~le~~ment~~);

60 return m_element->getAttributeNodeNS(namespaceURI, localName);

}

PassRefPtr<Node> NamedNodeMap::removeNamedItem(const String& name, ExceptionCode& ec)

{

    ElementAttributeData* attributeData = m_element->attributeData();

    size_t index = attributeData->getAttributeItemIndex(name, shouldIgnoreAttributeCase(m_element));

65 size_t index = m_element->getAttributeItemIndex(name, shouldIgnoreAttributeCase(m_element));

    if (index == notFound) {

        ec = NOT_FOUND_ERR;

        return 0;

    }

72

73 return attributeData->takeAttribute(index, m_element);

70 return m_element->takeAttribute(index);

}

PassRefPtr<Node> NamedNodeMap::removeNamedItemNS(const String& namespaceURI, const String& localName, ExceptionCode& ec)

{

    ElementAttributeData* attributeData = m_element->attributeData();

    size_t index = attributeData->getAttributeItemIndex(QualifiedName(nullAtom, localName, namespaceURI));

75 size_t index = m_element->getAttributeItemIndex(QualifiedName(nullAtom, localName, namespaceURI));

    if (index == notFound) {

        ec = NOT_FOUND_ERR;

        return 0;

    }

85

86 return attributeData->takeAttribute(index, m_element);

80 return m_element->takeAttribute(index);

}

PassRefPtr<Node> NamedNodeMap::setNamedItem(Node* node, ExceptionCode& ec)

@@PassRefPtr<Node> NamedNodeMap::item(unsigned index) const

{

    if (index >= length())

        return 0;

114 return m_element->attributeItem(index)->~~createAttrIfNeeded(m_element~~);

108 return m_element->getOrCreateAttr(m_element->attributeItem(index)->name());

}

size_t NamedNodeMap::length() const

Source/WebCore/dom/Node.cpp

@@unsigned short Node::compareDocumentPosition(Node* otherNode)

            // the same nodeType are inserted into or removed from the direct container. This would be the case, for example, 

            // when comparing two attributes of the same element, and inserting or removing additional attributes might change 

            // the order between existing attributes.

2093 Attribute* attr = owner1->attributeItem(i);

2094 if (attr1->~~attr~~() == attr)

2093 Attribute* attribute = owner1->attributeItem(i);

2094 if (attr1->qualifiedName() == attribute->name())

20952095 return DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC | DOCUMENT_POSITION_FOLLOWING;

2096 if (attr2->~~attr~~() == attr)

2096 if (attr2->qualifiedName() == attribute->name())

                return DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC | DOCUMENT_POSITION_PRECEDING;

        }

Source/WebCore/html/parser/HTMLConstructionSite.cpp

@@void HTMLConstructionSite::dispatchDocumentElementAvailableIfNeeded()

void HTMLConstructionSite::insertHTMLHtmlStartTagBeforeHTML(AtomicHTMLToken& token)

{

    RefPtr<HTMLHtmlElement> element = HTMLHtmlElement::create(m_document);

197 element->parserSetAttributes(token.t~~akeA~~ttributes(), m_fragmentScriptingPermission);

197 element->parserSetAttributes(token.attributes(), m_fragmentScriptingPermission);

    attachLater(m_attachmentRoot, element);

    m_openElements.pushHTMLHtmlElement(element);

@@void HTMLConstructionSite::insertHTMLHtmlStartTagBeforeHTML(AtomicHTMLToken& tok

void HTMLConstructionSite::mergeAttributesFromTokenIntoElement(AtomicHTMLToken& token, Element* element)

{

208 if (!token.attributes())

208 if (token.attributes().isEmpty())

        return;

    ElementAttributeData* attributes = element->ensureAttributeData();

212 for (unsigned i = 0; i < token.attributes()->size(); ++i) {

213 Attribute* attribute = token.attributes()->attributeItem(i);

212 for (unsigned i = 0; i < token.attributes().size(); ++i) {

213 Attribute* attribute = token.attributes().attributeItem(i);

        if (!attributes->getAttributeItem(attribute->name()))

            element->setAttribute(attribute->name(), attribute->value());

    }

@@void HTMLConstructionSite::insertScriptElement(AtomicHTMLToken& token)

{

    RefPtr<HTMLScriptElement> element = HTMLScriptElement::create(scriptTag, currentNode()->document(), true);

    if (m_fragmentScriptingPermission == FragmentScriptingAllowed)

339 element->parserSetAttributes(token.t~~akeA~~ttributes(), m_fragmentScriptingPermission);

339 element->parserSetAttributes(token.attributes(), m_fragmentScriptingPermission);

    attachLater(currentNode(), element);

    m_openElements.push(element.release());

}

@@PassRefPtr<Element> HTMLConstructionSite::createElement(AtomicHTMLToken& token,

{

    QualifiedName tagName(nullAtom, token.name(), namespaceURI);

    RefPtr<Element> element = currentNode()->document()->createElement(tagName, true);

402 element->parserSetAttributes(token.t~~akeA~~ttributes(), m_fragmentScriptingPermission);

402 element->parserSetAttributes(token.attributes(), m_fragmentScriptingPermission);

    return element.release();

}

@@PassRefPtr<Element> HTMLConstructionSite::createHTMLElement(AtomicHTMLToken& tok

    // have to pass the current form element.  We should rework form association

    // to occur after construction to allow better code sharing here.

    RefPtr<Element> element = HTMLElementFactory::createHTMLElement(tagName, currentNode()->document(), form(), true);

413 element->parserSetAttributes(token.t~~akeA~~ttributes(), m_fragmentScriptingPermission);

413 element->parserSetAttributes(token.attributes(), m_fragmentScriptingPermission);

    ASSERT(element->isHTMLElement());

    return element.release();

}

@@PassRefPtr<Element> HTMLConstructionSite::createHTMLElementFromElementRecord(HTM

    return createHTMLElementFromSavedElement(record->element());

}

namespace {

// FIXME: Move this function to the top of the file.

inline PassOwnPtr<AttributeVector> cloneAttributes(Element* element)

{

    ElementAttributeData* attributes = element->updatedAttributeData();

    if (!attributes)

        return nullptr;

    OwnPtr<AttributeVector> newAttributes = AttributeVector::create();

    for (size_t i = 0; i < attributes->length(); ++i) {

        Attribute* attribute = attributes->attributeItem(i);

        RefPtr<Attribute> clone = Attribute::create(attribute->name(), attribute->value());

        newAttributes->append(clone);

    }

    return newAttributes.release();

}

} // namespace

PassRefPtr<Element> HTMLConstructionSite::createHTMLElementFromSavedElement(Element* element)

{

    // FIXME: This method is wrong.  We should be using the original token.

@@PassRefPtr<Element> HTMLConstructionSite::createHTMLElementFromSavedElement(Elem

    // spec implies it should be "1".  Minefield matches the HTML5 spec here.

    ASSERT(element->isHTMLElement()); // otherwise localName() might be wrong.

453 AtomicHTMLToken fakeToken(HTMLTokenTypes::StartTag, element->localName(), cloneAttributes(element));

    AttributeVector attributes;

    if (ElementAttributeData* attributeData = element->updatedAttributeData())

        attributes = attributeData->attributeVector();

    AtomicHTMLToken fakeToken(HTMLTokenTypes::StartTag, element->localName(), attributes);

    return createHTMLElement(fakeToken);

}

Source/WebCore/html/parser/HTMLToken.h

@@class AtomicHTMLToken : public AtomicMarkupTokenBase<HTMLToken> {

public:

    AtomicHTMLToken(HTMLToken& token) : AtomicMarkupTokenBase<HTMLToken>(&token) { }

89 AtomicHTMLToken(HTMLTokenTypes::Type type, AtomicString name, Pa~~ssOwnPtr<~~AttributeVector> attributes = ~~nullp~~tr)

89 AtomicHTMLToken(HTMLTokenTypes::Type type, AtomicString name, const AttributeVector& attributes = AttributeVector())

        : AtomicMarkupTokenBase<HTMLToken>(type, name, attributes)

    {

    }

Source/WebCore/html/parser/HTMLTreeBuilder.cpp

@@void HTMLTreeBuilder::processDoctypeToken(AtomicHTMLToken& token)

    parseError(token);

}

534 void HTMLTreeBuilder::processFakeStartTag(const QualifiedName& tagName, Pa~~ssOwnPtr<~~AttributeVector> attributes)

534void HTMLTreeBuilder::processFakeStartTag(const QualifiedName& tagName, const AttributeVector& attributes)

{

    // FIXME: We'll need a fancier conversion than just "localName" for SVG/MathML tags.

    AtomicHTMLToken fakeToken(HTMLTokenTypes::StartTag, tagName.localName(), attributes);

@@void HTMLTreeBuilder::processFakePEndTagIfPInButtonScope()

    processEndTag(endP);

}

563 ~~PassOwnPtr<~~AttributeVector> HTMLTreeBuilder::attributesForIsindexInput(AtomicHTMLToken& token)

563AttributeVector HTMLTreeBuilder::attributesForIsindexInput(AtomicHTMLToken& token)

564564{

    OwnPtr<AttributeVector> attributes = token.takeAttributes();

    if (!attributes)

        attributes = AttributeVector::create();

    else {

        attributes->removeAttribute(nameAttr);

        attributes->removeAttribute(actionAttr);

        attributes->removeAttribute(promptAttr);

    AttributeVector& attributes = token.attributes();

    if (!attributes.isEmpty()) {

        attributes.removeAttribute(nameAttr);

        attributes.removeAttribute(actionAttr);

        attributes.removeAttribute(promptAttr);

572570 }

573571

    RefPtr<Attribute> mappedAttribute = Attribute::create(nameAttr, isindexTag.localName());

    attributes->insertAttribute(mappedAttribute.release());

    return attributes.release();

572 attributes.insertAttribute(Attribute(nameAttr, isindexTag.localName()));

573 return attributes;

}

void HTMLTreeBuilder::processIsindexStartTagForInBody(AtomicHTMLToken& token)

@@void HTMLTreeBuilder::processIsindexStartTagForInBody(AtomicHTMLToken& token)

        return;

    notImplemented(); // Acknowledge self-closing flag

    processFakeStartTag(formTag);

588 ~~RefPtr<~~Attribute> actionAttribute = token.getAttributeItem(actionAttr);

585 Attribute* actionAttribute = token.getAttributeItem(actionAttr);

    if (actionAttribute)

        m_tree.form()->setAttribute(actionAttr, actionAttribute->value());

    processFakeStartTag(hrTag);

    processFakeStartTag(labelTag);

593 ~~RefPtr<~~Attribute> promptAttribute = token.getAttributeItem(promptAttr);

590 Attribute* promptAttribute = token.getAttributeItem(promptAttr);

    if (promptAttribute)

        processFakeCharacters(promptAttribute->value());

    else

@@void adjustAttributes(AtomicHTMLToken& token)

        mapLoweredLocalNameToName(caseMap, attrs, length);

    }

    AttributeVector* attributes = token.attributes();

    if (!attributes)

        return;

    for (unsigned x = 0; x < attributes->size(); ++x) {

        Attribute* attribute = attributes->attributeItem(x);

679 for (unsigned i = 0; i < token.attributes().size(); ++i) {

680 Attribute* attribute = token.attributes().attributeItem(i);

        const QualifiedName& casedName = caseMap->get(attribute->localName());

        if (!casedName.localName().isNull())

            attribute->parserSetName(casedName);

@@void adjustForeignAttributes(AtomicHTMLToken& token)

        map->add("xmlns:xlink", QualifiedName("xmlns", "xlink", XMLNSNames::xmlnsNamespaceURI));

    }

    AttributeVector* attributes = token.attributes();

    if (!attributes)

        return;

    for (unsigned x = 0; x < attributes->size(); ++x) {

        Attribute* attribute = attributes->attributeItem(x);

724 for (unsigned i = 0; i < token.attributes().size(); ++i) {

725 Attribute* attribute = token.attributes().attributeItem(i);

        const QualifiedName& name = map->get(attribute->localName());

        if (!name.localName().isNull())

            attribute->parserSetName(name);

@@void HTMLTreeBuilder::processStartTagForInBody(AtomicHTMLToken& token)

        return;

    }

    if (token.name() == inputTag) {

933 ~~RefPtr<~~Attribute> typeAttribute = token.getAttributeItem(typeAttr);

922 Attribute* typeAttribute = token.getAttributeItem(typeAttr);

        m_tree.reconstructTheActiveFormattingElements();

        m_tree.insertSelfClosingHTMLElement(token);

        if (!typeAttribute || !equalIgnoringCase(typeAttribute->value(), "hidden"))

Source/WebCore/html/parser/HTMLTreeBuilder.h

@@private:

    void processCharacterBuffer(ExternalCharacterTokenBuffer&);

    inline void processCharacterBufferForInBody(ExternalCharacterTokenBuffer&);

154 void processFakeStartTag(const QualifiedName&, Pa~~ssOwnPtr<~~AttributeVector> attributes = ~~nullp~~tr);

154 void processFakeStartTag(const QualifiedName&, const AttributeVector& attributes = AttributeVector());

    void processFakeEndTag(const QualifiedName&);

    void processFakeCharacters(const String&);

    void processFakePEndTagIfPInButtonScope();

@@private:

    inline bool shouldProcessTokenInForeignContent(AtomicHTMLToken&);

    void processTokenInForeignContent(AtomicHTMLToken&);

175 ~~PassOwnPtr<~~AttributeVector> attributesForIsindexInput(AtomicHTMLToken&);

175 AttributeVector attributesForIsindexInput(AtomicHTMLToken&);

    HTMLElementStack::ElementRecord* furthestBlockForFormattingElement(Element*);

    void callTheAdoptionAgency(AtomicHTMLToken&);

Source/WebCore/html/parser/TextDocumentParser.cpp

@@void TextDocumentParser::insertFakePreElement()

    // sending fake bytes through the front-end of the parser to avoid

    // distrubing the line/column number calculations.

    RefPtr<Attribute> styleAttribute = Attribute::create("style", "word-wrap: break-word; white-space: pre-wrap;");

    OwnPtr<AttributeVector> attributes = AttributeVector::create();

    attributes->insertAttribute(styleAttribute.release());

    AtomicHTMLToken fakePre(HTMLTokenTypes::StartTag, preTag.localName(), attributes.release());

    AttributeVector attributes;

    attributes.insertAttribute(Attribute("style", "word-wrap: break-word; white-space: pre-wrap;"));

    AtomicHTMLToken fakePre(HTMLTokenTypes::StartTag, preTag.localName(), attributes);

    treeBuilder()->constructTreeFromAtomicToken(fakePre);

    // Normally we would skip the first \n after a <pre> element, but we don't

Source/WebCore/page/PageSerializer.cpp

@@void SerializerMarkupAccumulator::appendCustomAttributes(StringBuilder& out, Ele

    // We need to give a fake location to blank frames so they can be referenced by the serialized frame.

    url = m_serializer->urlForBlankFrame(frame);

162 RefPtr<Attribute> attribute = Attribute::create(frameOwnerURLAttributeName(*frameOwner), url.string());

163 appendAttribute(out, element, *attribute, namespaces);

162 appendAttribute(out, element, Attribute(frameOwnerURLAttributeName(*frameOwner), url.string()), namespaces);

}

void SerializerMarkupAccumulator::appendEndTag(Node* node)

Source/WebCore/svg/SVGFitToViewBox.cpp

#include "SVGFitToViewBox.h"

#include "AffineTransform.h"

27 #include "Attr.h"

27#include "Attribute.h"

#include "Document.h"

#include "FloatRect.h"

#include "SVGDocumentExtensions.h"

Source/WebCore/svg/properties/SVGAnimatedPropertySynchronizer.h

@@struct SVGAnimatedPropertySynchronizer<true> {

        if (old && value.isNull())

            attributeData->removeAttribute(old->name(), ownerElement);

        else if (!old && !value.isNull())

45 attributeData->addAttribute(Attribute~~::create~~(attrName, value), ownerElement);

45 attributeData->addAttribute(Attribute(attrName, value), ownerElement);

        else if (old && !value.isNull())

            old->setValue(value);

    }

Source/WebCore/xml/XMLErrors.cpp

@@static inline PassRefPtr<Element> createXHTMLParserErrorHeader(Document* doc, co

{

    RefPtr<Element> reportElement = doc->createElement(QualifiedName(nullAtom, "parsererror", xhtmlNamespaceURI), true);

    OwnPtr<AttributeVector> reportAttributes = AttributeVector::create();

    reportAttributes->append(Attribute::create(styleAttr, "display: block; white-space: pre; border: 2px solid #c77; padding: 0 1em 0 1em; margin: 1em; background-color: #fdd; color: black"));

    reportElement->parserSetAttributes(reportAttributes.release(), FragmentScriptingNotAllowed);

    AttributeVector reportAttributes;

    reportAttributes.append(Attribute(styleAttr, "display: block; white-space: pre; border: 2px solid #c77; padding: 0 1em 0 1em; margin: 1em; background-color: #fdd; color: black"));

    reportElement->parserSetAttributes(reportAttributes, FragmentScriptingNotAllowed);

    RefPtr<Element> h3 = doc->createElement(h3Tag, true);

    reportElement->parserAddChild(h3.get());

    h3->parserAddChild(doc->createTextNode("This page contains the following errors:"));

    RefPtr<Element> fixed = doc->createElement(divTag, true);

    OwnPtr<AttributeVector> fixedAttributes = AttributeVector::create();

    fixedAttributes->append(Attribute::create(styleAttr, "font-family:monospace;font-size:12px"));

    fixed->parserSetAttributes(fixedAttributes.release(), FragmentScriptingNotAllowed);

    AttributeVector fixedAttributes;

    fixedAttributes.append(Attribute(styleAttr, "font-family:monospace;font-size:12px"));

    fixed->parserSetAttributes(fixedAttributes, FragmentScriptingNotAllowed);

    reportElement->parserAddChild(fixed.get());

    fixed->parserAddChild(doc->createTextNode(errorMessages));

@@void XMLErrors::insertErrorMessageBlock()

#if ENABLE(XSLT)

    if (m_document->transformSourceDocument()) {

161 ~~OwnPtr<AttributeVector> attributes =~~ AttributeVector~~::cre~~at~~e()~~;

162 attributes->append(Attribu~~te::crea~~te(styleAttr, "white-space: normal"));

161 AttributeVector attributes;

162 attributes.append(Attribute(styleAttr, "white-space: normal"));

163163 RefPtr<Element> paragraph = m_document->createElement(pTag, true);

164 paragraph->parserSetAttributes(attributes~~.release()~~, FragmentScriptingNotAllowed);

164 paragraph->parserSetAttributes(attributes, FragmentScriptingNotAllowed);

        paragraph->parserAddChild(m_document->createTextNode("This document was created as the result of an XSL transformation. The line and column numbers given are from the transformed result."));

        reportElement->parserAddChild(paragraph.release());

    }

Source/WebCore/xml/XPathNodeSet.cpp

@@void NodeSet::traversalSort() const

        unsigned attributeCount = element->attributeCount();

        for (unsigned i = 0; i < attributeCount; ++i) {

            Attr* attribute = element->attributeItem(i)->attr();

            if (attribute && nodes.contains(attribute))

                sortedNodes.append(attribute);

            RefPtr<Attr> attr = element->attributeData()->getAttr(element, element->attributeItem(i)->name());

            if (attr && nodes.contains(attr.get()))

                sortedNodes.append(attr);

        }

    }

Source/WebCore/xml/XPathStep.cpp

@@void Step::nodesInAxis(Node* context, NodeSet& nodes) const

                return;

            for (unsigned i = 0; i < contextElement->attributeCount(); ++i) {

349 RefPtr<Attr> attr = contextElement->attributeItem(i)->~~createAttrIfNeeded(static_cast<Element*>(context~~));

349 RefPtr<Attr> attr = contextElement->attributeData()->getOrCreateAttr(contextElement, contextElement->attributeItem(i)->name());

                if (nodeMatches(attr.get(), AttributeAxis, m_nodeTest))

                    nodes.append(attr.release());

            }

Source/WebCore/xml/parser/MarkupTokenBase.h

#define MarkupTokenBase_h

#include "ElementAttributeData.h"

31 #include <wtf/PassOwnPtr.h>

#include <wtf/Vector.h>

#ifndef NDEBUG

@@public:

        }

    }

413 AtomicMarkupTokenBase(typename Token::Type::Type type, AtomicString name, Pa~~ssOwnPtr<~~AttributeVector> attributes = ~~nullp~~tr)

412 AtomicMarkupTokenBase(typename Token::Type::Type type, AtomicString name, const AttributeVector& attributes = AttributeVector())

        : m_type(type)

        , m_name(name)

        , m_externalCharacters(0)

@@public:

    Attribute* getAttributeItem(const QualifiedName& attributeName)

    {

        ASSERT(usesAttributes());

        if (!m_attributes)

            return 0;

        return m_attributes->getAttributeItem(attributeName);

444 return m_attributes.getAttributeItem(attributeName);

448445 }

449446

450 AttributeVector* attributes() ~~const~~

447 AttributeVector& attributes()

451448 {

452449 ASSERT(usesAttributes());

453 return m_attributes~~.get()~~;

450 return m_attributes;

454451 }

455452

456 Pa~~ssOwnPtr<~~AttributeVector> t~~akeA~~ttributes()

453 const AttributeVector& attributes() const

457454 {

458455 ASSERT(usesAttributes());

459 return m_attributes~~.release()~~;

456 return m_attributes;

    }

    const typename Token::DataVector& characters() const

@@protected:

    // For StartTag and EndTag

    bool m_selfClosing;

520 ~~OwnPtr<~~AttributeVector> m_attributes;

517 AttributeVector m_attributes;

};

template<typename Token>

@@inline void AtomicMarkupTokenBase<Token>::initializeAttributes(const typename To

    if (!size)

        return;

530 m_attributes ~~= AttributeVector::create~~();

531 m_attributes->reserveInitialCapacity(size);

527 m_attributes.clear();

528 m_attributes.reserveInitialCapacity(size);

    for (size_t i = 0; i < size; ++i) {

        const typename Token::Attribute& attribute = attributes[i];

        if (attribute.m_name.isEmpty())

@@inline void AtomicMarkupTokenBase<Token>::initializeAttributes(const typename To

        ASSERT(attribute.m_valueRange.m_end);

        AtomicString value(attribute.m_value.data(), attribute.m_value.size());

545 m_attributes->insertAttribute(Attribu~~te::crea~~te(nameForAttribute(attribute), value));

542 m_attributes.insertAttribute(Attribute(nameForAttribute(attribute), value));

    }

}

Source/WebCore/xml/parser/XMLToken.h

@@public:

        }

    }

434 AtomicXMLToken(XMLTokenTypes::Type type, AtomicString name, Pa~~ssOwnPtr<~~AttributeVector> attributes = ~~nullp~~tr)

434 AtomicXMLToken(XMLTokenTypes::Type type, AtomicString name, const AttributeVector& attributes = AttributeVector())

        : AtomicMarkupTokenBase<XMLToken>(type, name, attributes)

    {

    }

Source/WebCore/xml/parser/XMLTreeBuilder.cpp

@@void XMLTreeBuilder::processEntity(const AtomicXMLToken& token)

void XMLTreeBuilder::processNamespaces(const AtomicXMLToken& token, NodeStackItem& stackItem)

{

    if (!token.attributes())

        return;

    for (size_t i = 0; i < token.attributes()->size(); ++i) {

        Attribute* attribute = token.attributes()->attributeItem(i);

301 for (unsigned i = 0; i < token.attributes().size(); ++i) {

302 Attribute* attribute = token.attributes().attributeItem(i);

        if (attribute->name().prefix() == xmlnsAtom)

            stackItem.setNamespaceURI(attribute->name().localName(), attribute->value());

        else if (attribute->name() == xmlnsAtom)

@@void XMLTreeBuilder::processNamespaces(const AtomicXMLToken& token, NodeStackIte

void XMLTreeBuilder::processAttributes(const AtomicXMLToken& token, NodeStackItem& stackItem, PassRefPtr<Element> newElement)

{

    if (!token.attributes())

        return;

    for (size_t i = 0; i < token.attributes()->size(); ++i) {

        Attribute* attribute = token.attributes()->attributeItem(i);

312 for (unsigned i = 0; i < token.attributes().size(); ++i) {

313 Attribute* attribute = token.attributes().attributeItem(i);

        ExceptionCode ec = 0;

        if (attribute->name().prefix() == xmlnsAtom)

            newElement->setAttributeNS(XMLNSNames::xmlnsNamespaceURI, "xmlns:" + attribute->name().localName(), attribute->value(), ec);

Source/WebKit/chromium/ChangeLog

2012-04-13  Andreas Kling  <kling@webkit.org>

        Optimize Element attribute storage for the common case (no Attr objects.)

        <http://webkit.org/b/83440>

        Reviewed by NOBODY (OOPS!).

        Neuter the WebKit/chromium API wrapper for WebCore::Attribute in an attempt

        to get cr-ews results. This is not the final patch, obviously.

        * public/WebAttribute.h:

        (WebAttribute):

        * src/WebAttribute.cpp:

        (WebKit::WebAttribute::reset):

        (WebKit::WebAttribute::assign):

        (WebKit::WebAttribute::localName):

        (WebKit::WebAttribute::value):

2012-04-12  Kent Tamura  <tkent@chromium.org>

        [Chromium] Enable INPUT_TYPE_DATE

Source/WebKit/chromium/public/WebAttribute.h

#include "platform/WebPrivatePtr.h"

namespace WebCore { class Attribute; }

#if WEBKIT_IMPLEMENTATION

namespace WTF { template <typename T> class PassRefPtr; }

#endif

namespace WebKit {

class WebString;

@@public:

    WEBKIT_EXPORT WebString localName() const;

    WEBKIT_EXPORT WebString value() const;

#if WEBKIT_IMPLEMENTATION

    WebAttribute(const WTF::PassRefPtr<WebCore::Attribute>&);

#endif

private:

    WebPrivatePtr<WebCore::Attribute> m_private;

};

} // namespace WebKit

Source/WebKit/chromium/src/WebAttribute.cpp

@@namespace WebKit {

void WebAttribute::reset()

{

44 m_private.reset();

}

void WebAttribute::assign(const WebAttribute& other)

{

    m_private = other.m_private;

}

WebAttribute::WebAttribute(const PassRefPtr<Attribute>& other)

    : m_private(other)

{

}

WebString WebAttribute::localName() const

{

59 return WebString(~~m_private->localName()~~);

52 return WebString();

}

WebString WebAttribute::value() const

{

64 return WebString(~~m_private->value()~~);

57 return WebString();

}

} // namespace WebKit