bd4d62198d0c30d074c9f44728939a8d140d6783
[WebKit-https.git] / Source / WebCore / dom / Element.h
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  * Copyright (C) 2003-2017 Apple Inc. All rights reserved.
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Library General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Library General Public License for more details.
17  *
18  * You should have received a copy of the GNU Library General Public License
19  * along with this library; see the file COPYING.LIB.  If not, write to
20  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21  * Boston, MA 02110-1301, USA.
22  *
23  */
24
25 #pragma once
26
27 #include "AXTextStateChangeIntent.h"
28 #include "Document.h"
29 #include "ElementData.h"
30 #include "HTMLNames.h"
31 #include "ScrollToOptions.h"
32 #include "ScrollTypes.h"
33 #include "ShadowRootMode.h"
34 #include "SimulatedClickOptions.h"
35 #include "StyleChange.h"
36
37 namespace WebCore {
38
39 class CustomElementReactionQueue;
40 class DatasetDOMStringMap;
41 class DOMRect;
42 class DOMRectList;
43 class DOMTokenList;
44 class ElementRareData;
45 class HTMLDocument;
46 class IntSize;
47 class JSCustomElementInterface;
48 class KeyboardEvent;
49 class Locale;
50 class PlatformKeyboardEvent;
51 class PlatformMouseEvent;
52 class PlatformWheelEvent;
53 class PseudoElement;
54 class RenderTreePosition;
55 class WebAnimation;
56 struct ElementStyle;
57
58 enum SpellcheckAttributeState {
59     SpellcheckAttributeTrue,
60     SpellcheckAttributeFalse,
61     SpellcheckAttributeDefault
62 };
63
64 enum class SelectionRevealMode {
65     Reveal,
66     RevealUpToMainFrame, // Scroll overflow and iframes, but not the main frame.
67     DoNotReveal
68 };
69
70 class Element : public ContainerNode {
71 public:
72     static Ref<Element> create(const QualifiedName&, Document&);
73     virtual ~Element();
74
75     WEBCORE_EXPORT bool hasAttribute(const QualifiedName&) const;
76     WEBCORE_EXPORT const AtomicString& getAttribute(const QualifiedName&) const;
77     WEBCORE_EXPORT void setAttribute(const QualifiedName&, const AtomicString& value);
78     WEBCORE_EXPORT void setAttributeWithoutSynchronization(const QualifiedName&, const AtomicString& value);
79     void setSynchronizedLazyAttribute(const QualifiedName&, const AtomicString& value);
80     bool removeAttribute(const QualifiedName&);
81     Vector<String> getAttributeNames() const;
82
83     // Typed getters and setters for language bindings.
84     WEBCORE_EXPORT int getIntegralAttribute(const QualifiedName& attributeName) const;
85     WEBCORE_EXPORT void setIntegralAttribute(const QualifiedName& attributeName, int value);
86     WEBCORE_EXPORT unsigned getUnsignedIntegralAttribute(const QualifiedName& attributeName) const;
87     WEBCORE_EXPORT void setUnsignedIntegralAttribute(const QualifiedName& attributeName, unsigned value);
88
89     // Call this to get the value of an attribute that is known not to be the style
90     // attribute or one of the SVG animatable attributes.
91     bool hasAttributeWithoutSynchronization(const QualifiedName&) const;
92     const AtomicString& attributeWithoutSynchronization(const QualifiedName&) const;
93 #ifndef NDEBUG
94     WEBCORE_EXPORT bool fastAttributeLookupAllowed(const QualifiedName&) const;
95 #endif
96
97 #ifdef DUMP_NODE_STATISTICS
98     bool hasNamedNodeMap() const;
99 #endif
100     WEBCORE_EXPORT bool hasAttributes() const;
101     // This variant will not update the potentially invalid attributes. To be used when not interested
102     // in style attribute or one of the SVG animation attributes.
103     bool hasAttributesWithoutUpdate() const;
104
105     WEBCORE_EXPORT bool hasAttribute(const AtomicString& name) const;
106     WEBCORE_EXPORT bool hasAttributeNS(const AtomicString& namespaceURI, const AtomicString& localName) const;
107
108     WEBCORE_EXPORT const AtomicString& getAttribute(const AtomicString& name) const;
109     WEBCORE_EXPORT const AtomicString& getAttributeNS(const AtomicString& namespaceURI, const AtomicString& localName) const;
110
111     WEBCORE_EXPORT ExceptionOr<void> setAttribute(const AtomicString& name, const AtomicString& value);
112     static ExceptionOr<QualifiedName> parseAttributeName(const AtomicString& namespaceURI, const AtomicString& qualifiedName);
113     WEBCORE_EXPORT ExceptionOr<void> setAttributeNS(const AtomicString& namespaceURI, const AtomicString& qualifiedName, const AtomicString& value);
114
115     const AtomicString& getIdAttribute() const;
116     void setIdAttribute(const AtomicString&);
117
118     const AtomicString& getNameAttribute() const;
119
120     // Call this to get the value of the id attribute for style resolution purposes.
121     // The value will already be lowercased if the document is in compatibility mode,
122     // so this function is not suitable for non-style uses.
123     const AtomicString& idForStyleResolution() const;
124
125     // Internal methods that assume the existence of attribute storage, one should use hasAttributes()
126     // before calling them.
127     AttributeIteratorAccessor attributesIterator() const { return elementData()->attributesIterator(); }
128     unsigned attributeCount() const;
129     const Attribute& attributeAt(unsigned index) const;
130     const Attribute* findAttributeByName(const QualifiedName&) const;
131     unsigned findAttributeIndexByName(const QualifiedName& name) const { return elementData()->findAttributeIndexByName(name); }
132     unsigned findAttributeIndexByName(const AtomicString& name, bool shouldIgnoreAttributeCase) const { return elementData()->findAttributeIndexByName(name, shouldIgnoreAttributeCase); }
133
134     WEBCORE_EXPORT void scrollIntoView(bool alignToTop = true);
135     WEBCORE_EXPORT void scrollIntoViewIfNeeded(bool centerIfNeeded = true);
136     WEBCORE_EXPORT void scrollIntoViewIfNotVisible(bool centerIfNotVisible = true);
137
138     void scrollBy(const ScrollToOptions&);
139     void scrollBy(double x, double y);
140     virtual void scrollTo(const ScrollToOptions&);
141     void scrollTo(double x, double y);
142
143     WEBCORE_EXPORT void scrollByLines(int lines);
144     WEBCORE_EXPORT void scrollByPages(int pages);
145
146     WEBCORE_EXPORT double offsetLeft();
147     WEBCORE_EXPORT double offsetTop();
148     WEBCORE_EXPORT double offsetWidth();
149     WEBCORE_EXPORT double offsetHeight();
150
151     bool mayCauseRepaintInsideViewport(const IntRect* visibleRect = nullptr) const;
152
153     // FIXME: Replace uses of offsetParent in the platform with calls
154     // to the render layer and merge bindingsOffsetParent and offsetParent.
155     WEBCORE_EXPORT Element* bindingsOffsetParent();
156
157     const Element* rootElement() const;
158
159     Element* offsetParent();
160     WEBCORE_EXPORT double clientLeft();
161     WEBCORE_EXPORT double clientTop();
162     WEBCORE_EXPORT double clientWidth();
163     WEBCORE_EXPORT double clientHeight();
164
165     virtual int scrollLeft();
166     virtual int scrollTop();
167     virtual void setScrollLeft(int);
168     virtual void setScrollTop(int);
169     virtual int scrollWidth();
170     virtual int scrollHeight();
171
172     WEBCORE_EXPORT IntRect boundsInRootViewSpace();
173
174     FloatRect boundingClientRect();
175
176     WEBCORE_EXPORT Ref<DOMRectList> getClientRects();
177     Ref<DOMRect> getBoundingClientRect();
178
179     // Returns the absolute bounding box translated into client coordinates.
180     WEBCORE_EXPORT IntRect clientRect() const;
181     // Returns the absolute bounding box translated into screen coordinates.
182     WEBCORE_EXPORT IntRect screenRect() const;
183
184     WEBCORE_EXPORT bool removeAttribute(const AtomicString& name);
185     WEBCORE_EXPORT bool removeAttributeNS(const AtomicString& namespaceURI, const AtomicString& localName);
186
187     Ref<Attr> detachAttribute(unsigned index);
188
189     WEBCORE_EXPORT RefPtr<Attr> getAttributeNode(const AtomicString& name);
190     WEBCORE_EXPORT RefPtr<Attr> getAttributeNodeNS(const AtomicString& namespaceURI, const AtomicString& localName);
191     WEBCORE_EXPORT ExceptionOr<RefPtr<Attr>> setAttributeNode(Attr&);
192     WEBCORE_EXPORT ExceptionOr<RefPtr<Attr>> setAttributeNodeNS(Attr&);
193     WEBCORE_EXPORT ExceptionOr<Ref<Attr>> removeAttributeNode(Attr&);
194
195     RefPtr<Attr> attrIfExists(const QualifiedName&);
196     RefPtr<Attr> attrIfExists(const AtomicString& localName, bool shouldIgnoreAttributeCase);
197     Ref<Attr> ensureAttr(const QualifiedName&);
198
199     const Vector<RefPtr<Attr>>& attrNodeList();
200
201     const QualifiedName& tagQName() const { return m_tagName; }
202 #if ENABLE(JIT)
203     static ptrdiff_t tagQNameMemoryOffset() { return OBJECT_OFFSETOF(Element, m_tagName); }
204 #endif // ENABLE(JIT)
205     String tagName() const { return nodeName(); }
206     bool hasTagName(const QualifiedName& tagName) const { return m_tagName.matches(tagName); }
207     bool hasTagName(const HTMLQualifiedName& tagName) const { return ContainerNode::hasTagName(tagName); }
208     bool hasTagName(const MathMLQualifiedName& tagName) const { return ContainerNode::hasTagName(tagName); }
209     bool hasTagName(const SVGQualifiedName& tagName) const { return ContainerNode::hasTagName(tagName); }
210
211     // A fast function for checking the local name against another atomic string.
212     bool hasLocalName(const AtomicString& other) const { return m_tagName.localName() == other; }
213
214     const AtomicString& localName() const final { return m_tagName.localName(); }
215     const AtomicString& prefix() const final { return m_tagName.prefix(); }
216     const AtomicString& namespaceURI() const final { return m_tagName.namespaceURI(); }
217
218     ExceptionOr<void> setPrefix(const AtomicString&) final;
219
220     String nodeName() const override;
221
222     Ref<Element> cloneElementWithChildren(Document&);
223     Ref<Element> cloneElementWithoutChildren(Document&);
224
225     void normalizeAttributes();
226     String nodeNamePreservingCase() const;
227
228     WEBCORE_EXPORT void setBooleanAttribute(const QualifiedName& name, bool);
229
230     // For exposing to DOM only.
231     WEBCORE_EXPORT NamedNodeMap& attributes() const;
232
233     enum AttributeModificationReason {
234         ModifiedDirectly,
235         ModifiedByCloning
236     };
237
238     // This method is called whenever an attribute is added, changed or removed.
239     virtual void attributeChanged(const QualifiedName&, const AtomicString& oldValue, const AtomicString& newValue, AttributeModificationReason = ModifiedDirectly);
240     virtual void parseAttribute(const QualifiedName&, const AtomicString&) { }
241
242     // Only called by the parser immediately after element construction.
243     void parserSetAttributes(const Vector<Attribute>&);
244
245     bool isEventHandlerAttribute(const Attribute&) const;
246     bool isJavaScriptURLAttribute(const Attribute&) const;
247
248     // Remove attributes that might introduce scripting from the vector leaving the element unchanged.
249     void stripScriptingAttributes(Vector<Attribute>&) const;
250
251     const ElementData* elementData() const { return m_elementData.get(); }
252     static ptrdiff_t elementDataMemoryOffset() { return OBJECT_OFFSETOF(Element, m_elementData); }
253     UniqueElementData& ensureUniqueElementData();
254
255     void synchronizeAllAttributes() const;
256
257     // Clones attributes only.
258     void cloneAttributesFromElement(const Element&);
259
260     // Clones all attribute-derived data, including subclass specifics (through copyNonAttributeProperties.)
261     void cloneDataFromElement(const Element&);
262
263     bool hasEquivalentAttributes(const Element* other) const;
264
265     virtual void copyNonAttributePropertiesFromElement(const Element&) { }
266
267     virtual RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&);
268     virtual bool rendererIsNeeded(const RenderStyle&);
269
270     WEBCORE_EXPORT ShadowRoot* shadowRoot() const;
271     ShadowRoot* shadowRootForBindings(JSC::ExecState&) const;
272
273     struct ShadowRootInit {
274         ShadowRootMode mode;
275     };
276     ExceptionOr<ShadowRoot&> attachShadow(const ShadowRootInit&);
277
278     RefPtr<ShadowRoot> userAgentShadowRoot() const;
279     WEBCORE_EXPORT ShadowRoot& ensureUserAgentShadowRoot();
280
281     void setIsDefinedCustomElement(JSCustomElementInterface&);
282     void setIsFailedCustomElement(JSCustomElementInterface&);
283     void setIsCustomElementUpgradeCandidate();
284     void enqueueToUpgrade(JSCustomElementInterface&);
285     CustomElementReactionQueue* reactionQueue() const;
286
287     // FIXME: this should not be virtual, do not override this.
288     virtual const AtomicString& shadowPseudoId() const;
289
290     bool inActiveChain() const { return isUserActionElement() && isUserActionElementInActiveChain(); }
291     bool active() const { return isUserActionElement() && isUserActionElementActive(); }
292     bool hovered() const { return isUserActionElement() && isUserActionElementHovered(); }
293     bool focused() const { return isUserActionElement() && isUserActionElementFocused(); }
294     bool hasFocusWithin() const { return getFlag(HasFocusWithin); };
295
296     virtual void setActive(bool flag = true, bool pause = false);
297     virtual void setHovered(bool flag = true);
298     virtual void setFocus(bool flag);
299     void setHasFocusWithin(bool flag);
300
301     bool tabIndexSetExplicitly() const;
302     virtual bool supportsFocus() const;
303     virtual bool isFocusable() const;
304     virtual bool isKeyboardFocusable(KeyboardEvent&) const;
305     virtual bool isMouseFocusable() const;
306
307     virtual bool shouldUseInputMethod();
308
309     virtual int tabIndex() const;
310     WEBCORE_EXPORT void setTabIndex(int);
311     virtual RefPtr<Element> focusDelegate();
312
313     WEBCORE_EXPORT ExceptionOr<Element*> insertAdjacentElement(const String& where, Element& newChild);
314     WEBCORE_EXPORT ExceptionOr<void> insertAdjacentHTML(const String& where, const String& html);
315     WEBCORE_EXPORT ExceptionOr<void> insertAdjacentText(const String& where, const String& text);
316
317     const RenderStyle* computedStyle(PseudoId = NOPSEUDO) override;
318
319     bool needsStyleInvalidation() const;
320
321     // Methods for indicating the style is affected by dynamic updates (e.g., children changing, our position changing in our sibling list, etc.)
322     bool styleAffectedByActive() const { return hasRareData() && rareDataStyleAffectedByActive(); }
323     bool styleAffectedByEmpty() const { return hasRareData() && rareDataStyleAffectedByEmpty(); }
324     bool styleAffectedByFocusWithin() const { return hasRareData() && rareDataStyleAffectedByFocusWithin(); }
325     bool childrenAffectedByHover() const { return getFlag(ChildrenAffectedByHoverRulesFlag); }
326     bool childrenAffectedByDrag() const { return hasRareData() && rareDataChildrenAffectedByDrag(); }
327     bool childrenAffectedByFirstChildRules() const { return getFlag(ChildrenAffectedByFirstChildRulesFlag); }
328     bool childrenAffectedByLastChildRules() const { return getFlag(ChildrenAffectedByLastChildRulesFlag); }
329     bool childrenAffectedByBackwardPositionalRules() const { return hasRareData() && rareDataChildrenAffectedByBackwardPositionalRules(); }
330     bool childrenAffectedByPropertyBasedBackwardPositionalRules() const { return hasRareData() && rareDataChildrenAffectedByPropertyBasedBackwardPositionalRules(); }
331     bool affectsNextSiblingElementStyle() const { return getFlag(AffectsNextSiblingElementStyle); }
332     unsigned childIndex() const { return hasRareData() ? rareDataChildIndex() : 0; }
333
334     bool hasFlagsSetDuringStylingOfChildren() const;
335
336     void setStyleAffectedByEmpty();
337     void setStyleAffectedByFocusWithin();
338     void setChildrenAffectedByHover() { setFlag(ChildrenAffectedByHoverRulesFlag); }
339     void setStyleAffectedByActive();
340     void setChildrenAffectedByDrag();
341     void setChildrenAffectedByFirstChildRules() { setFlag(ChildrenAffectedByFirstChildRulesFlag); }
342     void setChildrenAffectedByLastChildRules() { setFlag(ChildrenAffectedByLastChildRulesFlag); }
343     void setChildrenAffectedByBackwardPositionalRules();
344     void setChildrenAffectedByPropertyBasedBackwardPositionalRules();
345     void setAffectsNextSiblingElementStyle() { setFlag(AffectsNextSiblingElementStyle); }
346     void setStyleIsAffectedByPreviousSibling() { setFlag(StyleIsAffectedByPreviousSibling); }
347     void setChildIndex(unsigned);
348
349     AtomicString computeInheritedLanguage() const;
350     Locale& locale() const;
351
352     virtual void accessKeyAction(bool /*sendToAnyEvent*/) { }
353
354     virtual bool isURLAttribute(const Attribute&) const { return false; }
355     virtual bool attributeContainsURL(const Attribute& attribute) const { return isURLAttribute(attribute); }
356     virtual String completeURLsInAttributeValue(const URL& base, const Attribute&) const;
357     virtual bool isHTMLContentAttribute(const Attribute&) const { return false; }
358
359     WEBCORE_EXPORT URL getURLAttribute(const QualifiedName&) const;
360     URL getNonEmptyURLAttribute(const QualifiedName&) const;
361
362     virtual const AtomicString& imageSourceURL() const;
363     virtual String target() const { return String(); }
364
365     static AXTextStateChangeIntent defaultFocusTextStateChangeIntent() { return AXTextStateChangeIntent(AXTextStateChangeTypeSelectionMove, AXTextSelection { AXTextSelectionDirectionDiscontiguous, AXTextSelectionGranularityUnknown, true }); }
366     void updateFocusAppearanceAfterAttachIfNeeded();
367     virtual void focus(bool restorePreviousSelection = true, FocusDirection = FocusDirectionNone);
368     virtual void updateFocusAppearance(SelectionRestorationMode, SelectionRevealMode = SelectionRevealMode::Reveal);
369     virtual void blur();
370
371     WEBCORE_EXPORT String innerHTML() const;
372     WEBCORE_EXPORT String outerHTML() const;
373     WEBCORE_EXPORT ExceptionOr<void> setInnerHTML(const String&);
374     WEBCORE_EXPORT ExceptionOr<void> setOuterHTML(const String&);
375     WEBCORE_EXPORT String innerText();
376     WEBCORE_EXPORT String outerText();
377  
378     virtual String title() const;
379
380     const AtomicString& pseudo() const;
381     WEBCORE_EXPORT void setPseudo(const AtomicString&);
382
383     LayoutSize minimumSizeForResizing() const;
384     void setMinimumSizeForResizing(const LayoutSize&);
385
386     // Use Document::registerForDocumentActivationCallbacks() to subscribe to these
387     virtual void prepareForDocumentSuspension() { }
388     virtual void resumeFromDocumentSuspension() { }
389
390     // Use Document::registerForMediaVolumeCallbacks() to subscribe to this
391     virtual void mediaVolumeDidChange() { }
392
393     // Use Document::registerForPrivateBrowsingStateChangedCallbacks() to subscribe to this.
394     virtual void privateBrowsingStateDidChange() { }
395
396     virtual void willBecomeFullscreenElement();
397     virtual void ancestorWillEnterFullscreen() { }
398     virtual void didBecomeFullscreenElement() { }
399     virtual void willStopBeingFullscreenElement() { }
400
401 #if ENABLE(VIDEO_TRACK)
402     virtual void captionPreferencesChanged() { }
403 #endif
404
405     bool isFinishedParsingChildren() const { return isParsingChildrenFinished(); }
406     void finishParsingChildren() override;
407     void beginParsingChildren() final;
408
409     WEBCORE_EXPORT PseudoElement* beforePseudoElement() const;
410     WEBCORE_EXPORT PseudoElement* afterPseudoElement() const;
411     bool childNeedsShadowWalker() const;
412     void didShadowTreeAwareChildrenChange();
413
414     virtual bool matchesValidPseudoClass() const;
415     virtual bool matchesInvalidPseudoClass() const;
416     virtual bool matchesReadWritePseudoClass() const;
417     virtual bool matchesIndeterminatePseudoClass() const;
418     virtual bool matchesDefaultPseudoClass() const;
419     WEBCORE_EXPORT ExceptionOr<bool> matches(const String& selectors);
420     WEBCORE_EXPORT ExceptionOr<Element*> closest(const String& selectors);
421     virtual bool shouldAppearIndeterminate() const;
422
423     WEBCORE_EXPORT DOMTokenList& classList();
424
425     DatasetDOMStringMap& dataset();
426
427 #if ENABLE(VIDEO)
428     virtual bool isMediaElement() const { return false; }
429 #endif
430
431     virtual bool isFormControlElement() const { return false; }
432     virtual bool isSpinButtonElement() const { return false; }
433     virtual bool isTextFormControl() const { return false; }
434     virtual bool isOptionalFormControl() const { return false; }
435     virtual bool isRequiredFormControl() const { return false; }
436     virtual bool isInRange() const { return false; }
437     virtual bool isOutOfRange() const { return false; }
438     virtual bool isFrameElementBase() const { return false; }
439     virtual bool isUploadButton() const { return false; }
440     virtual bool isSliderContainerElement() const { return false; }
441
442     bool canContainRangeEndPoint() const override;
443
444     // Used for disabled form elements; if true, prevents mouse events from being dispatched
445     // to event listeners, and prevents DOMActivate events from being sent at all.
446     virtual bool isDisabledFormControl() const { return false; }
447
448     virtual bool childShouldCreateRenderer(const Node&) const;
449
450     bool hasPendingResources() const;
451     void setHasPendingResources();
452     void clearHasPendingResources();
453     virtual void buildPendingResource() { };
454
455     bool hasCSSAnimation() const;
456     void setHasCSSAnimation();
457     void clearHasCSSAnimation();
458
459 #if ENABLE(FULLSCREEN_API)
460     WEBCORE_EXPORT bool containsFullScreenElement() const;
461     void setContainsFullScreenElement(bool);
462     void setContainsFullScreenElementOnAncestorsCrossingFrameBoundaries(bool);
463     WEBCORE_EXPORT void webkitRequestFullscreen();
464 #endif
465
466 #if ENABLE(POINTER_LOCK)
467     WEBCORE_EXPORT void requestPointerLock();
468 #endif
469
470     bool isSpellCheckingEnabled() const;
471
472     bool hasID() const;
473     bool hasClass() const;
474     bool hasName() const;
475     const SpaceSplitString& classNames() const;
476
477     IntPoint savedLayerScrollPosition() const;
478     void setSavedLayerScrollPosition(const IntPoint&);
479
480     bool dispatchMouseEvent(const PlatformMouseEvent&, const AtomicString& eventType, int clickCount = 0, Element* relatedTarget = nullptr);
481     bool dispatchWheelEvent(const PlatformWheelEvent&);
482     bool dispatchKeyEvent(const PlatformKeyboardEvent&);
483     void dispatchSimulatedClick(Event* underlyingEvent, SimulatedClickMouseEventOptions = SendNoEvents, SimulatedClickVisualOptions = ShowPressedLook);
484     void dispatchFocusInEvent(const AtomicString& eventType, RefPtr<Element>&& oldFocusedElement);
485     void dispatchFocusOutEvent(const AtomicString& eventType, RefPtr<Element>&& newFocusedElement);
486     virtual void dispatchFocusEvent(RefPtr<Element>&& oldFocusedElement, FocusDirection);
487     virtual void dispatchBlurEvent(RefPtr<Element>&& newFocusedElement);
488     void dispatchWebKitImageReadyEventForTesting();
489
490     WEBCORE_EXPORT bool dispatchMouseForceWillBegin();
491
492     virtual void willRecalcStyle(Style::Change);
493     virtual void didRecalcStyle(Style::Change);
494     virtual void willResetComputedStyle();
495     virtual void willAttachRenderers();
496     virtual void didAttachRenderers();
497     virtual void willDetachRenderers();
498     virtual void didDetachRenderers();
499     virtual std::optional<ElementStyle> resolveCustomStyle(const RenderStyle& parentStyle, const RenderStyle* shadowHostStyle);
500
501     LayoutRect absoluteEventHandlerBounds(bool& includesFixedPositionElements) override;
502
503     const RenderStyle* existingComputedStyle() const;
504
505     void setBeforePseudoElement(Ref<PseudoElement>&&);
506     void setAfterPseudoElement(Ref<PseudoElement>&&);
507     void clearBeforePseudoElement();
508     void clearAfterPseudoElement();
509     void resetComputedStyle();
510     void resetStyleRelations();
511     void clearStyleDerivedDataBeforeDetachingRenderer();
512     void clearHoverAndActiveStatusBeforeDetachingRenderer();
513
514     WEBCORE_EXPORT URL absoluteLinkURL() const;
515
516 #if ENABLE(TOUCH_EVENTS)
517     bool allowsDoubleTapGesture() const override;
518 #endif
519
520     StyleResolver& styleResolver();
521     ElementStyle resolveStyle(const RenderStyle* parentStyle);
522
523     // Invalidates the style of a single element. Style is resolved lazily.
524     // Descendant elements are resolved as needed, for example if an inherited property changes.
525     // This should be called whenever an element changes in a manner that can affect its style.
526     void invalidateStyle();
527
528     // As above but also call RenderElement::setStyle with StyleDifferenceRecompositeLayer flag for
529     // the element even when the style doesn't change. This is mostly needed by the animation code.
530     WEBCORE_EXPORT void invalidateStyleAndLayerComposition();
531
532     // Invalidate the element and all its descendants. This is used when there is some sort of change
533     // in the tree that may affect the style of any of the descendants and we don't know how to optimize
534     // the case to limit the scope. This is expensive and should be avoided.
535     void invalidateStyleForSubtree();
536
537     // Invalidates renderers for the element and all its descendants causing them to be torn down
538     // and rebuild during style resolution. Style is also recomputed. This is used in code dealing with
539     // custom (not style based) renderers. This is expensive and should be avoided.
540     // Elements newly added to the tree are also in this state.
541     void invalidateStyleAndRenderersForSubtree();
542
543     bool hasDisplayContents() const;
544     void storeDisplayContentsStyle(std::unique_ptr<RenderStyle>);
545
546     using ContainerNode::setAttributeEventListener;
547     void setAttributeEventListener(const AtomicString& eventType, const QualifiedName& attributeName, const AtomicString& value);
548
549     Element* findAnchorElementForLink(String& outAnchorName);
550
551 protected:
552     Element(const QualifiedName&, Document&, ConstructionType);
553
554     InsertedIntoAncestorResult insertedIntoAncestor(InsertionType, ContainerNode&) override;
555     void removedFromAncestor(RemovalType, ContainerNode&) override;
556     void childrenChanged(const ChildChange&) override;
557     void removeAllEventListeners() final;
558     virtual void parserDidSetAttributes();
559     void didMoveToNewDocument(Document& oldDocument, Document& newDocument) override;
560
561     void clearTabIndexExplicitlyIfNeeded();
562     void setTabIndexExplicitly(int);
563
564     // classAttributeChanged() exists to share code between
565     // parseAttribute (called via setAttribute()) and
566     // svgAttributeChanged (called when element.className.baseValue is set)
567     void classAttributeChanged(const AtomicString& newClassString);
568
569     void addShadowRoot(Ref<ShadowRoot>&&);
570
571     static ExceptionOr<void> mergeWithNextTextNode(Text&);
572
573 private:
574     bool isTextNode() const;
575
576     bool isUserActionElementInActiveChain() const;
577     bool isUserActionElementActive() const;
578     bool isUserActionElementFocused() const;
579     bool isUserActionElementHovered() const;
580
581     virtual void didAddUserAgentShadowRoot(ShadowRoot*) { }
582     virtual bool alwaysCreateUserAgentShadowRoot() const { return false; }
583
584     // FIXME: Remove the need for Attr to call willModifyAttribute/didModifyAttribute.
585     friend class Attr;
586
587     enum SynchronizationOfLazyAttribute { NotInSynchronizationOfLazyAttribute = 0, InSynchronizationOfLazyAttribute };
588
589     void didAddAttribute(const QualifiedName&, const AtomicString&);
590     void willModifyAttribute(const QualifiedName&, const AtomicString& oldValue, const AtomicString& newValue);
591     void didModifyAttribute(const QualifiedName&, const AtomicString& oldValue, const AtomicString& newValue);
592     void didRemoveAttribute(const QualifiedName&, const AtomicString& oldValue);
593
594     void synchronizeAttribute(const QualifiedName&) const;
595     void synchronizeAttribute(const AtomicString& localName) const;
596
597     void updateName(const AtomicString& oldName, const AtomicString& newName);
598     void updateNameForTreeScope(TreeScope&, const AtomicString& oldName, const AtomicString& newName);
599     void updateNameForDocument(HTMLDocument&, const AtomicString& oldName, const AtomicString& newName);
600
601     enum class NotifyObservers { No, Yes };
602     void updateId(const AtomicString& oldId, const AtomicString& newId, NotifyObservers = NotifyObservers::Yes);
603     void updateIdForTreeScope(TreeScope&, const AtomicString& oldId, const AtomicString& newId, NotifyObservers = NotifyObservers::Yes);
604
605     enum HTMLDocumentNamedItemMapsUpdatingCondition { AlwaysUpdateHTMLDocumentNamedItemMaps, UpdateHTMLDocumentNamedItemMapsOnlyIfDiffersFromNameAttribute };
606     void updateIdForDocument(HTMLDocument&, const AtomicString& oldId, const AtomicString& newId, HTMLDocumentNamedItemMapsUpdatingCondition);
607     void updateLabel(TreeScope&, const AtomicString& oldForAttributeValue, const AtomicString& newForAttributeValue);
608
609     ExceptionOr<Node*> insertAdjacent(const String& where, Ref<Node>&& newChild);
610
611     void scrollByUnits(int units, ScrollGranularity);
612
613     NodeType nodeType() const final;
614     bool childTypeAllowed(NodeType) const final;
615
616     void setAttributeInternal(unsigned index, const QualifiedName&, const AtomicString& value, SynchronizationOfLazyAttribute);
617     void addAttributeInternal(const QualifiedName&, const AtomicString& value, SynchronizationOfLazyAttribute);
618     void removeAttributeInternal(unsigned index, SynchronizationOfLazyAttribute);
619
620     LayoutRect absoluteEventBounds(bool& boundsIncludeAllDescendantElements, bool& includesFixedPositionElements);
621     LayoutRect absoluteEventBoundsOfElementAndDescendants(bool& includesFixedPositionElements);
622     
623 #if ENABLE(TREE_DEBUGGING)
624     void formatForDebugger(char* buffer, unsigned length) const override;
625 #endif
626
627     // The cloneNode function is private so that non-virtual cloneElementWith/WithoutChildren are used instead.
628     Ref<Node> cloneNodeInternal(Document&, CloningOperation) override;
629     virtual Ref<Element> cloneElementWithoutAttributesAndChildren(Document&);
630
631     void removeShadowRoot();
632
633     const RenderStyle& resolveComputedStyle();
634     const RenderStyle& resolvePseudoElementStyle(PseudoId);
635
636     bool rareDataStyleAffectedByEmpty() const;
637     bool rareDataStyleAffectedByFocusWithin() const;
638     bool rareDataChildrenAffectedByHover() const;
639     bool rareDataStyleAffectedByActive() const;
640     bool rareDataChildrenAffectedByDrag() const;
641     bool rareDataChildrenAffectedByLastChildRules() const;
642     bool rareDataChildrenAffectedByBackwardPositionalRules() const;
643     bool rareDataChildrenAffectedByPropertyBasedBackwardPositionalRules() const;
644     unsigned rareDataChildIndex() const;
645
646     SpellcheckAttributeState spellcheckAttributeState() const;
647
648     void createUniqueElementData();
649
650     ElementRareData* elementRareData() const;
651     ElementRareData& ensureElementRareData();
652
653     void detachAllAttrNodesFromElement();
654     void detachAttrNodeFromElementWithValue(Attr*, const AtomicString& value);
655
656     // Anyone thinking of using this should call document instead of ownerDocument.
657     void ownerDocument() const = delete;
658     
659     void attachAttributeNodeIfNeeded(Attr&);
660
661     QualifiedName m_tagName;
662     RefPtr<ElementData> m_elementData;
663 };
664
665 inline bool Node::hasAttributes() const
666 {
667     return is<Element>(*this) && downcast<Element>(*this).hasAttributes();
668 }
669
670 inline NamedNodeMap* Node::attributes() const
671 {
672     return is<Element>(*this) ? &downcast<Element>(*this).attributes() : nullptr;
673 }
674
675 inline Element* Node::parentElement() const
676 {
677     ContainerNode* parent = parentNode();
678     return is<Element>(parent) ? downcast<Element>(parent) : nullptr;
679 }
680
681 inline const Element* Element::rootElement() const
682 {
683     if (isConnected())
684         return document().documentElement();
685
686     const Element* highest = this;
687     while (highest->parentElement())
688         highest = highest->parentElement();
689     return highest;
690 }
691
692 inline bool Element::hasAttributeWithoutSynchronization(const QualifiedName& name) const
693 {
694     ASSERT(fastAttributeLookupAllowed(name));
695     return elementData() && findAttributeByName(name);
696 }
697
698 inline const AtomicString& Element::attributeWithoutSynchronization(const QualifiedName& name) const
699 {
700     ASSERT(fastAttributeLookupAllowed(name));
701     if (elementData()) {
702         if (const Attribute* attribute = findAttributeByName(name))
703             return attribute->value();
704     }
705     return nullAtom();
706 }
707
708 inline bool Element::hasAttributesWithoutUpdate() const
709 {
710     return elementData() && !elementData()->isEmpty();
711 }
712
713 inline const AtomicString& Element::idForStyleResolution() const
714 {
715     return hasID() ? elementData()->idForStyleResolution() : nullAtom();
716 }
717
718 inline const AtomicString& Element::getIdAttribute() const
719 {
720     if (hasID())
721         return elementData()->findAttributeByName(HTMLNames::idAttr)->value();
722     return nullAtom();
723 }
724
725 inline const AtomicString& Element::getNameAttribute() const
726 {
727     if (hasName())
728         return elementData()->findAttributeByName(HTMLNames::nameAttr)->value();
729     return nullAtom();
730 }
731
732 inline void Element::setIdAttribute(const AtomicString& value)
733 {
734     setAttributeWithoutSynchronization(HTMLNames::idAttr, value);
735 }
736
737 inline const SpaceSplitString& Element::classNames() const
738 {
739     ASSERT(hasClass());
740     ASSERT(elementData());
741     return elementData()->classNames();
742 }
743
744 inline unsigned Element::attributeCount() const
745 {
746     ASSERT(elementData());
747     return elementData()->length();
748 }
749
750 inline const Attribute& Element::attributeAt(unsigned index) const
751 {
752     ASSERT(elementData());
753     return elementData()->attributeAt(index);
754 }
755
756 inline const Attribute* Element::findAttributeByName(const QualifiedName& name) const
757 {
758     ASSERT(elementData());
759     return elementData()->findAttributeByName(name);
760 }
761
762 inline bool Element::hasID() const
763 {
764     return elementData() && elementData()->hasID();
765 }
766
767 inline bool Element::hasClass() const
768 {
769     return elementData() && elementData()->hasClass();
770 }
771
772 inline bool Element::hasName() const
773 {
774     return elementData() && elementData()->hasName();
775 }
776
777 inline UniqueElementData& Element::ensureUniqueElementData()
778 {
779     if (!elementData() || !elementData()->isUnique())
780         createUniqueElementData();
781     return static_cast<UniqueElementData&>(*m_elementData);
782 }
783
784 inline bool shouldIgnoreAttributeCase(const Element& element)
785 {
786     return element.isHTMLElement() && element.document().isHTMLDocument();
787 }
788
789 inline void Element::setHasFocusWithin(bool flag)
790 {
791     if (hasFocusWithin() == flag)
792         return;
793     setFlag(flag, HasFocusWithin);
794     if (styleAffectedByFocusWithin())
795         invalidateStyleForSubtree();
796 }
797
798 } // namespace WebCore
799
800 SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::Element)
801     static bool isType(const WebCore::Node& node) { return node.isElementNode(); }
802 SPECIALIZE_TYPE_TRAITS_END()