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