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