Eliminate styleDidChange with StyleDifferenceEqual when updates are actually necessary
[WebKit-https.git] / Source / WebCore / rendering / RenderElement.h
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
4  * Copyright (C) 2003, 2006, 2007, 2009, 2013 Apple Inc. All rights reserved.
5  * Copyright (C) 2010, 2012 Google Inc. All rights reserved.
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Library General Public
9  * License as published by the Free Software Foundation; either
10  * version 2 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Library General Public License for more details.
16  *
17  * You should have received a copy of the GNU Library General Public License
18  * along with this library; see the file COPYING.LIB.  If not, write to
19  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20  * Boston, MA 02110-1301, USA.
21  */
22
23 #ifndef RenderElement_h
24 #define RenderElement_h
25
26 #include "AnimationController.h"
27 #include "RenderObject.h"
28
29 namespace WebCore {
30
31 class ControlStates;
32 class RenderBlock;
33
34 class RenderElement : public RenderObject {
35 public:
36     virtual ~RenderElement();
37
38     static RenderPtr<RenderElement> createFor(Element&, Ref<RenderStyle>&&);
39
40     bool hasInitializedStyle() const { return m_hasInitializedStyle; }
41
42     RenderStyle& style() const { return const_cast<RenderStyle&>(m_style.get()); }
43     RenderStyle& firstLineStyle() const;
44
45     void initializeStyle();
46
47     // Calling with minimalStyleDifference > StyleDifferenceEqual indicates that
48     // out-of-band state (e.g. animations) requires that styleDidChange processing
49     // continue even if the style isn't different from the current style.
50     void setStyle(Ref<RenderStyle>&&, StyleDifference minimalStyleDifference = StyleDifferenceEqual);
51
52     // Called to update a style that is allowed to trigger animations.
53     void setAnimatableStyle(Ref<RenderStyle>&&, StyleDifference minimalStyleDifference);
54
55     // The pseudo element style can be cached or uncached.  Use the cached method if the pseudo element doesn't respect
56     // any pseudo classes (and therefore has no concept of changing state).
57     RenderStyle* getCachedPseudoStyle(PseudoId, RenderStyle* parentStyle = nullptr) const;
58     PassRefPtr<RenderStyle> getUncachedPseudoStyle(const PseudoStyleRequest&, RenderStyle* parentStyle = nullptr, RenderStyle* ownStyle = nullptr) const;
59
60     // This is null for anonymous renderers.
61     Element* element() const { return downcast<Element>(RenderObject::node()); }
62     Element* nonPseudoElement() const { return downcast<Element>(RenderObject::nonPseudoNode()); }
63     Element* generatingElement() const;
64
65     RenderObject* firstChild() const { return m_firstChild; }
66     RenderObject* lastChild() const { return m_lastChild; }
67
68     virtual bool isEmpty() const override { return !firstChild(); }
69
70     bool canContainFixedPositionObjects() const;
71     bool canContainAbsolutelyPositionedObjects() const;
72
73     RenderBlock* containingBlockForFixedPosition() const;
74     RenderBlock* containingBlockForAbsolutePosition() const;
75     RenderBlock* containingBlockForObjectInFlow() const;
76
77     Color selectionColor(int colorProperty) const;
78     PassRefPtr<RenderStyle> selectionPseudoStyle() const;
79
80     // Obtains the selection colors that should be used when painting a selection.
81     Color selectionBackgroundColor() const;
82     Color selectionForegroundColor() const;
83     Color selectionEmphasisMarkColor() const;
84
85     // FIXME: Make these standalone and move to relevant files.
86     bool isRenderLayerModelObject() const;
87     bool isBoxModelObject() const;
88     bool isRenderBlock() const;
89     bool isRenderBlockFlow() const;
90     bool isRenderReplaced() const;
91     bool isRenderInline() const;
92     bool isRenderNamedFlowFragmentContainer() const;
93
94     virtual bool isChildAllowed(const RenderObject&, const RenderStyle&) const { return true; }
95     virtual void addChild(RenderObject* newChild, RenderObject* beforeChild = nullptr);
96     virtual void addChildIgnoringContinuation(RenderObject* newChild, RenderObject* beforeChild = nullptr) { return addChild(newChild, beforeChild); }
97     virtual void removeChild(RenderObject&);
98
99     // The following functions are used when the render tree hierarchy changes to make sure layers get
100     // properly added and removed. Since containership can be implemented by any subclass, and since a hierarchy
101     // can contain a mixture of boxes and other object types, these functions need to be in the base class.
102     void addLayers(RenderLayer* parentLayer);
103     void removeLayers(RenderLayer* parentLayer);
104     void moveLayers(RenderLayer* oldParent, RenderLayer* newParent);
105     RenderLayer* findNextLayer(RenderLayer* parentLayer, RenderObject* startPoint, bool checkParent = true);
106
107     enum NotifyChildrenType { NotifyChildren, DontNotifyChildren };
108     void insertChildInternal(RenderObject*, RenderObject* beforeChild, NotifyChildrenType);
109     void removeChildInternal(RenderObject&, NotifyChildrenType);
110
111     virtual RenderElement* hoverAncestor() const;
112
113     virtual void dirtyLinesFromChangedChild(RenderObject&) { }
114
115     bool ancestorLineBoxDirty() const { return m_ancestorLineBoxDirty; }
116     void setAncestorLineBoxDirty(bool f = true);
117
118     void setChildNeedsLayout(MarkingBehavior = MarkContainingBlockChain);
119     void clearChildNeedsLayout();
120     void setNeedsPositionedMovementLayout(const RenderStyle* oldStyle);
121     void setNeedsSimplifiedNormalFlowLayout();
122
123     virtual void paint(PaintInfo&, const LayoutPoint&) = 0;
124
125     // inline-block elements paint all phases atomically. This function ensures that. Certain other elements
126     // (grid items, flex items) require this behavior as well, and this function exists as a helper for them.
127     // It is expected that the caller will call this function independent of the value of paintInfo.phase.
128     void paintAsInlineBlock(PaintInfo&, const LayoutPoint&);
129
130     // Recursive function that computes the size and position of this object and all its descendants.
131     virtual void layout();
132
133     /* This function performs a layout only if one is needed. */
134     void layoutIfNeeded() { if (needsLayout()) layout(); }
135
136     // Return the renderer whose background style is used to paint the root background. Should only be called on the renderer for which isRoot() is true.
137     RenderElement& rendererForRootBackground();
138
139     // Used only by Element::pseudoStyleCacheIsInvalid to get a first line style based off of a
140     // given new style, without accessing the cache.
141     PassRefPtr<RenderStyle> uncachedFirstLineStyle(RenderStyle*) const;
142
143     // Updates only the local style ptr of the object. Does not update the state of the object,
144     // and so only should be called when the style is known not to have changed (or from setStyle).
145     void setStyleInternal(Ref<RenderStyle>&& style) { m_style = WTF::move(style); }
146
147     // Repaint only if our old bounds and new bounds are different. The caller may pass in newBounds and newOutlineBox if they are known.
148     bool repaintAfterLayoutIfNeeded(const RenderLayerModelObject* repaintContainer, const LayoutRect& oldBounds, const LayoutRect& oldOutlineBox, const LayoutRect* newBoundsPtr = nullptr, const LayoutRect* newOutlineBoxPtr = nullptr);
149
150     bool borderImageIsLoadedAndCanBeRendered() const;
151     bool mayCauseRepaintInsideViewport(const IntRect* visibleRect = nullptr) const;
152
153     // Returns true if this renderer requires a new stacking context.
154     bool createsGroup() const { return isTransparent() || hasMask() || hasFilter() || hasBackdropFilter() || hasBlendMode(); }
155
156     bool isTransparent() const { return style().opacity() < 1.0f; }
157     float opacity() const { return style().opacity(); }
158
159     bool visibleToHitTesting() const { return style().visibility() == VISIBLE && style().pointerEvents() != PE_NONE; }
160
161     bool hasBackground() const { return style().hasBackground(); }
162     bool hasMask() const { return style().hasMask(); }
163     bool hasClip() const { return isOutOfFlowPositioned() && style().hasClip(); }
164     bool hasClipOrOverflowClip() const { return hasClip() || hasOverflowClip(); }
165     bool hasClipPath() const { return style().clipPath(); }
166     bool hasHiddenBackface() const { return style().backfaceVisibility() == BackfaceVisibilityHidden; }
167
168     // anchorRect() is conceptually similar to absoluteBoundingBoxRect(), but is intended for scrolling to an anchor.
169     // For inline renderers, this gets the logical top left of the first leaf child and the logical bottom right of the
170     // last leaf child, converts them to absolute coordinates, and makes a box out of them.
171     LayoutRect anchorRect() const;
172
173     bool hasFilter() const { return style().hasFilter(); }
174     bool hasBackdropFilter() const
175     {
176 #if ENABLE(FILTERS_LEVEL_2)
177         return style().hasBackdropFilter();
178 #else
179         return false;
180 #endif
181     }
182
183 #if ENABLE(CSS_COMPOSITING)
184     bool hasBlendMode() const { return style().hasBlendMode(); }
185 #else
186     bool hasBlendMode() const { return false; }
187 #endif
188
189 #if ENABLE(CSS_SHAPES)
190     bool hasShapeOutside() const { return style().shapeOutside(); }
191 #else
192     bool hasShapeOutside() const { return false; }
193 #endif
194
195     bool repaintForPausedImageAnimationsIfNeeded(const IntRect& visibleRect);
196     bool hasPausedImageAnimations() const { return m_hasPausedImageAnimations; }
197     void setHasPausedImageAnimations(bool b) { m_hasPausedImageAnimations = b; }
198
199     RenderNamedFlowThread* renderNamedFlowThreadWrapper();
200
201     void setRenderBoxNeedsLazyRepaint(bool b) { m_renderBoxNeedsLazyRepaint = b; }
202     bool renderBoxNeedsLazyRepaint() const { return m_renderBoxNeedsLazyRepaint; }
203
204     bool hasCounterNodeMap() const { return m_hasCounterNodeMap; }
205     void setHasCounterNodeMap(bool f) { m_hasCounterNodeMap = f; }
206
207     bool isCSSAnimating() const { return m_isCSSAnimating; }
208     void setIsCSSAnimating(bool b) { m_isCSSAnimating = b; }
209     
210     const RenderElement* enclosingRendererWithTextDecoration(TextDecoration, bool firstLine) const;
211
212 protected:
213     enum BaseTypeFlags {
214         RenderLayerModelObjectFlag = 1 << 0,
215         RenderBoxModelObjectFlag = 1 << 1,
216         RenderInlineFlag = 1 << 2,
217         RenderReplacedFlag = 1 << 3,
218         RenderBlockFlag = 1 << 4,
219         RenderBlockFlowFlag = 1 << 5,
220     };
221
222     RenderElement(Element&, Ref<RenderStyle>&&, unsigned baseTypeFlags);
223     RenderElement(Document&, Ref<RenderStyle>&&, unsigned baseTypeFlags);
224
225     bool layerCreationAllowedForSubtree() const;
226
227     enum StylePropagationType { PropagateToAllChildren, PropagateToBlockChildrenOnly };
228     void propagateStyleToAnonymousChildren(StylePropagationType);
229
230     LayoutUnit valueForLength(const Length&, LayoutUnit maximumValue) const;
231     LayoutUnit minimumValueForLength(const Length&, LayoutUnit maximumValue, bool roundPercentages = false) const;
232
233     void setFirstChild(RenderObject* child) { m_firstChild = child; }
234     void setLastChild(RenderObject* child) { m_lastChild = child; }
235     void destroyLeftoverChildren();
236
237     virtual void styleWillChange(StyleDifference, const RenderStyle& newStyle);
238     virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle);
239
240     virtual void insertedIntoTree() override;
241     virtual void willBeRemovedFromTree() override;
242     virtual void willBeDestroyed() override;
243
244     void setRenderInlineAlwaysCreatesLineBoxes(bool b) { m_renderInlineAlwaysCreatesLineBoxes = b; }
245     bool renderInlineAlwaysCreatesLineBoxes() const { return m_renderInlineAlwaysCreatesLineBoxes; }
246
247     void setHasContinuation(bool b) { m_hasContinuation = b; }
248     bool hasContinuation() const { return m_hasContinuation; }
249
250     static bool hasControlStatesForRenderer(const RenderObject*);
251     static ControlStates* controlStatesForRenderer(const RenderObject*);
252     static void removeControlStatesForRenderer(const RenderObject*);
253     static void addControlStatesForRenderer(const RenderObject*, ControlStates*);
254
255     void setRenderBlockHasMarginBeforeQuirk(bool b) { m_renderBlockHasMarginBeforeQuirk = b; }
256     void setRenderBlockHasMarginAfterQuirk(bool b) { m_renderBlockHasMarginAfterQuirk = b; }
257     void setRenderBlockHasBorderOrPaddingLogicalWidthChanged(bool b) { m_renderBlockHasBorderOrPaddingLogicalWidthChanged = b; }
258     bool renderBlockHasMarginBeforeQuirk() const { return m_renderBlockHasMarginBeforeQuirk; }
259     bool renderBlockHasMarginAfterQuirk() const { return m_renderBlockHasMarginAfterQuirk; }
260     bool renderBlockHasBorderOrPaddingLogicalWidthChanged() const { return m_renderBlockHasBorderOrPaddingLogicalWidthChanged; }
261
262     void setRenderBlockFlowLineLayoutPath(unsigned u) { m_renderBlockFlowLineLayoutPath = u; }
263     void setRenderBlockFlowHasMarkupTruncation(bool b) { m_renderBlockFlowHasMarkupTruncation = b; }
264     unsigned renderBlockFlowLineLayoutPath() const { return m_renderBlockFlowLineLayoutPath; }
265     bool renderBlockFlowHasMarkupTruncation() const { return m_renderBlockFlowHasMarkupTruncation; }
266
267 private:
268     RenderElement(ContainerNode&, Ref<RenderStyle>&&, unsigned baseTypeFlags);
269     void node() const = delete;
270     void nonPseudoNode() const = delete;
271     void generatingNode() const = delete;
272     void isText() const = delete;
273     void isRenderElement() const = delete;
274
275     virtual RenderObject* firstChildSlow() const override final { return firstChild(); }
276     virtual RenderObject* lastChildSlow() const override final { return lastChild(); }
277
278     // Called when an object that was floating or positioned becomes a normal flow object
279     // again.  We have to make sure the render tree updates as needed to accommodate the new
280     // normal flow object.
281     void handleDynamicFloatPositionChange();
282     void removeAnonymousWrappersForInlinesIfNecessary();
283
284     bool shouldRepaintForStyleDifference(StyleDifference) const;
285     bool hasImmediateNonWhitespaceTextChildOrBorderOrOutline() const;
286
287     void updateFillImages(const FillLayer*, const FillLayer*);
288     void updateImage(StyleImage*, StyleImage*);
289 #if ENABLE(CSS_SHAPES)
290     void updateShapeImage(const ShapeValue*, const ShapeValue*);
291 #endif
292
293     StyleDifference adjustStyleDifference(StyleDifference, unsigned contextSensitiveProperties) const;
294     RenderStyle* cachedFirstLineStyle() const;
295
296     virtual void newImageAnimationFrameAvailable(CachedImage&) final override;
297
298     bool getLeadingCorner(FloatPoint& output) const;
299     bool getTrailingCorner(FloatPoint& output) const;
300
301     unsigned m_baseTypeFlags : 6;
302     unsigned m_ancestorLineBoxDirty : 1;
303     unsigned m_hasInitializedStyle : 1;
304
305     unsigned m_renderInlineAlwaysCreatesLineBoxes : 1;
306     unsigned m_renderBoxNeedsLazyRepaint : 1;
307     unsigned m_hasPausedImageAnimations : 1;
308     unsigned m_hasCounterNodeMap : 1;
309     unsigned m_isCSSAnimating : 1;
310     unsigned m_hasContinuation : 1;
311
312     unsigned m_renderBlockHasMarginBeforeQuirk : 1;
313     unsigned m_renderBlockHasMarginAfterQuirk : 1;
314     unsigned m_renderBlockHasBorderOrPaddingLogicalWidthChanged : 1;
315     unsigned m_renderBlockFlowHasMarkupTruncation : 1;
316     unsigned m_renderBlockFlowLineLayoutPath : 2;
317
318     RenderObject* m_firstChild;
319     RenderObject* m_lastChild;
320
321     Ref<RenderStyle> m_style;
322
323     // FIXME: Get rid of this hack.
324     // Store state between styleWillChange and styleDidChange
325     static bool s_affectsParentBlock;
326     static bool s_noLongerAffectsParentBlock;
327 };
328
329 inline void RenderElement::setAnimatableStyle(Ref<RenderStyle>&& style, StyleDifference minimalStyleDifference)
330 {
331     Ref<RenderStyle> animatedStyle = WTF::move(style);
332     if (animation().updateAnimations(*this, animatedStyle, animatedStyle))
333         minimalStyleDifference = std::max(minimalStyleDifference, StyleDifferenceRecompositeLayer);
334     
335     setStyle(WTF::move(animatedStyle), minimalStyleDifference);
336 }
337
338 inline RenderStyle& RenderElement::firstLineStyle() const
339 {
340     return document().styleSheetCollection().usesFirstLineRules() ? *cachedFirstLineStyle() : style();
341 }
342
343 inline void RenderElement::setAncestorLineBoxDirty(bool f)
344 {
345     m_ancestorLineBoxDirty = f;
346     if (m_ancestorLineBoxDirty)
347         setNeedsLayout();
348 }
349
350 inline void RenderElement::setChildNeedsLayout(MarkingBehavior markParents)
351 {
352     ASSERT(!isSetNeedsLayoutForbidden());
353     if (normalChildNeedsLayout())
354         return;
355     setNormalChildNeedsLayoutBit(true);
356     if (markParents == MarkContainingBlockChain)
357         markContainingBlocksForLayout();
358 }
359
360 inline LayoutUnit RenderElement::valueForLength(const Length& length, LayoutUnit maximumValue) const
361 {
362     return WebCore::valueForLength(length, maximumValue);
363 }
364
365 inline LayoutUnit RenderElement::minimumValueForLength(const Length& length, LayoutUnit maximumValue, bool roundPercentages) const
366 {
367     return WebCore::minimumValueForLength(length, maximumValue, roundPercentages);
368 }
369
370 inline bool RenderElement::isRenderLayerModelObject() const
371 {
372     return m_baseTypeFlags & RenderLayerModelObjectFlag;
373 }
374
375 inline bool RenderElement::isBoxModelObject() const
376 {
377     return m_baseTypeFlags & RenderBoxModelObjectFlag;
378 }
379
380 inline bool RenderElement::isRenderBlock() const
381 {
382     return m_baseTypeFlags & RenderBlockFlag;
383 }
384
385 inline bool RenderElement::isRenderBlockFlow() const
386 {
387     return m_baseTypeFlags & RenderBlockFlowFlag;
388 }
389
390 inline bool RenderElement::isRenderReplaced() const
391 {
392     return m_baseTypeFlags & RenderReplacedFlag;
393 }
394
395 inline bool RenderElement::isRenderInline() const
396 {
397     return m_baseTypeFlags & RenderInlineFlag;
398 }
399
400 inline Element* RenderElement::generatingElement() const
401 {
402     if (parent() && isRenderNamedFlowFragment())
403         return parent()->generatingElement();
404     return downcast<Element>(RenderObject::generatingNode());
405 }
406
407 inline bool RenderElement::canContainFixedPositionObjects() const
408 {
409     return isRenderView()
410         || (hasTransform() && isRenderBlock())
411         || isSVGForeignObject()
412         || isOutOfFlowRenderFlowThread();
413 }
414
415 inline bool RenderElement::canContainAbsolutelyPositionedObjects() const
416 {
417     return style().position() != StaticPosition
418         || (isRenderBlock() && hasTransformRelatedProperty())
419         || isSVGForeignObject()
420         || isRenderView();
421 }
422
423 inline bool RenderObject::isRenderLayerModelObject() const
424 {
425     return is<RenderElement>(*this) && downcast<RenderElement>(*this).isRenderLayerModelObject();
426 }
427
428 inline bool RenderObject::isBoxModelObject() const
429 {
430     return is<RenderElement>(*this) && downcast<RenderElement>(*this).isBoxModelObject();
431 }
432
433 inline bool RenderObject::isRenderBlock() const
434 {
435     return is<RenderElement>(*this) && downcast<RenderElement>(*this).isRenderBlock();
436 }
437
438 inline bool RenderObject::isRenderBlockFlow() const
439 {
440     return is<RenderElement>(*this) && downcast<RenderElement>(*this).isRenderBlockFlow();
441 }
442
443 inline bool RenderObject::isRenderReplaced() const
444 {
445     return is<RenderElement>(*this) && downcast<RenderElement>(*this).isRenderReplaced();
446 }
447
448 inline bool RenderObject::isRenderInline() const
449 {
450     return is<RenderElement>(*this) && downcast<RenderElement>(*this).isRenderInline();
451 }
452
453 inline RenderStyle& RenderObject::style() const
454 {
455     if (isText())
456         return m_parent->style();
457     return downcast<RenderElement>(*this).style();
458 }
459
460 inline RenderStyle& RenderObject::firstLineStyle() const
461 {
462     if (isText())
463         return m_parent->firstLineStyle();
464     return downcast<RenderElement>(*this).firstLineStyle();
465 }
466
467 inline RenderElement* ContainerNode::renderer() const
468 {
469     return downcast<RenderElement>(Node::renderer());
470 }
471
472 inline int adjustForAbsoluteZoom(int value, const RenderElement& renderer)
473 {
474     return adjustForAbsoluteZoom(value, renderer.style());
475 }
476
477 inline LayoutUnit adjustLayoutUnitForAbsoluteZoom(LayoutUnit value, const RenderElement& renderer)
478 {
479     return adjustLayoutUnitForAbsoluteZoom(value, renderer.style());
480 }
481
482 } // namespace WebCore
483
484 SPECIALIZE_TYPE_TRAITS_RENDER_OBJECT(RenderElement, isRenderElement())
485
486 #endif // RenderElement_h