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