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