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