663049ab014c2761989595525c946a573f0a597f
[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, 2013 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 "DocumentSharedObjectPool.h"
41 #include "ElementRareData.h"
42 #include "ExceptionCode.h"
43 #include "FlowThreadController.h"
44 #include "FocusController.h"
45 #include "Frame.h"
46 #include "FrameView.h"
47 #include "HTMLCollection.h"
48 #include "HTMLDocument.h"
49 #include "HTMLElement.h"
50 #include "HTMLFormControlsCollection.h"
51 #include "HTMLFrameOwnerElement.h"
52 #include "HTMLLabelElement.h"
53 #include "HTMLNames.h"
54 #include "HTMLOptionsCollection.h"
55 #include "HTMLParserIdioms.h"
56 #include "HTMLTableRowsCollection.h"
57 #include "InsertionPoint.h"
58 #include "InspectorInstrumentation.h"
59 #include "MutationObserverInterestGroup.h"
60 #include "MutationRecord.h"
61 #include "NamedNodeMap.h"
62 #include "NodeList.h"
63 #include "NodeRenderStyle.h"
64 #include "NodeRenderingContext.h"
65 #include "NodeTraversal.h"
66 #include "Page.h"
67 #include "PointerLockController.h"
68 #include "PseudoElement.h"
69 #include "RenderRegion.h"
70 #include "RenderView.h"
71 #include "RenderWidget.h"
72 #include "SelectorQuery.h"
73 #include "Settings.h"
74 #include "ShadowRoot.h"
75 #include "StylePropertySet.h"
76 #include "StyleResolver.h"
77 #include "Text.h"
78 #include "TextIterator.h"
79 #include "VoidCallback.h"
80 #include "WebCoreMemoryInstrumentation.h"
81 #include "XMLNSNames.h"
82 #include "XMLNames.h"
83 #include "htmlediting.h"
84 #include <wtf/BitVector.h>
85 #include <wtf/MemoryInstrumentationVector.h>
86 #include <wtf/text/CString.h>
87
88 #if ENABLE(SVG)
89 #include "SVGDocumentExtensions.h"
90 #include "SVGElement.h"
91 #include "SVGNames.h"
92 #endif
93
94 namespace WebCore {
95
96 using namespace HTMLNames;
97 using namespace XMLNames;
98
99 static inline bool shouldIgnoreAttributeCase(const Element* e)
100 {
101     return e && e->document()->isHTMLDocument() && e->isHTMLElement();
102 }
103     
104 class StyleResolverParentPusher {
105 public:
106     StyleResolverParentPusher(Element* parent)
107         : m_parent(parent)
108         , m_pushedStyleResolver(0)
109     {
110     }
111     void push()
112     {
113         if (m_pushedStyleResolver)
114             return;
115         m_pushedStyleResolver = m_parent->document()->styleResolver();
116         m_pushedStyleResolver->pushParentElement(m_parent);
117     }
118     ~StyleResolverParentPusher()
119     {
120
121         if (!m_pushedStyleResolver)
122             return;
123
124         // This tells us that our pushed style selector is in a bad state,
125         // so we should just bail out in that scenario.
126         ASSERT(m_pushedStyleResolver == m_parent->document()->styleResolver());
127         if (m_pushedStyleResolver != m_parent->document()->styleResolver())
128             return;
129
130         m_pushedStyleResolver->popParentElement(m_parent);
131     }
132
133 private:
134     Element* m_parent;
135     StyleResolver* m_pushedStyleResolver;
136 };
137
138 typedef Vector<RefPtr<Attr> > AttrNodeList;
139 typedef HashMap<Element*, OwnPtr<AttrNodeList> > AttrNodeListMap;
140
141 static AttrNodeListMap& attrNodeListMap()
142 {
143     DEFINE_STATIC_LOCAL(AttrNodeListMap, map, ());
144     return map;
145 }
146
147 static AttrNodeList* attrNodeListForElement(Element* element)
148 {
149     if (!element->hasSyntheticAttrChildNodes())
150         return 0;
151     ASSERT(attrNodeListMap().contains(element));
152     return attrNodeListMap().get(element);
153 }
154
155 static AttrNodeList* ensureAttrNodeListForElement(Element* element)
156 {
157     if (element->hasSyntheticAttrChildNodes()) {
158         ASSERT(attrNodeListMap().contains(element));
159         return attrNodeListMap().get(element);
160     }
161     ASSERT(!attrNodeListMap().contains(element));
162     element->setHasSyntheticAttrChildNodes(true);
163     AttrNodeListMap::AddResult result = attrNodeListMap().add(element, adoptPtr(new AttrNodeList));
164     return result.iterator->value.get();
165 }
166
167 static void removeAttrNodeListForElement(Element* element)
168 {
169     ASSERT(element->hasSyntheticAttrChildNodes());
170     ASSERT(attrNodeListMap().contains(element));
171     attrNodeListMap().remove(element);
172     element->setHasSyntheticAttrChildNodes(false);
173 }
174
175 static Attr* findAttrNodeInList(AttrNodeList* attrNodeList, const QualifiedName& name)
176 {
177     for (unsigned i = 0; i < attrNodeList->size(); ++i) {
178         if (attrNodeList->at(i)->qualifiedName() == name)
179             return attrNodeList->at(i).get();
180     }
181     return 0;
182 }
183
184 PassRefPtr<Element> Element::create(const QualifiedName& tagName, Document* document)
185 {
186     return adoptRef(new Element(tagName, document, CreateElement));
187 }
188
189 Element::~Element()
190 {
191 #ifndef NDEBUG
192     if (document() && document()->renderer()) {
193         // When the document is not destroyed, an element that was part of a named flow
194         // content nodes should have been removed from the content nodes collection
195         // and the inNamedFlow flag reset.
196         ASSERT(!inNamedFlow());
197     }
198 #endif
199
200     if (hasRareData()) {
201         ElementRareData* data = elementRareData();
202         data->setPseudoElement(BEFORE, 0);
203         data->setPseudoElement(AFTER, 0);
204         data->clearShadow();
205     }
206
207     if (hasSyntheticAttrChildNodes())
208         detachAllAttrNodesFromElement();
209
210 #if ENABLE(SVG)
211     if (hasPendingResources()) {
212         document()->accessSVGExtensions()->removeElementFromPendingResources(this);
213         ASSERT(!hasPendingResources());
214     }
215 #endif
216 }
217
218 inline ElementRareData* Element::elementRareData() const
219 {
220     ASSERT(hasRareData());
221     return static_cast<ElementRareData*>(rareData());
222 }
223
224 inline ElementRareData* Element::ensureElementRareData()
225 {
226     return static_cast<ElementRareData*>(ensureRareData());
227 }
228
229 void Element::clearTabIndexExplicitlyIfNeeded()
230 {
231     if (hasRareData())
232         elementRareData()->clearTabIndexExplicitly();
233 }
234
235 void Element::setTabIndexExplicitly(short tabIndex)
236 {
237     ensureElementRareData()->setTabIndexExplicitly(tabIndex);
238 }
239
240 bool Element::supportsFocus() const
241 {
242     return hasRareData() && elementRareData()->tabIndexSetExplicitly();
243 }
244
245 short Element::tabIndex() const
246 {
247     return hasRareData() ? elementRareData()->tabIndex() : 0;
248 }
249
250 DEFINE_VIRTUAL_ATTRIBUTE_EVENT_LISTENER(Element, blur);
251 DEFINE_VIRTUAL_ATTRIBUTE_EVENT_LISTENER(Element, error);
252 DEFINE_VIRTUAL_ATTRIBUTE_EVENT_LISTENER(Element, focus);
253 DEFINE_VIRTUAL_ATTRIBUTE_EVENT_LISTENER(Element, load);
254
255 PassRefPtr<Node> Element::cloneNode(bool deep)
256 {
257     return deep ? cloneElementWithChildren() : cloneElementWithoutChildren();
258 }
259
260 PassRefPtr<Element> Element::cloneElementWithChildren()
261 {
262     RefPtr<Element> clone = cloneElementWithoutChildren();
263     cloneChildNodes(clone.get());
264     return clone.release();
265 }
266
267 PassRefPtr<Element> Element::cloneElementWithoutChildren()
268 {
269     RefPtr<Element> clone = cloneElementWithoutAttributesAndChildren();
270     // This will catch HTML elements in the wrong namespace that are not correctly copied.
271     // This is a sanity check as HTML overloads some of the DOM methods.
272     ASSERT(isHTMLElement() == clone->isHTMLElement());
273
274     clone->cloneDataFromElement(*this);
275     return clone.release();
276 }
277
278 PassRefPtr<Element> Element::cloneElementWithoutAttributesAndChildren()
279 {
280     return document()->createElement(tagQName(), false);
281 }
282
283 PassRefPtr<Attr> Element::detachAttribute(size_t index)
284 {
285     ASSERT(elementData());
286
287     const Attribute* attribute = elementData()->attributeItem(index);
288     ASSERT(attribute);
289
290     RefPtr<Attr> attrNode = attrIfExists(attribute->name());
291     if (attrNode)
292         detachAttrNodeFromElementWithValue(attrNode.get(), attribute->value());
293     else
294         attrNode = Attr::create(document(), attribute->name(), attribute->value());
295
296     removeAttributeInternal(index, NotInSynchronizationOfLazyAttribute);
297     return attrNode.release();
298 }
299
300 void Element::removeAttribute(const QualifiedName& name)
301 {
302     if (!elementData())
303         return;
304
305     size_t index = elementData()->getAttributeItemIndex(name);
306     if (index == notFound)
307         return;
308
309     removeAttributeInternal(index, NotInSynchronizationOfLazyAttribute);
310 }
311
312 void Element::setBooleanAttribute(const QualifiedName& name, bool value)
313 {
314     if (value)
315         setAttribute(name, emptyAtom);
316     else
317         removeAttribute(name);
318 }
319
320 NamedNodeMap* Element::attributes() const
321 {
322     ElementRareData* rareData = const_cast<Element*>(this)->ensureElementRareData();
323     if (NamedNodeMap* attributeMap = rareData->attributeMap())
324         return attributeMap;
325
326     rareData->setAttributeMap(NamedNodeMap::create(const_cast<Element*>(this)));
327     return rareData->attributeMap();
328 }
329
330 Node::NodeType Element::nodeType() const
331 {
332     return ELEMENT_NODE;
333 }
334
335 bool Element::hasAttribute(const QualifiedName& name) const
336 {
337     return hasAttributeNS(name.namespaceURI(), name.localName());
338 }
339
340 void Element::synchronizeAllAttributes() const
341 {
342     if (!elementData())
343         return;
344     if (elementData()->m_styleAttributeIsDirty) {
345         ASSERT(isStyledElement());
346         static_cast<const StyledElement*>(this)->synchronizeStyleAttributeInternal();
347     }
348 #if ENABLE(SVG)
349     if (elementData()->m_animatedSVGAttributesAreDirty) {
350         ASSERT(isSVGElement());
351         toSVGElement(this)->synchronizeAnimatedSVGAttribute(anyQName());
352     }
353 #endif
354 }
355
356 inline void Element::synchronizeAttribute(const QualifiedName& name) const
357 {
358     if (!elementData())
359         return;
360     if (UNLIKELY(name == styleAttr && elementData()->m_styleAttributeIsDirty)) {
361         ASSERT(isStyledElement());
362         static_cast<const StyledElement*>(this)->synchronizeStyleAttributeInternal();
363         return;
364     }
365 #if ENABLE(SVG)
366     if (UNLIKELY(elementData()->m_animatedSVGAttributesAreDirty)) {
367         ASSERT(isSVGElement());
368         toSVGElement(this)->synchronizeAnimatedSVGAttribute(name);
369     }
370 #endif
371 }
372
373 inline void Element::synchronizeAttribute(const AtomicString& localName) const
374 {
375     // This version of synchronizeAttribute() is streamlined for the case where you don't have a full QualifiedName,
376     // e.g when called from DOM API.
377     if (!elementData())
378         return;
379     if (elementData()->m_styleAttributeIsDirty && equalPossiblyIgnoringCase(localName, styleAttr.localName(), shouldIgnoreAttributeCase(this))) {
380         ASSERT(isStyledElement());
381         static_cast<const StyledElement*>(this)->synchronizeStyleAttributeInternal();
382         return;
383     }
384 #if ENABLE(SVG)
385     if (elementData()->m_animatedSVGAttributesAreDirty) {
386         // We're not passing a namespace argument on purpose. SVGNames::*Attr are defined w/o namespaces as well.
387         ASSERT(isSVGElement());
388         static_cast<const SVGElement*>(this)->synchronizeAnimatedSVGAttribute(QualifiedName(nullAtom, localName, nullAtom));
389     }
390 #endif
391 }
392
393 const AtomicString& Element::getAttribute(const QualifiedName& name) const
394 {
395     if (!elementData())
396         return nullAtom;
397     synchronizeAttribute(name);
398     if (const Attribute* attribute = getAttributeItem(name))
399         return attribute->value();
400     return nullAtom;
401 }
402
403 void Element::scrollIntoView(bool alignToTop) 
404 {
405     document()->updateLayoutIgnorePendingStylesheets();
406
407     if (!renderer())
408         return;
409
410     LayoutRect bounds = boundingBox();
411     // Align to the top / bottom and to the closest edge.
412     if (alignToTop)
413         renderer()->scrollRectToVisible(bounds, ScrollAlignment::alignToEdgeIfNeeded, ScrollAlignment::alignTopAlways);
414     else
415         renderer()->scrollRectToVisible(bounds, ScrollAlignment::alignToEdgeIfNeeded, ScrollAlignment::alignBottomAlways);
416 }
417
418 void Element::scrollIntoViewIfNeeded(bool centerIfNeeded)
419 {
420     document()->updateLayoutIgnorePendingStylesheets();
421
422     if (!renderer())
423         return;
424
425     LayoutRect bounds = boundingBox();
426     if (centerIfNeeded)
427         renderer()->scrollRectToVisible(bounds, ScrollAlignment::alignCenterIfNeeded, ScrollAlignment::alignCenterIfNeeded);
428     else
429         renderer()->scrollRectToVisible(bounds, ScrollAlignment::alignToEdgeIfNeeded, ScrollAlignment::alignToEdgeIfNeeded);
430 }
431
432 void Element::scrollByUnits(int units, ScrollGranularity granularity)
433 {
434     document()->updateLayoutIgnorePendingStylesheets();
435
436     if (!renderer())
437         return;
438
439     if (!renderer()->hasOverflowClip())
440         return;
441
442     ScrollDirection direction = ScrollDown;
443     if (units < 0) {
444         direction = ScrollUp;
445         units = -units;
446     }
447     Node* stopNode = this;
448     toRenderBox(renderer())->scroll(direction, granularity, units, &stopNode);
449 }
450
451 void Element::scrollByLines(int lines)
452 {
453     scrollByUnits(lines, ScrollByLine);
454 }
455
456 void Element::scrollByPages(int pages)
457 {
458     scrollByUnits(pages, ScrollByPage);
459 }
460
461 static float localZoomForRenderer(RenderObject* renderer)
462 {
463     // FIXME: This does the wrong thing if two opposing zooms are in effect and canceled each
464     // other out, but the alternative is that we'd have to crawl up the whole render tree every
465     // time (or store an additional bit in the RenderStyle to indicate that a zoom was specified).
466     float zoomFactor = 1;
467     if (renderer->style()->effectiveZoom() != 1) {
468         // Need to find the nearest enclosing RenderObject that set up
469         // a differing zoom, and then we divide our result by it to eliminate the zoom.
470         RenderObject* prev = renderer;
471         for (RenderObject* curr = prev->parent(); curr; curr = curr->parent()) {
472             if (curr->style()->effectiveZoom() != prev->style()->effectiveZoom()) {
473                 zoomFactor = prev->style()->zoom();
474                 break;
475             }
476             prev = curr;
477         }
478         if (prev->isRenderView())
479             zoomFactor = prev->style()->zoom();
480     }
481     return zoomFactor;
482 }
483
484 static int adjustForLocalZoom(LayoutUnit value, RenderObject* renderer)
485 {
486     float zoomFactor = localZoomForRenderer(renderer);
487     if (zoomFactor == 1)
488         return value;
489 #if ENABLE(SUBPIXEL_LAYOUT)
490     return lroundf(value / zoomFactor);
491 #else
492     // Needed because computeLengthInt truncates (rather than rounds) when scaling up.
493     if (zoomFactor > 1)
494         value++;
495     return static_cast<int>(value / zoomFactor);
496 #endif
497 }
498
499 int Element::offsetLeft()
500 {
501     document()->updateLayoutIgnorePendingStylesheets();
502     if (RenderBoxModelObject* renderer = renderBoxModelObject())
503         return adjustForLocalZoom(renderer->pixelSnappedOffsetLeft(), renderer);
504     return 0;
505 }
506
507 int Element::offsetTop()
508 {
509     document()->updateLayoutIgnorePendingStylesheets();
510     if (RenderBoxModelObject* renderer = renderBoxModelObject())
511         return adjustForLocalZoom(renderer->pixelSnappedOffsetTop(), renderer);
512     return 0;
513 }
514
515 int Element::offsetWidth()
516 {
517     document()->updateLayoutIgnorePendingStylesheets();
518     if (RenderBoxModelObject* renderer = renderBoxModelObject())
519 #if ENABLE(SUBPIXEL_LAYOUT)
520         return adjustLayoutUnitForAbsoluteZoom(renderer->pixelSnappedOffsetWidth(), renderer).round();
521 #else
522         return adjustForAbsoluteZoom(renderer->pixelSnappedOffsetWidth(), renderer);
523 #endif
524     return 0;
525 }
526
527 int Element::offsetHeight()
528 {
529     document()->updateLayoutIgnorePendingStylesheets();
530     if (RenderBoxModelObject* renderer = renderBoxModelObject())
531 #if ENABLE(SUBPIXEL_LAYOUT)
532         return adjustLayoutUnitForAbsoluteZoom(renderer->pixelSnappedOffsetHeight(), renderer).round();
533 #else
534         return adjustForAbsoluteZoom(renderer->pixelSnappedOffsetHeight(), renderer);
535 #endif
536     return 0;
537 }
538
539 Element* Element::offsetParent()
540 {
541     document()->updateLayoutIgnorePendingStylesheets();
542     if (RenderObject* rend = renderer())
543         if (RenderObject* offsetParent = rend->offsetParent())
544             return static_cast<Element*>(offsetParent->node());
545     return 0;
546 }
547
548 int Element::clientLeft()
549 {
550     document()->updateLayoutIgnorePendingStylesheets();
551
552     if (RenderBox* renderer = renderBox())
553         return adjustForAbsoluteZoom(roundToInt(renderer->clientLeft()), renderer);
554     return 0;
555 }
556
557 int Element::clientTop()
558 {
559     document()->updateLayoutIgnorePendingStylesheets();
560
561     if (RenderBox* renderer = renderBox())
562         return adjustForAbsoluteZoom(roundToInt(renderer->clientTop()), renderer);
563     return 0;
564 }
565
566 int Element::clientWidth()
567 {
568     document()->updateLayoutIgnorePendingStylesheets();
569
570     // When in strict mode, clientWidth for the document element should return the width of the containing frame.
571     // When in quirks mode, clientWidth for the body element should return the width of the containing frame.
572     bool inQuirksMode = document()->inQuirksMode();
573     if ((!inQuirksMode && document()->documentElement() == this) ||
574         (inQuirksMode && isHTMLElement() && document()->body() == this)) {
575         if (FrameView* view = document()->view()) {
576             if (RenderView* renderView = document()->renderView())
577                 return adjustForAbsoluteZoom(view->layoutWidth(), renderView);
578         }
579     }
580     
581     if (RenderBox* renderer = renderBox())
582 #if ENABLE(SUBPIXEL_LAYOUT)
583         return adjustLayoutUnitForAbsoluteZoom(renderer->pixelSnappedClientWidth(), renderer).round();
584 #else
585         return adjustForAbsoluteZoom(renderer->pixelSnappedClientWidth(), renderer);
586 #endif
587     return 0;
588 }
589
590 int Element::clientHeight()
591 {
592     document()->updateLayoutIgnorePendingStylesheets();
593
594     // When in strict mode, clientHeight for the document element should return the height of the containing frame.
595     // When in quirks mode, clientHeight for the body element should return the height of the containing frame.
596     bool inQuirksMode = document()->inQuirksMode();     
597
598     if ((!inQuirksMode && document()->documentElement() == this) ||
599         (inQuirksMode && isHTMLElement() && document()->body() == this)) {
600         if (FrameView* view = document()->view()) {
601             if (RenderView* renderView = document()->renderView())
602                 return adjustForAbsoluteZoom(view->layoutHeight(), renderView);
603         }
604     }
605     
606     if (RenderBox* renderer = renderBox())
607 #if ENABLE(SUBPIXEL_LAYOUT)
608         return adjustLayoutUnitForAbsoluteZoom(renderer->pixelSnappedClientHeight(), renderer).round();
609 #else
610         return adjustForAbsoluteZoom(renderer->pixelSnappedClientHeight(), renderer);
611 #endif
612     return 0;
613 }
614
615 int Element::scrollLeft()
616 {
617     document()->updateLayoutIgnorePendingStylesheets();
618     if (RenderBox* rend = renderBox())
619         return adjustForAbsoluteZoom(rend->scrollLeft(), rend);
620     return 0;
621 }
622
623 int Element::scrollTop()
624 {
625     document()->updateLayoutIgnorePendingStylesheets();
626     if (RenderBox* rend = renderBox())
627         return adjustForAbsoluteZoom(rend->scrollTop(), rend);
628     return 0;
629 }
630
631 void Element::setScrollLeft(int newLeft)
632 {
633     document()->updateLayoutIgnorePendingStylesheets();
634     if (RenderBox* rend = renderBox())
635         rend->setScrollLeft(static_cast<int>(newLeft * rend->style()->effectiveZoom()));
636 }
637
638 void Element::setScrollTop(int newTop)
639 {
640     document()->updateLayoutIgnorePendingStylesheets();
641     if (RenderBox* rend = renderBox())
642         rend->setScrollTop(static_cast<int>(newTop * rend->style()->effectiveZoom()));
643 }
644
645 int Element::scrollWidth()
646 {
647     document()->updateLayoutIgnorePendingStylesheets();
648     if (RenderBox* rend = renderBox())
649         return adjustForAbsoluteZoom(rend->scrollWidth(), rend);
650     return 0;
651 }
652
653 int Element::scrollHeight()
654 {
655     document()->updateLayoutIgnorePendingStylesheets();
656     if (RenderBox* rend = renderBox())
657         return adjustForAbsoluteZoom(rend->scrollHeight(), rend);
658     return 0;
659 }
660
661 IntRect Element::boundsInRootViewSpace()
662 {
663     document()->updateLayoutIgnorePendingStylesheets();
664
665     FrameView* view = document()->view();
666     if (!view)
667         return IntRect();
668
669     Vector<FloatQuad> quads;
670 #if ENABLE(SVG)
671     if (isSVGElement() && renderer()) {
672         // Get the bounding rectangle from the SVG model.
673         SVGElement* svgElement = static_cast<SVGElement*>(this);
674         FloatRect localRect;
675         if (svgElement->getBoundingBox(localRect))
676             quads.append(renderer()->localToAbsoluteQuad(localRect));
677     } else
678 #endif
679     {
680         // Get the bounding rectangle from the box model.
681         if (renderBoxModelObject())
682             renderBoxModelObject()->absoluteQuads(quads);
683     }
684
685     if (quads.isEmpty())
686         return IntRect();
687
688     IntRect result = quads[0].enclosingBoundingBox();
689     for (size_t i = 1; i < quads.size(); ++i)
690         result.unite(quads[i].enclosingBoundingBox());
691
692     result = view->contentsToRootView(result);
693     return result;
694 }
695
696 PassRefPtr<ClientRectList> Element::getClientRects()
697 {
698     document()->updateLayoutIgnorePendingStylesheets();
699
700     RenderBoxModelObject* renderBoxModelObject = this->renderBoxModelObject();
701     if (!renderBoxModelObject)
702         return ClientRectList::create();
703
704     // FIXME: Handle SVG elements.
705     // FIXME: Handle table/inline-table with a caption.
706
707     Vector<FloatQuad> quads;
708     renderBoxModelObject->absoluteQuads(quads);
709     document()->adjustFloatQuadsForScrollAndAbsoluteZoomAndFrameScale(quads, renderBoxModelObject);
710     return ClientRectList::create(quads);
711 }
712
713 PassRefPtr<ClientRect> Element::getBoundingClientRect()
714 {
715     document()->updateLayoutIgnorePendingStylesheets();
716
717     Vector<FloatQuad> quads;
718 #if ENABLE(SVG)
719     if (isSVGElement() && renderer() && !renderer()->isSVGRoot()) {
720         // Get the bounding rectangle from the SVG model.
721         SVGElement* svgElement = static_cast<SVGElement*>(this);
722         FloatRect localRect;
723         if (svgElement->getBoundingBox(localRect))
724             quads.append(renderer()->localToAbsoluteQuad(localRect));
725     } else
726 #endif
727     {
728         // Get the bounding rectangle from the box model.
729         if (renderBoxModelObject())
730             renderBoxModelObject()->absoluteQuads(quads);
731     }
732
733     if (quads.isEmpty())
734         return ClientRect::create();
735
736     FloatRect result = quads[0].boundingBox();
737     for (size_t i = 1; i < quads.size(); ++i)
738         result.unite(quads[i].boundingBox());
739
740     document()->adjustFloatRectForScrollAndAbsoluteZoomAndFrameScale(result, renderer());
741     return ClientRect::create(result);
742 }
743     
744 IntRect Element::screenRect() const
745 {
746     if (!renderer())
747         return IntRect();
748     // FIXME: this should probably respect transforms
749     return document()->view()->contentsToScreen(renderer()->absoluteBoundingBoxRectIgnoringTransforms());
750 }
751
752 const AtomicString& Element::getAttribute(const AtomicString& localName) const
753 {
754     if (!elementData())
755         return nullAtom;
756     synchronizeAttribute(localName);
757     if (const Attribute* attribute = elementData()->getAttributeItem(localName, shouldIgnoreAttributeCase(this)))
758         return attribute->value();
759     return nullAtom;
760 }
761
762 const AtomicString& Element::getAttributeNS(const AtomicString& namespaceURI, const AtomicString& localName) const
763 {
764     return getAttribute(QualifiedName(nullAtom, localName, namespaceURI));
765 }
766
767 void Element::setAttribute(const AtomicString& localName, const AtomicString& value, ExceptionCode& ec)
768 {
769     if (!Document::isValidName(localName)) {
770         ec = INVALID_CHARACTER_ERR;
771         return;
772     }
773
774     synchronizeAttribute(localName);
775     const AtomicString& caseAdjustedLocalName = shouldIgnoreAttributeCase(this) ? localName.lower() : localName;
776
777     size_t index = elementData() ? elementData()->getAttributeItemIndex(caseAdjustedLocalName, false) : notFound;
778     const QualifiedName& qName = index != notFound ? attributeItem(index)->name() : QualifiedName(nullAtom, caseAdjustedLocalName, nullAtom);
779     setAttributeInternal(index, qName, value, NotInSynchronizationOfLazyAttribute);
780 }
781
782 void Element::setAttribute(const QualifiedName& name, const AtomicString& value)
783 {
784     synchronizeAttribute(name);
785     size_t index = elementData() ? elementData()->getAttributeItemIndex(name) : notFound;
786     setAttributeInternal(index, name, value, NotInSynchronizationOfLazyAttribute);
787 }
788
789 void Element::setSynchronizedLazyAttribute(const QualifiedName& name, const AtomicString& value)
790 {
791     size_t index = elementData() ? elementData()->getAttributeItemIndex(name) : notFound;
792     setAttributeInternal(index, name, value, InSynchronizationOfLazyAttribute);
793 }
794
795 inline void Element::setAttributeInternal(size_t index, const QualifiedName& name, const AtomicString& newValue, SynchronizationOfLazyAttribute inSynchronizationOfLazyAttribute)
796 {
797     if (newValue.isNull()) {
798         if (index != notFound)
799             removeAttributeInternal(index, inSynchronizationOfLazyAttribute);
800         return;
801     }
802
803     if (index == notFound) {
804         addAttributeInternal(name, newValue, inSynchronizationOfLazyAttribute);
805         return;
806     }
807
808     if (!inSynchronizationOfLazyAttribute)
809         willModifyAttribute(name, attributeItem(index)->value(), newValue);
810
811     if (newValue != attributeItem(index)->value()) {
812         ensureUniqueElementData()->attributeItem(index)->setValue(newValue);
813
814         if (RefPtr<Attr> attrNode = inSynchronizationOfLazyAttribute ? 0 : attrIfExists(name))
815             attrNode->recreateTextChildAfterAttributeValueChanged();
816     }
817
818     if (!inSynchronizationOfLazyAttribute)
819         didModifyAttribute(name, newValue);
820 }
821
822 static inline AtomicString makeIdForStyleResolution(const AtomicString& value, bool inQuirksMode)
823 {
824     if (inQuirksMode)
825         return value.lower();
826     return value;
827 }
828
829 static bool checkNeedsStyleInvalidationForIdChange(const AtomicString& oldId, const AtomicString& newId, StyleResolver* styleResolver)
830 {
831     ASSERT(newId != oldId);
832     if (!oldId.isEmpty() && styleResolver->hasSelectorForId(oldId))
833         return true;
834     if (!newId.isEmpty() && styleResolver->hasSelectorForId(newId))
835         return true;
836     return false;
837 }
838
839 void Element::attributeChanged(const QualifiedName& name, const AtomicString& newValue)
840 {
841     if (ElementShadow* parentElementShadow = shadowOfParentForDistribution(this)) {
842         if (shouldInvalidateDistributionWhenAttributeChanged(parentElementShadow, name, newValue))
843             parentElementShadow->invalidateDistribution();
844     }
845
846     parseAttribute(name, newValue);
847
848     document()->incDOMTreeVersion();
849
850     StyleResolver* styleResolver = document()->styleResolverIfExists();
851     bool testShouldInvalidateStyle = attached() && styleResolver && styleChangeType() < FullStyleChange;
852     bool shouldInvalidateStyle = false;
853
854     if (isIdAttributeName(name)) {
855         AtomicString oldId = elementData()->idForStyleResolution();
856         AtomicString newId = makeIdForStyleResolution(newValue, document()->inQuirksMode());
857         if (newId != oldId) {
858             elementData()->setIdForStyleResolution(newId);
859             shouldInvalidateStyle = testShouldInvalidateStyle && checkNeedsStyleInvalidationForIdChange(oldId, newId, styleResolver);
860         }
861     } else if (name == classAttr)
862         classAttributeChanged(newValue);
863     else if (name == HTMLNames::nameAttr)
864         setHasName(!newValue.isNull());
865     else if (name == HTMLNames::pseudoAttr)
866         shouldInvalidateStyle |= testShouldInvalidateStyle && isInShadowTree();
867
868     shouldInvalidateStyle |= testShouldInvalidateStyle && styleResolver->hasSelectorForAttribute(name.localName());
869
870     invalidateNodeListCachesInAncestors(&name, this);
871
872     // If there is currently no StyleResolver, we can't be sure that this attribute change won't affect style.
873     shouldInvalidateStyle |= !styleResolver;
874
875     if (shouldInvalidateStyle)
876         setNeedsStyleRecalc();
877
878     if (AXObjectCache::accessibilityEnabled())
879         document()->axObjectCache()->handleAttributeChanged(name, this);
880 }
881
882 template <typename CharacterType>
883 static inline bool classStringHasClassName(const CharacterType* characters, unsigned length)
884 {
885     ASSERT(length > 0);
886
887     unsigned i = 0;
888     do {
889         if (isNotHTMLSpace(characters[i]))
890             break;
891         ++i;
892     } while (i < length);
893
894     return i < length;
895 }
896
897 static inline bool classStringHasClassName(const AtomicString& newClassString)
898 {
899     unsigned length = newClassString.length();
900
901     if (!length)
902         return false;
903
904     if (newClassString.is8Bit())
905         return classStringHasClassName(newClassString.characters8(), length);
906     return classStringHasClassName(newClassString.characters16(), length);
907 }
908
909 template<typename Checker>
910 static bool checkSelectorForClassChange(const SpaceSplitString& changedClasses, const Checker& checker)
911 {
912     unsigned changedSize = changedClasses.size();
913     for (unsigned i = 0; i < changedSize; ++i) {
914         if (checker.hasSelectorForClass(changedClasses[i]))
915             return true;
916     }
917     return false;
918 }
919
920 template<typename Checker>
921 static bool checkSelectorForClassChange(const SpaceSplitString& oldClasses, const SpaceSplitString& newClasses, const Checker& checker)
922 {
923     unsigned oldSize = oldClasses.size();
924     if (!oldSize)
925         return checkSelectorForClassChange(newClasses, checker);
926     BitVector remainingClassBits;
927     remainingClassBits.ensureSize(oldSize);
928     // Class vectors tend to be very short. This is faster than using a hash table.
929     unsigned newSize = newClasses.size();
930     for (unsigned i = 0; i < newSize; ++i) {
931         for (unsigned j = 0; j < oldSize; ++j) {
932             if (newClasses[i] == oldClasses[j]) {
933                 remainingClassBits.quickSet(j);
934                 continue;
935             }
936         }
937         if (checker.hasSelectorForClass(newClasses[i]))
938             return true;
939     }
940     for (unsigned i = 0; i < oldSize; ++i) {
941         // If the bit is not set the the corresponding class has been removed.
942         if (remainingClassBits.quickGet(i))
943             continue;
944         if (checker.hasSelectorForClass(oldClasses[i]))
945             return true;
946     }
947     return false;
948 }
949
950 void Element::classAttributeChanged(const AtomicString& newClassString)
951 {
952     StyleResolver* styleResolver = document()->styleResolverIfExists();
953     bool testShouldInvalidateStyle = attached() && styleResolver && styleChangeType() < FullStyleChange;
954     bool shouldInvalidateStyle = false;
955
956     if (classStringHasClassName(newClassString)) {
957         const bool shouldFoldCase = document()->inQuirksMode();
958         const SpaceSplitString oldClasses = elementData()->classNames();
959         elementData()->setClass(newClassString, shouldFoldCase);
960         const SpaceSplitString& newClasses = elementData()->classNames();
961         shouldInvalidateStyle = testShouldInvalidateStyle && checkSelectorForClassChange(oldClasses, newClasses, *styleResolver);
962     } else {
963         const SpaceSplitString& oldClasses = elementData()->classNames();
964         shouldInvalidateStyle = testShouldInvalidateStyle && checkSelectorForClassChange(oldClasses, *styleResolver);
965         elementData()->clearClass();
966     }
967
968     if (hasRareData())
969         elementRareData()->clearClassListValueForQuirksMode();
970
971     if (shouldInvalidateStyle)
972         setNeedsStyleRecalc();
973 }
974
975 bool Element::shouldInvalidateDistributionWhenAttributeChanged(ElementShadow* elementShadow, const QualifiedName& name, const AtomicString& newValue)
976 {
977     ASSERT(elementShadow);
978     const SelectRuleFeatureSet& featureSet = elementShadow->distributor().ensureSelectFeatureSet(elementShadow);
979
980     if (isIdAttributeName(name)) {
981         AtomicString oldId = elementData()->idForStyleResolution();
982         AtomicString newId = makeIdForStyleResolution(newValue, document()->inQuirksMode());
983         if (newId != oldId) {
984             if (!oldId.isEmpty() && featureSet.hasSelectorForId(oldId))
985                 return true;
986             if (!newId.isEmpty() && featureSet.hasSelectorForId(newId))
987                 return true;
988         }
989     }
990
991     if (name == HTMLNames::classAttr) {
992         const AtomicString& newClassString = newValue;
993         if (classStringHasClassName(newClassString)) {
994             const bool shouldFoldCase = document()->inQuirksMode();
995             const SpaceSplitString& oldClasses = elementData()->classNames();
996             const SpaceSplitString newClasses(newClassString, shouldFoldCase);
997             if (checkSelectorForClassChange(oldClasses, newClasses, featureSet))
998                 return true;
999         } else {
1000             const SpaceSplitString& oldClasses = elementData()->classNames();
1001             if (checkSelectorForClassChange(oldClasses, featureSet))
1002                 return true;
1003         }
1004     }
1005
1006     return featureSet.hasSelectorForAttribute(name.localName());
1007 }
1008
1009 // Returns true is the given attribute is an event handler.
1010 // We consider an event handler any attribute that begins with "on".
1011 // It is a simple solution that has the advantage of not requiring any
1012 // code or configuration change if a new event handler is defined.
1013
1014 static bool isEventHandlerAttribute(const QualifiedName& name)
1015 {
1016     return name.namespaceURI().isNull() && name.localName().startsWith("on");
1017 }
1018
1019 // FIXME: Share code with Element::isURLAttribute.
1020 static bool isAttributeToRemove(const QualifiedName& name, const AtomicString& value)
1021 {
1022     return (name.localName() == hrefAttr.localName() || name.localName() == nohrefAttr.localName()
1023         || name == srcAttr || name == actionAttr || name == formactionAttr) && protocolIsJavaScript(stripLeadingAndTrailingHTMLSpaces(value));
1024 }
1025
1026 void Element::parserSetAttributes(const Vector<Attribute>& attributeVector, FragmentScriptingPermission scriptingPermission)
1027 {
1028     ASSERT(!inDocument());
1029     ASSERT(!parentNode());
1030
1031     ASSERT(!m_elementData);
1032
1033     if (attributeVector.isEmpty())
1034         return;
1035
1036     Vector<Attribute> filteredAttributes = attributeVector;
1037
1038     // If the element is created as result of a paste or drag-n-drop operation
1039     // we want to remove all the script and event handlers.
1040     if (!scriptingContentIsAllowed(scriptingPermission)) {
1041         size_t i = 0;
1042         while (i < filteredAttributes.size()) {
1043             Attribute& attribute = filteredAttributes[i];
1044             if (isEventHandlerAttribute(attribute.name())) {
1045                 filteredAttributes.remove(i);
1046                 continue;
1047             }
1048
1049             if (isAttributeToRemove(attribute.name(), attribute.value()))
1050                 attribute.setValue(emptyAtom);
1051             i++;
1052         }
1053     }
1054
1055     if (document() && document()->sharedObjectPool())
1056         m_elementData = document()->sharedObjectPool()->cachedShareableElementDataWithAttributes(filteredAttributes);
1057     else
1058         m_elementData = ShareableElementData::createWithAttributes(filteredAttributes);
1059
1060     // Iterate over the set of attributes we already have on the stack in case
1061     // attributeChanged mutates m_elementData.
1062     // FIXME: Find a way so we don't have to do this.
1063     for (unsigned i = 0; i < filteredAttributes.size(); ++i)
1064         attributeChanged(filteredAttributes[i].name(), filteredAttributes[i].value());
1065 }
1066
1067 bool Element::hasAttributes() const
1068 {
1069     synchronizeAllAttributes();
1070     return elementData() && elementData()->length();
1071 }
1072
1073 bool Element::hasEquivalentAttributes(const Element* other) const
1074 {
1075     synchronizeAllAttributes();
1076     other->synchronizeAllAttributes();
1077     if (elementData() == other->elementData())
1078         return true;
1079     if (elementData())
1080         return elementData()->isEquivalent(other->elementData());
1081     if (other->elementData())
1082         return other->elementData()->isEquivalent(elementData());
1083     return true;
1084 }
1085
1086 String Element::nodeName() const
1087 {
1088     return m_tagName.toString();
1089 }
1090
1091 String Element::nodeNamePreservingCase() const
1092 {
1093     return m_tagName.toString();
1094 }
1095
1096 void Element::setPrefix(const AtomicString& prefix, ExceptionCode& ec)
1097 {
1098     ec = 0;
1099     checkSetPrefix(prefix, ec);
1100     if (ec)
1101         return;
1102
1103     m_tagName.setPrefix(prefix.isEmpty() ? AtomicString() : prefix);
1104 }
1105
1106 KURL Element::baseURI() const
1107 {
1108     const AtomicString& baseAttribute = getAttribute(baseAttr);
1109     KURL base(KURL(), baseAttribute);
1110     if (!base.protocol().isEmpty())
1111         return base;
1112
1113     ContainerNode* parent = parentNode();
1114     if (!parent)
1115         return base;
1116
1117     const KURL& parentBase = parent->baseURI();
1118     if (parentBase.isNull())
1119         return base;
1120
1121     return KURL(parentBase, baseAttribute);
1122 }
1123
1124 const QualifiedName& Element::imageSourceAttributeName() const
1125 {
1126     return srcAttr;
1127 }
1128
1129 bool Element::rendererIsNeeded(const NodeRenderingContext& context)
1130 {
1131     return context.style()->display() != NONE;
1132 }
1133
1134 RenderObject* Element::createRenderer(RenderArena*, RenderStyle* style)
1135 {
1136     return RenderObject::createObject(this, style);
1137 }
1138
1139 #if ENABLE(INPUT_MULTIPLE_FIELDS_UI)
1140 bool Element::isDateTimeFieldElement() const
1141 {
1142     return false;
1143 }
1144 #endif
1145
1146 bool Element::wasChangedSinceLastFormControlChangeEvent() const
1147 {
1148     return false;
1149 }
1150
1151 void Element::setChangedSinceLastFormControlChangeEvent(bool)
1152 {
1153 }
1154
1155 Node::InsertionNotificationRequest Element::insertedInto(ContainerNode* insertionPoint)
1156 {
1157     // need to do superclass processing first so inDocument() is true
1158     // by the time we reach updateId
1159     ContainerNode::insertedInto(insertionPoint);
1160
1161 #if ENABLE(FULLSCREEN_API)
1162     if (containsFullScreenElement() && parentElement() && !parentElement()->containsFullScreenElement())
1163         setContainsFullScreenElementOnAncestorsCrossingFrameBoundaries(true);
1164 #endif
1165
1166     if (Element* before = pseudoElement(BEFORE))
1167         before->insertedInto(insertionPoint);
1168
1169     if (Element* after = pseudoElement(AFTER))
1170         after->insertedInto(insertionPoint);
1171
1172     if (!insertionPoint->isInTreeScope())
1173         return InsertionDone;
1174
1175     if (hasRareData())
1176         elementRareData()->clearClassListValueForQuirksMode();
1177
1178     TreeScope* scope = insertionPoint->treeScope();
1179     if (scope != treeScope())
1180         return InsertionDone;
1181
1182     const AtomicString& idValue = getIdAttribute();
1183     if (!idValue.isNull())
1184         updateId(scope, nullAtom, idValue);
1185
1186     const AtomicString& nameValue = getNameAttribute();
1187     if (!nameValue.isNull())
1188         updateName(nullAtom, nameValue);
1189
1190     if (hasTagName(labelTag)) {
1191         if (scope->shouldCacheLabelsByForAttribute())
1192             updateLabel(scope, nullAtom, fastGetAttribute(forAttr));
1193     }
1194
1195     return InsertionDone;
1196 }
1197
1198 void Element::removedFrom(ContainerNode* insertionPoint)
1199 {
1200 #if ENABLE(SVG)
1201     bool wasInDocument = insertionPoint->document();
1202 #endif
1203
1204     if (Element* before = pseudoElement(BEFORE))
1205         before->removedFrom(insertionPoint);
1206
1207     if (Element* after = pseudoElement(AFTER))
1208         after->removedFrom(insertionPoint);
1209
1210 #if ENABLE(DIALOG_ELEMENT)
1211     document()->removeFromTopLayer(this);
1212 #endif
1213 #if ENABLE(FULLSCREEN_API)
1214     if (containsFullScreenElement())
1215         setContainsFullScreenElementOnAncestorsCrossingFrameBoundaries(false);
1216 #endif
1217 #if ENABLE(POINTER_LOCK)
1218     if (document()->page())
1219         document()->page()->pointerLockController()->elementRemoved(this);
1220 #endif
1221
1222     setSavedLayerScrollOffset(IntSize());
1223
1224     if (insertionPoint->isInTreeScope() && treeScope() == document()) {
1225         const AtomicString& idValue = getIdAttribute();
1226         if (!idValue.isNull())
1227             updateId(insertionPoint->treeScope(), idValue, nullAtom);
1228
1229         const AtomicString& nameValue = getNameAttribute();
1230         if (!nameValue.isNull())
1231             updateName(nameValue, nullAtom);
1232
1233         if (hasTagName(labelTag)) {
1234             TreeScope* treeScope = insertionPoint->treeScope();
1235             if (treeScope->shouldCacheLabelsByForAttribute())
1236                 updateLabel(treeScope, fastGetAttribute(forAttr), nullAtom);
1237         }
1238     }
1239
1240     ContainerNode::removedFrom(insertionPoint);
1241 #if ENABLE(SVG)
1242     if (wasInDocument && hasPendingResources())
1243         document()->accessSVGExtensions()->removeElementFromPendingResources(this);
1244 #endif
1245 }
1246
1247 void Element::createRendererIfNeeded()
1248 {
1249     NodeRenderingContext(this).createRendererForElementIfNeeded();
1250 }
1251
1252 void Element::attach()
1253 {
1254     PostAttachCallbackDisabler callbackDisabler(this);
1255     StyleResolverParentPusher parentPusher(this);
1256     WidgetHierarchyUpdatesSuspensionScope suspendWidgetHierarchyUpdates;
1257
1258     createRendererIfNeeded();
1259
1260     if (parentElement() && parentElement()->isInCanvasSubtree())
1261         setIsInCanvasSubtree(true);
1262
1263     updatePseudoElement(BEFORE);
1264
1265     // When a shadow root exists, it does the work of attaching the children.
1266     if (ElementShadow* shadow = this->shadow()) {
1267         parentPusher.push();
1268         shadow->attach();
1269     } else if (firstChild())
1270         parentPusher.push();
1271
1272     ContainerNode::attach();
1273
1274     updatePseudoElement(AFTER);
1275
1276     if (hasRareData()) {   
1277         ElementRareData* data = elementRareData();
1278         if (data->needsFocusAppearanceUpdateSoonAfterAttach()) {
1279             if (isFocusable() && document()->focusedNode() == this)
1280                 document()->updateFocusAppearanceSoon(false /* don't restore selection */);
1281             data->setNeedsFocusAppearanceUpdateSoonAfterAttach(false);
1282         }
1283     }
1284 }
1285
1286 void Element::unregisterNamedFlowContentNode()
1287 {
1288     if (document()->cssRegionsEnabled() && inNamedFlow() && document()->renderView())
1289         document()->renderView()->flowThreadController()->unregisterNamedFlowContentNode(this);
1290 }
1291
1292 void Element::detach()
1293 {
1294     WidgetHierarchyUpdatesSuspensionScope suspendWidgetHierarchyUpdates;
1295     unregisterNamedFlowContentNode();
1296     cancelFocusAppearanceUpdate();
1297     if (hasRareData()) {
1298         ElementRareData* data = elementRareData();
1299         data->setPseudoElement(BEFORE, 0);
1300         data->setPseudoElement(AFTER, 0);
1301         data->setIsInCanvasSubtree(false);
1302         data->resetComputedStyle();
1303         data->resetDynamicRestyleObservations();
1304     }
1305
1306     if (ElementShadow* shadow = this->shadow()) {
1307         detachChildrenIfNeeded();
1308         shadow->detach();
1309     }
1310     ContainerNode::detach();
1311 }
1312
1313 bool Element::pseudoStyleCacheIsInvalid(const RenderStyle* currentStyle, RenderStyle* newStyle)
1314 {
1315     ASSERT(currentStyle == renderStyle());
1316     ASSERT(renderer());
1317
1318     if (!currentStyle)
1319         return false;
1320
1321     const PseudoStyleCache* pseudoStyleCache = currentStyle->cachedPseudoStyles();
1322     if (!pseudoStyleCache)
1323         return false;
1324
1325     size_t cacheSize = pseudoStyleCache->size();
1326     for (size_t i = 0; i < cacheSize; ++i) {
1327         RefPtr<RenderStyle> newPseudoStyle;
1328         PseudoId pseudoId = pseudoStyleCache->at(i)->styleType();
1329         if (pseudoId == FIRST_LINE || pseudoId == FIRST_LINE_INHERITED)
1330             newPseudoStyle = renderer()->uncachedFirstLineStyle(newStyle);
1331         else
1332             newPseudoStyle = renderer()->getUncachedPseudoStyle(PseudoStyleRequest(pseudoId), newStyle, newStyle);
1333         if (!newPseudoStyle)
1334             return true;
1335         if (*newPseudoStyle != *pseudoStyleCache->at(i)) {
1336             if (pseudoId < FIRST_INTERNAL_PSEUDOID)
1337                 newStyle->setHasPseudoStyle(pseudoId);
1338             newStyle->addCachedPseudoStyle(newPseudoStyle);
1339             if (pseudoId == FIRST_LINE || pseudoId == FIRST_LINE_INHERITED) {
1340                 // FIXME: We should do an actual diff to determine whether a repaint vs. layout
1341                 // is needed, but for now just assume a layout will be required.  The diff code
1342                 // in RenderObject::setStyle would need to be factored out so that it could be reused.
1343                 renderer()->setNeedsLayoutAndPrefWidthsRecalc();
1344             }
1345             return true;
1346         }
1347     }
1348     return false;
1349 }
1350
1351 PassRefPtr<RenderStyle> Element::styleForRenderer()
1352 {
1353     if (hasCustomStyleCallbacks()) {
1354         if (RefPtr<RenderStyle> style = customStyleForRenderer())
1355             return style.release();
1356     }
1357
1358     return document()->styleResolver()->styleForElement(this);
1359 }
1360
1361 void Element::recalcStyle(StyleChange change)
1362 {
1363     if (hasCustomStyleCallbacks()) {
1364         if (!willRecalcStyle(change))
1365             return;
1366     }
1367
1368     // Ref currentStyle in case it would otherwise be deleted when setting the new style in the renderer.
1369     RefPtr<RenderStyle> currentStyle(renderStyle());
1370     bool hasParentStyle = parentNodeForRenderingAndStyle() ? static_cast<bool>(parentNodeForRenderingAndStyle()->renderStyle()) : false;
1371     bool hasDirectAdjacentRules = childrenAffectedByDirectAdjacentRules();
1372     bool hasIndirectAdjacentRules = childrenAffectedByForwardPositionalRules();
1373
1374     if ((change > NoChange || needsStyleRecalc())) {
1375         if (hasRareData())
1376             elementRareData()->resetComputedStyle();
1377     }
1378     if (hasParentStyle && (change >= Inherit || needsStyleRecalc())) {
1379         RefPtr<RenderStyle> newStyle = styleForRenderer();
1380         StyleChange ch = Node::diff(currentStyle.get(), newStyle.get(), document());
1381         if (ch == Detach || !currentStyle) {
1382             // FIXME: The style gets computed twice by calling attach. We could do better if we passed the style along.
1383             reattach();
1384             // attach recalculates the style for all children. No need to do it twice.
1385             clearNeedsStyleRecalc();
1386             clearChildNeedsStyleRecalc();
1387
1388             if (hasCustomStyleCallbacks())
1389                 didRecalcStyle(change);
1390             return;
1391         }
1392
1393         if (RenderObject* renderer = this->renderer()) {
1394             if (ch != NoChange || pseudoStyleCacheIsInvalid(currentStyle.get(), newStyle.get()) || (change == Force && renderer->requiresForcedStyleRecalcPropagation()) || styleChangeType() == SyntheticStyleChange)
1395                 renderer->setAnimatableStyle(newStyle.get());
1396             else if (needsStyleRecalc()) {
1397                 // Although no change occurred, we use the new style so that the cousin style sharing code won't get
1398                 // fooled into believing this style is the same.
1399                 renderer->setStyleInternal(newStyle.get());
1400             }
1401         }
1402
1403         // 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
1404         // 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).
1405         if (document()->styleSheetCollection()->usesRemUnits() && document()->documentElement() == this && ch != NoChange && currentStyle && newStyle && currentStyle->fontSize() != newStyle->fontSize()) {
1406             // Cached RenderStyles may depend on the re units.
1407             document()->styleResolver()->invalidateMatchedPropertiesCache();
1408             change = Force;
1409         }
1410
1411         if (change != Force) {
1412             if (styleChangeType() >= FullStyleChange)
1413                 change = Force;
1414             else
1415                 change = ch;
1416         }
1417     }
1418     StyleResolverParentPusher parentPusher(this);
1419
1420     // FIXME: This does not care about sibling combinators. Will be necessary in XBL2 world.
1421     if (ElementShadow* shadow = this->shadow()) {
1422         if (change >= Inherit || shadow->childNeedsStyleRecalc() || shadow->needsStyleRecalc()) {
1423             parentPusher.push();
1424             shadow->recalcStyle(change);
1425         }
1426     }
1427
1428     updatePseudoElement(BEFORE, change);
1429
1430     // FIXME: This check is good enough for :hover + foo, but it is not good enough for :hover + foo + bar.
1431     // For now we will just worry about the common case, since it's a lot trickier to get the second case right
1432     // without doing way too much re-resolution.
1433     bool forceCheckOfNextElementSibling = false;
1434     bool forceCheckOfAnyElementSibling = false;
1435     for (Node *n = firstChild(); n; n = n->nextSibling()) {
1436         if (n->isTextNode()) {
1437             toText(n)->recalcTextStyle(change);
1438             continue;
1439         } 
1440         if (!n->isElementNode()) 
1441             continue;
1442         Element* element = static_cast<Element*>(n);
1443         bool childRulesChanged = element->needsStyleRecalc() && element->styleChangeType() == FullStyleChange;
1444         if ((forceCheckOfNextElementSibling || forceCheckOfAnyElementSibling))
1445             element->setNeedsStyleRecalc();
1446         if (change >= Inherit || element->childNeedsStyleRecalc() || element->needsStyleRecalc()) {
1447             parentPusher.push();
1448             element->recalcStyle(change);
1449         }
1450         forceCheckOfNextElementSibling = childRulesChanged && hasDirectAdjacentRules;
1451         forceCheckOfAnyElementSibling = forceCheckOfAnyElementSibling || (childRulesChanged && hasIndirectAdjacentRules);
1452     }
1453
1454     updatePseudoElement(AFTER, change);
1455
1456     clearNeedsStyleRecalc();
1457     clearChildNeedsStyleRecalc();
1458     
1459     if (hasCustomStyleCallbacks())
1460         didRecalcStyle(change);
1461 }
1462
1463 ElementShadow* Element::shadow() const
1464 {
1465     return hasRareData() ? elementRareData()->shadow() : 0;
1466 }
1467
1468 ElementShadow* Element::ensureShadow()
1469 {
1470     return ensureElementRareData()->ensureShadow();
1471 }
1472
1473 void Element::didAffectSelector(AffectedSelectorMask mask)
1474 {
1475     setNeedsStyleRecalc();
1476     if (ElementShadow* elementShadow = shadowOfParentForDistribution(this))
1477         elementShadow->didAffectSelector(mask);
1478 }
1479
1480 PassRefPtr<ShadowRoot> Element::createShadowRoot(ExceptionCode& ec)
1481 {
1482     if (alwaysCreateUserAgentShadowRoot())
1483         ensureUserAgentShadowRoot();
1484
1485 #if ENABLE(SHADOW_DOM)
1486     if (RuntimeEnabledFeatures::authorShadowDOMForAnyElementEnabled())
1487         return ensureShadow()->addShadowRoot(this, ShadowRoot::AuthorShadowRoot);
1488 #endif
1489
1490     // Since some elements recreates shadow root dynamically, multiple shadow
1491     // subtrees won't work well in that element. Until they are fixed, we disable
1492     // adding author shadow root for them.
1493     if (!areAuthorShadowsAllowed()) {
1494         ec = HIERARCHY_REQUEST_ERR;
1495         return 0;
1496     }
1497     return ensureShadow()->addShadowRoot(this, ShadowRoot::AuthorShadowRoot);
1498 }
1499
1500 ShadowRoot* Element::shadowRoot() const
1501 {
1502     ElementShadow* elementShadow = shadow();
1503     if (!elementShadow)
1504         return 0;
1505     ShadowRoot* shadowRoot = elementShadow->youngestShadowRoot();
1506     if (shadowRoot->type() == ShadowRoot::AuthorShadowRoot)
1507         return shadowRoot;
1508     return 0;
1509 }
1510
1511 ShadowRoot* Element::userAgentShadowRoot() const
1512 {
1513     if (ElementShadow* elementShadow = shadow()) {
1514         if (ShadowRoot* shadowRoot = elementShadow->oldestShadowRoot()) {
1515             ASSERT(shadowRoot->type() == ShadowRoot::UserAgentShadowRoot);
1516             return shadowRoot;
1517         }
1518     }
1519
1520     return 0;
1521 }
1522
1523 ShadowRoot* Element::ensureUserAgentShadowRoot()
1524 {
1525     if (ShadowRoot* shadowRoot = userAgentShadowRoot())
1526         return shadowRoot;
1527     ShadowRoot* shadowRoot = ensureShadow()->addShadowRoot(this, ShadowRoot::UserAgentShadowRoot);
1528     didAddUserAgentShadowRoot(shadowRoot);
1529     return shadowRoot;
1530 }
1531
1532 const AtomicString& Element::shadowPseudoId() const
1533 {
1534     return pseudo();
1535 }
1536
1537 bool Element::childTypeAllowed(NodeType type) const
1538 {
1539     switch (type) {
1540     case ELEMENT_NODE:
1541     case TEXT_NODE:
1542     case COMMENT_NODE:
1543     case PROCESSING_INSTRUCTION_NODE:
1544     case CDATA_SECTION_NODE:
1545     case ENTITY_REFERENCE_NODE:
1546         return true;
1547     default:
1548         break;
1549     }
1550     return false;
1551 }
1552
1553 static void checkForEmptyStyleChange(Element* element, RenderStyle* style)
1554 {
1555     if (!style && !element->styleAffectedByEmpty())
1556         return;
1557
1558     if (!style || (element->styleAffectedByEmpty() && (!style->emptyState() || element->hasChildNodes())))
1559         element->setNeedsStyleRecalc();
1560 }
1561
1562 static void checkForSiblingStyleChanges(Element* e, RenderStyle* style, bool finishedParsingCallback,
1563                                         Node* beforeChange, Node* afterChange, int childCountDelta)
1564 {
1565     // :empty selector.
1566     checkForEmptyStyleChange(e, style);
1567     
1568     if (!style || (e->needsStyleRecalc() && e->childrenAffectedByPositionalRules()))
1569         return;
1570
1571     // :first-child.  In the parser callback case, we don't have to check anything, since we were right the first time.
1572     // In the DOM case, we only need to do something if |afterChange| is not 0.
1573     // |afterChange| is 0 in the parser case, so it works out that we'll skip this block.
1574     if (e->childrenAffectedByFirstChildRules() && afterChange) {
1575         // Find our new first child.
1576         Node* newFirstChild = 0;
1577         for (newFirstChild = e->firstChild(); newFirstChild && !newFirstChild->isElementNode(); newFirstChild = newFirstChild->nextSibling()) {};
1578         
1579         // Find the first element node following |afterChange|
1580         Node* firstElementAfterInsertion = 0;
1581         for (firstElementAfterInsertion = afterChange;
1582              firstElementAfterInsertion && !firstElementAfterInsertion->isElementNode();
1583              firstElementAfterInsertion = firstElementAfterInsertion->nextSibling()) {};
1584         
1585         // This is the insert/append case.
1586         if (newFirstChild != firstElementAfterInsertion && firstElementAfterInsertion && firstElementAfterInsertion->attached() &&
1587             firstElementAfterInsertion->renderStyle() && firstElementAfterInsertion->renderStyle()->firstChildState())
1588             firstElementAfterInsertion->setNeedsStyleRecalc();
1589             
1590         // We also have to handle node removal.
1591         if (childCountDelta < 0 && newFirstChild == firstElementAfterInsertion && newFirstChild && (!newFirstChild->renderStyle() || !newFirstChild->renderStyle()->firstChildState()))
1592             newFirstChild->setNeedsStyleRecalc();
1593     }
1594
1595     // :last-child.  In the parser callback case, we don't have to check anything, since we were right the first time.
1596     // In the DOM case, we only need to do something if |afterChange| is not 0.
1597     if (e->childrenAffectedByLastChildRules() && beforeChange) {
1598         // Find our new last child.
1599         Node* newLastChild = 0;
1600         for (newLastChild = e->lastChild(); newLastChild && !newLastChild->isElementNode(); newLastChild = newLastChild->previousSibling()) {};
1601         
1602         // Find the last element node going backwards from |beforeChange|
1603         Node* lastElementBeforeInsertion = 0;
1604         for (lastElementBeforeInsertion = beforeChange;
1605              lastElementBeforeInsertion && !lastElementBeforeInsertion->isElementNode();
1606              lastElementBeforeInsertion = lastElementBeforeInsertion->previousSibling()) {};
1607         
1608         if (newLastChild != lastElementBeforeInsertion && lastElementBeforeInsertion && lastElementBeforeInsertion->attached() &&
1609             lastElementBeforeInsertion->renderStyle() && lastElementBeforeInsertion->renderStyle()->lastChildState())
1610             lastElementBeforeInsertion->setNeedsStyleRecalc();
1611             
1612         // 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
1613         // to match now.
1614         if ((childCountDelta < 0 || finishedParsingCallback) && newLastChild == lastElementBeforeInsertion && newLastChild && (!newLastChild->renderStyle() || !newLastChild->renderStyle()->lastChildState()))
1615             newLastChild->setNeedsStyleRecalc();
1616     }
1617
1618     // The + selector.  We need to invalidate the first element following the insertion point.  It is the only possible element
1619     // that could be affected by this DOM change.
1620     if (e->childrenAffectedByDirectAdjacentRules() && afterChange) {
1621         Node* firstElementAfterInsertion = 0;
1622         for (firstElementAfterInsertion = afterChange;
1623              firstElementAfterInsertion && !firstElementAfterInsertion->isElementNode();
1624              firstElementAfterInsertion = firstElementAfterInsertion->nextSibling()) {};
1625         if (firstElementAfterInsertion && firstElementAfterInsertion->attached())
1626             firstElementAfterInsertion->setNeedsStyleRecalc();
1627     }
1628
1629     // Forward positional selectors include the ~ selector, nth-child, nth-of-type, first-of-type and only-of-type.
1630     // Backward positional selectors include nth-last-child, nth-last-of-type, last-of-type and only-of-type.
1631     // We have to invalidate everything following the insertion point in the forward case, and everything before the insertion point in the
1632     // backward case.
1633     // |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.
1634     // 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
1635     // here.  recalcStyle will then force a walk of the children when it sees that this has happened.
1636     if ((e->childrenAffectedByForwardPositionalRules() && afterChange)
1637         || (e->childrenAffectedByBackwardPositionalRules() && beforeChange))
1638         e->setNeedsStyleRecalc();
1639 }
1640
1641 void Element::childrenChanged(bool changedByParser, Node* beforeChange, Node* afterChange, int childCountDelta)
1642 {
1643     ContainerNode::childrenChanged(changedByParser, beforeChange, afterChange, childCountDelta);
1644     if (changedByParser)
1645         checkForEmptyStyleChange(this, renderStyle());
1646     else
1647         checkForSiblingStyleChanges(this, renderStyle(), false, beforeChange, afterChange, childCountDelta);
1648
1649     if (ElementShadow * shadow = this->shadow())
1650         shadow->invalidateDistribution();
1651 }
1652
1653 void Element::beginParsingChildren()
1654 {
1655     clearIsParsingChildrenFinished();
1656     StyleResolver* styleResolver = document()->styleResolverIfExists();
1657     if (styleResolver && attached())
1658         styleResolver->pushParentElement(this);
1659 }
1660
1661 void Element::finishParsingChildren()
1662 {
1663     ContainerNode::finishParsingChildren();
1664     setIsParsingChildrenFinished();
1665     checkForSiblingStyleChanges(this, renderStyle(), true, lastChild(), 0, 0);
1666     if (StyleResolver* styleResolver = document()->styleResolverIfExists())
1667         styleResolver->popParentElement(this);
1668 }
1669
1670 #ifndef NDEBUG
1671 void Element::formatForDebugger(char* buffer, unsigned length) const
1672 {
1673     StringBuilder result;
1674     String s;
1675
1676     result.append(nodeName());
1677
1678     s = getIdAttribute();
1679     if (s.length() > 0) {
1680         if (result.length() > 0)
1681             result.appendLiteral("; ");
1682         result.appendLiteral("id=");
1683         result.append(s);
1684     }
1685
1686     s = getAttribute(classAttr);
1687     if (s.length() > 0) {
1688         if (result.length() > 0)
1689             result.appendLiteral("; ");
1690         result.appendLiteral("class=");
1691         result.append(s);
1692     }
1693
1694     strncpy(buffer, result.toString().utf8().data(), length - 1);
1695 }
1696 #endif
1697
1698 const Vector<RefPtr<Attr> >& Element::attrNodeList()
1699 {
1700     ASSERT(hasSyntheticAttrChildNodes());
1701     return *attrNodeListForElement(this);
1702 }
1703
1704 PassRefPtr<Attr> Element::setAttributeNode(Attr* attrNode, ExceptionCode& ec)
1705 {
1706     if (!attrNode) {
1707         ec = TYPE_MISMATCH_ERR;
1708         return 0;
1709     }
1710
1711     RefPtr<Attr> oldAttrNode = attrIfExists(attrNode->qualifiedName());
1712     if (oldAttrNode.get() == attrNode)
1713         return attrNode; // This Attr is already attached to the element.
1714
1715     // INUSE_ATTRIBUTE_ERR: Raised if node is an Attr that is already an attribute of another Element object.
1716     // The DOM user must explicitly clone Attr nodes to re-use them in other elements.
1717     if (attrNode->ownerElement()) {
1718         ec = INUSE_ATTRIBUTE_ERR;
1719         return 0;
1720     }
1721
1722     synchronizeAllAttributes();
1723     UniqueElementData* elementData = ensureUniqueElementData();
1724
1725     size_t index = elementData->getAttributeItemIndex(attrNode->qualifiedName());
1726     if (index != notFound) {
1727         if (oldAttrNode)
1728             detachAttrNodeFromElementWithValue(oldAttrNode.get(), elementData->attributeItem(index)->value());
1729         else
1730             oldAttrNode = Attr::create(document(), attrNode->qualifiedName(), elementData->attributeItem(index)->value());
1731     }
1732
1733     setAttributeInternal(index, attrNode->qualifiedName(), attrNode->value(), NotInSynchronizationOfLazyAttribute);
1734
1735     attrNode->attachToElement(this);
1736     ensureAttrNodeListForElement(this)->append(attrNode);
1737
1738     return oldAttrNode.release();
1739 }
1740
1741 PassRefPtr<Attr> Element::setAttributeNodeNS(Attr* attr, ExceptionCode& ec)
1742 {
1743     return setAttributeNode(attr, ec);
1744 }
1745
1746 PassRefPtr<Attr> Element::removeAttributeNode(Attr* attr, ExceptionCode& ec)
1747 {
1748     if (!attr) {
1749         ec = TYPE_MISMATCH_ERR;
1750         return 0;
1751     }
1752     if (attr->ownerElement() != this) {
1753         ec = NOT_FOUND_ERR;
1754         return 0;
1755     }
1756
1757     ASSERT(document() == attr->document());
1758
1759     synchronizeAttribute(attr->qualifiedName());
1760
1761     size_t index = elementData()->getAttributeItemIndex(attr->qualifiedName());
1762     if (index == notFound) {
1763         ec = NOT_FOUND_ERR;
1764         return 0;
1765     }
1766
1767     return detachAttribute(index);
1768 }
1769
1770 bool Element::parseAttributeName(QualifiedName& out, const AtomicString& namespaceURI, const AtomicString& qualifiedName, ExceptionCode& ec)
1771 {
1772     String prefix, localName;
1773     if (!Document::parseQualifiedName(qualifiedName, prefix, localName, ec))
1774         return false;
1775     ASSERT(!ec);
1776
1777     QualifiedName qName(prefix, localName, namespaceURI);
1778
1779     if (!Document::hasValidNamespaceForAttributes(qName)) {
1780         ec = NAMESPACE_ERR;
1781         return false;
1782     }
1783
1784     out = qName;
1785     return true;
1786 }
1787
1788 void Element::setAttributeNS(const AtomicString& namespaceURI, const AtomicString& qualifiedName, const AtomicString& value, ExceptionCode& ec)
1789 {
1790     QualifiedName parsedName = anyName;
1791     if (!parseAttributeName(parsedName, namespaceURI, qualifiedName, ec))
1792         return;
1793     setAttribute(parsedName, value);
1794 }
1795
1796 void Element::removeAttributeInternal(size_t index, SynchronizationOfLazyAttribute inSynchronizationOfLazyAttribute)
1797 {
1798     ASSERT_WITH_SECURITY_IMPLICATION(index < attributeCount());
1799
1800     UniqueElementData* elementData = ensureUniqueElementData();
1801
1802     QualifiedName name = elementData->attributeItem(index)->name();
1803     AtomicString valueBeingRemoved = elementData->attributeItem(index)->value();
1804
1805     if (!inSynchronizationOfLazyAttribute) {
1806         if (!valueBeingRemoved.isNull())
1807             willModifyAttribute(name, valueBeingRemoved, nullAtom);
1808     }
1809
1810     if (RefPtr<Attr> attrNode = attrIfExists(name))
1811         detachAttrNodeFromElementWithValue(attrNode.get(), elementData->attributeItem(index)->value());
1812
1813     elementData->removeAttribute(index);
1814
1815     if (!inSynchronizationOfLazyAttribute)
1816         didRemoveAttribute(name);
1817 }
1818
1819 void Element::addAttributeInternal(const QualifiedName& name, const AtomicString& value, SynchronizationOfLazyAttribute inSynchronizationOfLazyAttribute)
1820 {
1821     if (!inSynchronizationOfLazyAttribute)
1822         willModifyAttribute(name, nullAtom, value);
1823     ensureUniqueElementData()->addAttribute(name, value);
1824     if (!inSynchronizationOfLazyAttribute)
1825         didAddAttribute(name, value);
1826 }
1827
1828 void Element::removeAttribute(const AtomicString& name)
1829 {
1830     if (!elementData())
1831         return;
1832
1833     AtomicString localName = shouldIgnoreAttributeCase(this) ? name.lower() : name;
1834     size_t index = elementData()->getAttributeItemIndex(localName, false);
1835     if (index == notFound) {
1836         if (UNLIKELY(localName == styleAttr) && elementData()->m_styleAttributeIsDirty && isStyledElement())
1837             static_cast<StyledElement*>(this)->removeAllInlineStyleProperties();
1838         return;
1839     }
1840
1841     removeAttributeInternal(index, NotInSynchronizationOfLazyAttribute);
1842 }
1843
1844 void Element::removeAttributeNS(const AtomicString& namespaceURI, const AtomicString& localName)
1845 {
1846     removeAttribute(QualifiedName(nullAtom, localName, namespaceURI));
1847 }
1848
1849 PassRefPtr<Attr> Element::getAttributeNode(const AtomicString& localName)
1850 {
1851     if (!elementData())
1852         return 0;
1853     synchronizeAttribute(localName);
1854     const Attribute* attribute = elementData()->getAttributeItem(localName, shouldIgnoreAttributeCase(this));
1855     if (!attribute)
1856         return 0;
1857     return ensureAttr(attribute->name());
1858 }
1859
1860 PassRefPtr<Attr> Element::getAttributeNodeNS(const AtomicString& namespaceURI, const AtomicString& localName)
1861 {
1862     if (!elementData())
1863         return 0;
1864     QualifiedName qName(nullAtom, localName, namespaceURI);
1865     synchronizeAttribute(qName);
1866     const Attribute* attribute = elementData()->getAttributeItem(qName);
1867     if (!attribute)
1868         return 0;
1869     return ensureAttr(attribute->name());
1870 }
1871
1872 bool Element::hasAttribute(const AtomicString& localName) const
1873 {
1874     if (!elementData())
1875         return false;
1876     synchronizeAttribute(localName);
1877     return elementData()->getAttributeItem(shouldIgnoreAttributeCase(this) ? localName.lower() : localName, false);
1878 }
1879
1880 bool Element::hasAttributeNS(const AtomicString& namespaceURI, const AtomicString& localName) const
1881 {
1882     if (!elementData())
1883         return false;
1884     QualifiedName qName(nullAtom, localName, namespaceURI);
1885     synchronizeAttribute(qName);
1886     return elementData()->getAttributeItem(qName);
1887 }
1888
1889 CSSStyleDeclaration *Element::style()
1890 {
1891     return 0;
1892 }
1893
1894 void Element::focus(bool restorePreviousSelection, FocusDirection direction)
1895 {
1896     if (!inDocument())
1897         return;
1898
1899     Document* doc = document();
1900     if (doc->focusedNode() == this)
1901         return;
1902
1903     // If the stylesheets have already been loaded we can reliably check isFocusable.
1904     // If not, we continue and set the focused node on the focus controller below so
1905     // that it can be updated soon after attach. 
1906     if (doc->haveStylesheetsLoaded()) {
1907         doc->updateLayoutIgnorePendingStylesheets();
1908         if (!isFocusable())
1909             return;
1910     }
1911
1912     if (!supportsFocus())
1913         return;
1914
1915     RefPtr<Node> protect;
1916     if (Page* page = doc->page()) {
1917         // Focus and change event handlers can cause us to lose our last ref.
1918         // If a focus event handler changes the focus to a different node it
1919         // does not make sense to continue and update appearence.
1920         protect = this;
1921         if (!page->focusController()->setFocusedNode(this, doc->frame(), direction))
1922             return;
1923     }
1924
1925     // Setting the focused node above might have invalidated the layout due to scripts.
1926     doc->updateLayoutIgnorePendingStylesheets();
1927
1928     if (!isFocusable()) {
1929         ensureElementRareData()->setNeedsFocusAppearanceUpdateSoonAfterAttach(true);
1930         return;
1931     }
1932         
1933     cancelFocusAppearanceUpdate();
1934     updateFocusAppearance(restorePreviousSelection);
1935 }
1936
1937 void Element::updateFocusAppearance(bool /*restorePreviousSelection*/)
1938 {
1939     if (isRootEditableElement()) {
1940         Frame* frame = document()->frame();
1941         if (!frame)
1942             return;
1943         
1944         // When focusing an editable element in an iframe, don't reset the selection if it already contains a selection.
1945         if (this == frame->selection()->rootEditableElement())
1946             return;
1947
1948         // FIXME: We should restore the previous selection if there is one.
1949         VisibleSelection newSelection = VisibleSelection(firstPositionInOrBeforeNode(this), DOWNSTREAM);
1950         
1951         if (frame->selection()->shouldChangeSelection(newSelection)) {
1952             frame->selection()->setSelection(newSelection);
1953             frame->selection()->revealSelection();
1954         }
1955     } else if (renderer() && !renderer()->isWidget())
1956         renderer()->scrollRectToVisible(boundingBox());
1957 }
1958
1959 void Element::blur()
1960 {
1961     cancelFocusAppearanceUpdate();
1962     Document* doc = document();
1963     if (treeScope()->focusedNode() == this) {
1964         if (doc->frame())
1965             doc->frame()->page()->focusController()->setFocusedNode(0, doc->frame());
1966         else
1967             doc->setFocusedNode(0);
1968     }
1969 }
1970
1971 String Element::innerText()
1972 {
1973     // We need to update layout, since plainText uses line boxes in the render tree.
1974     document()->updateLayoutIgnorePendingStylesheets();
1975
1976     if (!renderer())
1977         return textContent(true);
1978
1979     return plainText(rangeOfContents(const_cast<Element*>(this)).get());
1980 }
1981
1982 String Element::outerText()
1983 {
1984     // Getting outerText is the same as getting innerText, only
1985     // setting is different. You would think this should get the plain
1986     // text for the outer range, but this is wrong, <br> for instance
1987     // would return different values for inner and outer text by such
1988     // a rule, but it doesn't in WinIE, and we want to match that.
1989     return innerText();
1990 }
1991
1992 String Element::title() const
1993 {
1994     return String();
1995 }
1996
1997 const AtomicString& Element::pseudo() const
1998 {
1999     return getAttribute(pseudoAttr);
2000 }
2001
2002 void Element::setPseudo(const AtomicString& value)
2003 {
2004     setAttribute(pseudoAttr, value);
2005 }
2006
2007 LayoutSize Element::minimumSizeForResizing() const
2008 {
2009     return hasRareData() ? elementRareData()->minimumSizeForResizing() : defaultMinimumSizeForResizing();
2010 }
2011
2012 void Element::setMinimumSizeForResizing(const LayoutSize& size)
2013 {
2014     if (!hasRareData() && size == defaultMinimumSizeForResizing())
2015         return;
2016     ensureElementRareData()->setMinimumSizeForResizing(size);
2017 }
2018
2019 RenderStyle* Element::computedStyle(PseudoId pseudoElementSpecifier)
2020 {
2021     if (PseudoElement* element = pseudoElement(pseudoElementSpecifier))
2022         return element->computedStyle();
2023
2024     // FIXME: Find and use the renderer from the pseudo element instead of the actual element so that the 'length'
2025     // properties, which are only known by the renderer because it did the layout, will be correct and so that the
2026     // values returned for the ":selection" pseudo-element will be correct.
2027     if (RenderStyle* usedStyle = renderStyle()) {
2028         if (pseudoElementSpecifier) {
2029             RenderStyle* cachedPseudoStyle = usedStyle->getCachedPseudoStyle(pseudoElementSpecifier);
2030             return cachedPseudoStyle ? cachedPseudoStyle : usedStyle;
2031          } else
2032             return usedStyle;
2033     }
2034
2035     if (!attached())
2036         // FIXME: Try to do better than this. Ensure that styleForElement() works for elements that are not in the
2037         // document tree and figure out when to destroy the computed style for such elements.
2038         return 0;
2039
2040     ElementRareData* data = ensureElementRareData();
2041     if (!data->computedStyle())
2042         data->setComputedStyle(document()->styleForElementIgnoringPendingStylesheets(this));
2043     return pseudoElementSpecifier ? data->computedStyle()->getCachedPseudoStyle(pseudoElementSpecifier) : data->computedStyle();
2044 }
2045
2046 void Element::setStyleAffectedByEmpty()
2047 {
2048     ensureElementRareData()->setStyleAffectedByEmpty(true);
2049 }
2050
2051 void Element::setChildrenAffectedByHover(bool value)
2052 {
2053     if (value || hasRareData())
2054         ensureElementRareData()->setChildrenAffectedByHover(value);
2055 }
2056
2057 void Element::setChildrenAffectedByActive(bool value)
2058 {
2059     if (value || hasRareData())
2060         ensureElementRareData()->setChildrenAffectedByActive(value);
2061 }
2062
2063 void Element::setChildrenAffectedByDrag(bool value)
2064 {
2065     if (value || hasRareData())
2066         ensureElementRareData()->setChildrenAffectedByDrag(value);
2067 }
2068
2069 void Element::setChildrenAffectedByFirstChildRules()
2070 {
2071     ensureElementRareData()->setChildrenAffectedByFirstChildRules(true);
2072 }
2073
2074 void Element::setChildrenAffectedByLastChildRules()
2075 {
2076     ensureElementRareData()->setChildrenAffectedByLastChildRules(true);
2077 }
2078
2079 void Element::setChildrenAffectedByDirectAdjacentRules()
2080 {
2081     ensureElementRareData()->setChildrenAffectedByDirectAdjacentRules(true);
2082 }
2083
2084 void Element::setChildrenAffectedByForwardPositionalRules()
2085 {
2086     ensureElementRareData()->setChildrenAffectedByForwardPositionalRules(true);
2087 }
2088
2089 void Element::setChildrenAffectedByBackwardPositionalRules()
2090 {
2091     ensureElementRareData()->setChildrenAffectedByBackwardPositionalRules(true);
2092 }
2093
2094 void Element::setChildIndex(unsigned index)
2095 {
2096     ElementRareData* rareData = ensureElementRareData();
2097     if (RenderStyle* style = renderStyle())
2098         style->setUnique();
2099     rareData->setChildIndex(index);
2100 }
2101
2102 bool Element::hasFlagsSetDuringStylingOfChildren() const
2103 {
2104     if (!hasRareData())
2105         return false;
2106     return rareDataChildrenAffectedByHover()
2107         || rareDataChildrenAffectedByActive()
2108         || rareDataChildrenAffectedByDrag()
2109         || rareDataChildrenAffectedByFirstChildRules()
2110         || rareDataChildrenAffectedByLastChildRules()
2111         || rareDataChildrenAffectedByDirectAdjacentRules()
2112         || rareDataChildrenAffectedByForwardPositionalRules()
2113         || rareDataChildrenAffectedByBackwardPositionalRules();
2114 }
2115
2116 bool Element::rareDataStyleAffectedByEmpty() const
2117 {
2118     ASSERT(hasRareData());
2119     return elementRareData()->styleAffectedByEmpty();
2120 }
2121
2122 bool Element::rareDataChildrenAffectedByHover() const
2123 {
2124     ASSERT(hasRareData());
2125     return elementRareData()->childrenAffectedByHover();
2126 }
2127
2128 bool Element::rareDataChildrenAffectedByActive() const
2129 {
2130     ASSERT(hasRareData());
2131     return elementRareData()->childrenAffectedByActive();
2132 }
2133
2134 bool Element::rareDataChildrenAffectedByDrag() const
2135 {
2136     ASSERT(hasRareData());
2137     return elementRareData()->childrenAffectedByDrag();
2138 }
2139
2140 bool Element::rareDataChildrenAffectedByFirstChildRules() const
2141 {
2142     ASSERT(hasRareData());
2143     return elementRareData()->childrenAffectedByFirstChildRules();
2144 }
2145
2146 bool Element::rareDataChildrenAffectedByLastChildRules() const
2147 {
2148     ASSERT(hasRareData());
2149     return elementRareData()->childrenAffectedByLastChildRules();
2150 }
2151
2152 bool Element::rareDataChildrenAffectedByDirectAdjacentRules() const
2153 {
2154     ASSERT(hasRareData());
2155     return elementRareData()->childrenAffectedByDirectAdjacentRules();
2156 }
2157
2158 bool Element::rareDataChildrenAffectedByForwardPositionalRules() const
2159 {
2160     ASSERT(hasRareData());
2161     return elementRareData()->childrenAffectedByForwardPositionalRules();
2162 }
2163
2164 bool Element::rareDataChildrenAffectedByBackwardPositionalRules() const
2165 {
2166     ASSERT(hasRareData());
2167     return elementRareData()->childrenAffectedByBackwardPositionalRules();
2168 }
2169
2170 unsigned Element::rareDataChildIndex() const
2171 {
2172     ASSERT(hasRareData());
2173     return elementRareData()->childIndex();
2174 }
2175
2176 void Element::setIsInCanvasSubtree(bool isInCanvasSubtree)
2177 {
2178     ensureElementRareData()->setIsInCanvasSubtree(isInCanvasSubtree);
2179 }
2180
2181 bool Element::isInCanvasSubtree() const
2182 {
2183     return hasRareData() && elementRareData()->isInCanvasSubtree();
2184 }
2185
2186 AtomicString Element::computeInheritedLanguage() const
2187 {
2188     const Node* n = this;
2189     AtomicString value;
2190     // The language property is inherited, so we iterate over the parents to find the first language.
2191     do {
2192         if (n->isElementNode()) {
2193             if (const ElementData* elementData = static_cast<const Element*>(n)->elementData()) {
2194                 // Spec: xml:lang takes precedence -- http://www.w3.org/TR/xhtml1/#C_7
2195                 if (const Attribute* attribute = elementData->getAttributeItem(XMLNames::langAttr))
2196                     value = attribute->value();
2197                 else if (const Attribute* attribute = elementData->getAttributeItem(HTMLNames::langAttr))
2198                     value = attribute->value();
2199             }
2200         } else if (n->isDocumentNode()) {
2201             // checking the MIME content-language
2202             value = static_cast<const Document*>(n)->contentLanguage();
2203         }
2204
2205         n = n->parentNode();
2206     } while (n && value.isNull());
2207
2208     return value;
2209 }
2210
2211 Locale& Element::locale() const
2212 {
2213     return document()->getCachedLocale(computeInheritedLanguage());
2214 }
2215
2216 void Element::cancelFocusAppearanceUpdate()
2217 {
2218     if (hasRareData())
2219         elementRareData()->setNeedsFocusAppearanceUpdateSoonAfterAttach(false);
2220     if (document()->focusedNode() == this)
2221         document()->cancelFocusAppearanceUpdate();
2222 }
2223
2224 void Element::normalizeAttributes()
2225 {
2226     if (!hasAttributes())
2227         return;
2228     for (unsigned i = 0; i < attributeCount(); ++i) {
2229         if (RefPtr<Attr> attr = attrIfExists(attributeItem(i)->name()))
2230             attr->normalize();
2231     }
2232 }
2233
2234 void Element::updatePseudoElement(PseudoId pseudoId, StyleChange change)
2235 {
2236     PseudoElement* existing = pseudoElement(pseudoId);
2237     if (existing) {
2238         // PseudoElement styles hang off their parent element's style so if we needed
2239         // a style recalc we should Force one on the pseudo.
2240         existing->recalcStyle(needsStyleRecalc() ? Force : change);
2241
2242         // Wait until our parent is not displayed or pseudoElementRendererIsNeeded
2243         // is false, otherwise we could continously create and destroy PseudoElements
2244         // when RenderObject::isChildAllowed on our parent returns false for the
2245         // PseudoElement's renderer for each style recalc.
2246         if (!renderer() || !pseudoElementRendererIsNeeded(renderer()->getCachedPseudoStyle(pseudoId)))
2247             setPseudoElement(pseudoId, 0);
2248     } else if (RefPtr<PseudoElement> element = createPseudoElementIfNeeded(pseudoId)) {
2249         element->attach();
2250         setPseudoElement(pseudoId, element.release());
2251     }
2252 }
2253
2254 PassRefPtr<PseudoElement> Element::createPseudoElementIfNeeded(PseudoId pseudoId)
2255 {
2256     if (!document()->styleSheetCollection()->usesBeforeAfterRules())
2257         return 0;
2258
2259     if (!renderer() || !renderer()->canHaveGeneratedChildren())
2260         return 0;
2261
2262     if (isPseudoElement())
2263         return 0;
2264
2265     if (!pseudoElementRendererIsNeeded(renderer()->getCachedPseudoStyle(pseudoId)))
2266         return 0;
2267
2268     return PseudoElement::create(this, pseudoId);
2269 }
2270
2271 bool Element::hasPseudoElements() const
2272 {
2273     return hasRareData() && elementRareData()->hasPseudoElements();
2274 }
2275
2276 PseudoElement* Element::pseudoElement(PseudoId pseudoId) const
2277 {
2278     return hasRareData() ? elementRareData()->pseudoElement(pseudoId) : 0;
2279 }
2280
2281 void Element::setPseudoElement(PseudoId pseudoId, PassRefPtr<PseudoElement> element)
2282 {
2283     ensureElementRareData()->setPseudoElement(pseudoId, element);
2284     resetNeedsShadowTreeWalker();
2285 }
2286
2287 RenderObject* Element::pseudoElementRenderer(PseudoId pseudoId) const
2288 {
2289     if (PseudoElement* element = pseudoElement(pseudoId))
2290         return element->renderer();
2291     return 0;
2292 }
2293
2294 // ElementTraversal API
2295 Element* Element::firstElementChild() const
2296 {
2297     return ElementTraversal::firstWithin(this);
2298 }
2299
2300 Element* Element::lastElementChild() const
2301 {
2302     Node* n = lastChild();
2303     while (n && !n->isElementNode())
2304         n = n->previousSibling();
2305     return static_cast<Element*>(n);
2306 }
2307
2308 unsigned Element::childElementCount() const
2309 {
2310     unsigned count = 0;
2311     Node* n = firstChild();
2312     while (n) {
2313         count += n->isElementNode();
2314         n = n->nextSibling();
2315     }
2316     return count;
2317 }
2318
2319 bool Element::matchesReadOnlyPseudoClass() const
2320 {
2321     return false;
2322 }
2323
2324 bool Element::matchesReadWritePseudoClass() const
2325 {
2326     return false;
2327 }
2328
2329 bool Element::webkitMatchesSelector(const String& selector, ExceptionCode& ec)
2330 {
2331     if (selector.isEmpty()) {
2332         ec = SYNTAX_ERR;
2333         return false;
2334     }
2335
2336     SelectorQuery* selectorQuery = document()->selectorQueryCache()->add(selector, document(), ec);
2337     if (!selectorQuery)
2338         return false;
2339     return selectorQuery->matches(this);
2340 }
2341
2342 DOMTokenList* Element::classList()
2343 {
2344     ElementRareData* data = ensureElementRareData();
2345     if (!data->classList())
2346         data->setClassList(ClassList::create(this));
2347     return data->classList();
2348 }
2349
2350 DOMStringMap* Element::dataset()
2351 {
2352     ElementRareData* data = ensureElementRareData();
2353     if (!data->dataset())
2354         data->setDataset(DatasetDOMStringMap::create(this));
2355     return data->dataset();
2356 }
2357
2358 KURL Element::getURLAttribute(const QualifiedName& name) const
2359 {
2360 #if !ASSERT_DISABLED
2361     if (elementData()) {
2362         if (const Attribute* attribute = getAttributeItem(name))
2363             ASSERT(isURLAttribute(*attribute));
2364     }
2365 #endif
2366     return document()->completeURL(stripLeadingAndTrailingHTMLSpaces(getAttribute(name)));
2367 }
2368
2369 KURL Element::getNonEmptyURLAttribute(const QualifiedName& name) const
2370 {
2371 #if !ASSERT_DISABLED
2372     if (elementData()) {
2373         if (const Attribute* attribute = getAttributeItem(name))
2374             ASSERT(isURLAttribute(*attribute));
2375     }
2376 #endif
2377     String value = stripLeadingAndTrailingHTMLSpaces(getAttribute(name));
2378     if (value.isEmpty())
2379         return KURL();
2380     return document()->completeURL(value);
2381 }
2382
2383 int Element::getIntegralAttribute(const QualifiedName& attributeName) const
2384 {
2385     return getAttribute(attributeName).string().toInt();
2386 }
2387
2388 void Element::setIntegralAttribute(const QualifiedName& attributeName, int value)
2389 {
2390     // FIXME: Need an AtomicString version of String::number.
2391     setAttribute(attributeName, String::number(value));
2392 }
2393
2394 unsigned Element::getUnsignedIntegralAttribute(const QualifiedName& attributeName) const
2395 {
2396     return getAttribute(attributeName).string().toUInt();
2397 }
2398
2399 void Element::setUnsignedIntegralAttribute(const QualifiedName& attributeName, unsigned value)
2400 {
2401     // FIXME: Need an AtomicString version of String::number.
2402     setAttribute(attributeName, String::number(value));
2403 }
2404
2405 #if ENABLE(SVG)
2406 bool Element::childShouldCreateRenderer(const NodeRenderingContext& childContext) const
2407 {
2408     // Only create renderers for SVG elements whose parents are SVG elements, or for proper <svg xmlns="svgNS"> subdocuments.
2409     if (childContext.node()->isSVGElement())
2410         return childContext.node()->hasTagName(SVGNames::svgTag) || isSVGElement();
2411
2412     return ContainerNode::childShouldCreateRenderer(childContext);
2413 }
2414 #endif
2415
2416 #if ENABLE(FULLSCREEN_API)
2417 void Element::webkitRequestFullscreen()
2418 {
2419     document()->requestFullScreenForElement(this, ALLOW_KEYBOARD_INPUT, Document::EnforceIFrameAllowFullScreenRequirement);
2420 }
2421
2422 void Element::webkitRequestFullScreen(unsigned short flags)
2423 {
2424     document()->requestFullScreenForElement(this, (flags | LEGACY_MOZILLA_REQUEST), Document::EnforceIFrameAllowFullScreenRequirement);
2425 }
2426
2427 bool Element::containsFullScreenElement() const
2428 {
2429     return hasRareData() && elementRareData()->containsFullScreenElement();
2430 }
2431
2432 void Element::setContainsFullScreenElement(bool flag)
2433 {
2434     ensureElementRareData()->setContainsFullScreenElement(flag);
2435     setNeedsStyleRecalc(SyntheticStyleChange);
2436 }
2437
2438 static Element* parentCrossingFrameBoundaries(Element* element)
2439 {
2440     ASSERT(element);
2441     return element->parentElement() ? element->parentElement() : element->document()->ownerElement();
2442 }
2443
2444 void Element::setContainsFullScreenElementOnAncestorsCrossingFrameBoundaries(bool flag)
2445 {
2446     Element* element = this;
2447     while ((element = parentCrossingFrameBoundaries(element)))
2448         element->setContainsFullScreenElement(flag);
2449 }
2450 #endif    
2451
2452 #if ENABLE(DIALOG_ELEMENT)
2453 bool Element::isInTopLayer() const
2454 {
2455     return hasRareData() && elementRareData()->isInTopLayer();
2456 }
2457
2458 void Element::setIsInTopLayer(bool inTopLayer)
2459 {
2460     if (isInTopLayer() == inTopLayer)
2461         return;
2462     ensureElementRareData()->setIsInTopLayer(inTopLayer);
2463
2464     // We must ensure a reattach occurs so the renderer is inserted in the correct sibling order under RenderView according to its
2465     // top layer position, or in its usual place if not in the top layer.
2466     reattachIfAttached();
2467 }
2468 #endif
2469
2470 #if ENABLE(POINTER_LOCK)
2471 void Element::webkitRequestPointerLock()
2472 {
2473     if (document()->page())
2474         document()->page()->pointerLockController()->requestPointerLock(this);
2475 }
2476 #endif
2477
2478 SpellcheckAttributeState Element::spellcheckAttributeState() const
2479 {
2480     const AtomicString& value = getAttribute(HTMLNames::spellcheckAttr);
2481     if (value == nullAtom)
2482         return SpellcheckAttributeDefault;
2483     if (equalIgnoringCase(value, "true") || equalIgnoringCase(value, ""))
2484         return SpellcheckAttributeTrue;
2485     if (equalIgnoringCase(value, "false"))
2486         return SpellcheckAttributeFalse;
2487
2488     return SpellcheckAttributeDefault;
2489 }
2490
2491 bool Element::isSpellCheckingEnabled() const
2492 {
2493     for (const Element* element = this; element; element = element->parentOrShadowHostElement()) {
2494         switch (element->spellcheckAttributeState()) {
2495         case SpellcheckAttributeTrue:
2496             return true;
2497         case SpellcheckAttributeFalse:
2498             return false;
2499         case SpellcheckAttributeDefault:
2500             break;
2501         }
2502     }
2503
2504     return true;
2505 }
2506
2507 RenderRegion* Element::renderRegion() const
2508 {
2509     if (renderer() && renderer()->isRenderRegion())
2510         return toRenderRegion(renderer());
2511
2512     return 0;
2513 }
2514
2515 #if ENABLE(CSS_REGIONS)
2516
2517 const AtomicString& Element::webkitRegionOverset() const
2518 {
2519     document()->updateLayoutIgnorePendingStylesheets();
2520
2521     DEFINE_STATIC_LOCAL(AtomicString, undefinedState, ("undefined", AtomicString::ConstructFromLiteral));
2522     if (!document()->cssRegionsEnabled() || !renderRegion())
2523         return undefinedState;
2524
2525     switch (renderRegion()->regionState()) {
2526     case RenderRegion::RegionFit: {
2527         DEFINE_STATIC_LOCAL(AtomicString, fitState, ("fit", AtomicString::ConstructFromLiteral));
2528         return fitState;
2529     }
2530     case RenderRegion::RegionEmpty: {
2531         DEFINE_STATIC_LOCAL(AtomicString, emptyState, ("empty", AtomicString::ConstructFromLiteral));
2532         return emptyState;
2533     }
2534     case RenderRegion::RegionOverset: {
2535         DEFINE_STATIC_LOCAL(AtomicString, overflowState, ("overset", AtomicString::ConstructFromLiteral));
2536         return overflowState;
2537     }
2538     case RenderRegion::RegionUndefined:
2539         return undefinedState;
2540     }
2541
2542     ASSERT_NOT_REACHED();
2543     return undefinedState;
2544 }
2545
2546 Vector<RefPtr<Range> > Element::webkitGetRegionFlowRanges() const
2547 {
2548     document()->updateLayoutIgnorePendingStylesheets();
2549
2550     Vector<RefPtr<Range> > rangeObjects;
2551     if (document()->cssRegionsEnabled() && renderer() && renderer()->isRenderRegion()) {
2552         RenderRegion* region = toRenderRegion(renderer());
2553         if (region->isValid())
2554             region->getRanges(rangeObjects);
2555     }
2556
2557     return rangeObjects;
2558 }
2559
2560 #endif
2561
2562 #ifndef NDEBUG
2563 bool Element::fastAttributeLookupAllowed(const QualifiedName& name) const
2564 {
2565     if (name == HTMLNames::styleAttr)
2566         return false;
2567
2568 #if ENABLE(SVG)
2569     if (isSVGElement())
2570         return !static_cast<const SVGElement*>(this)->isAnimatableAttribute(name);
2571 #endif
2572
2573     return true;
2574 }
2575 #endif
2576
2577 #ifdef DUMP_NODE_STATISTICS
2578 bool Element::hasNamedNodeMap() const
2579 {
2580     return hasRareData() && elementRareData()->attributeMap();
2581 }
2582 #endif
2583
2584 inline void Element::updateName(const AtomicString& oldName, const AtomicString& newName)
2585 {
2586     if (!inDocument() || isInShadowTree())
2587         return;
2588
2589     if (oldName == newName)
2590         return;
2591
2592     if (shouldRegisterAsNamedItem())
2593         updateNamedItemRegistration(oldName, newName);
2594 }
2595
2596 inline void Element::updateId(const AtomicString& oldId, const AtomicString& newId)
2597 {
2598     if (!isInTreeScope())
2599         return;
2600
2601     if (oldId == newId)
2602         return;
2603
2604     updateId(treeScope(), oldId, newId);
2605 }
2606
2607 inline void Element::updateId(TreeScope* scope, const AtomicString& oldId, const AtomicString& newId)
2608 {
2609     ASSERT(isInTreeScope());
2610     ASSERT(oldId != newId);
2611
2612     if (!oldId.isEmpty())
2613         scope->removeElementById(oldId, this);
2614     if (!newId.isEmpty())
2615         scope->addElementById(newId, this);
2616
2617     if (shouldRegisterAsExtraNamedItem())
2618         updateExtraNamedItemRegistration(oldId, newId);
2619 }
2620
2621 void Element::updateLabel(TreeScope* scope, const AtomicString& oldForAttributeValue, const AtomicString& newForAttributeValue)
2622 {
2623     ASSERT(hasTagName(labelTag));
2624
2625     if (!inDocument())
2626         return;
2627
2628     if (oldForAttributeValue == newForAttributeValue)
2629         return;
2630
2631     if (!oldForAttributeValue.isEmpty())
2632         scope->removeLabel(oldForAttributeValue, static_cast<HTMLLabelElement*>(this));
2633     if (!newForAttributeValue.isEmpty())
2634         scope->addLabel(newForAttributeValue, static_cast<HTMLLabelElement*>(this));
2635 }
2636
2637 void Element::willModifyAttribute(const QualifiedName& name, const AtomicString& oldValue, const AtomicString& newValue)
2638 {
2639     if (isIdAttributeName(name))
2640         updateId(oldValue, newValue);
2641     else if (name == HTMLNames::nameAttr)
2642         updateName(oldValue, newValue);
2643     else if (name == HTMLNames::forAttr && hasTagName(labelTag)) {
2644         TreeScope* scope = treeScope();
2645         if (scope->shouldCacheLabelsByForAttribute())
2646             updateLabel(scope, oldValue, newValue);
2647     }
2648
2649     if (OwnPtr<MutationObserverInterestGroup> recipients = MutationObserverInterestGroup::createForAttributesMutation(this, name))
2650         recipients->enqueueMutationRecord(MutationRecord::createAttributes(this, name, oldValue));
2651
2652 #if ENABLE(INSPECTOR)
2653     InspectorInstrumentation::willModifyDOMAttr(document(), this, oldValue, newValue);
2654 #endif
2655 }
2656
2657 void Element::didAddAttribute(const QualifiedName& name, const AtomicString& value)
2658 {
2659     attributeChanged(name, value);
2660     InspectorInstrumentation::didModifyDOMAttr(document(), this, name.localName(), value);
2661     dispatchSubtreeModifiedEvent();
2662 }
2663
2664 void Element::didModifyAttribute(const QualifiedName& name, const AtomicString& value)
2665 {
2666     attributeChanged(name, value);
2667     InspectorInstrumentation::didModifyDOMAttr(document(), this, name.localName(), value);
2668     // Do not dispatch a DOMSubtreeModified event here; see bug 81141.
2669 }
2670
2671 void Element::didRemoveAttribute(const QualifiedName& name)
2672 {
2673     attributeChanged(name, nullAtom);
2674     InspectorInstrumentation::didRemoveDOMAttr(document(), this, name.localName());
2675     dispatchSubtreeModifiedEvent();
2676 }
2677
2678
2679 void Element::updateNamedItemRegistration(const AtomicString& oldName, const AtomicString& newName)
2680 {
2681     if (!document()->isHTMLDocument())
2682         return;
2683
2684     if (!oldName.isEmpty())
2685         static_cast<HTMLDocument*>(document())->removeNamedItem(oldName);
2686
2687     if (!newName.isEmpty())
2688         static_cast<HTMLDocument*>(document())->addNamedItem(newName);
2689 }
2690
2691 void Element::updateExtraNamedItemRegistration(const AtomicString& oldId, const AtomicString& newId)
2692 {
2693     if (!document()->isHTMLDocument())
2694         return;
2695
2696     if (!oldId.isEmpty())
2697         static_cast<HTMLDocument*>(document())->removeExtraNamedItem(oldId);
2698
2699     if (!newId.isEmpty())
2700         static_cast<HTMLDocument*>(document())->addExtraNamedItem(newId);
2701 }
2702
2703 PassRefPtr<HTMLCollection> Element::ensureCachedHTMLCollection(CollectionType type)
2704 {
2705     if (HTMLCollection* collection = cachedHTMLCollection(type))
2706         return collection;
2707
2708     RefPtr<HTMLCollection> collection;
2709     if (type == TableRows) {
2710         ASSERT(hasTagName(tableTag));
2711         return ensureRareData()->ensureNodeLists()->addCacheWithAtomicName<HTMLTableRowsCollection>(this, type);
2712     } else if (type == SelectOptions) {
2713         ASSERT(hasTagName(selectTag));
2714         return ensureRareData()->ensureNodeLists()->addCacheWithAtomicName<HTMLOptionsCollection>(this, type);
2715     } else if (type == FormControls) {
2716         ASSERT(hasTagName(formTag) || hasTagName(fieldsetTag));
2717         return ensureRareData()->ensureNodeLists()->addCacheWithAtomicName<HTMLFormControlsCollection>(this, type);
2718 #if ENABLE(MICRODATA)
2719     } else if (type == ItemProperties) {
2720         return ensureRareData()->ensureNodeLists()->addCacheWithAtomicName<HTMLPropertiesCollection>(this, type);
2721 #endif
2722     }
2723     return ensureRareData()->ensureNodeLists()->addCacheWithAtomicName<HTMLCollection>(this, type);
2724 }
2725
2726 HTMLCollection* Element::cachedHTMLCollection(CollectionType type)
2727 {
2728     return hasRareData() && rareData()->nodeLists() ? rareData()->nodeLists()->cacheWithAtomicName<HTMLCollection>(type) : 0;
2729 }
2730
2731 IntSize Element::savedLayerScrollOffset() const
2732 {
2733     return hasRareData() ? elementRareData()->savedLayerScrollOffset() : IntSize();
2734 }
2735
2736 void Element::setSavedLayerScrollOffset(const IntSize& size)
2737 {
2738     if (size.isZero() && !hasRareData())
2739         return;
2740     ensureElementRareData()->setSavedLayerScrollOffset(size);
2741 }
2742
2743 PassRefPtr<Attr> Element::attrIfExists(const QualifiedName& name)
2744 {
2745     if (AttrNodeList* attrNodeList = attrNodeListForElement(this))
2746         return findAttrNodeInList(attrNodeList, name);
2747     return 0;
2748 }
2749
2750 PassRefPtr<Attr> Element::ensureAttr(const QualifiedName& name)
2751 {
2752     AttrNodeList* attrNodeList = ensureAttrNodeListForElement(this);
2753     RefPtr<Attr> attrNode = findAttrNodeInList(attrNodeList, name);
2754     if (!attrNode) {
2755         attrNode = Attr::create(this, name);
2756         treeScope()->adoptIfNeeded(attrNode.get());
2757         attrNodeList->append(attrNode);
2758     }
2759     return attrNode.release();
2760 }
2761
2762 void Element::detachAttrNodeFromElementWithValue(Attr* attrNode, const AtomicString& value)
2763 {
2764     ASSERT(hasSyntheticAttrChildNodes());
2765     attrNode->detachFromElementWithValue(value);
2766
2767     AttrNodeList* attrNodeList = attrNodeListForElement(this);
2768     for (unsigned i = 0; i < attrNodeList->size(); ++i) {
2769         if (attrNodeList->at(i)->qualifiedName() == attrNode->qualifiedName()) {
2770             attrNodeList->remove(i);
2771             if (attrNodeList->isEmpty())
2772                 removeAttrNodeListForElement(this);
2773             return;
2774         }
2775     }
2776     ASSERT_NOT_REACHED();
2777 }
2778
2779 void Element::detachAllAttrNodesFromElement()
2780 {
2781     AttrNodeList* attrNodeList = attrNodeListForElement(this);
2782     ASSERT(attrNodeList);
2783
2784     for (unsigned i = 0; i < attributeCount(); ++i) {
2785         const Attribute* attribute = attributeItem(i);
2786         if (RefPtr<Attr> attrNode = findAttrNodeInList(attrNodeList, attribute->name()))
2787             attrNode->detachFromElementWithValue(attribute->value());
2788     }
2789
2790     removeAttrNodeListForElement(this);
2791 }
2792
2793 bool Element::willRecalcStyle(StyleChange)
2794 {
2795     ASSERT(hasCustomStyleCallbacks());
2796     return true;
2797 }
2798
2799 void Element::didRecalcStyle(StyleChange)
2800 {
2801     ASSERT(hasCustomStyleCallbacks());
2802 }
2803
2804
2805 PassRefPtr<RenderStyle> Element::customStyleForRenderer()
2806 {
2807     ASSERT(hasCustomStyleCallbacks());
2808     return 0;
2809 }
2810
2811 void Element::cloneAttributesFromElement(const Element& other)
2812 {
2813     if (hasSyntheticAttrChildNodes())
2814         detachAllAttrNodesFromElement();
2815
2816     other.synchronizeAllAttributes();
2817     if (!other.m_elementData) {
2818         m_elementData.clear();
2819         return;
2820     }
2821
2822     const AtomicString& oldID = getIdAttribute();
2823     const AtomicString& newID = other.getIdAttribute();
2824
2825     if (!oldID.isNull() || !newID.isNull())
2826         updateId(oldID, newID);
2827
2828     const AtomicString& oldName = getNameAttribute();
2829     const AtomicString& newName = other.getNameAttribute();
2830
2831     if (!oldName.isNull() || !newName.isNull())
2832         updateName(oldName, newName);
2833
2834     // If 'other' has a mutable ElementData, convert it to an immutable one so we can share it between both elements.
2835     // We can only do this if there is no CSSOM wrapper for other's inline style, and there are no presentation attributes.
2836     if (other.m_elementData->isUnique()
2837         && !other.m_elementData->presentationAttributeStyle()
2838         && (!other.m_elementData->inlineStyle() || !other.m_elementData->inlineStyle()->hasCSSOMWrapper()))
2839         const_cast<Element&>(other).m_elementData = static_cast<const UniqueElementData*>(other.m_elementData.get())->makeShareableCopy();
2840
2841     if (!other.m_elementData->isUnique())
2842         m_elementData = other.m_elementData;
2843     else
2844         m_elementData = other.m_elementData->makeUniqueCopy();
2845
2846     for (unsigned i = 0; i < m_elementData->length(); ++i) {
2847         const Attribute* attribute = const_cast<const ElementData*>(m_elementData.get())->attributeItem(i);
2848         attributeChanged(attribute->name(), attribute->value());
2849     }
2850 }
2851
2852 void Element::cloneDataFromElement(const Element& other)
2853 {
2854     cloneAttributesFromElement(other);
2855     copyNonAttributePropertiesFromElement(other);
2856 }
2857
2858 void Element::createUniqueElementData()
2859 {
2860     if (!m_elementData)
2861         m_elementData = UniqueElementData::create();
2862     else {
2863         ASSERT(!m_elementData->isUnique());
2864         m_elementData = static_cast<ShareableElementData*>(m_elementData.get())->makeUniqueCopy();
2865     }
2866 }
2867
2868 void Element::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
2869 {
2870     MemoryClassInfo info(memoryObjectInfo, this, WebCoreMemoryTypes::DOM);
2871     ContainerNode::reportMemoryUsage(memoryObjectInfo);
2872     info.addMember(m_tagName, "tagName");
2873     info.addMember(m_elementData, "elementData");
2874 }
2875
2876 #if ENABLE(SVG)
2877 bool Element::hasPendingResources() const
2878 {
2879     return hasRareData() && elementRareData()->hasPendingResources();
2880 }
2881
2882 void Element::setHasPendingResources()
2883 {
2884     ensureElementRareData()->setHasPendingResources(true);
2885 }
2886
2887 void Element::clearHasPendingResources()
2888 {
2889     ensureElementRareData()->setHasPendingResources(false);
2890 }
2891 #endif
2892
2893 void ElementData::deref()
2894 {
2895     if (!derefBase())
2896         return;
2897
2898     if (m_isUnique)
2899         delete static_cast<UniqueElementData*>(this);
2900     else
2901         delete static_cast<ShareableElementData*>(this);
2902 }
2903
2904 ElementData::ElementData()
2905     : m_isUnique(true)
2906     , m_arraySize(0)
2907     , m_presentationAttributeStyleIsDirty(false)
2908     , m_styleAttributeIsDirty(false)
2909 #if ENABLE(SVG)
2910     , m_animatedSVGAttributesAreDirty(false)
2911 #endif
2912 {
2913 }
2914
2915 ElementData::ElementData(unsigned arraySize)
2916     : m_isUnique(false)
2917     , m_arraySize(arraySize)
2918     , m_presentationAttributeStyleIsDirty(false)
2919     , m_styleAttributeIsDirty(false)
2920 #if ENABLE(SVG)
2921     , m_animatedSVGAttributesAreDirty(false)
2922 #endif
2923 {
2924 }
2925
2926 struct SameSizeAsElementData : public RefCounted<SameSizeAsElementData> {
2927     unsigned bitfield;
2928     void* refPtrs[3];
2929 };
2930
2931 COMPILE_ASSERT(sizeof(ElementData) == sizeof(SameSizeAsElementData), element_attribute_data_should_stay_small);
2932
2933 static size_t sizeForShareableElementDataWithAttributeCount(unsigned count)
2934 {
2935     return sizeof(ShareableElementData) + sizeof(Attribute) * count;
2936 }
2937
2938 PassRefPtr<ShareableElementData> ShareableElementData::createWithAttributes(const Vector<Attribute>& attributes)
2939 {
2940     void* slot = WTF::fastMalloc(sizeForShareableElementDataWithAttributeCount(attributes.size()));
2941     return adoptRef(new (slot) ShareableElementData(attributes));
2942 }
2943
2944 PassRefPtr<UniqueElementData> UniqueElementData::create()
2945 {
2946     return adoptRef(new UniqueElementData);
2947 }
2948
2949 ShareableElementData::ShareableElementData(const Vector<Attribute>& attributes)
2950     : ElementData(attributes.size())
2951 {
2952     for (unsigned i = 0; i < m_arraySize; ++i)
2953         new (&m_attributeArray[i]) Attribute(attributes[i]);
2954 }
2955
2956 ShareableElementData::~ShareableElementData()
2957 {
2958     for (unsigned i = 0; i < m_arraySize; ++i)
2959         m_attributeArray[i].~Attribute();
2960 }
2961
2962 ShareableElementData::ShareableElementData(const UniqueElementData& other)
2963     : ElementData(other, false)
2964 {
2965     ASSERT(!other.m_presentationAttributeStyle);
2966
2967     if (other.m_inlineStyle) {
2968         ASSERT(!other.m_inlineStyle->hasCSSOMWrapper());
2969         m_inlineStyle = other.m_inlineStyle->immutableCopyIfNeeded();
2970     }
2971
2972     for (unsigned i = 0; i < m_arraySize; ++i)
2973         new (&m_attributeArray[i]) Attribute(other.m_attributeVector.at(i));
2974 }
2975
2976 ElementData::ElementData(const ElementData& other, bool isUnique)
2977     : m_isUnique(isUnique)
2978     , m_arraySize(isUnique ? 0 : other.length())
2979     , m_presentationAttributeStyleIsDirty(other.m_presentationAttributeStyleIsDirty)
2980     , m_styleAttributeIsDirty(other.m_styleAttributeIsDirty)
2981 #if ENABLE(SVG)
2982     , m_animatedSVGAttributesAreDirty(other.m_animatedSVGAttributesAreDirty)
2983 #endif
2984     , m_classNames(other.m_classNames)
2985     , m_idForStyleResolution(other.m_idForStyleResolution)
2986 {
2987     // NOTE: The inline style is copied by the subclass copy constructor since we don't know what to do with it here.
2988 }
2989
2990 UniqueElementData::UniqueElementData()
2991 {
2992 }
2993
2994 UniqueElementData::UniqueElementData(const UniqueElementData& other)
2995     : ElementData(other, true)
2996     , m_presentationAttributeStyle(other.m_presentationAttributeStyle)
2997     , m_attributeVector(other.m_attributeVector)
2998 {
2999     m_inlineStyle = other.m_inlineStyle ? other.m_inlineStyle->copy() : 0;
3000 }
3001
3002 UniqueElementData::UniqueElementData(const ShareableElementData& other)
3003     : ElementData(other, true)
3004 {
3005     // An ShareableElementData should never have a mutable inline StylePropertySet attached.
3006     ASSERT(!other.m_inlineStyle || !other.m_inlineStyle->isMutable());
3007     m_inlineStyle = other.m_inlineStyle;
3008
3009     m_attributeVector.reserveCapacity(other.length());
3010     for (unsigned i = 0; i < other.length(); ++i)
3011         m_attributeVector.uncheckedAppend(other.m_attributeArray[i]);
3012 }
3013
3014 PassRefPtr<UniqueElementData> ElementData::makeUniqueCopy() const
3015 {
3016     if (isUnique())
3017         return adoptRef(new UniqueElementData(static_cast<const UniqueElementData&>(*this)));
3018     return adoptRef(new UniqueElementData(static_cast<const ShareableElementData&>(*this)));
3019 }
3020
3021 PassRefPtr<ShareableElementData> UniqueElementData::makeShareableCopy() const
3022 {
3023     void* slot = WTF::fastMalloc(sizeForShareableElementDataWithAttributeCount(m_attributeVector.size()));
3024     return adoptRef(new (slot) ShareableElementData(*this));
3025 }
3026
3027 void UniqueElementData::addAttribute(const QualifiedName& attributeName, const AtomicString& value)
3028 {
3029     m_attributeVector.append(Attribute(attributeName, value));
3030 }
3031
3032 void UniqueElementData::removeAttribute(size_t index)
3033 {
3034     ASSERT_WITH_SECURITY_IMPLICATION(index < length());
3035     m_attributeVector.remove(index);
3036 }
3037
3038 bool ElementData::isEquivalent(const ElementData* other) const
3039 {
3040     if (!other)
3041         return isEmpty();
3042
3043     unsigned len = length();
3044     if (len != other->length())
3045         return false;
3046
3047     for (unsigned i = 0; i < len; i++) {
3048         const Attribute* attribute = attributeItem(i);
3049         const Attribute* otherAttr = other->getAttributeItem(attribute->name());
3050         if (!otherAttr || attribute->value() != otherAttr->value())
3051             return false;
3052     }
3053
3054     return true;
3055 }
3056
3057 void ElementData::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
3058 {
3059     size_t actualSize = m_isUnique ? sizeof(ElementData) : sizeForShareableElementDataWithAttributeCount(m_arraySize);
3060     MemoryClassInfo info(memoryObjectInfo, this, WebCoreMemoryTypes::DOM, actualSize);
3061     info.addMember(m_inlineStyle, "inlineStyle");
3062     info.addMember(m_classNames, "classNames");
3063     info.addMember(m_idForStyleResolution, "idForStyleResolution");
3064     if (m_isUnique) {
3065         const UniqueElementData* uniqueThis = static_cast<const UniqueElementData*>(this);
3066         info.addMember(uniqueThis->m_presentationAttributeStyle, "presentationAttributeStyle");
3067         info.addMember(uniqueThis->m_attributeVector, "attributeVector");
3068     }
3069     for (unsigned i = 0, len = length(); i < len; i++)
3070         info.addMember(*attributeItem(i), "*attributeItem");
3071 }
3072
3073 size_t ElementData::getAttributeItemIndexSlowCase(const AtomicString& name, bool shouldIgnoreAttributeCase) const
3074 {
3075     // Continue to checking case-insensitively and/or full namespaced names if necessary:
3076     for (unsigned i = 0; i < length(); ++i) {
3077         const Attribute* attribute = attributeItem(i);
3078         if (!attribute->name().hasPrefix()) {
3079             if (shouldIgnoreAttributeCase && equalIgnoringCase(name, attribute->localName()))
3080                 return i;
3081         } else {
3082             // FIXME: Would be faster to do this comparison without calling toString, which
3083             // generates a temporary string by concatenation. But this branch is only reached
3084             // if the attribute name has a prefix, which is rare in HTML.
3085             if (equalPossiblyIgnoringCase(name, attribute->name().toString(), shouldIgnoreAttributeCase))
3086                 return i;
3087         }
3088     }
3089     return notFound;
3090 }
3091
3092 Attribute* UniqueElementData::getAttributeItem(const QualifiedName& name)
3093 {
3094     for (unsigned i = 0; i < length(); ++i) {
3095         if (m_attributeVector.at(i).name().matches(name))
3096             return &m_attributeVector.at(i);
3097     }
3098     return 0;
3099 }
3100
3101 Attribute* UniqueElementData::attributeItem(unsigned index)
3102 {
3103     ASSERT_WITH_SECURITY_IMPLICATION(index < length());
3104     return &m_attributeVector.at(index);
3105 }
3106
3107 } // namespace WebCore