Optimizations to Element::getAttribute
[WebKit-https.git] / WebCore / dom / NamedAttrMap.cpp
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
4  *           (C) 2001 Peter Kelly (pmk@post.com)
5  *           (C) 2001 Dirk Mueller (mueller@kde.org)
6  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
7  *           (C) 2007 Eric Seidel (eric@webkit.org)
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Library General Public
11  * License as published by the Free Software Foundation; either
12  * version 2 of the License, or (at your option) any later version.
13  *
14  * This library is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Library General Public License for more details.
18  *
19  * You should have received a copy of the GNU Library General Public License
20  * along with this library; see the file COPYING.LIB.  If not, write to
21  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
22  * Boston, MA 02110-1301, USA.
23  */
24
25 #include "config.h"
26 #include "NamedNodeMap.h"
27
28 #include "Attr.h"
29 #include "Document.h"
30 #include "Element.h"
31 #include "ExceptionCode.h"
32 #include "HTMLNames.h"
33
34 namespace WebCore {
35
36 using namespace HTMLNames;
37
38 static inline bool shouldIgnoreAttributeCase(const Element* e)
39 {
40     return e && e->document()->isHTMLDocument() && e->isHTMLElement();
41 }
42
43 inline void NamedNodeMap::detachAttributesFromElement()
44 {
45     size_t size = m_attributes.size();
46     for (size_t i = 0; i < size; i++) {
47         if (Attr* attr = m_attributes[i]->attr())
48             attr->m_element = 0;
49     }
50 }
51
52 NamedNodeMap::~NamedNodeMap()
53 {
54     detachAttributesFromElement();
55 }
56
57 bool NamedNodeMap::isMappedAttributeMap() const
58 {
59     return false;
60 }
61
62 PassRefPtr<Node> NamedNodeMap::getNamedItem(const String& name) const
63 {
64     Attribute* a = getAttributeItem(name, shouldIgnoreAttributeCase(m_element));
65     if (!a)
66         return 0;
67     
68     return a->createAttrIfNeeded(m_element);
69 }
70
71 PassRefPtr<Node> NamedNodeMap::getNamedItemNS(const String& namespaceURI, const String& localName) const
72 {
73     return getNamedItem(QualifiedName(nullAtom, localName, namespaceURI));
74 }
75
76 PassRefPtr<Node> NamedNodeMap::removeNamedItem(const String& name, ExceptionCode& ec)
77 {
78     Attribute* a = getAttributeItem(name, shouldIgnoreAttributeCase(m_element));
79     if (!a) {
80         ec = NOT_FOUND_ERR;
81         return 0;
82     }
83     
84     return removeNamedItem(a->name(), ec);
85 }
86
87 PassRefPtr<Node> NamedNodeMap::removeNamedItemNS(const String& namespaceURI, const String& localName, ExceptionCode& ec)
88 {
89     return removeNamedItem(QualifiedName(nullAtom, localName, namespaceURI), ec);
90 }
91
92 PassRefPtr<Node> NamedNodeMap::getNamedItem(const QualifiedName& name) const
93 {
94     Attribute* a = getAttributeItem(name);
95     if (!a)
96         return 0;
97
98     return a->createAttrIfNeeded(m_element);
99 }
100
101 PassRefPtr<Node> NamedNodeMap::setNamedItem(Node* arg, ExceptionCode& ec)
102 {
103     if (!m_element || !arg) {
104         ec = NOT_FOUND_ERR;
105         return 0;
106     }
107
108     // WRONG_DOCUMENT_ERR: Raised if arg was created from a different document than the one that created this map.
109     if (arg->document() != m_element->document()) {
110         ec = WRONG_DOCUMENT_ERR;
111         return 0;
112     }
113
114     // Not mentioned in spec: throw a HIERARCHY_REQUEST_ERROR if the user passes in a non-attribute node
115     if (!arg->isAttributeNode()) {
116         ec = HIERARCHY_REQUEST_ERR;
117         return 0;
118     }
119     Attr *attr = static_cast<Attr*>(arg);
120
121     Attribute* a = attr->attr();
122     Attribute* old = getAttributeItem(a->name());
123     if (old == a)
124         return RefPtr<Node>(arg); // we know about it already
125
126     // INUSE_ATTRIBUTE_ERR: Raised if arg is an Attr that is already an attribute of another Element object.
127     // The DOM user must explicitly clone Attr nodes to re-use them in other elements.
128     if (attr->ownerElement()) {
129         ec = INUSE_ATTRIBUTE_ERR;
130         return 0;
131     }
132
133     if (a->name() == idAttr)
134         m_element->updateId(old ? old->value() : nullAtom, a->value());
135
136     // ### slightly inefficient - resizes attribute array twice.
137     RefPtr<Node> r;
138     if (old) {
139         r = old->createAttrIfNeeded(m_element);
140         removeAttribute(a->name());
141     }
142
143     addAttribute(a);
144     return r.release();
145 }
146
147 // The DOM2 spec doesn't say that removeAttribute[NS] throws NOT_FOUND_ERR
148 // if the attribute is not found, but at this level we have to throw NOT_FOUND_ERR
149 // because of removeNamedItem, removeNamedItemNS, and removeAttributeNode.
150 PassRefPtr<Node> NamedNodeMap::removeNamedItem(const QualifiedName& name, ExceptionCode& ec)
151 {
152     Attribute* a = getAttributeItem(name);
153     if (!a) {
154         ec = NOT_FOUND_ERR;
155         return 0;
156     }
157
158     RefPtr<Node> r = a->createAttrIfNeeded(m_element);
159
160     if (name == idAttr)
161         m_element->updateId(a->value(), nullAtom);
162
163     removeAttribute(name);
164     return r.release();
165 }
166
167 PassRefPtr<Node> NamedNodeMap::item(unsigned index) const
168 {
169     if (index >= length())
170         return 0;
171
172     return m_attributes[index]->createAttrIfNeeded(m_element);
173 }
174
175 // We use a boolean parameter instead of calling shouldIgnoreAttributeCase so that the caller
176 // can tune the behaviour (hasAttribute is case sensitive whereas getAttribute is not).
177 Attribute* NamedNodeMap::getAttributeItem(const String& name, bool shouldIgnoreAttributeCase) const
178 {
179     unsigned len = length();
180     bool doSlowCheck = shouldIgnoreAttributeCase;
181     
182     // Optimize for the case where the attribute exists and its name exactly matches.
183     for (unsigned i = 0; i < len; ++i) {
184         const QualifiedName& attrName = m_attributes[i]->name();
185         if (!attrName.hasPrefix()) {
186             if (name == attrName.localName())
187                 return m_attributes[i].get();
188         } else
189             doSlowCheck = true;
190     }
191     
192     // Continue to checking case-insensitively and/or full namespaced names if necessary:
193     if (doSlowCheck) {
194         for (unsigned i = 0; i < len; ++i) {
195             const QualifiedName& attrName = m_attributes[i]->name();
196             if (!attrName.hasPrefix()) {
197                 if (shouldIgnoreAttributeCase && equalIgnoringCase(name, attrName.localName()))
198                     return m_attributes[i].get();
199             } else {
200                 // FIXME: Would be faster to do this comparison without calling toString, which
201                 // generates a temporary string by concatenation. But this branch is only reached
202                 // if the attribute name has a prefix, which is rare in HTML.
203                 if (equalPossiblyIgnoringCase(name, attrName.toString(), shouldIgnoreAttributeCase))
204                     return m_attributes[i].get();
205             }
206         }
207     }
208     return 0;
209 }
210
211 Attribute* NamedNodeMap::getAttributeItem(const QualifiedName& name) const
212 {
213     unsigned len = length();
214     for (unsigned i = 0; i < len; ++i) {
215         if (m_attributes[i]->name().matches(name))
216             return m_attributes[i].get();
217     }
218     return 0;
219 }
220
221 void NamedNodeMap::clearAttributes()
222 {
223     detachAttributesFromElement();
224     m_attributes.clear();
225 }
226
227 void NamedNodeMap::detachFromElement()
228 {
229     // This can't happen if the holder of the map is JavaScript, because we mark the
230     // element if the map is alive. So it has no impact on web page behavior. Because
231     // of that, we can simply clear all the attributes to avoid accessing stale
232     // pointers to do things like create Attr objects.
233     m_element = 0;
234     clearAttributes();
235 }
236
237 void NamedNodeMap::setAttributes(const NamedNodeMap& other)
238 {
239     // clone all attributes in the other map, but attach to our element
240     if (!m_element)
241         return;
242
243     // If assigning the map changes the id attribute, we need to call
244     // updateId.
245     Attribute *oldId = getAttributeItem(idAttr);
246     Attribute *newId = other.getAttributeItem(idAttr);
247
248     if (oldId || newId)
249         m_element->updateId(oldId ? oldId->value() : nullAtom, newId ? newId->value() : nullAtom);
250
251     clearAttributes();
252     unsigned newLength = other.length();
253     m_attributes.resize(newLength);
254     for (unsigned i = 0; i < newLength; i++)
255         m_attributes[i] = other.m_attributes[i]->clone();
256
257     // FIXME: This is wasteful.  The class list could be preserved on a copy, and we
258     // wouldn't have to waste time reparsing the attribute.
259     // The derived class, HTMLNamedNodeMap, which manages a parsed class list for the CLASS attribute,
260     // will update its member variable when parse attribute is called.
261     for (unsigned i = 0; i < newLength; i++)
262         m_element->attributeChanged(m_attributes[i].get(), true);
263 }
264
265 void NamedNodeMap::addAttribute(PassRefPtr<Attribute> prpAttribute)
266 {
267     RefPtr<Attribute> attribute = prpAttribute;
268     
269     // Add the attribute to the list
270     m_attributes.append(attribute);
271
272     if (Attr* attr = attribute->attr())
273         attr->m_element = m_element;
274
275     // Notify the element that the attribute has been added, and dispatch appropriate mutation events
276     // Note that element may be null here if we are called from insertAttribute() during parsing
277     if (m_element) {
278         m_element->attributeChanged(attribute.get());
279         // Because of our updateStyleAttribute() style modification events are never sent at the right time, so don't bother sending them.
280         if (attribute->name() != styleAttr) {
281             m_element->dispatchAttrAdditionEvent(attribute.get());
282             m_element->dispatchSubtreeModifiedEvent();
283         }
284     }
285 }
286
287 void NamedNodeMap::removeAttribute(const QualifiedName& name)
288 {
289     unsigned len = length();
290     unsigned index = len;
291     for (unsigned i = 0; i < len; ++i) {
292         if (m_attributes[i]->name().matches(name)) {
293             index = i;
294             break;
295         }
296     }
297
298     if (index >= len)
299         return;
300
301     // Remove the attribute from the list
302     RefPtr<Attribute> attr = m_attributes[index].get();
303     if (Attr* a = m_attributes[index]->attr())
304         a->m_element = 0;
305
306     m_attributes.remove(index);
307
308     // Notify the element that the attribute has been removed
309     // dispatch appropriate mutation events
310     if (m_element && !attr->m_value.isNull()) {
311         AtomicString value = attr->m_value;
312         attr->m_value = nullAtom;
313         m_element->attributeChanged(attr.get());
314         attr->m_value = value;
315     }
316     if (m_element) {
317         m_element->dispatchAttrRemovalEvent(attr.get());
318         m_element->dispatchSubtreeModifiedEvent();
319     }
320 }
321
322 bool NamedNodeMap::mapsEquivalent(const NamedNodeMap* otherMap) const
323 {
324     if (!otherMap)
325         return false;
326     
327     unsigned len = length();
328     if (len != otherMap->length())
329         return false;
330     
331     for (unsigned i = 0; i < len; i++) {
332         Attribute *attr = attributeItem(i);
333         Attribute *otherAttr = otherMap->getAttributeItem(attr->name());
334             
335         if (!otherAttr || attr->value() != otherAttr->value())
336             return false;
337     }
338     
339     return true;
340 }
341
342 }