9da5cb44ce65281d82b60f0aa50957e89a0e7780
[WebKit-https.git] / Source / WebCore / dom / Element.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  *           (C) 2007 David Smith (catfish.man@gmail.com)
7  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012 Apple Inc. All rights reserved.
8  *           (C) 2007 Eric Seidel (eric@webkit.org)
9  *
10  * This library is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Library General Public
12  * License as published by the Free Software Foundation; either
13  * version 2 of the License, or (at your option) any later version.
14  *
15  * This library is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * Library General Public License for more details.
19  *
20  * You should have received a copy of the GNU Library General Public License
21  * along with this library; see the file COPYING.LIB.  If not, write to
22  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
23  * Boston, MA 02110-1301, USA.
24  */
25
26 #include "config.h"
27 #include "Element.h"
28
29 #include "AXObjectCache.h"
30 #include "Attr.h"
31 #include "CSSParser.h"
32 #include "CSSSelectorList.h"
33 #include "ClassList.h"
34 #include "ClientRect.h"
35 #include "ClientRectList.h"
36 #include "DOMTokenList.h"
37 #include "DatasetDOMStringMap.h"
38 #include "Document.h"
39 #include "DocumentFragment.h"
40 #include "ElementRareData.h"
41 #include "ExceptionCode.h"
42 #include "FlowThreadController.h"
43 #include "FocusController.h"
44 #include "Frame.h"
45 #include "FrameView.h"
46 #include "HTMLCollection.h"
47 #include "HTMLDocument.h"
48 #include "HTMLElement.h"
49 #include "HTMLFormControlsCollection.h"
50 #include "HTMLFrameOwnerElement.h"
51 #include "HTMLLabelElement.h"
52 #include "HTMLNames.h"
53 #include "HTMLOptionsCollection.h"
54 #include "HTMLParserIdioms.h"
55 #include "HTMLTableRowsCollection.h"
56 #include "InspectorInstrumentation.h"
57 #include "MutationObserverInterestGroup.h"
58 #include "MutationRecord.h"
59 #include "NamedNodeMap.h"
60 #include "NodeList.h"
61 #include "NodeRenderStyle.h"
62 #include "NodeRenderingContext.h"
63 #include "Page.h"
64 #include "PointerLockController.h"
65 #include "RenderRegion.h"
66 #include "RenderView.h"
67 #include "RenderWidget.h"
68 #include "SelectorQuery.h"
69 #include "Settings.h"
70 #include "ShadowRoot.h"
71 #include "StyleResolver.h"
72 #include "Text.h"
73 #include "TextIterator.h"
74 #include "VoidCallback.h"
75 #include "WebCoreMemoryInstrumentation.h"
76 #include "WebKitAnimationList.h"
77 #include "XMLNSNames.h"
78 #include "XMLNames.h"
79 #include "htmlediting.h"
80 #include <wtf/BitVector.h>
81 #include <wtf/text/CString.h>
82
83 #if ENABLE(SVG)
84 #include "SVGElement.h"
85 #include "SVGNames.h"
86 #endif
87
88 namespace WebCore {
89
90 using namespace HTMLNames;
91 using namespace XMLNames;
92     
93 class StyleResolverParentPusher {
94 public:
95     StyleResolverParentPusher(Element* parent)
96         : m_parent(parent)
97         , m_pushedStyleResolver(0)
98     {
99     }
100     void push()
101     {
102         if (m_pushedStyleResolver)
103             return;
104         m_pushedStyleResolver = m_parent->document()->styleResolver();
105         m_pushedStyleResolver->pushParentElement(m_parent);
106     }
107     ~StyleResolverParentPusher()
108     {
109
110         if (!m_pushedStyleResolver)
111             return;
112
113         // This tells us that our pushed style selector is in a bad state,
114         // so we should just bail out in that scenario.
115         ASSERT(m_pushedStyleResolver == m_parent->document()->styleResolver());
116         if (m_pushedStyleResolver != m_parent->document()->styleResolver())
117             return;
118
119         m_pushedStyleResolver->popParentElement(m_parent);
120     }
121
122 private:
123     Element* m_parent;
124     StyleResolver* m_pushedStyleResolver;
125 };
126
127 typedef Vector<RefPtr<Attr> > AttrNodeList;
128 typedef HashMap<Element*, OwnPtr<AttrNodeList> > AttrNodeListMap;
129
130 static AttrNodeListMap& attrNodeListMap()
131 {
132     DEFINE_STATIC_LOCAL(AttrNodeListMap, map, ());
133     return map;
134 }
135
136 static AttrNodeList* attrNodeListForElement(Element* element)
137 {
138     if (!element->hasSyntheticAttrChildNodes())
139         return 0;
140     ASSERT(attrNodeListMap().contains(element));
141     return attrNodeListMap().get(element);
142 }
143
144 static AttrNodeList* ensureAttrNodeListForElement(Element* element)
145 {
146     if (element->hasSyntheticAttrChildNodes()) {
147         ASSERT(attrNodeListMap().contains(element));
148         return attrNodeListMap().get(element);
149     }
150     ASSERT(!attrNodeListMap().contains(element));
151     element->setHasSyntheticAttrChildNodes(true);
152     AttrNodeListMap::AddResult result = attrNodeListMap().add(element, adoptPtr(new AttrNodeList));
153     return result.iterator->value.get();
154 }
155
156 static void removeAttrNodeListForElement(Element* element)
157 {
158     ASSERT(element->hasSyntheticAttrChildNodes());
159     ASSERT(attrNodeListMap().contains(element));
160     attrNodeListMap().remove(element);
161     element->setHasSyntheticAttrChildNodes(false);
162 }
163
164 static Attr* findAttrNodeInList(AttrNodeList* attrNodeList, const QualifiedName& name)
165 {
166     for (unsigned i = 0; i < attrNodeList->size(); ++i) {
167         if (attrNodeList->at(i)->qualifiedName() == name)
168             return attrNodeList->at(i).get();
169     }
170     return 0;
171 }
172
173 PassRefPtr<Element> Element::create(const QualifiedName& tagName, Document* document)
174 {
175     return adoptRef(new Element(tagName, document, CreateElement));
176 }
177
178 Element::~Element()
179 {
180 #ifndef NDEBUG
181     if (document() && document()->renderer()) {
182         // When the document is not destroyed, an element that was part of a named flow
183         // content nodes should have been removed from the content nodes collection
184         // and the inNamedFlow flag reset.
185         ASSERT(!inNamedFlow());
186     }
187 #endif
188
189     if (ElementShadow* elementShadow = shadow()) {
190         elementShadow->removeAllShadowRoots();
191         elementRareData()->m_shadow.clear();
192     }
193
194     if (hasSyntheticAttrChildNodes())
195         detachAllAttrNodesFromElement();
196 }
197
198 inline ElementRareData* Element::elementRareData() const
199 {
200     ASSERT(hasRareData());
201     return static_cast<ElementRareData*>(rareData());
202 }
203
204 inline ElementRareData* Element::ensureElementRareData()
205 {
206     return static_cast<ElementRareData*>(ensureRareData());
207 }
208     
209 OwnPtr<NodeRareData> Element::createRareData()
210 {
211     return adoptPtr(new ElementRareData);
212 }
213
214 DEFINE_VIRTUAL_ATTRIBUTE_EVENT_LISTENER(Element, blur);
215 DEFINE_VIRTUAL_ATTRIBUTE_EVENT_LISTENER(Element, error);
216 DEFINE_VIRTUAL_ATTRIBUTE_EVENT_LISTENER(Element, focus);
217 DEFINE_VIRTUAL_ATTRIBUTE_EVENT_LISTENER(Element, load);
218
219 PassRefPtr<Node> Element::cloneNode(bool deep)
220 {
221     return deep ? cloneElementWithChildren() : cloneElementWithoutChildren();
222 }
223
224 PassRefPtr<Element> Element::cloneElementWithChildren()
225 {
226     RefPtr<Element> clone = cloneElementWithoutChildren();
227     cloneChildNodes(clone.get());
228     return clone.release();
229 }
230
231 PassRefPtr<Element> Element::cloneElementWithoutChildren()
232 {
233     RefPtr<Element> clone = cloneElementWithoutAttributesAndChildren();
234     // This will catch HTML elements in the wrong namespace that are not correctly copied.
235     // This is a sanity check as HTML overloads some of the DOM methods.
236     ASSERT(isHTMLElement() == clone->isHTMLElement());
237
238     clone->cloneDataFromElement(*this);
239     return clone.release();
240 }
241
242 PassRefPtr<Element> Element::cloneElementWithoutAttributesAndChildren()
243 {
244     return document()->createElement(tagQName(), false);
245 }
246
247 PassRefPtr<Attr> Element::detachAttribute(size_t index)
248 {
249     ASSERT(attributeData());
250
251     const Attribute* attribute = attributeData()->attributeItem(index);
252     ASSERT(attribute);
253
254     RefPtr<Attr> attrNode = attrIfExists(attribute->name());
255     if (attrNode)
256         detachAttrNodeFromElementWithValue(attrNode.get(), attribute->value());
257     else
258         attrNode = Attr::create(document(), attribute->name(), attribute->value());
259
260     removeAttributeInternal(index, NotInSynchronizationOfLazyAttribute);
261     return attrNode.release();
262 }
263
264 void Element::removeAttribute(const QualifiedName& name)
265 {
266     if (!attributeData())
267         return;
268
269     size_t index = attributeData()->getAttributeItemIndex(name);
270     if (index == notFound)
271         return;
272
273     removeAttributeInternal(index, NotInSynchronizationOfLazyAttribute);
274 }
275
276 void Element::setBooleanAttribute(const QualifiedName& name, bool value)
277 {
278     if (value)
279         setAttribute(name, emptyAtom);
280     else
281         removeAttribute(name);
282 }
283
284 NamedNodeMap* Element::attributes() const
285 {
286     ensureUpdatedAttributeData();
287     ElementRareData* rareData = const_cast<Element*>(this)->ensureElementRareData();
288     if (NamedNodeMap* attributeMap = rareData->m_attributeMap.get())
289         return attributeMap;
290
291     rareData->m_attributeMap = NamedNodeMap::create(const_cast<Element*>(this));
292     return rareData->m_attributeMap.get();
293 }
294
295 Node::NodeType Element::nodeType() const
296 {
297     return ELEMENT_NODE;
298 }
299
300 bool Element::hasAttribute(const QualifiedName& name) const
301 {
302     return hasAttributeNS(name.namespaceURI(), name.localName());
303 }
304
305 const AtomicString& Element::getAttribute(const QualifiedName& name) const
306 {
307     if (UNLIKELY(name == styleAttr) && attributeData() && attributeData()->m_styleAttributeIsDirty)
308         updateStyleAttribute();
309
310 #if ENABLE(SVG)
311     if (UNLIKELY(!areSVGAttributesValid()))
312         updateAnimatedSVGAttribute(name);
313 #endif
314
315     if (attributeData()) {
316         if (const Attribute* attribute = getAttributeItem(name))
317             return attribute->value();
318     }
319     return nullAtom;
320 }
321
322 void Element::scrollIntoView(bool alignToTop) 
323 {
324     document()->updateLayoutIgnorePendingStylesheets();
325
326     if (!renderer())
327         return;
328
329     LayoutRect bounds = boundingBox();
330     // Align to the top / bottom and to the closest edge.
331     if (alignToTop)
332         renderer()->scrollRectToVisible(bounds, ScrollAlignment::alignToEdgeIfNeeded, ScrollAlignment::alignTopAlways);
333     else
334         renderer()->scrollRectToVisible(bounds, ScrollAlignment::alignToEdgeIfNeeded, ScrollAlignment::alignBottomAlways);
335 }
336
337 void Element::scrollIntoViewIfNeeded(bool centerIfNeeded)
338 {
339     document()->updateLayoutIgnorePendingStylesheets();
340
341     if (!renderer())
342         return;
343
344     LayoutRect bounds = boundingBox();
345     if (centerIfNeeded)
346         renderer()->scrollRectToVisible(bounds, ScrollAlignment::alignCenterIfNeeded, ScrollAlignment::alignCenterIfNeeded);
347     else
348         renderer()->scrollRectToVisible(bounds, ScrollAlignment::alignToEdgeIfNeeded, ScrollAlignment::alignToEdgeIfNeeded);
349 }
350
351 void Element::scrollByUnits(int units, ScrollGranularity granularity)
352 {
353     document()->updateLayoutIgnorePendingStylesheets();
354
355     if (!renderer())
356         return;
357
358     if (!renderer()->hasOverflowClip())
359         return;
360
361     ScrollDirection direction = ScrollDown;
362     if (units < 0) {
363         direction = ScrollUp;
364         units = -units;
365     }
366     Node* stopNode = this;
367     toRenderBox(renderer())->scroll(direction, granularity, units, &stopNode);
368 }
369
370 void Element::scrollByLines(int lines)
371 {
372     scrollByUnits(lines, ScrollByLine);
373 }
374
375 void Element::scrollByPages(int pages)
376 {
377     scrollByUnits(pages, ScrollByPage);
378 }
379
380 static float localZoomForRenderer(RenderObject* renderer)
381 {
382     // FIXME: This does the wrong thing if two opposing zooms are in effect and canceled each
383     // other out, but the alternative is that we'd have to crawl up the whole render tree every
384     // time (or store an additional bit in the RenderStyle to indicate that a zoom was specified).
385     float zoomFactor = 1;
386     if (renderer->style()->effectiveZoom() != 1) {
387         // Need to find the nearest enclosing RenderObject that set up
388         // a differing zoom, and then we divide our result by it to eliminate the zoom.
389         RenderObject* prev = renderer;
390         for (RenderObject* curr = prev->parent(); curr; curr = curr->parent()) {
391             if (curr->style()->effectiveZoom() != prev->style()->effectiveZoom()) {
392                 zoomFactor = prev->style()->zoom();
393                 break;
394             }
395             prev = curr;
396         }
397         if (prev->isRenderView())
398             zoomFactor = prev->style()->zoom();
399     }
400     return zoomFactor;
401 }
402
403 static int adjustForLocalZoom(LayoutUnit value, RenderObject* renderer)
404 {
405     float zoomFactor = localZoomForRenderer(renderer);
406     if (zoomFactor == 1)
407         return value;
408 #if ENABLE(SUBPIXEL_LAYOUT)
409     return lroundf(value / zoomFactor);
410 #else
411     // Needed because computeLengthInt truncates (rather than rounds) when scaling up.
412     if (zoomFactor > 1)
413         value++;
414     return static_cast<int>(value / zoomFactor);
415 #endif
416 }
417
418 int Element::offsetLeft()
419 {
420     document()->updateLayoutIgnorePendingStylesheets();
421     if (RenderBoxModelObject* renderer = renderBoxModelObject())
422         return adjustForLocalZoom(renderer->pixelSnappedOffsetLeft(), renderer);
423     return 0;
424 }
425
426 int Element::offsetTop()
427 {
428     document()->updateLayoutIgnorePendingStylesheets();
429     if (RenderBoxModelObject* renderer = renderBoxModelObject())
430         return adjustForLocalZoom(renderer->pixelSnappedOffsetTop(), renderer);
431     return 0;
432 }
433
434 int Element::offsetWidth()
435 {
436     document()->updateLayoutIgnorePendingStylesheets();
437     if (RenderBoxModelObject* renderer = renderBoxModelObject())
438         return adjustForAbsoluteZoom(renderer->pixelSnappedOffsetWidth(), renderer);
439     return 0;
440 }
441
442 int Element::offsetHeight()
443 {
444     document()->updateLayoutIgnorePendingStylesheets();
445     if (RenderBoxModelObject* renderer = renderBoxModelObject())
446         return adjustForAbsoluteZoom(renderer->pixelSnappedOffsetHeight(), renderer);
447     return 0;
448 }
449
450 Element* Element::offsetParent()
451 {
452     document()->updateLayoutIgnorePendingStylesheets();
453     if (RenderObject* rend = renderer())
454         if (RenderObject* offsetParent = rend->offsetParent())
455             return static_cast<Element*>(offsetParent->node());
456     return 0;
457 }
458
459 int Element::clientLeft()
460 {
461     document()->updateLayoutIgnorePendingStylesheets();
462
463     if (RenderBox* renderer = renderBox())
464         return adjustForAbsoluteZoom(roundToInt(renderer->clientLeft()), renderer);
465     return 0;
466 }
467
468 int Element::clientTop()
469 {
470     document()->updateLayoutIgnorePendingStylesheets();
471
472     if (RenderBox* renderer = renderBox())
473         return adjustForAbsoluteZoom(roundToInt(renderer->clientTop()), renderer);
474     return 0;
475 }
476
477 int Element::clientWidth()
478 {
479     document()->updateLayoutIgnorePendingStylesheets();
480
481     // When in strict mode, clientWidth for the document element should return the width of the containing frame.
482     // When in quirks mode, clientWidth for the body element should return the width of the containing frame.
483     bool inQuirksMode = document()->inQuirksMode();
484     if ((!inQuirksMode && document()->documentElement() == this) ||
485         (inQuirksMode && isHTMLElement() && document()->body() == this)) {
486         if (FrameView* view = document()->view()) {
487             if (RenderView* renderView = document()->renderView())
488                 return adjustForAbsoluteZoom(view->layoutWidth(), renderView);
489         }
490     }
491     
492     if (RenderBox* renderer = renderBox())
493         return adjustForAbsoluteZoom(renderer->pixelSnappedClientWidth(), renderer);
494     return 0;
495 }
496
497 int Element::clientHeight()
498 {
499     document()->updateLayoutIgnorePendingStylesheets();
500
501     // When in strict mode, clientHeight for the document element should return the height of the containing frame.
502     // When in quirks mode, clientHeight for the body element should return the height of the containing frame.
503     bool inQuirksMode = document()->inQuirksMode();     
504
505     if ((!inQuirksMode && document()->documentElement() == this) ||
506         (inQuirksMode && isHTMLElement() && document()->body() == this)) {
507         if (FrameView* view = document()->view()) {
508             if (RenderView* renderView = document()->renderView())
509                 return adjustForAbsoluteZoom(view->layoutHeight(), renderView);
510         }
511     }
512     
513     if (RenderBox* renderer = renderBox())
514         return adjustForAbsoluteZoom(renderer->pixelSnappedClientHeight(), renderer);
515     return 0;
516 }
517
518 int Element::scrollLeft()
519 {
520     document()->updateLayoutIgnorePendingStylesheets();
521     if (RenderBox* rend = renderBox())
522         return adjustForAbsoluteZoom(rend->scrollLeft(), rend);
523     return 0;
524 }
525
526 int Element::scrollTop()
527 {
528     document()->updateLayoutIgnorePendingStylesheets();
529     if (RenderBox* rend = renderBox())
530         return adjustForAbsoluteZoom(rend->scrollTop(), rend);
531     return 0;
532 }
533
534 void Element::setScrollLeft(int newLeft)
535 {
536     document()->updateLayoutIgnorePendingStylesheets();
537     if (RenderBox* rend = renderBox())
538         rend->setScrollLeft(static_cast<int>(newLeft * rend->style()->effectiveZoom()));
539 }
540
541 void Element::setScrollTop(int newTop)
542 {
543     document()->updateLayoutIgnorePendingStylesheets();
544     if (RenderBox* rend = renderBox())
545         rend->setScrollTop(static_cast<int>(newTop * rend->style()->effectiveZoom()));
546 }
547
548 int Element::scrollWidth()
549 {
550     document()->updateLayoutIgnorePendingStylesheets();
551     if (RenderBox* rend = renderBox())
552         return adjustForAbsoluteZoom(rend->scrollWidth(), rend);
553     return 0;
554 }
555
556 int Element::scrollHeight()
557 {
558     document()->updateLayoutIgnorePendingStylesheets();
559     if (RenderBox* rend = renderBox())
560         return adjustForAbsoluteZoom(rend->scrollHeight(), rend);
561     return 0;
562 }
563
564 IntRect Element::boundsInRootViewSpace()
565 {
566     document()->updateLayoutIgnorePendingStylesheets();
567
568     FrameView* view = document()->view();
569     if (!view)
570         return IntRect();
571
572     Vector<FloatQuad> quads;
573 #if ENABLE(SVG)
574     if (isSVGElement() && renderer()) {
575         // Get the bounding rectangle from the SVG model.
576         SVGElement* svgElement = static_cast<SVGElement*>(this);
577         FloatRect localRect;
578         if (svgElement->getBoundingBox(localRect))
579             quads.append(renderer()->localToAbsoluteQuad(localRect));
580     } else
581 #endif
582     {
583         // Get the bounding rectangle from the box model.
584         if (renderBoxModelObject())
585             renderBoxModelObject()->absoluteQuads(quads);
586     }
587
588     if (quads.isEmpty())
589         return IntRect();
590
591     IntRect result = quads[0].enclosingBoundingBox();
592     for (size_t i = 1; i < quads.size(); ++i)
593         result.unite(quads[i].enclosingBoundingBox());
594
595     result = view->contentsToRootView(result);
596     return result;
597 }
598
599 PassRefPtr<ClientRectList> Element::getClientRects()
600 {
601     document()->updateLayoutIgnorePendingStylesheets();
602
603     RenderBoxModelObject* renderBoxModelObject = this->renderBoxModelObject();
604     if (!renderBoxModelObject)
605         return ClientRectList::create();
606
607     // FIXME: Handle SVG elements.
608     // FIXME: Handle table/inline-table with a caption.
609
610     Vector<FloatQuad> quads;
611     renderBoxModelObject->absoluteQuads(quads);
612     document()->adjustFloatQuadsForScrollAndAbsoluteZoomAndFrameScale(quads, renderBoxModelObject);
613     return ClientRectList::create(quads);
614 }
615
616 PassRefPtr<ClientRect> Element::getBoundingClientRect()
617 {
618     document()->updateLayoutIgnorePendingStylesheets();
619
620     Vector<FloatQuad> quads;
621 #if ENABLE(SVG)
622     if (isSVGElement() && renderer() && !renderer()->isSVGRoot()) {
623         // Get the bounding rectangle from the SVG model.
624         SVGElement* svgElement = static_cast<SVGElement*>(this);
625         FloatRect localRect;
626         if (svgElement->getBoundingBox(localRect))
627             quads.append(renderer()->localToAbsoluteQuad(localRect));
628     } else
629 #endif
630     {
631         // Get the bounding rectangle from the box model.
632         if (renderBoxModelObject())
633             renderBoxModelObject()->absoluteQuads(quads);
634     }
635
636     if (quads.isEmpty())
637         return ClientRect::create();
638
639     FloatRect result = quads[0].boundingBox();
640     for (size_t i = 1; i < quads.size(); ++i)
641         result.unite(quads[i].boundingBox());
642
643     document()->adjustFloatRectForScrollAndAbsoluteZoomAndFrameScale(result, renderer());
644     return ClientRect::create(result);
645 }
646     
647 IntRect Element::screenRect() const
648 {
649     if (!renderer())
650         return IntRect();
651     // FIXME: this should probably respect transforms
652     return document()->view()->contentsToScreen(renderer()->absoluteBoundingBoxRectIgnoringTransforms());
653 }
654
655 static inline bool shouldIgnoreAttributeCase(const Element* e)
656 {
657     return e && e->document()->isHTMLDocument() && e->isHTMLElement();
658 }
659
660 const AtomicString& Element::getAttribute(const AtomicString& name) const
661 {
662     bool ignoreCase = shouldIgnoreAttributeCase(this);
663
664     // Update the 'style' attribute if it's invalid and being requested:
665     if (attributeData() && attributeData()->m_styleAttributeIsDirty && equalPossiblyIgnoringCase(name, styleAttr.localName(), ignoreCase))
666         updateStyleAttribute();
667
668 #if ENABLE(SVG)
669     if (!areSVGAttributesValid()) {
670         // We're not passing a namespace argument on purpose. SVGNames::*Attr are defined w/o namespaces as well.
671         updateAnimatedSVGAttribute(QualifiedName(nullAtom, name, nullAtom));
672     }
673 #endif
674
675     if (attributeData()) {
676         if (const Attribute* attribute = attributeData()->getAttributeItem(name, ignoreCase))
677             return attribute->value();
678     }
679
680     return nullAtom;
681 }
682
683 const AtomicString& Element::getAttributeNS(const AtomicString& namespaceURI, const AtomicString& localName) const
684 {
685     return getAttribute(QualifiedName(nullAtom, localName, namespaceURI));
686 }
687
688 void Element::setAttribute(const AtomicString& name, const AtomicString& value, ExceptionCode& ec)
689 {
690     if (!Document::isValidName(name)) {
691         ec = INVALID_CHARACTER_ERR;
692         return;
693     }
694
695     const AtomicString& localName = shouldIgnoreAttributeCase(this) ? name.lower() : name;
696
697     size_t index = ensureUpdatedAttributeData()->getAttributeItemIndex(localName, false);
698     const QualifiedName& qName = index != notFound ? attributeItem(index)->name() : QualifiedName(nullAtom, localName, nullAtom);
699     setAttributeInternal(index, qName, value, NotInSynchronizationOfLazyAttribute);
700 }
701
702 void Element::setAttribute(const QualifiedName& name, const AtomicString& value)
703 {
704     setAttributeInternal(ensureUpdatedAttributeData()->getAttributeItemIndex(name), name, value, NotInSynchronizationOfLazyAttribute);
705 }
706
707 void Element::setSynchronizedLazyAttribute(const QualifiedName& name, const AtomicString& value)
708 {
709     setAttributeInternal(mutableAttributeData()->getAttributeItemIndex(name), name, value, InSynchronizationOfLazyAttribute);
710 }
711
712 inline void Element::setAttributeInternal(size_t index, const QualifiedName& name, const AtomicString& newValue, SynchronizationOfLazyAttribute inSynchronizationOfLazyAttribute)
713 {
714     if (newValue.isNull()) {
715         if (index != notFound)
716             removeAttributeInternal(index, inSynchronizationOfLazyAttribute);
717         return;
718     }
719
720     if (index == notFound) {
721         addAttributeInternal(name, newValue, inSynchronizationOfLazyAttribute);
722         return;
723     }
724
725     if (!inSynchronizationOfLazyAttribute)
726         willModifyAttribute(name, attributeItem(index)->value(), newValue);
727
728     if (newValue != attributeItem(index)->value()) {
729         // If there is an Attr node hooked to this attribute, the Attr::setValue() call below
730         // will write into the ElementAttributeData.
731         // FIXME: Refactor this so it makes some sense.
732         if (RefPtr<Attr> attrNode = attrIfExists(name))
733             attrNode->setValue(newValue);
734         else
735             mutableAttributeData()->attributeItem(index)->setValue(newValue);
736     }
737
738     if (!inSynchronizationOfLazyAttribute)
739         didModifyAttribute(name, newValue);
740 }
741
742 static inline AtomicString makeIdForStyleResolution(const AtomicString& value, bool inQuirksMode)
743 {
744     if (inQuirksMode)
745         return value.lower();
746     return value;
747 }
748
749 static bool checkNeedsStyleInvalidationForIdChange(const AtomicString& oldId, const AtomicString& newId, StyleResolver* styleResolver)
750 {
751     ASSERT(newId != oldId);
752     if (!oldId.isEmpty() && styleResolver->hasSelectorForId(oldId))
753         return true;
754     if (!newId.isEmpty() && styleResolver->hasSelectorForId(newId))
755         return true;
756     return false;
757 }
758
759 void Element::attributeChanged(const QualifiedName& name, const AtomicString& newValue)
760 {
761     parseAttribute(name, newValue);
762
763     document()->incDOMTreeVersion();
764
765     StyleResolver* styleResolver = document()->styleResolverIfExists();
766     bool testShouldInvalidateStyle = attached() && styleResolver && styleChangeType() < FullStyleChange;
767     bool shouldInvalidateStyle = false;
768
769     if (isIdAttributeName(name)) {
770         AtomicString oldId = attributeData()->idForStyleResolution();
771         AtomicString newId = makeIdForStyleResolution(newValue, document()->inQuirksMode());
772         if (newId != oldId) {
773             attributeData()->setIdForStyleResolution(newId);
774             shouldInvalidateStyle = testShouldInvalidateStyle && checkNeedsStyleInvalidationForIdChange(oldId, newId, styleResolver);
775         }
776     } else if (name == classAttr)
777         classAttributeChanged(newValue);
778     else if (name == HTMLNames::nameAttr)
779         setHasName(!newValue.isNull());
780     else if (name == HTMLNames::pseudoAttr)
781         shouldInvalidateStyle |= testShouldInvalidateStyle && isInShadowTree();
782
783     shouldInvalidateStyle |= testShouldInvalidateStyle && styleResolver->hasSelectorForAttribute(name.localName());
784
785     invalidateNodeListCachesInAncestors(&name, this);
786
787     if (shouldInvalidateStyle)
788         setNeedsStyleRecalc();
789
790     if (AXObjectCache::accessibilityEnabled())
791         document()->axObjectCache()->handleAttributeChanged(name, this);
792 }
793
794 template <typename CharacterType>
795 static inline bool classStringHasClassName(const CharacterType* characters, unsigned length)
796 {
797     ASSERT(length > 0);
798
799     unsigned i = 0;
800     do {
801         if (isNotHTMLSpace(characters[i]))
802             break;
803         ++i;
804     } while (i < length);
805
806     return i < length;
807 }
808
809 static inline bool classStringHasClassName(const AtomicString& newClassString)
810 {
811     unsigned length = newClassString.length();
812
813     if (!length)
814         return false;
815
816     if (newClassString.is8Bit())
817         return classStringHasClassName(newClassString.characters8(), length);
818     return classStringHasClassName(newClassString.characters16(), length);
819 }
820
821 static bool checkNeedsStyleInvalidationForClassChange(const SpaceSplitString& changedClasses, StyleResolver* styleResolver)
822 {
823     unsigned changedSize = changedClasses.size();
824     for (unsigned i = 0; i < changedSize; ++i) {
825         if (styleResolver->hasSelectorForClass(changedClasses[i]))
826             return true;
827     }
828     return false;
829 }
830
831 static bool checkNeedsStyleInvalidationForClassChange(const SpaceSplitString& oldClasses, const SpaceSplitString& newClasses, StyleResolver* styleResolver)
832 {
833     unsigned oldSize = oldClasses.size();
834     if (!oldSize)
835         return checkNeedsStyleInvalidationForClassChange(newClasses, styleResolver);
836     BitVector remainingClassBits;
837     remainingClassBits.ensureSize(oldSize);
838     // Class vectors tend to be very short. This is faster than using a hash table.
839     unsigned newSize = newClasses.size();
840     for (unsigned i = 0; i < newSize; ++i) {
841         for (unsigned j = 0; j < oldSize; ++j) {
842             if (newClasses[i] == oldClasses[j]) {
843                 remainingClassBits.quickSet(j);
844                 continue;
845             }
846         }
847         if (styleResolver->hasSelectorForClass(newClasses[i]))
848             return true;
849     }
850     for (unsigned i = 0; i < oldSize; ++i) {
851         // If the bit is not set the the corresponding class has been removed.
852         if (remainingClassBits.quickGet(i))
853             continue;
854         if (styleResolver->hasSelectorForClass(oldClasses[i]))
855             return true;
856     }
857     return false;
858 }
859
860 void Element::classAttributeChanged(const AtomicString& newClassString)
861 {
862     StyleResolver* styleResolver = document()->styleResolverIfExists();
863     bool testShouldInvalidateStyle = attached() && styleResolver && styleChangeType() < FullStyleChange;
864     bool shouldInvalidateStyle = false;
865
866     if (classStringHasClassName(newClassString)) {
867         const ElementAttributeData* attributeData = ensureAttributeData();
868         const bool shouldFoldCase = document()->inQuirksMode();
869         const SpaceSplitString oldClasses = attributeData->classNames();
870
871         attributeData->setClass(newClassString, shouldFoldCase);
872
873         const SpaceSplitString& newClasses = attributeData->classNames();
874         shouldInvalidateStyle = testShouldInvalidateStyle && checkNeedsStyleInvalidationForClassChange(oldClasses, newClasses, styleResolver);
875     } else if (const ElementAttributeData* attributeData = this->attributeData()) {
876         const SpaceSplitString& oldClasses = attributeData->classNames();
877         shouldInvalidateStyle = testShouldInvalidateStyle && checkNeedsStyleInvalidationForClassChange(oldClasses, styleResolver);
878
879         attributeData->clearClass();
880     }
881
882     if (DOMTokenList* classList = optionalClassList())
883         static_cast<ClassList*>(classList)->reset(newClassString);
884
885     if (shouldInvalidateStyle)
886         setNeedsStyleRecalc();
887 }
888
889 // Returns true is the given attribute is an event handler.
890 // We consider an event handler any attribute that begins with "on".
891 // It is a simple solution that has the advantage of not requiring any
892 // code or configuration change if a new event handler is defined.
893
894 static bool isEventHandlerAttribute(const QualifiedName& name)
895 {
896     return name.namespaceURI().isNull() && name.localName().startsWith("on");
897 }
898
899 // FIXME: Share code with Element::isURLAttribute.
900 static bool isAttributeToRemove(const QualifiedName& name, const AtomicString& value)
901 {
902     return (name.localName() == hrefAttr.localName() || name.localName() == nohrefAttr.localName()
903         || name == srcAttr || name == actionAttr || name == formactionAttr) && protocolIsJavaScript(stripLeadingAndTrailingHTMLSpaces(value));
904 }
905
906 void Element::parserSetAttributes(const Vector<Attribute>& attributeVector, FragmentScriptingPermission scriptingPermission)
907 {
908     ASSERT(!inDocument());
909     ASSERT(!parentNode());
910
911     ASSERT(!m_attributeData);
912
913     if (attributeVector.isEmpty())
914         return;
915
916     Vector<Attribute> filteredAttributes = attributeVector;
917
918     // If the element is created as result of a paste or drag-n-drop operation
919     // we want to remove all the script and event handlers.
920     if (scriptingPermission == DisallowScriptingContent) {
921         unsigned i = 0;
922         while (i < filteredAttributes.size()) {
923             Attribute& attribute = filteredAttributes[i];
924             if (isEventHandlerAttribute(attribute.name())) {
925                 filteredAttributes.remove(i);
926                 continue;
927             }
928
929             if (isAttributeToRemove(attribute.name(), attribute.value()))
930                 attribute.setValue(emptyAtom);
931             i++;
932         }
933     }
934
935     // When the document is in parsing state, we cache immutable ElementAttributeData objects with the
936     // input attribute vector (and the tag name) as key. (This cache is held by Document.)
937     if (!document() || !document()->parsing())
938         m_attributeData = ElementAttributeData::createImmutable(filteredAttributes);
939     else
940         m_attributeData = document()->cachedImmutableAttributeData(this, filteredAttributes);
941
942     // Iterate over the set of attributes we already have on the stack in case
943     // attributeChanged mutates m_attributeData.
944     // FIXME: Find a way so we don't have to do this.
945     for (unsigned i = 0; i < filteredAttributes.size(); ++i)
946         attributeChanged(filteredAttributes[i].name(), filteredAttributes[i].value());
947 }
948
949 bool Element::hasAttributes() const
950 {
951     updateInvalidAttributes();
952     return attributeData() && attributeData()->length();
953 }
954
955 bool Element::hasEquivalentAttributes(const Element* other) const
956 {
957     const ElementAttributeData* attributeData = updatedAttributeData();
958     const ElementAttributeData* otherAttributeData = other->updatedAttributeData();
959     if (attributeData == otherAttributeData)
960         return true;
961     if (attributeData)
962         return attributeData->isEquivalent(otherAttributeData);
963     if (otherAttributeData)
964         return otherAttributeData->isEquivalent(attributeData);
965     return true;
966 }
967
968 String Element::nodeName() const
969 {
970     return m_tagName.toString();
971 }
972
973 String Element::nodeNamePreservingCase() const
974 {
975     return m_tagName.toString();
976 }
977
978 void Element::setPrefix(const AtomicString& prefix, ExceptionCode& ec)
979 {
980     ec = 0;
981     checkSetPrefix(prefix, ec);
982     if (ec)
983         return;
984
985     m_tagName.setPrefix(prefix.isEmpty() ? AtomicString() : prefix);
986 }
987
988 KURL Element::baseURI() const
989 {
990     const AtomicString& baseAttribute = getAttribute(baseAttr);
991     KURL base(KURL(), baseAttribute);
992     if (!base.protocol().isEmpty())
993         return base;
994
995     ContainerNode* parent = parentNode();
996     if (!parent)
997         return base;
998
999     const KURL& parentBase = parent->baseURI();
1000     if (parentBase.isNull())
1001         return base;
1002
1003     return KURL(parentBase, baseAttribute);
1004 }
1005
1006 const QualifiedName& Element::imageSourceAttributeName() const
1007 {
1008     return srcAttr;
1009 }
1010
1011 RenderObject* Element::createRenderer(RenderArena* arena, RenderStyle* style)
1012 {
1013     if (document()->documentElement() == this && style->display() == NONE) {
1014         // Ignore display: none on root elements.  Force a display of block in that case.
1015         RenderBlock* result = new (arena) RenderBlock(this);
1016         if (result)
1017             result->setAnimatableStyle(style);
1018         return result;
1019     }
1020     return RenderObject::createObject(this, style);
1021 }
1022
1023 bool Element::wasChangedSinceLastFormControlChangeEvent() const
1024 {
1025     return false;
1026 }
1027
1028 void Element::setChangedSinceLastFormControlChangeEvent(bool)
1029 {
1030 }
1031
1032 Node::InsertionNotificationRequest Element::insertedInto(ContainerNode* insertionPoint)
1033 {
1034     // need to do superclass processing first so inDocument() is true
1035     // by the time we reach updateId
1036     ContainerNode::insertedInto(insertionPoint);
1037
1038 #if ENABLE(FULLSCREEN_API)
1039     if (containsFullScreenElement() && parentElement() && !parentElement()->containsFullScreenElement())
1040         setContainsFullScreenElementOnAncestorsCrossingFrameBoundaries(true);
1041 #endif
1042
1043     if (!insertionPoint->inDocument())
1044         return InsertionDone;
1045
1046     const AtomicString& idValue = getIdAttribute();
1047     if (!idValue.isNull())
1048         updateId(nullAtom, idValue);
1049
1050     const AtomicString& nameValue = getNameAttribute();
1051     if (!nameValue.isNull())
1052         updateName(nullAtom, nameValue);
1053
1054     if (hasTagName(labelTag)) {
1055         TreeScope* scope = treeScope();
1056         if (scope->shouldCacheLabelsByForAttribute())
1057             updateLabel(scope, nullAtom, fastGetAttribute(forAttr));
1058     }
1059
1060     return InsertionDone;
1061 }
1062
1063 void Element::removedFrom(ContainerNode* insertionPoint)
1064 {
1065 #if ENABLE(FULLSCREEN_API)
1066     if (containsFullScreenElement())
1067         setContainsFullScreenElementOnAncestorsCrossingFrameBoundaries(false);
1068 #endif
1069 #if ENABLE(POINTER_LOCK)
1070     if (document()->page())
1071         document()->page()->pointerLockController()->elementRemoved(this);
1072 #endif
1073
1074     setSavedLayerScrollOffset(IntSize());
1075
1076     if (insertionPoint->inDocument()) {
1077         const AtomicString& idValue = getIdAttribute();
1078         if (!idValue.isNull() && inDocument())
1079             updateId(insertionPoint->treeScope(), idValue, nullAtom);
1080
1081         const AtomicString& nameValue = getNameAttribute();
1082         if (!nameValue.isNull())
1083             updateName(nameValue, nullAtom);
1084
1085         if (hasTagName(labelTag)) {
1086             TreeScope* treeScope = insertionPoint->treeScope();
1087             if (treeScope->shouldCacheLabelsByForAttribute())
1088                 updateLabel(treeScope, fastGetAttribute(forAttr), nullAtom);
1089         }
1090     }
1091
1092     ContainerNode::removedFrom(insertionPoint);
1093 }
1094
1095 void Element::attach()
1096 {
1097     suspendPostAttachCallbacks();
1098     WidgetHierarchyUpdatesSuspensionScope suspendWidgetHierarchyUpdates;
1099
1100     createRendererIfNeeded();
1101     StyleResolverParentPusher parentPusher(this);
1102
1103     if (parentElement() && parentElement()->isInCanvasSubtree())
1104         setIsInCanvasSubtree(true);
1105
1106     // When a shadow root exists, it does the work of attaching the children.
1107     if (ElementShadow* shadow = this->shadow()) {
1108         parentPusher.push();
1109         shadow->attach();
1110     } else {
1111         if (firstChild())
1112             parentPusher.push();
1113     }
1114     ContainerNode::attach();
1115
1116     if (hasRareData()) {   
1117         ElementRareData* data = elementRareData();
1118         if (data->needsFocusAppearanceUpdateSoonAfterAttach()) {
1119             if (isFocusable() && document()->focusedNode() == this)
1120                 document()->updateFocusAppearanceSoon(false /* don't restore selection */);
1121             data->setNeedsFocusAppearanceUpdateSoonAfterAttach(false);
1122         }
1123     }
1124
1125     resumePostAttachCallbacks();
1126 }
1127
1128 void Element::unregisterNamedFlowContentNode()
1129 {
1130     if (document()->cssRegionsEnabled() && inNamedFlow() && document()->renderView())
1131         document()->renderView()->flowThreadController()->unregisterNamedFlowContentNode(this);
1132 }
1133
1134 void Element::detach()
1135 {
1136     WidgetHierarchyUpdatesSuspensionScope suspendWidgetHierarchyUpdates;
1137     unregisterNamedFlowContentNode();
1138     cancelFocusAppearanceUpdate();
1139     if (hasRareData()) {
1140         ElementRareData* data = elementRareData();
1141         data->setIsInCanvasSubtree(false);
1142         data->resetComputedStyle();
1143     }
1144
1145     if (ElementShadow* shadow = this->shadow()) {
1146         detachChildrenIfNeeded();
1147         shadow->detach();
1148     }
1149     ContainerNode::detach();
1150 }
1151
1152 bool Element::pseudoStyleCacheIsInvalid(const RenderStyle* currentStyle, RenderStyle* newStyle)
1153 {
1154     ASSERT(currentStyle == renderStyle());
1155     ASSERT(renderer());
1156
1157     if (!currentStyle)
1158         return false;
1159
1160     const PseudoStyleCache* pseudoStyleCache = currentStyle->cachedPseudoStyles();
1161     if (!pseudoStyleCache)
1162         return false;
1163
1164     size_t cacheSize = pseudoStyleCache->size();
1165     for (size_t i = 0; i < cacheSize; ++i) {
1166         RefPtr<RenderStyle> newPseudoStyle;
1167         PseudoId pseudoId = pseudoStyleCache->at(i)->styleType();
1168         if (pseudoId == FIRST_LINE || pseudoId == FIRST_LINE_INHERITED)
1169             newPseudoStyle = renderer()->uncachedFirstLineStyle(newStyle);
1170         else
1171             newPseudoStyle = renderer()->getUncachedPseudoStyle(pseudoId, newStyle, newStyle);
1172         if (!newPseudoStyle)
1173             return true;
1174         if (*newPseudoStyle != *pseudoStyleCache->at(i)) {
1175             if (pseudoId < FIRST_INTERNAL_PSEUDOID)
1176                 newStyle->setHasPseudoStyle(pseudoId);
1177             newStyle->addCachedPseudoStyle(newPseudoStyle);
1178             if (pseudoId == FIRST_LINE || pseudoId == FIRST_LINE_INHERITED) {
1179                 // FIXME: We should do an actual diff to determine whether a repaint vs. layout
1180                 // is needed, but for now just assume a layout will be required.  The diff code
1181                 // in RenderObject::setStyle would need to be factored out so that it could be reused.
1182                 renderer()->setNeedsLayoutAndPrefWidthsRecalc();
1183             }
1184             return true;
1185         }
1186     }
1187     return false;
1188 }
1189
1190 PassRefPtr<RenderStyle> Element::styleForRenderer()
1191 {
1192     if (hasCustomCallbacks()) {
1193         if (RefPtr<RenderStyle> style = customStyleForRenderer())
1194             return style.release();
1195     }
1196
1197     return document()->styleResolver()->styleForElement(this);
1198 }
1199
1200 void Element::recalcStyle(StyleChange change)
1201 {
1202     if (hasCustomCallbacks()) {
1203         if (!willRecalcStyle(change))
1204             return;
1205     }
1206
1207     // Ref currentStyle in case it would otherwise be deleted when setting the new style in the renderer.
1208     RefPtr<RenderStyle> currentStyle(renderStyle());
1209     bool hasParentStyle = parentNodeForRenderingAndStyle() ? static_cast<bool>(parentNodeForRenderingAndStyle()->renderStyle()) : false;
1210     bool hasDirectAdjacentRules = currentStyle && currentStyle->childrenAffectedByDirectAdjacentRules();
1211     bool hasIndirectAdjacentRules = currentStyle && currentStyle->childrenAffectedByForwardPositionalRules();
1212
1213     if ((change > NoChange || needsStyleRecalc())) {
1214         if (hasRareData()) {
1215             ElementRareData* data = elementRareData();
1216             data->resetComputedStyle();
1217             data->setStyleAffectedByEmpty(false);
1218         }
1219     }
1220     if (hasParentStyle && (change >= Inherit || needsStyleRecalc())) {
1221         RefPtr<RenderStyle> newStyle = styleForRenderer();
1222         StyleChange ch = Node::diff(currentStyle.get(), newStyle.get(), document());
1223         if (ch == Detach || !currentStyle) {
1224             // FIXME: The style gets computed twice by calling attach. We could do better if we passed the style along.
1225             reattach();
1226             // attach recalculates the style for all children. No need to do it twice.
1227             clearNeedsStyleRecalc();
1228             clearChildNeedsStyleRecalc();
1229
1230             if (hasCustomCallbacks())
1231                 didRecalcStyle(change);
1232             return;
1233         }
1234
1235         if (currentStyle) {
1236             // Preserve "affected by" bits that were propagated to us from descendants in the case where we didn't do a full
1237             // style change (e.g., only inline style changed).
1238             if (currentStyle->affectedByHoverRules())
1239                 newStyle->setAffectedByHoverRules(true);
1240             if (currentStyle->affectedByActiveRules())
1241                 newStyle->setAffectedByActiveRules(true);
1242             if (currentStyle->affectedByDragRules())
1243                 newStyle->setAffectedByDragRules(true);
1244             if (currentStyle->childrenAffectedByForwardPositionalRules())
1245                 newStyle->setChildrenAffectedByForwardPositionalRules();
1246             if (currentStyle->childrenAffectedByBackwardPositionalRules())
1247                 newStyle->setChildrenAffectedByBackwardPositionalRules();
1248             if (currentStyle->childrenAffectedByFirstChildRules())
1249                 newStyle->setChildrenAffectedByFirstChildRules();
1250             if (currentStyle->childrenAffectedByLastChildRules())
1251                 newStyle->setChildrenAffectedByLastChildRules();
1252             if (currentStyle->childrenAffectedByDirectAdjacentRules())
1253                 newStyle->setChildrenAffectedByDirectAdjacentRules();
1254         }
1255
1256         if (RenderObject* renderer = this->renderer()) {
1257             if (ch != NoChange || pseudoStyleCacheIsInvalid(currentStyle.get(), newStyle.get()) || (change == Force && renderer->requiresForcedStyleRecalcPropagation()) || styleChangeType() == SyntheticStyleChange)
1258                 renderer->setAnimatableStyle(newStyle.get());
1259             else if (needsStyleRecalc()) {
1260                 // Although no change occurred, we use the new style so that the cousin style sharing code won't get
1261                 // fooled into believing this style is the same.
1262                 renderer->setStyleInternal(newStyle.get());
1263             }
1264         }
1265
1266         // If "rem" units are used anywhere in the document, and if the document element's font size changes, then go ahead and force font updating
1267         // all the way down the tree. This is simpler than having to maintain a cache of objects (and such font size changes should be rare anyway).
1268         if (document()->styleSheetCollection()->usesRemUnits() && document()->documentElement() == this && ch != NoChange && currentStyle && newStyle && currentStyle->fontSize() != newStyle->fontSize()) {
1269             // Cached RenderStyles may depend on the rem units.
1270             document()->styleResolver()->invalidateMatchedPropertiesCache();
1271             change = Force;
1272         }
1273
1274         if (change != Force) {
1275             if (styleChangeType() >= FullStyleChange)
1276                 change = Force;
1277             else
1278                 change = ch;
1279         }
1280     }
1281     StyleResolverParentPusher parentPusher(this);
1282
1283     // FIXME: This does not care about sibling combinators. Will be necessary in XBL2 world.
1284     if (ElementShadow* shadow = this->shadow()) {
1285         if (change >= Inherit || shadow->childNeedsStyleRecalc() || shadow->needsStyleRecalc()) {
1286             parentPusher.push();
1287             shadow->recalcStyle(change);
1288         }
1289     }
1290
1291     // FIXME: This check is good enough for :hover + foo, but it is not good enough for :hover + foo + bar.
1292     // For now we will just worry about the common case, since it's a lot trickier to get the second case right
1293     // without doing way too much re-resolution.
1294     bool forceCheckOfNextElementSibling = false;
1295     bool forceCheckOfAnyElementSibling = false;
1296     for (Node *n = firstChild(); n; n = n->nextSibling()) {
1297         if (n->isTextNode()) {
1298             toText(n)->recalcTextStyle(change);
1299             continue;
1300         } 
1301         if (!n->isElementNode()) 
1302             continue;
1303         Element* element = static_cast<Element*>(n);
1304         bool childRulesChanged = element->needsStyleRecalc() && element->styleChangeType() == FullStyleChange;
1305         if ((forceCheckOfNextElementSibling || forceCheckOfAnyElementSibling))
1306             element->setNeedsStyleRecalc();
1307         if (change >= Inherit || element->childNeedsStyleRecalc() || element->needsStyleRecalc()) {
1308             parentPusher.push();
1309             element->recalcStyle(change);
1310         }
1311         forceCheckOfNextElementSibling = childRulesChanged && hasDirectAdjacentRules;
1312         forceCheckOfAnyElementSibling = forceCheckOfAnyElementSibling || (childRulesChanged && hasIndirectAdjacentRules);
1313     }
1314
1315     clearNeedsStyleRecalc();
1316     clearChildNeedsStyleRecalc();
1317     
1318     if (hasCustomCallbacks())
1319         didRecalcStyle(change);
1320 }
1321
1322 ElementShadow* Element::shadow() const
1323 {
1324     if (!hasRareData())
1325         return 0;
1326
1327     return elementRareData()->m_shadow.get();
1328 }
1329
1330 ElementShadow* Element::ensureShadow()
1331 {
1332     if (ElementShadow* shadow = ensureElementRareData()->m_shadow.get())
1333         return shadow;
1334
1335     ElementRareData* data = elementRareData();
1336     data->m_shadow = adoptPtr(new ElementShadow());
1337     return data->m_shadow.get();
1338 }
1339
1340 ShadowRoot* Element::userAgentShadowRoot() const
1341 {
1342     if (ElementShadow* elementShadow = shadow()) {
1343         if (ShadowRoot* shadowRoot = elementShadow->oldestShadowRoot()) {
1344             ASSERT(shadowRoot->type() == ShadowRoot::UserAgentShadowRoot);
1345             return shadowRoot;
1346         }
1347     }
1348
1349     return 0;
1350 }
1351
1352 const AtomicString& Element::shadowPseudoId() const
1353 {
1354     return pseudo();
1355 }
1356
1357 bool Element::childTypeAllowed(NodeType type) const
1358 {
1359     switch (type) {
1360     case ELEMENT_NODE:
1361     case TEXT_NODE:
1362     case COMMENT_NODE:
1363     case PROCESSING_INSTRUCTION_NODE:
1364     case CDATA_SECTION_NODE:
1365     case ENTITY_REFERENCE_NODE:
1366         return true;
1367     default:
1368         break;
1369     }
1370     return false;
1371 }
1372
1373 static void checkForEmptyStyleChange(Element* element, RenderStyle* style)
1374 {
1375     if (!style && !element->styleAffectedByEmpty())
1376         return;
1377
1378     if (!style || (style->affectedByEmpty() && (!style->emptyState() || element->hasChildNodes())))
1379         element->setNeedsStyleRecalc();
1380 }
1381
1382 static void checkForSiblingStyleChanges(Element* e, RenderStyle* style, bool finishedParsingCallback,
1383                                         Node* beforeChange, Node* afterChange, int childCountDelta)
1384 {
1385     // :empty selector.
1386     checkForEmptyStyleChange(e, style);
1387     
1388     if (!style || (e->needsStyleRecalc() && style->childrenAffectedByPositionalRules()))
1389         return;
1390
1391     // :first-child.  In the parser callback case, we don't have to check anything, since we were right the first time.
1392     // In the DOM case, we only need to do something if |afterChange| is not 0.
1393     // |afterChange| is 0 in the parser case, so it works out that we'll skip this block.
1394     if (style->childrenAffectedByFirstChildRules() && afterChange) {
1395         // Find our new first child.
1396         Node* newFirstChild = 0;
1397         for (newFirstChild = e->firstChild(); newFirstChild && !newFirstChild->isElementNode(); newFirstChild = newFirstChild->nextSibling()) {};
1398         
1399         // Find the first element node following |afterChange|
1400         Node* firstElementAfterInsertion = 0;
1401         for (firstElementAfterInsertion = afterChange;
1402              firstElementAfterInsertion && !firstElementAfterInsertion->isElementNode();
1403              firstElementAfterInsertion = firstElementAfterInsertion->nextSibling()) {};
1404         
1405         // This is the insert/append case.
1406         if (newFirstChild != firstElementAfterInsertion && firstElementAfterInsertion && firstElementAfterInsertion->attached() &&
1407             firstElementAfterInsertion->renderStyle() && firstElementAfterInsertion->renderStyle()->firstChildState())
1408             firstElementAfterInsertion->setNeedsStyleRecalc();
1409             
1410         // We also have to handle node removal.
1411         if (childCountDelta < 0 && newFirstChild == firstElementAfterInsertion && newFirstChild && (!newFirstChild->renderStyle() || !newFirstChild->renderStyle()->firstChildState()))
1412             newFirstChild->setNeedsStyleRecalc();
1413     }
1414
1415     // :last-child.  In the parser callback case, we don't have to check anything, since we were right the first time.
1416     // In the DOM case, we only need to do something if |afterChange| is not 0.
1417     if (style->childrenAffectedByLastChildRules() && beforeChange) {
1418         // Find our new last child.
1419         Node* newLastChild = 0;
1420         for (newLastChild = e->lastChild(); newLastChild && !newLastChild->isElementNode(); newLastChild = newLastChild->previousSibling()) {};
1421         
1422         // Find the last element node going backwards from |beforeChange|
1423         Node* lastElementBeforeInsertion = 0;
1424         for (lastElementBeforeInsertion = beforeChange;
1425              lastElementBeforeInsertion && !lastElementBeforeInsertion->isElementNode();
1426              lastElementBeforeInsertion = lastElementBeforeInsertion->previousSibling()) {};
1427         
1428         if (newLastChild != lastElementBeforeInsertion && lastElementBeforeInsertion && lastElementBeforeInsertion->attached() &&
1429             lastElementBeforeInsertion->renderStyle() && lastElementBeforeInsertion->renderStyle()->lastChildState())
1430             lastElementBeforeInsertion->setNeedsStyleRecalc();
1431             
1432         // We also have to handle node removal.  The parser callback case is similar to node removal as well in that we need to change the last child
1433         // to match now.
1434         if ((childCountDelta < 0 || finishedParsingCallback) && newLastChild == lastElementBeforeInsertion && newLastChild && (!newLastChild->renderStyle() || !newLastChild->renderStyle()->lastChildState()))
1435             newLastChild->setNeedsStyleRecalc();
1436     }
1437
1438     // The + selector.  We need to invalidate the first element following the insertion point.  It is the only possible element
1439     // that could be affected by this DOM change.
1440     if (style->childrenAffectedByDirectAdjacentRules() && afterChange) {
1441         Node* firstElementAfterInsertion = 0;
1442         for (firstElementAfterInsertion = afterChange;
1443              firstElementAfterInsertion && !firstElementAfterInsertion->isElementNode();
1444              firstElementAfterInsertion = firstElementAfterInsertion->nextSibling()) {};
1445         if (firstElementAfterInsertion && firstElementAfterInsertion->attached())
1446             firstElementAfterInsertion->setNeedsStyleRecalc();
1447     }
1448
1449     // Forward positional selectors include the ~ selector, nth-child, nth-of-type, first-of-type and only-of-type.
1450     // Backward positional selectors include nth-last-child, nth-last-of-type, last-of-type and only-of-type.
1451     // We have to invalidate everything following the insertion point in the forward case, and everything before the insertion point in the
1452     // backward case.
1453     // |afterChange| is 0 in the parser callback case, so we won't do any work for the forward case if we don't have to.
1454     // For performance reasons we just mark the parent node as changed, since we don't want to make childrenChanged O(n^2) by crawling all our kids
1455     // here.  recalcStyle will then force a walk of the children when it sees that this has happened.
1456     if ((style->childrenAffectedByForwardPositionalRules() && afterChange) ||
1457         (style->childrenAffectedByBackwardPositionalRules() && beforeChange))
1458         e->setNeedsStyleRecalc();
1459 }
1460
1461 void Element::childrenChanged(bool changedByParser, Node* beforeChange, Node* afterChange, int childCountDelta)
1462 {
1463     ContainerNode::childrenChanged(changedByParser, beforeChange, afterChange, childCountDelta);
1464     if (changedByParser)
1465         checkForEmptyStyleChange(this, renderStyle());
1466     else
1467         checkForSiblingStyleChanges(this, renderStyle(), false, beforeChange, afterChange, childCountDelta);
1468
1469     if (ElementShadow * shadow = this->shadow())
1470         shadow->invalidateDistribution();
1471 }
1472
1473 void Element::beginParsingChildren()
1474 {
1475     clearIsParsingChildrenFinished();
1476     StyleResolver* styleResolver = document()->styleResolverIfExists();
1477     if (styleResolver && attached())
1478         styleResolver->pushParentElement(this);
1479 }
1480
1481 void Element::finishParsingChildren()
1482 {
1483     ContainerNode::finishParsingChildren();
1484     setIsParsingChildrenFinished();
1485     checkForSiblingStyleChanges(this, renderStyle(), true, lastChild(), 0, 0);
1486     if (StyleResolver* styleResolver = document()->styleResolverIfExists())
1487         styleResolver->popParentElement(this);
1488 }
1489
1490 #ifndef NDEBUG
1491 void Element::formatForDebugger(char* buffer, unsigned length) const
1492 {
1493     StringBuilder result;
1494     String s;
1495
1496     result.append(nodeName());
1497
1498     s = getIdAttribute();
1499     if (s.length() > 0) {
1500         if (result.length() > 0)
1501             result.appendLiteral("; ");
1502         result.appendLiteral("id=");
1503         result.append(s);
1504     }
1505
1506     s = getAttribute(classAttr);
1507     if (s.length() > 0) {
1508         if (result.length() > 0)
1509             result.appendLiteral("; ");
1510         result.appendLiteral("class=");
1511         result.append(s);
1512     }
1513
1514     strncpy(buffer, result.toString().utf8().data(), length - 1);
1515 }
1516 #endif
1517
1518 PassRefPtr<Attr> Element::setAttributeNode(Attr* attrNode, ExceptionCode& ec)
1519 {
1520     if (!attrNode) {
1521         ec = TYPE_MISMATCH_ERR;
1522         return 0;
1523     }
1524
1525     RefPtr<Attr> oldAttrNode = attrIfExists(attrNode->qualifiedName());
1526     if (oldAttrNode.get() == attrNode)
1527         return attrNode; // This Attr is already attached to the element.
1528
1529     // INUSE_ATTRIBUTE_ERR: Raised if node is an Attr that is already an attribute of another Element object.
1530     // The DOM user must explicitly clone Attr nodes to re-use them in other elements.
1531     if (attrNode->ownerElement()) {
1532         ec = INUSE_ATTRIBUTE_ERR;
1533         return 0;
1534     }
1535
1536     updateInvalidAttributes();
1537     ElementAttributeData* attributeData = mutableAttributeData();
1538
1539     size_t index = attributeData->getAttributeItemIndex(attrNode->qualifiedName());
1540     if (index != notFound) {
1541         if (oldAttrNode)
1542             detachAttrNodeFromElementWithValue(oldAttrNode.get(), attributeData->attributeItem(index)->value());
1543         else
1544             oldAttrNode = Attr::create(document(), attrNode->qualifiedName(), attributeData->attributeItem(index)->value());
1545     }
1546
1547     setAttributeInternal(index, attrNode->qualifiedName(), attrNode->value(), NotInSynchronizationOfLazyAttribute);
1548
1549     attrNode->attachToElement(this);
1550     ensureAttrNodeListForElement(this)->append(attrNode);
1551
1552     return oldAttrNode.release();
1553 }
1554
1555 PassRefPtr<Attr> Element::setAttributeNodeNS(Attr* attr, ExceptionCode& ec)
1556 {
1557     return setAttributeNode(attr, ec);
1558 }
1559
1560 PassRefPtr<Attr> Element::removeAttributeNode(Attr* attr, ExceptionCode& ec)
1561 {
1562     if (!attr) {
1563         ec = TYPE_MISMATCH_ERR;
1564         return 0;
1565     }
1566     if (attr->ownerElement() != this) {
1567         ec = NOT_FOUND_ERR;
1568         return 0;
1569     }
1570
1571     ASSERT(document() == attr->document());
1572
1573     const ElementAttributeData* attributeData = updatedAttributeData();
1574     ASSERT(attributeData);
1575
1576     size_t index = attributeData->getAttributeItemIndex(attr->qualifiedName());
1577     if (index == notFound) {
1578         ec = NOT_FOUND_ERR;
1579         return 0;
1580     }
1581
1582     return detachAttribute(index);
1583 }
1584
1585 bool Element::parseAttributeName(QualifiedName& out, const AtomicString& namespaceURI, const AtomicString& qualifiedName, ExceptionCode& ec)
1586 {
1587     String prefix, localName;
1588     if (!Document::parseQualifiedName(qualifiedName, prefix, localName, ec))
1589         return false;
1590     ASSERT(!ec);
1591
1592     QualifiedName qName(prefix, localName, namespaceURI);
1593
1594     if (!Document::hasValidNamespaceForAttributes(qName)) {
1595         ec = NAMESPACE_ERR;
1596         return false;
1597     }
1598
1599     out = qName;
1600     return true;
1601 }
1602
1603 void Element::setAttributeNS(const AtomicString& namespaceURI, const AtomicString& qualifiedName, const AtomicString& value, ExceptionCode& ec)
1604 {
1605     QualifiedName parsedName = anyName;
1606     if (!parseAttributeName(parsedName, namespaceURI, qualifiedName, ec))
1607         return;
1608     setAttribute(parsedName, value);
1609 }
1610
1611 void Element::removeAttributeInternal(size_t index, SynchronizationOfLazyAttribute inSynchronizationOfLazyAttribute)
1612 {
1613     ASSERT(index < attributeCount());
1614
1615     ElementAttributeData* attributeData = mutableAttributeData();
1616
1617     QualifiedName name = attributeData->attributeItem(index)->name();
1618     AtomicString valueBeingRemoved = attributeData->attributeItem(index)->value();
1619
1620     if (!inSynchronizationOfLazyAttribute) {
1621         if (!valueBeingRemoved.isNull())
1622             willModifyAttribute(name, valueBeingRemoved, nullAtom);
1623     }
1624
1625     if (RefPtr<Attr> attrNode = attrIfExists(name))
1626         detachAttrNodeFromElementWithValue(attrNode.get(), attributeData->attributeItem(index)->value());
1627
1628     attributeData->removeAttribute(index);
1629
1630     if (!inSynchronizationOfLazyAttribute)
1631         didRemoveAttribute(name);
1632 }
1633
1634 void Element::addAttributeInternal(const QualifiedName& name, const AtomicString& value, SynchronizationOfLazyAttribute inSynchronizationOfLazyAttribute)
1635 {
1636     if (!inSynchronizationOfLazyAttribute)
1637         willModifyAttribute(name, nullAtom, value);
1638     mutableAttributeData()->addAttribute(Attribute(name, value));
1639     if (!inSynchronizationOfLazyAttribute)
1640         didAddAttribute(name, value);
1641 }
1642
1643 void Element::removeAttribute(const AtomicString& name)
1644 {
1645     if (!attributeData())
1646         return;
1647
1648     AtomicString localName = shouldIgnoreAttributeCase(this) ? name.lower() : name;
1649     size_t index = attributeData()->getAttributeItemIndex(localName, false);
1650     if (index == notFound) {
1651         if (UNLIKELY(localName == styleAttr) && attributeData()->m_styleAttributeIsDirty && isStyledElement())
1652             static_cast<StyledElement*>(this)->removeAllInlineStyleProperties();
1653         return;
1654     }
1655
1656     removeAttributeInternal(index, NotInSynchronizationOfLazyAttribute);
1657 }
1658
1659 void Element::removeAttributeNS(const AtomicString& namespaceURI, const AtomicString& localName)
1660 {
1661     removeAttribute(QualifiedName(nullAtom, localName, namespaceURI));
1662 }
1663
1664 PassRefPtr<Attr> Element::getAttributeNode(const AtomicString& name)
1665 {
1666     const ElementAttributeData* attributeData = updatedAttributeData();
1667     if (!attributeData)
1668         return 0;
1669     const Attribute* attribute = attributeData->getAttributeItem(name, shouldIgnoreAttributeCase(this));
1670     if (!attribute)
1671         return 0;
1672     return ensureAttr(attribute->name());
1673 }
1674
1675 PassRefPtr<Attr> Element::getAttributeNodeNS(const AtomicString& namespaceURI, const AtomicString& localName)
1676 {
1677     const ElementAttributeData* attributeData = updatedAttributeData();
1678     if (!attributeData)
1679         return 0;
1680     const Attribute* attribute = attributeData->getAttributeItem(QualifiedName(nullAtom, localName, namespaceURI));
1681     if (!attribute)
1682         return 0;
1683     return ensureAttr(attribute->name());
1684 }
1685
1686 bool Element::hasAttribute(const AtomicString& name) const
1687 {
1688     if (!attributeData())
1689         return false;
1690
1691     // This call to String::lower() seems to be required but
1692     // there may be a way to remove it.
1693     AtomicString localName = shouldIgnoreAttributeCase(this) ? name.lower() : name;
1694     return updatedAttributeData()->getAttributeItem(localName, false);
1695 }
1696
1697 bool Element::hasAttributeNS(const AtomicString& namespaceURI, const AtomicString& localName) const
1698 {
1699     const ElementAttributeData* attributeData = updatedAttributeData();
1700     if (!attributeData)
1701         return false;
1702     return attributeData->getAttributeItem(QualifiedName(nullAtom, localName, namespaceURI));
1703 }
1704
1705 CSSStyleDeclaration *Element::style()
1706 {
1707     return 0;
1708 }
1709
1710 void Element::focus(bool restorePreviousSelection)
1711 {
1712     if (!inDocument())
1713         return;
1714
1715     Document* doc = document();
1716     if (doc->focusedNode() == this)
1717         return;
1718
1719     // If the stylesheets have already been loaded we can reliably check isFocusable.
1720     // If not, we continue and set the focused node on the focus controller below so
1721     // that it can be updated soon after attach. 
1722     if (doc->haveStylesheetsLoaded()) {
1723         doc->updateLayoutIgnorePendingStylesheets();
1724         if (!isFocusable())
1725             return;
1726     }
1727
1728     if (!supportsFocus())
1729         return;
1730
1731     RefPtr<Node> protect;
1732     if (Page* page = doc->page()) {
1733         // Focus and change event handlers can cause us to lose our last ref.
1734         // If a focus event handler changes the focus to a different node it
1735         // does not make sense to continue and update appearence.
1736         protect = this;
1737         if (!page->focusController()->setFocusedNode(this, doc->frame()))
1738             return;
1739     }
1740
1741     // Setting the focused node above might have invalidated the layout due to scripts.
1742     doc->updateLayoutIgnorePendingStylesheets();
1743
1744     if (!isFocusable()) {
1745         ensureElementRareData()->setNeedsFocusAppearanceUpdateSoonAfterAttach(true);
1746         return;
1747     }
1748         
1749     cancelFocusAppearanceUpdate();
1750     updateFocusAppearance(restorePreviousSelection);
1751 }
1752
1753 void Element::updateFocusAppearance(bool /*restorePreviousSelection*/)
1754 {
1755     if (isRootEditableElement()) {
1756         Frame* frame = document()->frame();
1757         if (!frame)
1758             return;
1759         
1760         // When focusing an editable element in an iframe, don't reset the selection if it already contains a selection.
1761         if (this == frame->selection()->rootEditableElement())
1762             return;
1763
1764         // FIXME: We should restore the previous selection if there is one.
1765         VisibleSelection newSelection = VisibleSelection(firstPositionInOrBeforeNode(this), DOWNSTREAM);
1766         
1767         if (frame->selection()->shouldChangeSelection(newSelection)) {
1768             frame->selection()->setSelection(newSelection);
1769             frame->selection()->revealSelection();
1770         }
1771     } else if (renderer() && !renderer()->isWidget())
1772         renderer()->scrollRectToVisible(boundingBox());
1773 }
1774
1775 void Element::blur()
1776 {
1777     cancelFocusAppearanceUpdate();
1778     Document* doc = document();
1779     if (treeScope()->focusedNode() == this) {
1780         if (doc->frame())
1781             doc->frame()->page()->focusController()->setFocusedNode(0, doc->frame());
1782         else
1783             doc->setFocusedNode(0);
1784     }
1785 }
1786
1787 String Element::innerText()
1788 {
1789     // We need to update layout, since plainText uses line boxes in the render tree.
1790     document()->updateLayoutIgnorePendingStylesheets();
1791
1792     if (!renderer())
1793         return textContent(true);
1794
1795     return plainText(rangeOfContents(const_cast<Element*>(this)).get());
1796 }
1797
1798 String Element::outerText()
1799 {
1800     // Getting outerText is the same as getting innerText, only
1801     // setting is different. You would think this should get the plain
1802     // text for the outer range, but this is wrong, <br> for instance
1803     // would return different values for inner and outer text by such
1804     // a rule, but it doesn't in WinIE, and we want to match that.
1805     return innerText();
1806 }
1807
1808 String Element::title() const
1809 {
1810     return String();
1811 }
1812
1813 const AtomicString& Element::pseudo() const
1814 {
1815     return getAttribute(pseudoAttr);
1816 }
1817
1818 void Element::setPseudo(const AtomicString& value)
1819 {
1820     setAttribute(pseudoAttr, value);
1821 }
1822
1823 LayoutSize Element::minimumSizeForResizing() const
1824 {
1825     return hasRareData() ? elementRareData()->m_minimumSizeForResizing : defaultMinimumSizeForResizing();
1826 }
1827
1828 void Element::setMinimumSizeForResizing(const LayoutSize& size)
1829 {
1830     if (size == defaultMinimumSizeForResizing() && !hasRareData())
1831         return;
1832     ensureElementRareData()->m_minimumSizeForResizing = size;
1833 }
1834
1835 RenderStyle* Element::computedStyle(PseudoId pseudoElementSpecifier)
1836 {
1837     // FIXME: Find and use the renderer from the pseudo element instead of the actual element so that the 'length'
1838     // properties, which are only known by the renderer because it did the layout, will be correct and so that the
1839     // values returned for the ":selection" pseudo-element will be correct.
1840     if (RenderStyle* usedStyle = renderStyle()) {
1841         if (pseudoElementSpecifier) {
1842             RenderStyle* cachedPseudoStyle = usedStyle->getCachedPseudoStyle(pseudoElementSpecifier);
1843             return cachedPseudoStyle ? cachedPseudoStyle : usedStyle;
1844          } else
1845             return usedStyle;
1846     }
1847
1848     if (!attached())
1849         // FIXME: Try to do better than this. Ensure that styleForElement() works for elements that are not in the
1850         // document tree and figure out when to destroy the computed style for such elements.
1851         return 0;
1852
1853     ElementRareData* data = ensureElementRareData();
1854     if (!data->m_computedStyle)
1855         data->m_computedStyle = document()->styleForElementIgnoringPendingStylesheets(this);
1856     return pseudoElementSpecifier ? data->m_computedStyle->getCachedPseudoStyle(pseudoElementSpecifier) : data->m_computedStyle.get();
1857 }
1858
1859 void Element::setStyleAffectedByEmpty()
1860 {
1861     ensureElementRareData()->setStyleAffectedByEmpty(true);
1862 }
1863
1864 bool Element::styleAffectedByEmpty() const
1865 {
1866     return hasRareData() && elementRareData()->styleAffectedByEmpty();
1867 }
1868
1869 void Element::setIsInCanvasSubtree(bool isInCanvasSubtree)
1870 {
1871     ensureElementRareData()->setIsInCanvasSubtree(isInCanvasSubtree);
1872 }
1873
1874 bool Element::isInCanvasSubtree() const
1875 {
1876     return hasRareData() && elementRareData()->isInCanvasSubtree();
1877 }
1878
1879 AtomicString Element::computeInheritedLanguage() const
1880 {
1881     const Node* n = this;
1882     AtomicString value;
1883     // The language property is inherited, so we iterate over the parents to find the first language.
1884     do {
1885         if (n->isElementNode()) {
1886             if (const ElementAttributeData* attributeData = static_cast<const Element*>(n)->attributeData()) {
1887                 // Spec: xml:lang takes precedence -- http://www.w3.org/TR/xhtml1/#C_7
1888                 if (const Attribute* attribute = attributeData->getAttributeItem(XMLNames::langAttr))
1889                     value = attribute->value();
1890                 else if (const Attribute* attribute = attributeData->getAttributeItem(HTMLNames::langAttr))
1891                     value = attribute->value();
1892             }
1893         } else if (n->isDocumentNode()) {
1894             // checking the MIME content-language
1895             value = static_cast<const Document*>(n)->contentLanguage();
1896         }
1897
1898         n = n->parentNode();
1899     } while (n && value.isNull());
1900
1901     return value;
1902 }
1903
1904 Locale& Element::locale() const
1905 {
1906     return document()->getCachedLocale(computeInheritedLanguage());
1907 }
1908
1909 void Element::cancelFocusAppearanceUpdate()
1910 {
1911     if (hasRareData())
1912         elementRareData()->setNeedsFocusAppearanceUpdateSoonAfterAttach(false);
1913     if (document()->focusedNode() == this)
1914         document()->cancelFocusAppearanceUpdate();
1915 }
1916
1917 void Element::normalizeAttributes()
1918 {
1919     updateInvalidAttributes();
1920     if (AttrNodeList* attrNodeList = attrNodeListForElement(this)) {
1921         for (unsigned i = 0; i < attrNodeList->size(); ++i)
1922             attrNodeList->at(i)->normalize();
1923     }
1924 }
1925
1926 // ElementTraversal API
1927 Element* Element::firstElementChild() const
1928 {
1929     return WebCore::firstElementChild(this);
1930 }
1931
1932 Element* Element::lastElementChild() const
1933 {
1934     Node* n = lastChild();
1935     while (n && !n->isElementNode())
1936         n = n->previousSibling();
1937     return static_cast<Element*>(n);
1938 }
1939
1940 unsigned Element::childElementCount() const
1941 {
1942     unsigned count = 0;
1943     Node* n = firstChild();
1944     while (n) {
1945         count += n->isElementNode();
1946         n = n->nextSibling();
1947     }
1948     return count;
1949 }
1950
1951 bool Element::shouldMatchReadOnlySelector() const
1952 {
1953     return false;
1954 }
1955
1956 bool Element::shouldMatchReadWriteSelector() const
1957 {
1958     return false;
1959 }
1960
1961 bool Element::webkitMatchesSelector(const String& selector, ExceptionCode& ec)
1962 {
1963     if (selector.isEmpty()) {
1964         ec = SYNTAX_ERR;
1965         return false;
1966     }
1967
1968     SelectorQuery* selectorQuery = document()->selectorQueryCache()->add(selector, document(), ec);
1969     if (!selectorQuery)
1970         return false;
1971     return selectorQuery->matches(this);
1972 }
1973
1974 DOMTokenList* Element::classList()
1975 {
1976     ElementRareData* data = ensureElementRareData();
1977     if (!data->m_classList)
1978         data->m_classList = ClassList::create(this);
1979     return data->m_classList.get();
1980 }
1981
1982 DOMTokenList* Element::optionalClassList() const
1983 {
1984     if (!hasRareData())
1985         return 0;
1986     return elementRareData()->m_classList.get();
1987 }
1988
1989 DOMStringMap* Element::dataset()
1990 {
1991     ElementRareData* data = ensureElementRareData();
1992     if (!data->m_datasetDOMStringMap)
1993         data->m_datasetDOMStringMap = DatasetDOMStringMap::create(this);
1994     return data->m_datasetDOMStringMap.get();
1995 }
1996
1997 KURL Element::getURLAttribute(const QualifiedName& name) const
1998 {
1999 #if !ASSERT_DISABLED
2000     if (attributeData()) {
2001         if (const Attribute* attribute = getAttributeItem(name))
2002             ASSERT(isURLAttribute(*attribute));
2003     }
2004 #endif
2005     return document()->completeURL(stripLeadingAndTrailingHTMLSpaces(getAttribute(name)));
2006 }
2007
2008 KURL Element::getNonEmptyURLAttribute(const QualifiedName& name) const
2009 {
2010 #if !ASSERT_DISABLED
2011     if (attributeData()) {
2012         if (const Attribute* attribute = getAttributeItem(name))
2013             ASSERT(isURLAttribute(*attribute));
2014     }
2015 #endif
2016     String value = stripLeadingAndTrailingHTMLSpaces(getAttribute(name));
2017     if (value.isEmpty())
2018         return KURL();
2019     return document()->completeURL(value);
2020 }
2021
2022 int Element::getIntegralAttribute(const QualifiedName& attributeName) const
2023 {
2024     return getAttribute(attributeName).string().toInt();
2025 }
2026
2027 void Element::setIntegralAttribute(const QualifiedName& attributeName, int value)
2028 {
2029     // FIXME: Need an AtomicString version of String::number.
2030     setAttribute(attributeName, String::number(value));
2031 }
2032
2033 unsigned Element::getUnsignedIntegralAttribute(const QualifiedName& attributeName) const
2034 {
2035     return getAttribute(attributeName).string().toUInt();
2036 }
2037
2038 void Element::setUnsignedIntegralAttribute(const QualifiedName& attributeName, unsigned value)
2039 {
2040     // FIXME: Need an AtomicString version of String::number.
2041     setAttribute(attributeName, String::number(value));
2042 }
2043
2044 #if ENABLE(SVG)
2045 bool Element::childShouldCreateRenderer(const NodeRenderingContext& childContext) const
2046 {
2047     // Only create renderers for SVG elements whose parents are SVG elements, or for proper <svg xmlns="svgNS"> subdocuments.
2048     if (childContext.node()->isSVGElement())
2049         return childContext.node()->hasTagName(SVGNames::svgTag) || isSVGElement();
2050
2051     return Node::childShouldCreateRenderer(childContext);
2052 }
2053 #endif
2054     
2055 #if ENABLE(FULLSCREEN_API)
2056 void Element::webkitRequestFullscreen()
2057 {
2058     document()->requestFullScreenForElement(this, ALLOW_KEYBOARD_INPUT, Document::EnforceIFrameAllowFullScreenRequirement);
2059 }
2060
2061 void Element::webkitRequestFullScreen(unsigned short flags)
2062 {
2063     document()->requestFullScreenForElement(this, (flags | LEGACY_MOZILLA_REQUEST), Document::EnforceIFrameAllowFullScreenRequirement);
2064 }
2065
2066 bool Element::containsFullScreenElement() const
2067 {
2068     return hasRareData() && elementRareData()->containsFullScreenElement();
2069 }
2070
2071 void Element::setContainsFullScreenElement(bool flag)
2072 {
2073     ensureElementRareData()->setContainsFullScreenElement(flag);
2074     setNeedsStyleRecalc(SyntheticStyleChange);
2075 }
2076
2077 static Element* parentCrossingFrameBoundaries(Element* element)
2078 {
2079     ASSERT(element);
2080     return element->parentElement() ? element->parentElement() : element->document()->ownerElement();
2081 }
2082
2083 void Element::setContainsFullScreenElementOnAncestorsCrossingFrameBoundaries(bool flag)
2084 {
2085     Element* element = this;
2086     while ((element = parentCrossingFrameBoundaries(element)))
2087         element->setContainsFullScreenElement(flag);
2088 }
2089 #endif    
2090
2091 #if ENABLE(POINTER_LOCK)
2092 void Element::webkitRequestPointerLock()
2093 {
2094     if (document()->page())
2095         document()->page()->pointerLockController()->requestPointerLock(this);
2096 }
2097 #endif
2098
2099 SpellcheckAttributeState Element::spellcheckAttributeState() const
2100 {
2101     const AtomicString& value = getAttribute(HTMLNames::spellcheckAttr);
2102     if (value == nullAtom)
2103         return SpellcheckAttributeDefault;
2104     if (equalIgnoringCase(value, "true") || equalIgnoringCase(value, ""))
2105         return SpellcheckAttributeTrue;
2106     if (equalIgnoringCase(value, "false"))
2107         return SpellcheckAttributeFalse;
2108
2109     return SpellcheckAttributeDefault;
2110 }
2111
2112 bool Element::isSpellCheckingEnabled() const
2113 {
2114     const Element* element = this;
2115     while (element) {
2116         switch (element->spellcheckAttributeState()) {
2117         case SpellcheckAttributeTrue:
2118             return true;
2119         case SpellcheckAttributeFalse:
2120             return false;
2121         case SpellcheckAttributeDefault:
2122             break;
2123         }
2124
2125         ContainerNode* parent = const_cast<Element*>(element)->parentOrHostNode();
2126         if (parent && parent->isElementNode())
2127             element = toElement(parent);
2128         else if (parent && parent->isShadowRoot())
2129             element = toElement(parent->parentOrHostNode());
2130         else
2131             element = 0;
2132     }
2133
2134     return true;
2135 }
2136
2137 PassRefPtr<WebKitAnimationList> Element::webkitGetAnimations() const
2138 {
2139     if (!renderer())
2140         return 0;
2141
2142     AnimationController* animController = renderer()->animation();
2143
2144     if (!animController)
2145         return 0;
2146     
2147     return animController->animationsForRenderer(renderer());
2148 }
2149
2150 RenderRegion* Element::renderRegion() const
2151 {
2152     if (renderer() && renderer()->isRenderRegion())
2153         return toRenderRegion(renderer());
2154
2155     return 0;
2156 }
2157
2158 #if ENABLE(CSS_REGIONS)
2159
2160 const AtomicString& Element::webkitRegionOverset() const
2161 {
2162     document()->updateLayoutIgnorePendingStylesheets();
2163
2164     DEFINE_STATIC_LOCAL(AtomicString, undefinedState, ("undefined", AtomicString::ConstructFromLiteral));
2165     if (!document()->cssRegionsEnabled() || !renderRegion())
2166         return undefinedState;
2167
2168     switch (renderRegion()->regionState()) {
2169     case RenderRegion::RegionFit: {
2170         DEFINE_STATIC_LOCAL(AtomicString, fitState, ("fit", AtomicString::ConstructFromLiteral));
2171         return fitState;
2172     }
2173     case RenderRegion::RegionEmpty: {
2174         DEFINE_STATIC_LOCAL(AtomicString, emptyState, ("empty", AtomicString::ConstructFromLiteral));
2175         return emptyState;
2176     }
2177     case RenderRegion::RegionOverset: {
2178         DEFINE_STATIC_LOCAL(AtomicString, overflowState, ("overset", AtomicString::ConstructFromLiteral));
2179         return overflowState;
2180     }
2181     case RenderRegion::RegionUndefined:
2182         return undefinedState;
2183     }
2184
2185     ASSERT_NOT_REACHED();
2186     return undefinedState;
2187 }
2188
2189 Vector<RefPtr<Range> > Element::webkitGetRegionFlowRanges() const
2190 {
2191     document()->updateLayoutIgnorePendingStylesheets();
2192
2193     Vector<RefPtr<Range> > rangeObjects;
2194     if (document()->cssRegionsEnabled() && renderer() && renderer()->isRenderRegion()) {
2195         RenderRegion* region = toRenderRegion(renderer());
2196         if (region->isValid())
2197             region->getRanges(rangeObjects);
2198     }
2199
2200     return rangeObjects;
2201 }
2202
2203 #endif
2204
2205 #ifndef NDEBUG
2206 bool Element::fastAttributeLookupAllowed(const QualifiedName& name) const
2207 {
2208     if (name == HTMLNames::styleAttr)
2209         return false;
2210
2211 #if ENABLE(SVG)
2212     if (isSVGElement())
2213         return !SVGElement::isAnimatableAttribute(name);
2214 #endif
2215
2216     return true;
2217 }
2218 #endif
2219
2220 #ifdef DUMP_NODE_STATISTICS
2221 bool Element::hasNamedNodeMap() const
2222 {
2223     return hasRareData() && elementRareData()->m_attributeMap;
2224 }
2225 #endif
2226
2227 void Element::updateLabel(TreeScope* scope, const AtomicString& oldForAttributeValue, const AtomicString& newForAttributeValue)
2228 {
2229     ASSERT(hasTagName(labelTag));
2230
2231     if (!inDocument())
2232         return;
2233
2234     if (oldForAttributeValue == newForAttributeValue)
2235         return;
2236
2237     if (!oldForAttributeValue.isEmpty())
2238         scope->removeLabel(oldForAttributeValue, static_cast<HTMLLabelElement*>(this));
2239     if (!newForAttributeValue.isEmpty())
2240         scope->addLabel(newForAttributeValue, static_cast<HTMLLabelElement*>(this));
2241 }
2242
2243 void Element::willModifyAttribute(const QualifiedName& name, const AtomicString& oldValue, const AtomicString& newValue)
2244 {
2245     if (isIdAttributeName(name))
2246         updateId(oldValue, newValue);
2247     else if (name == HTMLNames::nameAttr)
2248         updateName(oldValue, newValue);
2249     else if (name == HTMLNames::forAttr && hasTagName(labelTag)) {
2250         TreeScope* scope = treeScope();
2251         if (scope->shouldCacheLabelsByForAttribute())
2252             updateLabel(scope, oldValue, newValue);
2253     }
2254
2255 #if ENABLE(MUTATION_OBSERVERS)
2256     if (OwnPtr<MutationObserverInterestGroup> recipients = MutationObserverInterestGroup::createForAttributesMutation(this, name))
2257         recipients->enqueueMutationRecord(MutationRecord::createAttributes(this, name, oldValue));
2258 #endif
2259
2260 #if ENABLE(INSPECTOR)
2261     InspectorInstrumentation::willModifyDOMAttr(document(), this, oldValue, newValue);
2262 #endif
2263 }
2264
2265 void Element::didAddAttribute(const QualifiedName& name, const AtomicString& value)
2266 {
2267     attributeChanged(name, value);
2268     InspectorInstrumentation::didModifyDOMAttr(document(), this, name.localName(), value);
2269     dispatchSubtreeModifiedEvent();
2270 }
2271
2272 void Element::didModifyAttribute(const QualifiedName& name, const AtomicString& value)
2273 {
2274     attributeChanged(name, value);
2275     InspectorInstrumentation::didModifyDOMAttr(document(), this, name.localName(), value);
2276     // Do not dispatch a DOMSubtreeModified event here; see bug 81141.
2277 }
2278
2279 void Element::didRemoveAttribute(const QualifiedName& name)
2280 {
2281     attributeChanged(name, nullAtom);
2282     InspectorInstrumentation::didRemoveDOMAttr(document(), this, name.localName());
2283     dispatchSubtreeModifiedEvent();
2284 }
2285
2286
2287 void Element::updateNamedItemRegistration(const AtomicString& oldName, const AtomicString& newName)
2288 {
2289     if (!document()->isHTMLDocument())
2290         return;
2291
2292     if (!oldName.isEmpty())
2293         static_cast<HTMLDocument*>(document())->removeNamedItem(oldName);
2294
2295     if (!newName.isEmpty())
2296         static_cast<HTMLDocument*>(document())->addNamedItem(newName);
2297 }
2298
2299 void Element::updateExtraNamedItemRegistration(const AtomicString& oldId, const AtomicString& newId)
2300 {
2301     if (!document()->isHTMLDocument())
2302         return;
2303
2304     if (!oldId.isEmpty())
2305         static_cast<HTMLDocument*>(document())->removeExtraNamedItem(oldId);
2306
2307     if (!newId.isEmpty())
2308         static_cast<HTMLDocument*>(document())->addExtraNamedItem(newId);
2309 }
2310
2311 PassRefPtr<HTMLCollection> Element::ensureCachedHTMLCollection(CollectionType type)
2312 {
2313     return ensureElementRareData()->ensureCachedHTMLCollection(this, type);
2314 }
2315
2316 PassRefPtr<HTMLCollection> ElementRareData::ensureCachedHTMLCollection(Element* element, CollectionType type)
2317 {
2318     if (!m_cachedCollections) {
2319         m_cachedCollections = adoptPtr(new CachedHTMLCollectionArray);
2320         for (unsigned i = 0; i < NumNodeCollectionTypes; i++)
2321             (*m_cachedCollections)[i] = 0;
2322     }
2323
2324     if (HTMLCollection* collection = (*m_cachedCollections)[type - FirstNodeCollectionType])
2325         return collection;
2326
2327     RefPtr<HTMLCollection> collection;
2328     if (type == TableRows) {
2329         ASSERT(element->hasTagName(tableTag));
2330         collection = HTMLTableRowsCollection::create(element);
2331     } else if (type == SelectOptions) {
2332         ASSERT(element->hasTagName(selectTag));
2333         collection = HTMLOptionsCollection::create(element);
2334     } else if (type == FormControls) {
2335         ASSERT(element->hasTagName(formTag) || element->hasTagName(fieldsetTag));
2336         collection = HTMLFormControlsCollection::create(element);
2337 #if ENABLE(MICRODATA)
2338     } else if (type == ItemProperties) {
2339         collection = HTMLPropertiesCollection::create(element);
2340 #endif
2341     } else
2342         collection = HTMLCollection::create(element, type);
2343     (*m_cachedCollections)[type - FirstNodeCollectionType] = collection.get();
2344     return collection.release();
2345 }
2346
2347 HTMLCollection* Element::cachedHTMLCollection(CollectionType type)
2348 {
2349     return hasRareData() ? elementRareData()->cachedHTMLCollection(type) : 0;
2350 }
2351
2352 void Element::removeCachedHTMLCollection(HTMLCollection* collection, CollectionType type)
2353 {
2354     ASSERT(hasRareData());
2355     elementRareData()->removeCachedHTMLCollection(collection, type);
2356 }
2357
2358 IntSize Element::savedLayerScrollOffset() const
2359 {
2360     return hasRareData() ? elementRareData()->m_savedLayerScrollOffset : IntSize();
2361 }
2362
2363 void Element::setSavedLayerScrollOffset(const IntSize& size)
2364 {
2365     if (size.isZero() && !hasRareData())
2366         return;
2367     ensureElementRareData()->m_savedLayerScrollOffset = size;
2368 }
2369
2370 PassRefPtr<Attr> Element::attrIfExists(const QualifiedName& name)
2371 {
2372     if (AttrNodeList* attrNodeList = attrNodeListForElement(this))
2373         return findAttrNodeInList(attrNodeList, name);
2374     return 0;
2375 }
2376
2377 PassRefPtr<Attr> Element::ensureAttr(const QualifiedName& name)
2378 {
2379     AttrNodeList* attrNodeList = ensureAttrNodeListForElement(this);
2380     RefPtr<Attr> attrNode = findAttrNodeInList(attrNodeList, name);
2381     if (!attrNode) {
2382         attrNode = Attr::create(this, name);
2383         attrNodeList->append(attrNode);
2384     }
2385     return attrNode.release();
2386 }
2387
2388 void Element::detachAttrNodeFromElementWithValue(Attr* attrNode, const AtomicString& value)
2389 {
2390     ASSERT(hasSyntheticAttrChildNodes());
2391     attrNode->detachFromElementWithValue(value);
2392
2393     AttrNodeList* attrNodeList = attrNodeListForElement(this);
2394     for (unsigned i = 0; i < attrNodeList->size(); ++i) {
2395         if (attrNodeList->at(i)->qualifiedName() == attrNode->qualifiedName()) {
2396             attrNodeList->remove(i);
2397             if (attrNodeList->isEmpty())
2398                 removeAttrNodeListForElement(this);
2399             return;
2400         }
2401     }
2402     ASSERT_NOT_REACHED();
2403 }
2404
2405 void Element::detachAllAttrNodesFromElement()
2406 {
2407     AttrNodeList* attrNodeList = attrNodeListForElement(this);
2408     ASSERT(attrNodeList);
2409
2410     for (unsigned i = 0; i < attributeCount(); ++i) {
2411         const Attribute* attribute = attributeItem(i);
2412         if (RefPtr<Attr> attrNode = findAttrNodeInList(attrNodeList, attribute->name()))
2413             attrNode->detachFromElementWithValue(attribute->value());
2414     }
2415
2416     removeAttrNodeListForElement(this);
2417 }
2418
2419 bool Element::willRecalcStyle(StyleChange)
2420 {
2421     ASSERT(hasCustomCallbacks());
2422     return true;
2423 }
2424
2425 void Element::didRecalcStyle(StyleChange)
2426 {
2427     ASSERT(hasCustomCallbacks());
2428 }
2429
2430
2431 PassRefPtr<RenderStyle> Element::customStyleForRenderer()
2432 {
2433     ASSERT(hasCustomCallbacks());
2434     return 0;
2435 }
2436
2437
2438 void Element::cloneAttributesFromElement(const Element& other)
2439 {
2440     if (hasSyntheticAttrChildNodes())
2441         detachAllAttrNodesFromElement();
2442
2443     other.updateInvalidAttributes();
2444     if (!other.m_attributeData) {
2445         m_attributeData.clear();
2446         return;
2447     }
2448
2449     const AtomicString& oldID = getIdAttribute();
2450     const AtomicString& newID = other.getIdAttribute();
2451
2452     if (!oldID.isNull() || !newID.isNull())
2453         updateId(oldID, newID);
2454
2455     const AtomicString& oldName = getNameAttribute();
2456     const AtomicString& newName = other.getNameAttribute();
2457
2458     if (!oldName.isNull() || !newName.isNull())
2459         updateName(oldName, newName);
2460
2461     // If 'other' has a mutable ElementAttributeData, convert it to an immutable one so we can share it between both elements.
2462     // We can only do this if there is no CSSOM wrapper for other's inline style (the isMutable() check.)
2463     if (other.m_attributeData->isMutable() && (!other.m_attributeData->inlineStyle() || !other.m_attributeData->inlineStyle()->isMutable()))
2464         const_cast<Element&>(other).m_attributeData = other.m_attributeData->makeImmutableCopy();
2465
2466     if (!other.m_attributeData->isMutable())
2467         m_attributeData = other.m_attributeData;
2468     else
2469         m_attributeData = other.m_attributeData->makeMutableCopy();
2470
2471     for (unsigned i = 0; i < m_attributeData->length(); ++i) {
2472         const Attribute* attribute = const_cast<const ElementAttributeData*>(m_attributeData.get())->attributeItem(i);
2473         attributeChanged(attribute->name(), attribute->value());
2474     }
2475 }
2476
2477 void Element::cloneDataFromElement(const Element& other)
2478 {
2479     cloneAttributesFromElement(other);
2480     copyNonAttributePropertiesFromElement(other);
2481 }
2482
2483 void Element::createMutableAttributeData()
2484 {
2485     if (!m_attributeData)
2486         m_attributeData = ElementAttributeData::create();
2487     else
2488         m_attributeData = m_attributeData->makeMutableCopy();
2489 }
2490
2491 void Element::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
2492 {
2493     MemoryClassInfo info(memoryObjectInfo, this, WebCoreMemoryTypes::DOM);
2494     ContainerNode::reportMemoryUsage(memoryObjectInfo);
2495     info.addMember(m_tagName);
2496     info.addMember(m_attributeData);
2497 }
2498
2499 } // namespace WebCore