014a28d1b0d9409656f6161ab70a50982642e1b2
[WebKit-https.git] / Source / WebCore / dom / Element.h
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) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Library General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Library General Public License for more details.
17  *
18  * You should have received a copy of the GNU Library General Public License
19  * along with this library; see the file COPYING.LIB.  If not, write to
20  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21  * Boston, MA 02110-1301, USA.
22  *
23  */
24
25 #ifndef Element_h
26 #define Element_h
27
28 #include "CollectionType.h"
29 #include "Document.h"
30 #include "FragmentScriptingPermission.h"
31 #include "HTMLNames.h"
32 #include "NamedNodeMap.h"
33 #include "ScrollTypes.h"
34
35 namespace WebCore {
36
37 class Attribute;
38 class ClientRect;
39 class ClientRectList;
40 class DOMStringMap;
41 class DOMTokenList;
42 class ElementRareData;
43 class IntSize;
44 class ShadowRoot;
45 class WebKitAnimationList;
46
47 enum SpellcheckAttributeState {
48     SpellcheckAttributeTrue,
49     SpellcheckAttributeFalse,
50     SpellcheckAttributeDefault
51 };
52
53 class Element : public ContainerNode {
54 public:
55     static PassRefPtr<Element> create(const QualifiedName&, Document*);
56     virtual ~Element();
57
58     DEFINE_ATTRIBUTE_EVENT_LISTENER(abort);
59     DEFINE_ATTRIBUTE_EVENT_LISTENER(change);
60     DEFINE_ATTRIBUTE_EVENT_LISTENER(click);
61     DEFINE_ATTRIBUTE_EVENT_LISTENER(contextmenu);
62     DEFINE_ATTRIBUTE_EVENT_LISTENER(dblclick);
63     DEFINE_ATTRIBUTE_EVENT_LISTENER(dragenter);
64     DEFINE_ATTRIBUTE_EVENT_LISTENER(dragover);
65     DEFINE_ATTRIBUTE_EVENT_LISTENER(dragleave);
66     DEFINE_ATTRIBUTE_EVENT_LISTENER(drop);
67     DEFINE_ATTRIBUTE_EVENT_LISTENER(dragstart);
68     DEFINE_ATTRIBUTE_EVENT_LISTENER(drag);
69     DEFINE_ATTRIBUTE_EVENT_LISTENER(dragend);
70     DEFINE_ATTRIBUTE_EVENT_LISTENER(input);
71     DEFINE_ATTRIBUTE_EVENT_LISTENER(invalid);
72     DEFINE_ATTRIBUTE_EVENT_LISTENER(keydown);
73     DEFINE_ATTRIBUTE_EVENT_LISTENER(keypress);
74     DEFINE_ATTRIBUTE_EVENT_LISTENER(keyup);
75     DEFINE_ATTRIBUTE_EVENT_LISTENER(mousedown);
76     DEFINE_ATTRIBUTE_EVENT_LISTENER(mousemove);
77     DEFINE_ATTRIBUTE_EVENT_LISTENER(mouseout);
78     DEFINE_ATTRIBUTE_EVENT_LISTENER(mouseover);
79     DEFINE_ATTRIBUTE_EVENT_LISTENER(mouseup);
80     DEFINE_ATTRIBUTE_EVENT_LISTENER(mousewheel);
81     DEFINE_ATTRIBUTE_EVENT_LISTENER(scroll);
82     DEFINE_ATTRIBUTE_EVENT_LISTENER(select);
83     DEFINE_ATTRIBUTE_EVENT_LISTENER(submit);
84
85     // These four attribute event handler attributes are overridden by HTMLBodyElement
86     // and HTMLFrameSetElement to forward to the DOMWindow.
87     DECLARE_VIRTUAL_ATTRIBUTE_EVENT_LISTENER(blur);
88     DECLARE_VIRTUAL_ATTRIBUTE_EVENT_LISTENER(error);
89     DECLARE_VIRTUAL_ATTRIBUTE_EVENT_LISTENER(focus);
90     DECLARE_VIRTUAL_ATTRIBUTE_EVENT_LISTENER(load);
91
92     // WebKit extensions
93     DEFINE_ATTRIBUTE_EVENT_LISTENER(beforecut);
94     DEFINE_ATTRIBUTE_EVENT_LISTENER(cut);
95     DEFINE_ATTRIBUTE_EVENT_LISTENER(beforecopy);
96     DEFINE_ATTRIBUTE_EVENT_LISTENER(copy);
97     DEFINE_ATTRIBUTE_EVENT_LISTENER(beforepaste);
98     DEFINE_ATTRIBUTE_EVENT_LISTENER(paste);
99     DEFINE_ATTRIBUTE_EVENT_LISTENER(reset);
100     DEFINE_ATTRIBUTE_EVENT_LISTENER(search);
101     DEFINE_ATTRIBUTE_EVENT_LISTENER(selectstart);
102 #if ENABLE(TOUCH_EVENTS)
103     DEFINE_ATTRIBUTE_EVENT_LISTENER(touchstart);
104     DEFINE_ATTRIBUTE_EVENT_LISTENER(touchmove);
105     DEFINE_ATTRIBUTE_EVENT_LISTENER(touchend);
106     DEFINE_ATTRIBUTE_EVENT_LISTENER(touchcancel);
107 #endif
108 #if ENABLE(FULLSCREEN_API)
109     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitfullscreenchange);
110     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitfullscreenerror);
111 #endif
112
113     bool hasAttribute(const QualifiedName&) const;
114     const AtomicString& getAttribute(const QualifiedName&) const;
115     void setAttribute(const QualifiedName&, const AtomicString& value);
116     void removeAttribute(const QualifiedName&);
117
118     // Typed getters and setters for language bindings.
119     int getIntegralAttribute(const QualifiedName& attributeName) const;
120     void setIntegralAttribute(const QualifiedName& attributeName, int value);
121     unsigned getUnsignedIntegralAttribute(const QualifiedName& attributeName) const;
122     void setUnsignedIntegralAttribute(const QualifiedName& attributeName, unsigned value);
123
124     // Call this to get the value of an attribute that is known not to be the style
125     // attribute or one of the SVG animatable attributes.
126     bool fastHasAttribute(const QualifiedName&) const;
127     const AtomicString& fastGetAttribute(const QualifiedName&) const;
128 #ifndef NDEBUG
129     bool fastAttributeLookupAllowed(const QualifiedName&) const;
130 #endif
131
132     bool hasAttributes() const;
133
134     bool hasAttribute(const String& name) const;
135     bool hasAttributeNS(const String& namespaceURI, const String& localName) const;
136
137     const AtomicString& getAttribute(const String& name) const;
138     const AtomicString& getAttributeNS(const String& namespaceURI, const String& localName) const;
139
140     void setAttribute(const AtomicString& name, const AtomicString& value, ExceptionCode&);
141     void setAttributeNS(const AtomicString& namespaceURI, const AtomicString& qualifiedName, const AtomicString& value, ExceptionCode&, FragmentScriptingPermission = FragmentScriptingAllowed);
142
143     bool isIdAttributeName(const QualifiedName&) const;
144     const AtomicString& getIdAttribute() const;
145     void setIdAttribute(const AtomicString&);
146
147     // Call this to get the value of the id attribute for style resolution purposes.
148     // The value will already be lowercased if the document is in compatibility mode,
149     // so this function is not suitable for non-style uses.
150     const AtomicString& idForStyleResolution() const;
151
152     void scrollIntoView(bool alignToTop = true);
153     void scrollIntoViewIfNeeded(bool centerIfNeeded = true);
154
155     void scrollByLines(int lines);
156     void scrollByPages(int pages);
157
158     int offsetLeft();
159     int offsetTop();
160     int offsetWidth();
161     int offsetHeight();
162     Element* offsetParent();
163     int clientLeft();
164     int clientTop();
165     int clientWidth();
166     int clientHeight();
167     virtual int scrollLeft();
168     virtual int scrollTop();
169     virtual void setScrollLeft(int);
170     virtual void setScrollTop(int);
171     virtual int scrollWidth();
172     virtual int scrollHeight();
173
174     LayoutRect boundsInRootViewSpace();
175
176     PassRefPtr<ClientRectList> getClientRects();
177     PassRefPtr<ClientRect> getBoundingClientRect();
178     
179     // Returns the absolute bounding box translated into screen coordinates:
180     LayoutRect screenRect() const;
181
182     void removeAttribute(const String& name);
183     void removeAttributeNS(const String& namespaceURI, const String& localName);
184
185     PassRefPtr<Attr> getAttributeNode(const String& name);
186     PassRefPtr<Attr> getAttributeNodeNS(const String& namespaceURI, const String& localName);
187     PassRefPtr<Attr> setAttributeNode(Attr*, ExceptionCode&);
188     PassRefPtr<Attr> setAttributeNodeNS(Attr*, ExceptionCode&);
189     PassRefPtr<Attr> removeAttributeNode(Attr*, ExceptionCode&);
190     
191     virtual CSSStyleDeclaration* style();
192
193     const QualifiedName& tagQName() const { return m_tagName; }
194     String tagName() const { return nodeName(); }
195     bool hasTagName(const QualifiedName& tagName) const { return m_tagName.matches(tagName); }
196     
197     // A fast function for checking the local name against another atomic string.
198     bool hasLocalName(const AtomicString& other) const { return m_tagName.localName() == other; }
199     bool hasLocalName(const QualifiedName& other) const { return m_tagName.localName() == other.localName(); }
200
201     const AtomicString& localName() const { return m_tagName.localName(); }
202     const AtomicString& prefix() const { return m_tagName.prefix(); }
203     const AtomicString& namespaceURI() const { return m_tagName.namespaceURI(); }
204
205     virtual KURL baseURI() const;
206
207     virtual String nodeName() const;
208
209     PassRefPtr<Element> cloneElementWithChildren();
210     PassRefPtr<Element> cloneElementWithoutChildren();
211
212     void normalizeAttributes();
213     String nodeNamePreservingCase() const;
214
215     void setBooleanAttribute(const QualifiedName& name, bool);
216
217     NamedNodeMap* attributes(bool readonly = false) const;
218
219     // This method is called whenever an attribute is added, changed or removed.
220     virtual void attributeChanged(Attribute*, bool preserveDecls = false);
221
222     // Only called by the parser immediately after element construction.
223     void parserSetAttributeMap(PassOwnPtr<NamedNodeMap>, FragmentScriptingPermission);
224
225     NamedNodeMap* attributeMap() const { return m_attributeMap.get(); }
226
227     ElementAttributeData* attributeData() const { return m_attributeMap ? m_attributeMap->attributeData() : 0; }
228     ElementAttributeData* ensureAttributeData() const { return attributes()->attributeData(); }
229
230     void setAttributesFromElement(const Element&);
231
232     virtual void copyNonAttributeProperties(const Element* source);
233
234     virtual void attach();
235     virtual void detach();
236     virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
237     void recalcStyle(StyleChange = NoChange);
238
239     ShadowRoot* shadowRoot() const;
240     void setShadowRoot(PassRefPtr<ShadowRoot>, ExceptionCode&);
241     ShadowRoot* ensureShadowRoot();
242     void removeShadowRoot();
243
244     virtual const AtomicString& shadowPseudoId() const;
245     void setShadowPseudoId(const AtomicString&, ExceptionCode& = ASSERT_NO_EXCEPTION);
246
247     RenderStyle* computedStyle(PseudoId = NOPSEUDO);
248
249     void setStyleAffectedByEmpty();
250     bool styleAffectedByEmpty() const;
251
252     AtomicString computeInheritedLanguage() const;
253
254     virtual void accessKeyAction(bool /*sendToAnyEvent*/) { }
255
256     virtual bool isURLAttribute(Attribute*) const;
257
258     KURL getURLAttribute(const QualifiedName&) const;
259     KURL getNonEmptyURLAttribute(const QualifiedName&) const;
260
261     virtual const QualifiedName& imageSourceAttributeName() const;
262     virtual String target() const { return String(); }
263
264     virtual void focus(bool restorePreviousSelection = true);
265     virtual void updateFocusAppearance(bool restorePreviousSelection);
266     void blur();
267
268     String innerText();
269     String outerText();
270  
271     virtual String title() const;
272
273     void updateId(const AtomicString& oldId, const AtomicString& newId);
274     void updateName(const AtomicString& oldName, const AtomicString& newName);
275
276     void willModifyAttribute(const QualifiedName&, const AtomicString& oldValue, const AtomicString& newValue);
277     void willRemoveAttribute(const QualifiedName&, const AtomicString& value);
278     void didModifyAttribute(Attribute*);
279     void didRemoveAttribute(Attribute*);
280
281     LayoutSize minimumSizeForResizing() const;
282     void setMinimumSizeForResizing(const LayoutSize&);
283
284     // Use Document::registerForDocumentActivationCallbacks() to subscribe to these
285     virtual void documentWillSuspendForPageCache() { }
286     virtual void documentDidResumeFromPageCache() { }
287
288     // Use Document::registerForMediaVolumeCallbacks() to subscribe to this
289     virtual void mediaVolumeDidChange() { }
290
291     // Use Document::registerForPrivateBrowsingStateChangedCallbacks() to subscribe to this.
292     virtual void privateBrowsingStateDidChange() { }
293
294     virtual void didBecomeFullscreenElement() { }
295     virtual void willStopBeingFullscreenElement() { }
296
297     bool isFinishedParsingChildren() const { return isParsingChildrenFinished(); }
298     virtual void finishParsingChildren();
299     virtual void beginParsingChildren();
300
301     // ElementTraversal API
302     Element* firstElementChild() const;
303     Element* lastElementChild() const;
304     Element* previousElementSibling() const;
305     Element* nextElementSibling() const;
306     unsigned childElementCount() const;
307
308 #if ENABLE(STYLE_SCOPED)
309     void registerScopedHTMLStyleChild();
310     void unregisterScopedHTMLStyleChild();
311     bool hasScopedHTMLStyleChild() const;
312     size_t numberOfScopedHTMLStyleChildren() const;
313 #endif
314
315     bool webkitMatchesSelector(const String& selectors, ExceptionCode&);
316
317     DOMTokenList* classList();
318     DOMTokenList* optionalClassList() const;
319
320     DOMStringMap* dataset();
321
322 #if ENABLE(MATHML)
323     virtual bool isMathMLElement() const { return false; }
324 #else
325     static bool isMathMLElement() { return false; }
326 #endif
327
328 #if ENABLE(VIDEO)
329     virtual bool isMediaElement() const { return false; }
330 #endif
331
332 #if ENABLE(INPUT_SPEECH)
333     virtual bool isInputFieldSpeechButtonElement() const { return false; }
334 #endif
335
336     virtual bool isFormControlElement() const { return false; }
337     virtual bool isEnabledFormControl() const { return true; }
338     virtual bool isReadOnlyFormControl() const { return false; }
339     virtual bool isSpinButtonElement() const { return false; }
340     virtual bool isTextFormControl() const { return false; }
341     virtual bool isOptionalFormControl() const { return false; }
342     virtual bool isRequiredFormControl() const { return false; }
343     virtual bool isDefaultButtonForForm() const { return false; }
344     virtual bool willValidate() const { return false; }
345     virtual bool isValidFormControlElement() { return false; }
346     virtual bool hasUnacceptableValue() const { return false; }
347     virtual bool isInRange() const { return false; }
348     virtual bool isOutOfRange() const { return false; }
349     virtual bool isFrameElementBase() const { return false; }
350
351     virtual bool canContainRangeEndPoint() const { return true; }
352
353     virtual const AtomicString& formControlName() const { return nullAtom; }
354     virtual const AtomicString& formControlType() const { return nullAtom; }
355
356     virtual bool wasChangedSinceLastFormControlChangeEvent() const;
357     virtual void setChangedSinceLastFormControlChangeEvent(bool);
358     virtual void dispatchFormControlChangeEvent() { }
359
360 #if ENABLE(SVG)
361     virtual bool childShouldCreateRenderer(Node*) const; 
362 #endif
363     
364 #if ENABLE(FULLSCREEN_API)
365     enum {
366         ALLOW_KEYBOARD_INPUT = 1
367     };
368     
369     void webkitRequestFullScreen(unsigned short flags);
370     virtual bool containsFullScreenElement() const;
371     virtual void setContainsFullScreenElement(bool);
372     virtual void setContainsFullScreenElementOnAncestorsCrossingFrameBoundaries(bool);
373 #endif
374
375     virtual bool isSpellCheckingEnabled() const;
376
377     PassRefPtr<WebKitAnimationList> webkitGetAnimations() const;
378     
379     PassRefPtr<RenderStyle> styleForRenderer();
380
381 protected:
382     Element(const QualifiedName& tagName, Document* document, ConstructionType type)
383         : ContainerNode(document, type)
384         , m_tagName(tagName)
385     {
386     }
387
388     virtual void willRemove();
389     virtual void insertedIntoDocument();
390     virtual void removedFromDocument();
391     virtual void insertedIntoTree(bool);
392     virtual void removedFromTree(bool);
393     virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);
394     virtual bool willRecalcStyle(StyleChange) { return true; }
395     virtual void didRecalcStyle(StyleChange) { }
396     virtual PassRefPtr<RenderStyle> customStyleForRenderer();
397
398     virtual bool shouldRegisterAsNamedItem() const { return false; }
399     virtual bool shouldRegisterAsExtraNamedItem() const { return false; }
400
401     // The implementation of Element::attributeChanged() calls the following two functions.
402     // They are separated to allow a different flow of control in StyledElement::attributeChanged().
403     void recalcStyleIfNeededAfterAttributeChanged(Attribute*);
404     void updateAfterAttributeChanged(Attribute*);
405     
406     void idAttributeChanged(Attribute*);
407
408     HTMLCollection* ensureCachedHTMLCollection(CollectionType);
409
410 private:
411     void scrollByUnits(int units, ScrollGranularity);
412
413     virtual void setPrefix(const AtomicString&, ExceptionCode&);
414     virtual NodeType nodeType() const;
415     virtual bool childTypeAllowed(NodeType) const;
416
417     void setAttributeInternal(size_t index, const QualifiedName&, const AtomicString& value);
418     virtual PassRefPtr<Attribute> createAttribute(const QualifiedName&, const AtomicString& value);
419     
420 #ifndef NDEBUG
421     virtual void formatForDebugger(char* buffer, unsigned length) const;
422 #endif
423
424     bool pseudoStyleCacheIsInvalid(const RenderStyle* currentStyle, RenderStyle* newStyle);
425
426     void createAttributeMap() const;
427
428     virtual void updateStyleAttribute() const { }
429
430 #if ENABLE(SVG)
431     virtual void updateAnimatedSVGAttribute(const QualifiedName&) const { }
432 #endif
433
434     void cancelFocusAppearanceUpdate();
435
436     virtual const AtomicString& virtualPrefix() const { return prefix(); }
437     virtual const AtomicString& virtualLocalName() const { return localName(); }
438     virtual const AtomicString& virtualNamespaceURI() const { return namespaceURI(); }
439     virtual RenderStyle* virtualComputedStyle(PseudoId pseudoElementSpecifier = NOPSEUDO) { return computedStyle(pseudoElementSpecifier); }
440     
441     // cloneNode is private so that non-virtual cloneElementWithChildren and cloneElementWithoutChildren
442     // are used instead.
443     virtual PassRefPtr<Node> cloneNode(bool deep);
444     virtual PassRefPtr<Element> cloneElementWithoutAttributesAndChildren();
445
446     QualifiedName m_tagName;
447     virtual OwnPtr<NodeRareData> createRareData();
448
449     ElementRareData* rareData() const;
450     ElementRareData* ensureRareData();
451
452     SpellcheckAttributeState spellcheckAttributeState() const;
453
454     void updateNamedItemRegistration(const AtomicString& oldName, const AtomicString& newName);
455     void updateExtraNamedItemRegistration(const AtomicString& oldName, const AtomicString& newName);
456
457 private:
458     mutable OwnPtr<NamedNodeMap> m_attributeMap;
459 };
460     
461 inline Element* toElement(Node* node)
462 {
463     ASSERT(!node || node->isElementNode());
464     return static_cast<Element*>(node);
465 }
466
467 inline const Element* toElement(const Node* node)
468 {
469     ASSERT(!node || node->isElementNode());
470     return static_cast<const Element*>(node);
471 }
472
473 // This will catch anyone doing an unnecessary cast.
474 void toElement(const Element*);
475
476 inline bool Node::hasTagName(const QualifiedName& name) const
477 {
478     return isElementNode() && toElement(this)->hasTagName(name);
479 }
480     
481 inline bool Node::hasLocalName(const AtomicString& name) const
482 {
483     return isElementNode() && toElement(this)->hasLocalName(name);
484 }
485
486 inline bool Node::hasAttributes() const
487 {
488     return isElementNode() && toElement(this)->hasAttributes();
489 }
490
491 inline NamedNodeMap* Node::attributes() const
492 {
493     return isElementNode() ? toElement(this)->attributes() : 0;
494 }
495
496 inline Element* Node::parentElement() const
497 {
498     ContainerNode* parent = parentNode();
499     return parent && parent->isElementNode() ? toElement(parent) : 0;
500 }
501
502 inline NamedNodeMap* Element::attributes(bool readonly) const
503 {
504     if (!isStyleAttributeValid())
505         updateStyleAttribute();
506
507 #if ENABLE(SVG)
508     if (!areSVGAttributesValid())
509         updateAnimatedSVGAttribute(anyQName());
510 #endif
511
512     if (!readonly && !m_attributeMap)
513         createAttributeMap();
514     return m_attributeMap.get();
515 }
516
517 inline void Element::setAttributesFromElement(const Element& other)
518 {
519     if (NamedNodeMap* attributeMap = other.attributes(true))
520         attributes(false)->setAttributes(*attributeMap);
521 }
522
523 inline void Element::updateName(const AtomicString& oldName, const AtomicString& newName)
524 {
525     if (!inDocument())
526         return;
527
528     if (oldName == newName)
529         return;
530
531     if (shouldRegisterAsNamedItem())
532         updateNamedItemRegistration(oldName, newName);
533 }
534
535 inline void Element::updateId(const AtomicString& oldId, const AtomicString& newId)
536 {
537     if (!inDocument())
538         return;
539
540     if (oldId == newId)
541         return;
542
543     TreeScope* scope = treeScope();
544     if (!oldId.isEmpty())
545         scope->removeElementById(oldId, this);
546     if (!newId.isEmpty())
547         scope->addElementById(newId, this);
548
549     if (shouldRegisterAsExtraNamedItem())
550         updateExtraNamedItemRegistration(oldId, newId);
551 }
552
553 inline void Element::willRemoveAttribute(const QualifiedName& name, const AtomicString& value)
554 {
555     if (!value.isNull())
556         willModifyAttribute(name, value, nullAtom);
557 }
558
559 inline bool Element::fastHasAttribute(const QualifiedName& name) const
560 {
561     ASSERT(fastAttributeLookupAllowed(name));
562     return m_attributeMap && m_attributeMap->getAttributeItem(name);
563 }
564
565 inline const AtomicString& Element::fastGetAttribute(const QualifiedName& name) const
566 {
567     ASSERT(fastAttributeLookupAllowed(name));
568     if (m_attributeMap) {
569         if (Attribute* attribute = m_attributeMap->getAttributeItem(name))
570             return attribute->value();
571     }
572     return nullAtom;
573 }
574
575 inline const AtomicString& Element::idForStyleResolution() const
576 {
577     ASSERT(hasID());
578     return attributeData()->idForStyleResolution();
579 }
580
581 inline bool Element::isIdAttributeName(const QualifiedName& attributeName) const
582 {
583     // FIXME: This check is probably not correct for the case where the document has an id attribute
584     // with a non-null namespace, because it will return false, a false negative, if the prefixes
585     // don't match but the local name and namespace both do. However, since this has been like this
586     // for a while and the code paths may be hot, we'll have to measure performance if we fix it.
587     return attributeName == document()->idAttributeName();
588 }
589
590 inline const AtomicString& Element::getIdAttribute() const
591 {
592     return fastGetAttribute(document()->idAttributeName());
593 }
594
595 inline void Element::setIdAttribute(const AtomicString& value)
596 {
597     setAttribute(document()->idAttributeName(), value);
598 }
599
600 inline Element* firstElementChild(const ContainerNode* container)
601 {
602     ASSERT_ARG(container, container);
603     Node* child = container->firstChild();
604     while (child && !child->isElementNode())
605         child = child->nextSibling();
606     return static_cast<Element*>(child);
607 }
608
609 } // namespace
610
611 #endif