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