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