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