File indexing completed on 2024-05-05 16:11:38

 /**
  * This file is part of the DOM implementation for KDE.
  *
  * 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) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
  *           (C) 2005, 2008 Maksim Orlovich (maksim@kde.org)
  *           (C) 2006 Allan Sandfeld Jensen (kde@carewolf.com)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 //#define EVENT_DEBUG
 
 #include "dom_elementimpl.h"
 
 #include <dom/dom_exception.h>
 #include <dom/dom_node.h>
 #include <dom/html_image.h>
 #include "dom_textimpl.h"
 #include "dom_docimpl.h"
 #include "dom2_eventsimpl.h"
 #include "dom_restyler.h"
 #include "dom_xmlimpl.h"
 
 #include <html/dtd.h>
 #include <html/htmlparser.h>
 #include <html/html_imageimpl.h>
 
 #include <rendering/render_canvas.h>
 #include <css/css_valueimpl.h>
 #include <css/css_stylesheetimpl.h>
 #include <css/cssstyleselector.h>
 #include <css/cssvalues.h>
 #include <css/cssproperties.h>
 #include <khtml_part.h>
 #include <khtmlview.h>
 
 #include <editing/editing_p.h>
 #include <editing/editor.h>
 
 #include <QTextStream>
 #include <QTextDocument>
 #include "khtml_debug.h"
 #include <stdlib.h>
 
 #include <wtf/HashMap.h>
 
 // ### support default attributes
 // ### dispatch mutation events
 // ### check for INVALID_CHARACTER_ERR where appropriate
 
 using namespace khtml;
 
 namespace DOM
 {
 
 AttrImpl::AttrImpl(ElementImpl *element, DocumentImpl *docPtr, NamespaceName namespacename, LocalName localName, PrefixName prefix, DOMStringImpl *value)
     : NodeBaseImpl(docPtr)
 {
     m_value = value;
     m_value->ref();
 
     m_namespace = namespacename;
     m_localName = localName;
     m_prefix = prefix;
 
     // When creating the text node initially, we want element = 0,
     // so we don't attempt to update the getElementById cache or
     // call parseAttribute, etc. This is because we're normally lazily,
     // from previous attributes, so there is nothing really changing
     m_element = nullptr;
     createTextChild();
     m_element = element;
 }
 
 AttrImpl::~AttrImpl()
 {
     m_value->deref();
 }
 
 DOMString AttrImpl::nodeName() const
 {
     return name();
 }
 
 unsigned short AttrImpl::nodeType() const
 {
     return Node::ATTRIBUTE_NODE;
 }
 
 DOMString AttrImpl::prefix() const
 {
     return m_prefix.toString();
 }
 
 void AttrImpl::setPrefix(const DOMString &_prefix, int &exceptioncode)
 {
     checkSetPrefix(_prefix, exceptioncode);
     if (exceptioncode) {
         return;
     }
 
     m_prefix = PrefixName::fromString(_prefix);
 }
 
 DOMString AttrImpl::namespaceURI() const
 {
     if (m_htmlCompat) {
         return DOMString();
     }
     return m_namespace.toString();
 }
 
 DOMString AttrImpl::localName() const
 {
     return m_localName.toString();
 }
 
 DOMString AttrImpl::nodeValue() const
 {
     return m_value;
 }
 
 DOMString AttrImpl::name() const
 {
     DOMString n = m_localName.toString();
 
     // compat mode always return attribute names in lowercase.
     // that's not formally in the specification, but common
     // practice - a w3c erratum to DOM L2 is pending.
     if (m_htmlCompat) {
         n = n.lower();
     }
 
     DOMString p = m_prefix.toString();
     if (!p.isEmpty()) {
         return p + DOMString(":") + n;
     }
 
     return n;
 }
 
 void AttrImpl::createTextChild()
 {
     // add a text node containing the attribute value
     if (m_value->length() > 0) {
         TextImpl *textNode = ownerDocument()->createTextNode(m_value);
 
         // We want to use addChild and not appendChild here to avoid triggering
         // mutation events. childrenChanged() will still be called.
         addChild(textNode);
     }
 }
 
 void AttrImpl::childrenChanged()
 {
     NodeBaseImpl::childrenChanged();
 
     // update value
     DOMStringImpl *oldVal = m_value;
     m_value = new DOMStringImpl((QChar *)nullptr, 0);
     m_value->ref();
     for (NodeImpl *n = firstChild(); n; n = n->nextSibling()) {
         DOMStringImpl *data = static_cast<const TextImpl *>(n)->string();
         m_value->append(data);
     }
 
     if (m_element) {
         int curr = id();
         if (curr == ATTR_ID) {
             m_element->updateId(oldVal, m_value);
         }
         m_element->parseAttribute(this);
         m_element->attributeChanged(curr);
     }
 
     oldVal->deref();
 }
 
 void AttrImpl::setValue(const DOMString &v, int &exceptioncode)
 {
     exceptioncode = 0;
 
     // do not interpret entities in the string, it is literal!
 
     // NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly
     if (isReadOnly()) {
         exceptioncode = DOMException::NO_MODIFICATION_ALLOWED_ERR;
         return;
     }
 
     // ### what to do on 0 ?
     if (v.isNull()) {
         exceptioncode = DOMException::DOMSTRING_SIZE_ERR;
         return;
     }
 
     if (m_value == v.implementation()) {
         return;
     }
 
     int e = 0;
     removeChildren();
     appendChild(ownerDocument()->createTextNode(v.implementation()), e);
 }
 
 void AttrImpl::rewriteValue(const DOMString &newValue)
 {
     int ec;
 
     // We want to avoid any notifications, so temporarily set m_element to 0
     ElementImpl *saveElement = m_element;
     m_element = nullptr;
     setValue(newValue, ec);
     m_element = saveElement;
 }
 
 void AttrImpl::setNodeValue(const DOMString &v, int &exceptioncode)
 {
     exceptioncode = 0;
     // NO_MODIFICATION_ALLOWED_ERR: taken care of by setValue()
     setValue(v, exceptioncode);
 }
 
 WTF::PassRefPtr<NodeImpl> AttrImpl::cloneNode(bool /*deep*/)
 {
     AttrImpl *attr = new AttrImpl(nullptr, docPtr(), m_namespace, m_localName, m_prefix, m_value);
     attr->setHTMLCompat(m_htmlCompat);
     return attr;
 }
 
 // DOM Section 1.1.1
 bool AttrImpl::childAllowed(NodeImpl *newChild)
 {
     if (!newChild) {
         return false;
     }
 
     return childTypeAllowed(newChild->nodeType());
 }
 
 bool AttrImpl::childTypeAllowed(unsigned short type)
 {
     switch (type) {
     case Node::TEXT_NODE:
     case Node::ENTITY_REFERENCE_NODE:
         return true;
         break;
     default:
         return false;
     }
 }
 
 DOMString AttrImpl::toString() const
 {
     DOMString result;
 
     result += nodeName();
 
     // FIXME: substitute entities for any instances of " or ' --
     // maybe easier to just use text value and ignore existing
     // entity refs?
 
     if (!nodeValue().isEmpty()) {
         //remove the else once the AttributeImpl changes are merged
         result += "=\"";
         result += nodeValue();
         result += "\"";
     }
 
     return result;
 }
 
 void AttrImpl::setElement(ElementImpl *element)
 {
     m_element = element;
 }
 
 // -------------------------------------------------------------------------
 
 void AttributeImpl::setValue(DOMStringImpl *value, ElementImpl *element)
 {
     assert(value);
     if (m_localName.id()) {
         if (m_data.value == value) {
             return;
         }
 
         if (element && id() == ATTR_ID) {
             element->updateId(m_data.value, value);
         }
 
         m_data.value->deref();
         m_data.value = value;
         m_data.value->ref();
 
         if (element) {
             element->parseAttribute(this);
             element->attributeChanged(id());
         }
     } else {
         int exceptioncode = 0;
         m_data.attr->setValue(value, exceptioncode);
         // AttrImpl::setValue() calls parseAttribute()
     }
 }
 
 void AttributeImpl::rewriteValue(const DOMString &newValue)
 {
     if (m_localName.id()) {
         // We may have m_data.value == null if we were given a normalized value
         // off a removeAttribute (which would call parseNullAttribute()).
         // Ignore such requests.
         if (!m_data.value) {
             return;
         }
 
         DOMStringImpl *value = newValue.implementation();
         if (m_data.value == value) {
             return;
         }
 
         m_data.value->deref();
         m_data.value = value;
         m_data.value->ref();
     } else {
         m_data.attr->rewriteValue(newValue);
     }
 }
 
 AttrImpl *AttributeImpl::createAttr(ElementImpl *element, DocumentImpl *docPtr)
 {
     if (m_localName.id()) {
         AttrImpl *attr = new AttrImpl(element, docPtr, m_namespace, m_localName, m_prefix, m_data.value);
         if (!attr) {
             return nullptr;
         }
         attr->setHTMLCompat(element->htmlCompat());
         m_data.value->deref();
         m_data.attr = attr;
         m_data.attr->ref();
         m_localName = emptyLocalName; /* "has implementation" flag */
     }
 
     return m_data.attr;
 }
 
 void AttributeImpl::free()
 {
     if (m_localName.id()) {
         m_data.value->deref();
     } else {
         m_data.attr->setElement(nullptr);
         m_data.attr->deref();
     }
 }
 
 // -------------------------------------------------------------------------
 
 class ElementRareDataImpl
 {
 public:
     ElementRareDataImpl();
     void resetComputedStyle();
     short tabIndex() const
     {
         return m_tabIndex;
     }
     void setTabIndex(short _tabIndex)
     {
         m_tabIndex = _tabIndex;
         m_hasTabIndex = true;
     }
 
     RenderStyle *m_computedStyle;
     signed short m_tabIndex;
     bool m_hasTabIndex;
 };
 
 typedef WTF::HashMap<const ElementImpl *, ElementRareDataImpl *> ElementRareDataMap;
 
 static ElementRareDataMap &rareDataMap()
 {
     static ElementRareDataMap *dataMap = new ElementRareDataMap;
     return *dataMap;
 }
 
 static ElementRareDataImpl *rareDataFromMap(const ElementImpl *element)
 {
     return rareDataMap().get(element);
 }
 
 inline ElementRareDataImpl::ElementRareDataImpl()
     : m_computedStyle(nullptr), m_tabIndex(0), m_hasTabIndex(false)
 {}
 
 void ElementRareDataImpl::resetComputedStyle()
 {
     if (!m_computedStyle) {
         return;
     }
     m_computedStyle->deref();
     m_computedStyle = nullptr;
 }
 
 // -------------------------------------------------------------------------
 
 ElementImpl::ElementImpl(DocumentImpl *doc)
     : NodeBaseImpl(doc)
 {
     namedAttrMap = nullptr;
     m_style.inlineDecls = nullptr;
     m_prefix = emptyPrefixName;
 }
 
 ElementImpl::~ElementImpl()
 {
     if (namedAttrMap) {
         namedAttrMap->detachFromElement();
         namedAttrMap->deref();
     }
 
     if (m_style.inlineDecls) {
         if (CSSStyleDeclarationImpl *ild = inlineStyleDecls()) {
             // remove inline declarations
             ild->setNode(nullptr);
             ild->setParent(nullptr);
             ild->deref();
         }
         if (CSSStyleDeclarationImpl *ncd = nonCSSStyleDecls()) {
             // remove presentational declarations
             ncd->setNode(nullptr);
             ncd->setParent(nullptr);
             ncd->deref();
             delete m_style.combinedDecls;
         }
     }
 
     if (!m_elementHasRareData) {
         ASSERT(!rareDataMap().contains(this));
     } else {
         ElementRareDataMap &dataMap = rareDataMap();
         ElementRareDataMap::iterator it = dataMap.find(this);
         ASSERT(it != dataMap.end());
         delete it->second;
         dataMap.remove(it);
     }
 }
 
 ElementRareDataImpl *ElementImpl::rareData()
 {
     return m_elementHasRareData ? rareDataFromMap(this) : nullptr;
 }
 
 const ElementRareDataImpl *ElementImpl::rareData() const
 {
     return m_elementHasRareData ? rareDataFromMap(this) : nullptr;
 }
 
 ElementRareDataImpl *ElementImpl::createRareData()
 {
     if (m_elementHasRareData) {
         return rareDataMap().get(this);
     }
     ASSERT(!rareDataMap().contains(this));
     ElementRareDataImpl *data = new ElementRareDataImpl();
     rareDataMap().set(this, data);
     m_elementHasRareData = true;
     return data;
 }
 
 void ElementImpl::removeAttribute(NodeImpl::Id id, int &exceptioncode)
 {
     if (namedAttrMap) {
         namedAttrMap->removeNamedItem(id, emptyPrefixName, false, exceptioncode);
         if (exceptioncode == DOMException::NOT_FOUND_ERR) {
             exceptioncode = 0;
         }
     }
 }
 
 unsigned short ElementImpl::nodeType() const
 {
     return Node::ELEMENT_NODE;
 }
 
 DOMString ElementImpl::localName() const
 {
     return LocalName::fromId(id()).toString();
 }
 
 DOMString ElementImpl::tagName() const
 {
     DOMString tn = LocalName::fromId(id()).toString();
 
     if (m_htmlCompat) {
         tn = tn.upper();
     }
 
     DOMString prefix = m_prefix.toString();
     if (!prefix.isEmpty()) {
         return prefix + DOMString(":") + tn;
     }
 
     return tn;
 }
 
 DOMString ElementImpl::nonCaseFoldedTagName() const
 {
     DOMString tn = LocalName::fromId(id()).toString();
 
     DOMString prefix = m_prefix.toString();
     if (!prefix.isEmpty()) {
         return prefix + DOMString(":") + tn;
     }
 
     return tn;
 }
 
 /*DOMStringImpl* ElementImpl::getAttributeImpl(NodeImpl::Id id, PrefixName prefix, bool nsAware) const
 {
     return namedAttrMap ? namedAttrMap->getValue(id, prefix, nsAware) : 0;
 }*/
 
 void ElementImpl::setAttribute(NodeImpl::Id id, const PrefixName &prefix, bool nsAware, const DOMString &value, int &exceptioncode)
 {
     // NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly
     if (isReadOnly()) {
         exceptioncode = DOMException::NO_MODIFICATION_ALLOWED_ERR;
         return;
     }
     attributes()->setValue(id, value.implementation(), prefix, nsAware);
 }
 
 void ElementImpl::setAttributeNS(const DOMString &namespaceURI, const DOMString &qualifiedName,
                                  const DOMString &value, int &exceptioncode)
 {
     // NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly
     if (isReadOnly()) {
         exceptioncode = DOMException::NO_MODIFICATION_ALLOWED_ERR;
         return;
     }
     int colonPos;
     if (!DOM::checkQualifiedName(qualifiedName, namespaceURI, &colonPos,
                                  false/*nameCanBeNull*/, false/*nameCanBeEmpty*/,
                                  &exceptioncode)) {
         return;
     }
     LocalName localname;
     PrefixName prefixname;
     splitPrefixLocalName(qualifiedName, prefixname, localname, m_htmlCompat, colonPos);
     NamespaceName namespacename = NamespaceName::fromString(namespaceURI);
     attributes()->setValue(makeId(namespacename.id(), localname.id()), value.implementation(), prefixname, true /*nsAware*/);
 }
 
 void ElementImpl::setAttribute(NodeImpl::Id id, const DOMString &value)
 {
     int exceptioncode = 0;
     setAttribute(id, emptyPrefixName, false, value, exceptioncode);
 }
 
 void ElementImpl::setBooleanAttribute(NodeImpl::Id id, bool b)
 {
     if (b) {
         setAttribute(id, "1");
     } else {
         int ec;
         removeAttribute(id, ec);
     }
 }
 
 void ElementImpl::setAttributeMap(NamedAttrMapImpl *list)
 {
     // If setting the whole map changes the id attribute, we need to
     // call updateId.
     DOMStringImpl *oldId = namedAttrMap ? namedAttrMap->getValue(ATTR_ID) : nullptr;
     DOMStringImpl *newId = list ? list->getValue(ATTR_ID) : nullptr;
 
     if (oldId || newId) {
         updateId(oldId, newId);
     }
 
     if (namedAttrMap) {
         namedAttrMap->detachFromElement();
         namedAttrMap->deref();
     }
 
     namedAttrMap = list;
 
     if (namedAttrMap) {
         namedAttrMap->ref();
         assert(namedAttrMap->m_element == nullptr);
         namedAttrMap->setElement(this);
         unsigned len = namedAttrMap->length();
         for (unsigned i = 0; i < len; i++) {
             parseAttribute(&namedAttrMap->m_attrs[i]);
             attributeChanged(namedAttrMap->m_attrs[i].id());
         }
     }
 }
 
 WTF::PassRefPtr<NodeImpl> ElementImpl::cloneNode(bool deep)
 {
     WTF::RefPtr<ElementImpl> clone; // Make sure to guard...
     clone = document()->createElementNS(namespaceURI(), nonCaseFoldedTagName() /* includes prefix*/);
     if (!clone) {
         return nullptr;
     }
     finishCloneNode(clone.get(), deep);
     return clone;
 }
 
 void ElementImpl::finishCloneNode(ElementImpl *clone, bool deep)
 {
     // clone attributes
     if (namedAttrMap || m_needsStyleAttributeUpdate) {
         clone->attributes()->copyAttributes(attributes(true));
     }
 
     assert(!m_needsStyleAttributeUpdate);   // ensured by previous line
 
     // clone individual style rules
     if (m_style.inlineDecls) {
         if (m_hasCombinedStyle) {
             if (!clone->m_hasCombinedStyle) {
                 clone->createNonCSSDecl();
             }
             if (m_style.combinedDecls->inlineDecls) {
                 *(clone->getInlineStyleDecls()) = *m_style.combinedDecls->inlineDecls;
             }
             *clone->m_style.combinedDecls->nonCSSDecls = *m_style.combinedDecls->nonCSSDecls;
         } else {
             *(clone->getInlineStyleDecls()) = *m_style.inlineDecls;
         }
     }
 
     // ### fold above style cloning into this function?
     clone->copyNonAttributeProperties(this);
 
     if (deep) {
         cloneChildNodes(clone);
     }
 
     // copy over our compatibility mode.
     clone->setHTMLCompat(htmlCompat());
 }
 
 bool ElementImpl::hasAttributes() const
 {
     return namedAttrMap && namedAttrMap->length() > 0;
 }
 
 bool ElementImpl::hasAttribute(const DOMString &name) const
 {
     LocalName localname;
     PrefixName prefixname;
     splitPrefixLocalName(name, prefixname, localname, m_htmlCompat);
     if (!localname.id()) {
         return false;
     }
     if (!namedAttrMap) {
         return false;
     }
     return namedAttrMap->getValue(makeId(emptyNamespace, localname.id()), prefixname, false) != nullptr;
 }
 
 bool ElementImpl::hasAttributeNS(const DOMString &namespaceURI,
                                  const DOMString &localName) const
 {
     NamespaceName namespacename = NamespaceName::fromString(namespaceURI);
     LocalName localname = LocalName::fromString(localName, m_htmlCompat ? IDS_NormalizeLower : IDS_CaseSensitive);
     NodeImpl::Id id = makeId(namespacename.id(), localname.id());
     if (!id) {
         return false;
     }
     if (!namedAttrMap) {
         return false;
     }
     return namedAttrMap->getValue(id, emptyPrefixName, true) != nullptr;
 }
 
 DOMString ElementImpl::getAttribute(const DOMString &name)
 {
     LocalName localname;
     PrefixName prefixname;
     splitPrefixLocalName(name, prefixname, localname, m_htmlCompat);
     if (!localname.id()) {
         return DOMString();
     }
     return getAttribute(makeId(emptyNamespace, localname.id()), prefixname, false /*nsAware*/);
 }
 
 void ElementImpl::setAttribute(const DOMString &name, const DOMString &value, int &exceptioncode)
 {
     int colon;
     if (!DOM::checkQualifiedName(name, "", &colon, false/*nameCanBeNull*/, false/*nameCanBeEmpty*/, &exceptioncode)) {
         return;
     }
     LocalName localname;
     PrefixName prefixname;
     splitPrefixLocalName(name, prefixname, localname, m_htmlCompat, colon);
     setAttribute(makeId(emptyNamespace, localname.id()), prefixname, false, value.implementation(), exceptioncode);
 }
 
 void ElementImpl::removeAttribute(const DOMString &name, int &exceptioncode)
 {
     LocalName localname;
     PrefixName prefixname;
     splitPrefixLocalName(name, prefixname, localname, m_htmlCompat);
 
     // FIXME what if attributes(false) == 0?
     attributes(false)->removeNamedItem(makeId(emptyNamespace, localname.id()), prefixname, false, exceptioncode);
 
     // it's allowed to remove attributes that don't exist.
     if (exceptioncode == DOMException::NOT_FOUND_ERR) {
         exceptioncode = 0;
     }
 }
 
 AttrImpl *ElementImpl::getAttributeNode(const DOMString &name)
 {
     LocalName localname;
     PrefixName prefixname;
     splitPrefixLocalName(name, prefixname, localname, m_htmlCompat);
 
     if (!localname.id()) {
         return nullptr;
     }
     if (!namedAttrMap) {
         return nullptr;
     }
 
     return static_cast<AttrImpl *>(attributes()->getNamedItem(makeId(emptyNamespace, localname.id()), prefixname, false));
 }
 
 Attr ElementImpl::setAttributeNode(AttrImpl *newAttr, int &exceptioncode)
 {
     if (!newAttr) {
         exceptioncode = DOMException::NOT_FOUND_ERR;
         return nullptr;
     }
     Attr r = attributes(false)->setNamedItem(newAttr, emptyPrefixName, true, exceptioncode);
     if (!exceptioncode) {
         newAttr->setOwnerElement(this);
     }
     return r;
 }
 
 Attr ElementImpl::removeAttributeNode(AttrImpl *oldAttr, int &exceptioncode)
 {
     if (!oldAttr || oldAttr->ownerElement() != this) {
         exceptioncode = DOMException::NOT_FOUND_ERR;
         return nullptr;
     }
 
     if (isReadOnly()) {
         exceptioncode = DOMException::NO_MODIFICATION_ALLOWED_ERR;
         return nullptr;
     }
 
     if (!namedAttrMap) {
         exceptioncode = DOMException::NOT_FOUND_ERR;
         return nullptr;
     }
 
     return attributes(false)->removeAttr(oldAttr);
 }
 
 DOMString ElementImpl::getAttributeNS(const DOMString &namespaceURI,
                                       const DOMString &localName,
                                       int &exceptioncode)
 {
     if (!localName.implementation()) {
         exceptioncode = DOMException::NOT_FOUND_ERR;
         return DOMString();
     }
 
     LocalName localname = LocalName::fromString(localName, m_htmlCompat ? IDS_NormalizeLower : IDS_CaseSensitive);
     NamespaceName namespacename = NamespaceName::fromString(namespaceURI);
 
     NodeImpl::Id id = makeId(namespacename.id(), localname.id());
     return getAttribute(id, emptyPrefixName, true);
 }
 
 void ElementImpl::removeAttributeNS(const DOMString &namespaceURI,
                                     const DOMString &localName,
                                     int &exceptioncode)
 {
     if (!localName.implementation()) {
         exceptioncode = DOMException::NOT_FOUND_ERR;
         return;
     }
 
     NamespaceName namespacename = NamespaceName::fromString(namespaceURI);
     LocalName localname = LocalName::fromString(localName, m_htmlCompat ? IDS_NormalizeLower : IDS_CaseSensitive);
 
     NodeImpl::Id id = makeId(namespacename.id(), localname.id());
     attributes(false)->removeNamedItem(id, emptyPrefixName, true, exceptioncode);
 }
 
 AttrImpl *ElementImpl::getAttributeNodeNS(const DOMString &namespaceURI,
         const DOMString &localName,
         int &exceptioncode)
 {
     if (!localName.implementation()) {
         exceptioncode = DOMException::NOT_FOUND_ERR;
         return nullptr;
     }
 
     NamespaceName namespacename = NamespaceName::fromString(namespaceURI);
     LocalName localname = LocalName::fromString(localName, m_htmlCompat ? IDS_NormalizeLower : IDS_CaseSensitive);
 
     NodeImpl::Id id = makeId(namespacename.id(), localname.id());
     if (!attributes(true)) {
         return nullptr;
     }
     return static_cast<AttrImpl *>(attributes()->getNamedItem(id, emptyPrefixName, true));
 }
 
 Attr ElementImpl::setAttributeNodeNS(AttrImpl *newAttr, int &exceptioncode)
 {
     if (!newAttr) {
         exceptioncode = DOMException::NOT_FOUND_ERR;
         return nullptr;
     }
     // WRONG_DOCUMENT_ERR and INUSE_ATTRIBUTE_ERR are already tested & thrown by setNamedItem
     Attr r = attributes(false)->setNamedItem(newAttr, emptyPrefixName, true, exceptioncode);
     if (!exceptioncode) {
         newAttr->setOwnerElement(this);
     }
     return r;
 }
 
 DOMString ElementImpl::nodeName() const
 {
     return tagName();
 }
 
 DOMString ElementImpl::namespaceURI() const
 {
     return NamespaceName::fromId(namespacePart(id())).toString();
 }
 
 void ElementImpl::setPrefix(const DOMString &_prefix, int &exceptioncode)
 {
     checkSetPrefix(_prefix, exceptioncode);
     if (exceptioncode) {
         return;
     }
     m_prefix = PrefixName::fromString(_prefix);
 }
 
 short ElementImpl::tabIndex() const
 {
     return m_elementHasRareData ? rareData()->tabIndex() : 0;
 }
 
 void ElementImpl::setTabIndex(short _tabIndex)
 {
     createRareData()->setTabIndex(_tabIndex);
 }
 
 void ElementImpl::setNoTabIndex()
 {
     if (!m_elementHasRareData) {
         return;
     }
     rareData()->m_hasTabIndex = false;
 }
 
 bool ElementImpl::hasTabIndex() const
 {
     return m_elementHasRareData ? rareData()->m_hasTabIndex : false;
 }
 
 void ElementImpl::defaultEventHandler(EventImpl *e)
 {
     if (!e->defaultHandled() && document()->part() && e->id() == EventImpl::KEYPRESS_EVENT && e->isKeyRelatedEvent()) {
         const KHTMLPart *part = document()->part();
         bool isContentEditableElement = part->isEditable() || (focused() && isContentEditable());
         if (isContentEditableElement || part->isCaretMode()) {
             if (document()->view() && document()->view()->caretKeyPressEvent(static_cast<KeyEventBaseImpl *>(e)->qKeyEvent())) {
                 e->setDefaultHandled();
                 return;
             }
             if (isContentEditableElement && part->editor()->handleKeyEvent(static_cast<KeyEventBaseImpl *>(e)->qKeyEvent())) {
                 e->setDefaultHandled();
                 return;
             }
         }
     }
 
     if (m_render && m_render->scrollsOverflow()) {
         switch (e->id()) {
         case EventImpl::KEYDOWN_EVENT:
         case EventImpl::KEYUP_EVENT:
         case EventImpl::KEYPRESS_EVENT:
             if (!focused() || e->target() != this) {
                 break;
             }
         // fall through
         case EventImpl::KHTML_MOUSEWHEEL_EVENT:
             if (m_render->handleEvent(*e)) {
                 e->setDefaultHandled();
             }
         default:
             break;
         }
     }
 }
 
 void ElementImpl::createAttributeMap() const
 {
     namedAttrMap = new NamedAttrMapImpl(const_cast<ElementImpl *>(this));
     namedAttrMap->ref();
 }
 
 RenderStyle *ElementImpl::styleForRenderer(RenderObject * /*parentRenderer*/)
 {
     return document()->styleSelector()->styleForElement(this);
 }
 
 RenderObject *ElementImpl::createRenderer(RenderArena *arena, RenderStyle *style)
 {
     if (document()->documentElement() == this && style->display() == NONE) {
         // Ignore display: none on root elements.  Force a display of block in that case.
         RenderBlock *result = new(arena) RenderBlock(this);
         if (result) {
             result->setStyle(style);
         }
         return result;
     }
     return RenderObject::createObject(this, style);
 }
 
 void ElementImpl::attach()
 {
     assert(!attached());
     assert(!m_render);
     assert(parentNode());
 
 #if SPEED_DEBUG < 1
     createRendererIfNeeded();
 #endif
 
     NodeBaseImpl::attach();
 }
 
 void ElementImpl::close()
 {
     NodeImpl::close();
 
     // Trigger all the addChild changes as one large dynamic appendChildren change
     if (attached()) {
         backwardsStructureChanged();
     }
 }
 
 void ElementImpl::detach()
 {
     document()->dynamicDomRestyler().resetDependencies(this);
 
     if (ElementRareDataImpl *rd = rareData()) {
         rd->resetComputedStyle();
     }
 
     NodeBaseImpl::detach();
 }
 
 void ElementImpl::structureChanged()
 {
     NodeBaseImpl::structureChanged();
 
     if (!document()->renderer()) {
         return;    // the document is about to be destroyed
     }
 
     document()->dynamicDomRestyler().restyleDependent(this, StructuralDependency);
     // In theory BackwardsStructurualDependencies are indifferent to prepend,
     // but it's too rare to optimize.
     document()->dynamicDomRestyler().restyleDependent(this, BackwardsStructuralDependency);
 }
 
 void ElementImpl::backwardsStructureChanged()
 {
     NodeBaseImpl::backwardsStructureChanged();
 
     if (!document()->renderer()) {
         return;    // the document is about to be destroyed
     }
 
     // Most selectors are not affected by append. Fire the few that are.
     document()->dynamicDomRestyler().restyleDependent(this, BackwardsStructuralDependency);
 }
 
 void ElementImpl::attributeChanged(NodeImpl::Id id)
 {
     if (!document()->renderer()) {
         return;    // the document is about to be destroyed
     }
 
 #if 0 // one-one dependencies for attributes disabled
     document()->dynamicDomRestyler().restyleDependent(this, AttributeDependency);
 #endif
     if (document()->dynamicDomRestyler().checkDependency(id, PersonalDependency)) {
         setChanged(true);
     }
     if (document()->dynamicDomRestyler().checkDependency(id, AncestorDependency)) {
         setChangedAscendentAttribute(true);
     }
     if (document()->dynamicDomRestyler().checkDependency(id, PredecessorDependency) && parent())
         // Any element that dependt on a predecessors attribute, also depend structurally on parent
     {
         parent()->structureChanged();
     }
 }
 
 void ElementImpl::recalcStyle(StyleChange change)
 {
     // ### should go away and be done in renderobject
     RenderStyle *_style = m_render ? m_render->style() : nullptr;
     bool hasParentRenderer = parent() ? parent()->attached() : false;
 
     if ((change > NoChange || changed())) {
         if (ElementRareDataImpl *rd = rareData()) {
             rd->resetComputedStyle();
         }
     }
 
 #if 0
     const char *debug;
     switch (change) {
     case NoChange: debug = "NoChange";
         break;
     case NoInherit: debug = "NoInherit";
         break;
     case Inherit: debug = "Inherit";
         break;
     case Force: debug = "Force";
         break;
     }
     qDebug("recalcStyle(%d: %s, changed: %d)[%p: %s]", change, debug, changed(), this, tagName().string().toLatin1().constData());
 #endif
     if (hasParentRenderer && (change >= Inherit || changed() || (change == NoInherit && affectedByNoInherit()))) {
         RenderStyle *newStyle = document()->styleSelector()->styleForElement(this);
         newStyle->ref();
         StyleChange ch = diff(_style, newStyle);
         if (ch == Detach) {
             if (attached()) {
                 detach();
             }
             // ### Suboptimal. Style gets calculated again.
             attach();
             // attach recalulates the style for all children. No need to do it twice.
             setChanged(false);
             setHasChangedChild(false);
             newStyle->deref();
             return;
         } else if (ch != NoChange) {
             if (m_render) {
                 m_render->setStyle(newStyle);
             }
         }
         newStyle->deref();
 
         if (change != Force) {
             change = ch;
         }
     }
     // If a changed attribute has ancestor dependencies, restyle all children
     if (changedAscendentAttribute()) {
         change = Force;
         setChangedAscendentAttribute(false);
     }
 
     NodeImpl *n;
     for (n = _first; n; n = n->nextSibling()) {
         if (change >= Inherit || n->hasChangedChild() || n->changed() ||
                 (change == NoInherit && n->affectedByNoInherit())
            ) {
             //qDebug("    (%p) calling recalcStyle on child %p/%s, change=%d", this, n, n->isElementNode() ? ((ElementImpl *)n)->tagName().string().toLatin1().constData() : n->isTextNode() ? "text" : "unknown", change );
             n->recalcStyle(change);
         }
     }
 
     setChanged(false);
     setHasChangedChild(false);
 }
 
 bool ElementImpl::isFocusableImpl(FocusType ft) const
 {
     if (m_render && m_render->scrollsOverflow()) {
         return true;
     }
 
     // See WAI-ARIA 1.0, UA implementor's guide, 3.1 for the rules this
     // implements.
     if (hasTabIndex()) {
         int ti = tabIndex();
 
         // Negative things are focusable, but not in taborder
         if (ti < 0) {
             return (ft != FT_Tab);
         } else { // ... while everything else is completely focusable
             return true;
         }
     }
 
     // Only make editable elements selectable if its parent element
     // is not editable. FIXME: this is not 100% right as non-editable elements
     // within editable elements are focusable too.
     return isContentEditable() && !(parentNode() && parentNode()->isContentEditable());
 }
 
 bool ElementImpl::isContentEditable() const
 {
     if (document()->part() && document()->part()->isEditable()) {
         return true;
     }
 
     // document()->updateRendering();
 
     if (!renderer()) {
         if (parentNode()) {
             return parentNode()->isContentEditable();
         } else {
             return false;
         }
     }
 
     return renderer()->style()->userInput() == UI_ENABLED;
 }
 
 void ElementImpl::setContentEditable(bool enabled)
 {
     // FIXME: the approach is flawed, better use an enum instead of bool
     int value;
     if (enabled) {
         value = CSS_VAL_ENABLED;
     } else {
         // Intelligently use "none" or "disabled", depending on the type of
         // element
         // FIXME: intelligence not impl'd yet
         value = CSS_VAL_NONE;
 
         // FIXME: reset caret if it is in this node or a child
     }/*end if*/
     // FIXME: use addCSSProperty when I get permission to move it here
 //    qCDebug(KHTML_LOG) << "CSS_PROP__KHTML_USER_INPUT: "<< value;
     getInlineStyleDecls()->setProperty(CSS_PROP__KHTML_USER_INPUT, value, false);
     setChanged();
 }
 
 // DOM Section 1.1.1
 bool ElementImpl::childAllowed(NodeImpl *newChild)
 {
     if (!childTypeAllowed(newChild->nodeType())) {
         return false;
     }
 
     // ### check xml element allowedness according to DTD
 
     // If either this node or the other node is an XML element node, allow regardless (we don't do DTD checks for XML
     // yet)
     if (isXMLElementNode() || newChild->isXMLElementNode()) {
         return true;
     } else {
         return checkChild(id(), newChild->id(), document()->inStrictMode());
     }
 }
 
 bool ElementImpl::childTypeAllowed(unsigned short type)
 {
     switch (type) {
     case Node::ELEMENT_NODE:
     case Node::TEXT_NODE:
     case Node::COMMENT_NODE:
     case Node::PROCESSING_INSTRUCTION_NODE:
     case Node::CDATA_SECTION_NODE:
     case Node::ENTITY_REFERENCE_NODE:
         return true;
         break;
     default:
         return false;
     }
 }
 
 void ElementImpl::scrollIntoView(bool /*alignToTop*/)
 {
     // ###
     qCWarning(KHTML_LOG) << "non-standard scrollIntoView() not implemented";
 }
 
 void ElementImpl::createNonCSSDecl()
 {
     assert(!m_hasCombinedStyle);
     CSSInlineStyleDeclarationImpl *ild = m_style.inlineDecls;
     m_style.combinedDecls = new CombinedStyleDecl;
     m_style.combinedDecls->inlineDecls = ild;
     CSSStyleDeclarationImpl *ncd = new CSSStyleDeclarationImpl(nullptr);
     m_style.combinedDecls->nonCSSDecls = ncd;
     ncd->ref();
     ncd->setParent(document()->elementSheet());
     ncd->setNode(this);
     ncd->setStrictParsing(false);
     m_hasCombinedStyle = true;
 }
 
 CSSInlineStyleDeclarationImpl *ElementImpl::getInlineStyleDecls()
 {
     if (!inlineStyleDecls()) {
         createInlineDecl();
     }
     return inlineStyleDecls();
 }
 
 void ElementImpl::createInlineDecl()
 {
     assert(!m_style.inlineDecls || (m_hasCombinedStyle && !m_style.combinedDecls->inlineDecls));
 
     CSSInlineStyleDeclarationImpl *dcl = new CSSInlineStyleDeclarationImpl(nullptr);
     dcl->ref();
     dcl->setParent(document()->elementSheet());
     dcl->setNode(this);
     dcl->setStrictParsing(!document()->inCompatMode());
     if (m_hasCombinedStyle) {
         m_style.combinedDecls->inlineDecls = dcl;
     } else {
         m_style.inlineDecls = dcl;
     }
 }
 
 void ElementImpl::dispatchAttrRemovalEvent(NodeImpl::Id /*id*/, DOMStringImpl * /*value*/)
 {
     // ### enable this stuff again
     if (!document()->hasListenerType(DocumentImpl::DOMATTRMODIFIED_LISTENER)) {
         return;
     }
     //int exceptioncode = 0;
     //dispatchEvent(new MutationEventImpl(EventImpl::DOMATTRMODIFIED_EVENT,true,false,attr,attr->value(),
     //attr->value(), document()->attrName(attr->id()),MutationEvent::REMOVAL),exceptioncode);
 }
 
 void ElementImpl::dispatchAttrAdditionEvent(NodeImpl::Id /*id*/, DOMStringImpl * /*value*/)
 {
     // ### enable this stuff again
     if (!document()->hasListenerType(DocumentImpl::DOMATTRMODIFIED_LISTENER)) {
         return;
     }
     //int exceptioncode = 0;
     //dispatchEvent(new MutationEventImpl(EventImpl::DOMATTRMODIFIED_EVENT,true,false,attr,attr->value(),
     //attr->value(),document()->attrName(attr->id()),MutationEvent::ADDITION),exceptioncode);
 }
 
 void ElementImpl::updateId(DOMStringImpl *oldId, DOMStringImpl *newId)
 {
     if (!inDocument()) {
         return;
     }
 
     if (oldId && oldId->l) {
         removeId(DOMString(oldId));
     }
 
     if (newId && newId->l) {
         addId(DOMString(newId));
     }
 }
 
 void ElementImpl::removeId(const DOMString &id)
 {
     document()->getElementByIdCache().remove(id, this);
 }
 
 void ElementImpl::addId(const DOMString &id)
 {
     document()->getElementByIdCache().add(id, this);
 }
 
 void ElementImpl::insertedIntoDocument()
 {
     // need to do superclass processing first so inDocument() is true
     // by the time we reach updateId
     NodeBaseImpl::insertedIntoDocument();
 
     if (hasID()) {
         DOMString id = getAttribute(ATTR_ID);
         updateId(nullptr, id.implementation());
     }
 }
 
 void ElementImpl::removedFromDocument()
 {
     if (hasID()) {
         DOMString id = getAttribute(ATTR_ID);
         updateId(id.implementation(), nullptr);
     }
 
     NodeBaseImpl::removedFromDocument();
 }
 
 DOMString ElementImpl::openTagStartToString(bool expandurls) const
 {
     DOMString result = DOMString("<") + nonCaseFoldedTagName();
 
     NamedAttrMapImpl *attrMap = attributes(true);
 
     if (attrMap) {
         unsigned numAttrs = attrMap->length();
         for (unsigned i = 0; i < numAttrs; i++) {
             result += " ";
 
             const AttributeImpl &attribute = attrMap->attributeAt(i);
             AttrImpl *attr = attribute.attr();
 
             if (attr) {
                 result += attr->toString();
             } else {
                 //FIXME: should use prefix too and depends on html/xhtml case
                 PrefixName prefix = attribute.m_prefix;
                 DOMString current;
                 if (prefix.id()) {
                     current = prefix.toString() + DOMString(":") + attribute.localName();
                 } else {
                     current = attribute.localName();
                 }
                 if (m_htmlCompat) {
                     current = current.lower();
                 }
                 result += current;
                 if (!attribute.value().isNull()) {
                     result += "=\"";
                     // FIXME: substitute entities for any instances of " or '
                     // Expand out all urls, i.e. the src and href attributes
                     if (expandurls && (attribute.id() == ATTR_SRC || attribute.id() == ATTR_HREF))
                         if (document()) {
                             //We need to sanitize the urls - strip out the passwords.
                             //FIXME:   are src=  and href=  the only places that might have a password and need to be sanitized?
                             QUrl safeURL(document()->completeURL(attribute.value().string()));
                             safeURL.setPassword(QString());
                             result += safeURL.toDisplayString().toHtmlEscaped();
                         } else {
                             qCWarning(KHTML_LOG) << "document() returned false";
                             result += attribute.value();
                         }
                     else {
                         result += attribute.value();
                     }
                     result += "\"";
                 }
             }
         }
     }
 
     return result;
 }
 DOMString ElementImpl::selectionToString(NodeImpl *selectionStart, NodeImpl *selectionEnd, int startOffset, int endOffset, bool &found) const
 {
     DOMString result = openTagStartToString();
 
     if (hasChildNodes()) {
         result += ">";
 
         for (NodeImpl *child = firstChild(); child != nullptr; child = child->nextSibling()) {
             result += child->selectionToString(selectionStart, selectionEnd, startOffset, endOffset, found); // this might set found to true
             if (child == selectionEnd) {
                 found = true;
             }
             if (found) {
                 break;
             }
         }
 
         result += "</";
         result += nonCaseFoldedTagName();
         result += ">";
     } else {
         result += " />";
     }
 
     return result;
 }
 
 DOMString ElementImpl::toString() const
 {
     QString result = openTagStartToString().string(); //Accumulate in QString, since DOMString can't append well.
 
     if (hasChildNodes()) {
         result += ">";
 
         for (NodeImpl *child = firstChild(); child != nullptr; child = child->nextSibling()) {
             DOMString kid = child->toString();
             result += QString::fromRawData(kid.unicode(), kid.length());
         }
 
         result += "</";
         result += nonCaseFoldedTagName().string();
         result += ">";
     } else if (result.length() == 1) {
         // ensure we do not get results like < /> can happen when serialize document
         result = "";
     } else {
         result += " />";
     }
 
     return result;
 }
 
 RenderStyle *ElementImpl::computedStyle()
 {
     if (m_render && m_render->style()) {
         return m_render->style();
     }
 
     if (!attached())
         // FIXME: Try to do better than this. Ensure that styleForElement() works for elements that are not in the
         // document tree and figure out when to destroy the computed style for such elements.
     {
         return nullptr;
     }
 
     ElementRareDataImpl *rd = createRareData();
     if (!rd->m_computedStyle) {
         rd->m_computedStyle = document()->styleSelector()->styleForElement(this, parent() ? parent()->computedStyle() : nullptr);
         rd->m_computedStyle->ref();
     }
     return rd->m_computedStyle;
 }
 
 // ElementTraversal API
 ElementImpl *ElementImpl::firstElementChild() const
 {
     NodeImpl *n = firstChild();
     while (n && !n->isElementNode()) {
         n = n->nextSibling();
     }
     return static_cast<ElementImpl *>(n);
 }
 
 ElementImpl *ElementImpl::lastElementChild() const
 {
     NodeImpl *n = lastChild();
     while (n && !n->isElementNode()) {
         n = n->previousSibling();
     }
     return static_cast<ElementImpl *>(n);
 }
 
 ElementImpl *ElementImpl::previousElementSibling() const
 {
     NodeImpl *n = previousSibling();
     while (n && !n->isElementNode()) {
         n = n->previousSibling();
     }
     return static_cast<ElementImpl *>(n);
 }
 
 ElementImpl *ElementImpl::nextElementSibling() const
 {
     NodeImpl *n = nextSibling();
     while (n && !n->isElementNode()) {
         n = n->nextSibling();
     }
     return static_cast<ElementImpl *>(n);
 }
 
 unsigned ElementImpl::childElementCount() const
 {
     unsigned count = 0;
     NodeImpl *n = firstChild();
     while (n) {
         count += n->isElementNode();
         n = n->nextSibling();
     }
     return count;
 }
 
 void ElementImpl::blur()
 {
     if (document()->focusNode() == this) {
         document()->setFocusNode(nullptr);
     }
 }
 
 void ElementImpl::focus()
 {
     document()->setFocusNode(this);
 }
 
 void ElementImpl::synchronizeStyleAttribute() const
 {
     assert(inlineStyleDecls() && m_needsStyleAttributeUpdate);
     m_needsStyleAttributeUpdate = false;
     DOMString value = inlineStyleDecls()->cssText();
     attributes()->setValueWithoutElementUpdate(ATTR_STYLE, value.implementation());
 }
 
 // -------------------------------------------------------------------------
 
 XMLElementImpl::XMLElementImpl(DocumentImpl *doc, NamespaceName namespacename, LocalName localName, PrefixName prefix)
     : ElementImpl(doc)
 {
     // Called from createElement(). In this case localName, prefix, and namespaceURI all need to be null.
     m_localName = localName;
     m_namespace = namespacename;
     m_prefix = prefix;
 }
 
 XMLElementImpl::~XMLElementImpl()
 {
 }
 
 WTF::PassRefPtr<NodeImpl> XMLElementImpl::cloneNode(bool deep)
 {
     WTF::RefPtr<ElementImpl> clone = new XMLElementImpl(docPtr(), NamespaceName::fromId(namespacePart(id())), LocalName::fromId(localNamePart(id())), m_prefix);
     finishCloneNode(clone.get(), deep);
     return clone;
 }
 
 void XMLElementImpl::parseAttribute(AttributeImpl *attr)
 {
     if (attr->id() == ATTR_ID) {
         setHasID();
         document()->incDOMTreeVersion(DocumentImpl::TV_IDNameHref);
     }
 
     // Note: we do not want to handle ATTR_CLASS here, since the
     // class concept applies only to specific languages, like
     // HTML and SVG, not generic XML.
 }
 
 // -------------------------------------------------------------------------
 
 NamedAttrMapImpl::NamedAttrMapImpl(ElementImpl *element)
     : m_element(element)
 {
 }
 
 NamedAttrMapImpl::~NamedAttrMapImpl()
 {
     unsigned len = m_attrs.size();
     for (unsigned i = 0; i < len; i++) {
         m_attrs[i].free();
     }
     m_attrs.clear();
 }
 
 NodeImpl *NamedAttrMapImpl::getNamedItem(NodeImpl::Id id, const PrefixName &prefix, bool nsAware)
 {
     if (!m_element) {
         return nullptr;
     }
 
     int index = find(id, prefix, nsAware);
     return (index < 0) ? nullptr : m_attrs[index].createAttr(m_element, m_element->docPtr());
 }
 
 Node NamedAttrMapImpl::removeNamedItem(NodeImpl::Id id, const PrefixName &prefix, bool nsAware, int &exceptioncode)
 {
     if (!m_element) {
         exceptioncode = DOMException::NOT_FOUND_ERR;
         return nullptr;
     }
 
     // NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly
     if (isReadOnly()) {
         exceptioncode = DOMException::NO_MODIFICATION_ALLOWED_ERR;
         return nullptr;
     }
     int index = find(id, prefix, nsAware);
     if (index < 0) {
         exceptioncode = DOMException::NOT_FOUND_ERR;
         return nullptr;
     }
 
     id = m_attrs[index].id();
     if (id == ATTR_ID) {
         m_element->updateId(m_attrs[index].val(), nullptr);
     }
     Node removed(m_attrs[index].createAttr(m_element, m_element->docPtr()));
     m_attrs[index].free(); // Also sets the remove'd ownerElement to 0
     m_attrs.remove(index);
     m_element->parseNullAttribute(id, prefix);
     m_element->attributeChanged(id);
     return removed;
 }
 
 Node NamedAttrMapImpl::setNamedItem(NodeImpl *arg, const PrefixName &prefix, bool nsAware, int &exceptioncode)
 {
     if (!m_element || !arg) {
         exceptioncode = DOMException::NOT_FOUND_ERR;
         return nullptr;
     }
 
     // NO_MODIFICATION_ALLOWED_ERR: Raised if this map is readonly.
     if (isReadOnly()) {
         exceptioncode = DOMException::NO_MODIFICATION_ALLOWED_ERR;
         return nullptr;
     }
 
     // WRONG_DOCUMENT_ERR: Raised if arg was created from a different document than the one that created this map.
     if (arg->document() != m_element->document()) {
         exceptioncode = DOMException::WRONG_DOCUMENT_ERR;
         return nullptr;
     }
 
     // HIERARCHY_REQUEST_ERR: Raised if an attempt is made to add a node doesn't belong in this NamedNodeMap
     if (!arg->isAttributeNode()) {
         exceptioncode = DOMException::HIERARCHY_REQUEST_ERR;
         return nullptr;
     }
     AttrImpl *attr = static_cast<AttrImpl *>(arg);
 
     // INUSE_ATTRIBUTE_ERR: Raised if arg 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.
     if (attr->ownerElement() && attr->ownerElement() != m_element) {
         exceptioncode = DOMException::INUSE_ATTRIBUTE_ERR;
         return nullptr;
     }
 
     if (attr->ownerElement() == m_element) {
         // Already have this attribute.
         // DOMTS core-1 test "hc_elementreplaceattributewithself" says we should return it.
         return attr;
     }
 
     int index = find(attr->id(), prefix, nsAware);
     if (index >= 0) {
         if (attr->id() == ATTR_ID) {
             m_element->updateId(m_attrs[index].val(), attr->val());
         }
 
         Node replaced = m_attrs[index].createAttr(m_element, m_element->docPtr());
         m_attrs[index].free();
         m_attrs[index].m_localName = emptyLocalName; /* "has implementation" flag */
         m_attrs[index].m_data.attr = attr;
         m_attrs[index].m_data.attr->ref();
         attr->setElement(m_element);
         m_element->parseAttribute(&m_attrs[index]);
         m_element->attributeChanged(m_attrs[index].id());
         // ### dispatch mutation events
         return replaced;
     }
 
     // No existing attribute; add to list
     AttributeImpl attribute;
     attribute.m_localName = emptyLocalName; /* "has implementation" flag */
     attribute.m_namespace = NamespaceName::fromId(0);
     attribute.m_prefix = emptyPrefixName;
     attribute.m_data.attr = attr;
     attribute.m_data.attr->ref();
     m_attrs.append(attribute);
 
     attr->setElement(m_element);
     if (attr->id() == ATTR_ID) {
         m_element->updateId(nullptr, attr->val());
     }
     m_element->parseAttribute(&m_attrs.last());
     m_element->attributeChanged(m_attrs.last().id());
     // ### dispatch mutation events
 
     return nullptr;
 }
 
 NodeImpl *NamedAttrMapImpl::item(unsigned index)
 {
     return (index >= m_attrs.size()) ? nullptr : m_attrs[index].createAttr(m_element, m_element->docPtr());
 }
 
 NodeImpl::Id NamedAttrMapImpl::idAt(unsigned index) const
 {
     assert(index < m_attrs.size());
     return m_attrs[index].id();
 }
 
 DOMStringImpl *NamedAttrMapImpl::valueAt(unsigned index) const
 {
     assert(index < m_attrs.size());
     return m_attrs[index].val();
 }
 
 DOMStringImpl *NamedAttrMapImpl::getValue(NodeImpl::Id id, const PrefixName &prefix, bool nsAware) const
 {
     int index = find(id, prefix, nsAware);
     return index < 0 ? nullptr : m_attrs[index].val();
 }
 
 void NamedAttrMapImpl::setValue(NodeImpl::Id id, DOMStringImpl *value, const PrefixName &prefix, bool nsAware)
 {
     if (!id) {
         return;
     }
     // Passing in a null value here causes the attribute to be removed. This is a khtml extension
     // (the spec does not specify what to do in this situation).
     int exceptioncode = 0;
     if (!value) {
         removeNamedItem(id, prefix, nsAware, exceptioncode);
         return;
     }
     int index = find(id, prefix, nsAware);
     if (index >= 0) {
         if (m_attrs[index].attr()) {
             m_attrs[index].attr()->setPrefix(prefix.toString(), exceptioncode);
         } else {
             m_attrs[index].m_prefix = prefix;
         }
         m_attrs[index].setValue(value, m_element);
         // ### dispatch mutation events
         return;
     }
 
     AttributeImpl attr;
     attr.m_localName = LocalName::fromId(localNamePart(id));
     attr.m_namespace = NamespaceName::fromId(namespacePart(id));
     attr.m_prefix = prefix;
     attr.m_data.value = value;
     attr.m_data.value->ref();
     m_attrs.append(attr);
 
     if (m_element) {
         if (id == ATTR_ID) {
             m_element->updateId(nullptr, value);
         }
         m_element->parseAttribute(&m_attrs.last());
         m_element->attributeChanged(m_attrs.last().id());
     }
     // ### dispatch mutation events
 }
 
 Attr NamedAttrMapImpl::removeAttr(AttrImpl *attr)
 {
     unsigned len = m_attrs.size();
     for (unsigned i = 0; i < len; i++) {
         if (m_attrs[i].attr() == attr) {
             NodeImpl::Id id = m_attrs[i].id();
             if (id == ATTR_ID) {
                 m_element->updateId(attr->val(), nullptr);
             }
             Node removed(m_attrs[i].createAttr(m_element, m_element->docPtr()));
             m_attrs[i].free();
             m_attrs.remove(i);
             m_element->parseNullAttribute(id, PrefixName::fromString(attr->prefix()));
             m_element->attributeChanged(id);
             // ### dispatch mutation events
             return removed;
         }
     }
 
     return nullptr;
 }
 
 void NamedAttrMapImpl::copyAttributes(NamedAttrMapImpl *other)
 {
     assert(m_element);
     unsigned i;
     unsigned len = m_attrs.size();
     for (i = 0; i < len; i++) {
         if (m_attrs[i].id() == ATTR_ID) {
             m_element->updateId(m_attrs[i].val(), nullptr);
         }
         m_attrs[i].free();
     }
     m_attrs.resize(other->length());
     len = m_attrs.size();
     for (i = 0; i < len; i++) {
         m_attrs[i].m_localName = other->m_attrs[i].m_localName;
         m_attrs[i].m_prefix = other->m_attrs[i].m_prefix;
         m_attrs[i].m_namespace = other->m_attrs[i].m_namespace;
         if (m_attrs[i].m_localName.id()) {
             m_attrs[i].m_data.value = other->m_attrs[i].m_data.value;
             m_attrs[i].m_data.value->ref();
         } else {
             WTF::RefPtr<NodeImpl> clonedAttr = other->m_attrs[i].m_data.attr->cloneNode(true);
             m_attrs[i].m_data.attr = static_cast<AttrImpl *>(clonedAttr.get());
             m_attrs[i].m_data.attr->ref();
             m_attrs[i].m_data.attr->setElement(m_element);
         }
         if (m_attrs[i].id() == ATTR_ID) {
             m_element->updateId(nullptr, m_attrs[i].val());
         }
         m_element->parseAttribute(&m_attrs[i]);
         m_element->attributeChanged(m_attrs[i].id());
     }
 }
 
 int NamedAttrMapImpl::find(NodeImpl::Id id, const PrefixName &prefix, bool nsAware) const
 {
     //qCDebug(KHTML_LOG) << "In find:" << getPrintableName(id) << "[" << prefix.toString() << prefix.id() << "]" << nsAware;
     //qCDebug(KHTML_LOG) << "m_attrs.size()" << m_attrs.size();
     unsigned len = m_attrs.size();
     for (unsigned i = 0; i < len; ++i) {
         //qCDebug(KHTML_LOG) << "check attr[" << i << "]" << getPrintableName(m_attrs[i].id()) << "prefix:" << m_attrs[i].prefix();
         if (nsAware && namespacePart(id) == anyNamespace && localNamePart(id) == localNamePart(m_attrs[i].id())) {
             return i;
         }
         if ((nsAware && id == m_attrs[i].id()) || (!nsAware && localNamePart(id) == localNamePart(m_attrs[i].id()) && prefix == m_attrs[i].prefixName())) {
             //qCDebug(KHTML_LOG) << "attribute matched: exiting...";
             return i;
         }
     }
     //qCDebug(KHTML_LOG) << "attribute doesn't match: exiting... with -1";
     return -1;
 }
 
 void NamedAttrMapImpl::setElement(ElementImpl *element)
 {
     assert(!m_element);
     m_element = element;
 
     unsigned len = m_attrs.size();
     for (unsigned i = 0; i < len; i++)
         if (m_attrs[i].attr()) {
             m_attrs[i].attr()->setElement(element);
         }
 }
 
 void NamedAttrMapImpl::detachFromElement()
 {
     // This makes the map invalid; nothing can really be done with it now since it's not
     // associated with an element. But we have to keep it around in memory in case there
     // are still references to it.
     m_element = nullptr;
     unsigned len = m_attrs.size();
     for (unsigned i = 0; i < len; i++) {
         m_attrs[i].free();
     }
     m_attrs.clear();
 }
 
 void NamedAttrMapImpl::setClass(const DOMString &string)
 {
     if (!m_element) {
         return;
     }
 
     if (!m_element->hasClass()) {
         m_classNames.clear();
         return;
     }
 
     m_classNames.parseClassAttribute(string, m_element->document()->htmlMode() != DocumentImpl::XHtml &&
                                      m_element->document()->inCompatMode());
 }
 
 void NamedAttrMapImpl::setValueWithoutElementUpdate(NodeImpl::Id id, DOMStringImpl *value)
 {
     // FIXME properly fix case value == 0
     int index = find(id, emptyPrefixName, true);
     if (index >= 0) {
         m_attrs[index].rewriteValue(value ? value : DOMStringImpl::empty());
         return;
     }
 
     if (!value) {
         return;
     }
 
     AttributeImpl attr;
     attr.m_localName = LocalName::fromId(localNamePart(id));
     attr.m_namespace = NamespaceName::fromId(namespacePart(id));
     attr.m_prefix = emptyPrefixName;
     attr.m_data.value = value;
     attr.m_data.value->ref();
     m_attrs.append(attr);
 }
 
 }