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