Unreviewed, rolling out r245058.
[WebKit-https.git] / Source / WebCore / rendering / RenderLayer.h
1 /*
2  * Copyright (C) 2003, 2009, 2012, 2015 Apple Inc. All rights reserved.
3  *
4  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
5  *
6  * Other contributors:
7  *   Robert O'Callahan <roc+@cs.cmu.edu>
8  *   David Baron <dbaron@fas.harvard.edu>
9  *   Christian Biesinger <cbiesinger@web.de>
10  *   Randall Jesup <rjesup@wgate.com>
11  *   Roland Mainz <roland.mainz@informatik.med.uni-giessen.de>
12  *   Josh Soref <timeless@mac.com>
13  *   Boris Zbarsky <bzbarsky@mit.edu>
14  *
15  * This library is free software; you can redistribute it and/or
16  * modify it under the terms of the GNU Lesser General Public
17  * License as published by the Free Software Foundation; either
18  * version 2.1 of the License, or (at your option) any later version.
19  *
20  * This library is distributed in the hope that it will be useful,
21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
23  * Lesser General Public License for more details.
24  *
25  * You should have received a copy of the GNU Lesser General Public
26  * License along with this library; if not, write to the Free Software
27  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
28  *
29  * Alternatively, the contents of this file may be used under the terms
30  * of either the Mozilla Public License Version 1.1, found at
31  * http://www.mozilla.org/MPL/ (the "MPL") or the GNU General Public
32  * License Version 2.0, found at http://www.fsf.org/copyleft/gpl.html
33  * (the "GPL"), in which case the provisions of the MPL or the GPL are
34  * applicable instead of those above.  If you wish to allow use of your
35  * version of this file only under the terms of one of those two
36  * licenses (the MPL or the GPL) and not to allow others to use your
37  * version of this file under the LGPL, indicate your decision by
38  * deletingthe provisions above and replace them with the notice and
39  * other provisions required by the MPL or the GPL, as the case may be.
40  * If you do not delete the provisions above, a recipient may use your
41  * version of this file under any of the LGPL, the MPL or the GPL.
42  */
43
44 #pragma once
45
46 #include "ClipRect.h"
47 #include "GraphicsLayer.h"
48 #include "LayerFragment.h"
49 #include "PaintFrequencyTracker.h"
50 #include "PaintInfo.h"
51 #include "RenderBox.h"
52 #include "RenderPtr.h"
53 #include "ScrollableArea.h"
54 #include <memory>
55 #include <wtf/WeakPtr.h>
56
57 namespace WTF {
58 class TextStream;
59 }
60
61 namespace WebCore {
62
63 class CSSFilter;
64 class ClipRects;
65 class ClipRectsCache;
66 class EventRegion;
67 class HitTestRequest;
68 class HitTestResult;
69 class HitTestingTransformState;
70 class Region;
71 class RenderFragmentedFlow;
72 class RenderGeometryMap;
73 class RenderLayerBacking;
74 class RenderLayerCompositor;
75 class RenderLayerFilters;
76 class RenderMarquee;
77 class RenderReplica;
78 class RenderScrollbarPart;
79 class RenderStyle;
80 class RenderView;
81 class Scrollbar;
82 class TransformationMatrix;
83
84 enum BorderRadiusClippingRule { IncludeSelfForBorderRadius, DoNotIncludeSelfForBorderRadius };
85 enum IncludeSelfOrNot { IncludeSelf, ExcludeSelf };
86
87 enum RepaintStatus {
88     NeedsNormalRepaint,
89     NeedsFullRepaint,
90     NeedsFullRepaintForPositionedMovementLayout
91 };
92
93 enum ClipRectsType {
94     PaintingClipRects, // Relative to painting ancestor. Used for painting.
95     RootRelativeClipRects, // Relative to the ancestor treated as the root (e.g. transformed layer). Used for hit testing.
96     AbsoluteClipRects, // Relative to the RenderView's layer. Used for compositing overlap testing.
97     NumCachedClipRectsTypes,
98     AllClipRectTypes,
99     TemporaryClipRects
100 };
101
102 enum ShouldRespectOverflowClip {
103     IgnoreOverflowClip,
104     RespectOverflowClip
105 };
106
107 enum ShouldApplyRootOffsetToFragments {
108     ApplyRootOffsetToFragments,
109     IgnoreRootOffsetForFragments
110 };
111
112 enum class RequestState {
113     Unknown,
114     DontCare,
115     False,
116     True,
117     Undetermined
118 };
119
120 struct ScrollRectToVisibleOptions {
121     SelectionRevealMode revealMode { SelectionRevealMode::Reveal };
122     const ScrollAlignment& alignX { ScrollAlignment::alignCenterIfNeeded };
123     const ScrollAlignment& alignY { ScrollAlignment::alignCenterIfNeeded };
124     ShouldAllowCrossOriginScrolling shouldAllowCrossOriginScrolling { ShouldAllowCrossOriginScrolling::No };
125 };
126
127 class RenderLayer final : public ScrollableArea {
128     WTF_MAKE_FAST_ALLOCATED;
129 public:
130     friend class RenderReplica;
131     friend class RenderLayerFilters;
132
133     explicit RenderLayer(RenderLayerModelObject&);
134     virtual ~RenderLayer();
135
136 #if PLATFORM(IOS_FAMILY)
137     // Called before the renderer's widget (if any) has been nulled out.
138     void willBeDestroyed();
139 #endif
140     String name() const;
141
142     Page& page() const { return renderer().page(); }
143     RenderLayerModelObject& renderer() const { return m_renderer; }
144     RenderBox* renderBox() const { return is<RenderBox>(renderer()) ? &downcast<RenderBox>(renderer()) : nullptr; }
145
146     RenderLayer* parent() const { return m_parent; }
147     RenderLayer* previousSibling() const { return m_previous; }
148     RenderLayer* nextSibling() const { return m_next; }
149     RenderLayer* firstChild() const { return m_first; }
150     RenderLayer* lastChild() const { return m_last; }
151     bool isDescendantOf(const RenderLayer&) const;
152
153     // This does an ancestor tree walk. Avoid it!
154     const RenderLayer* root() const
155     {
156         const RenderLayer* curr = this;
157         while (curr->parent())
158             curr = curr->parent();
159         return curr;
160     }
161
162     void addChild(RenderLayer& newChild, RenderLayer* beforeChild = nullptr);
163     void removeChild(RenderLayer&);
164
165     void insertOnlyThisLayer();
166     void removeOnlyThisLayer();
167
168     bool isNormalFlowOnly() const { return m_isNormalFlowOnly; }
169
170     // isStackingContext is true for layers that we've determined should be stacking contexts for painting.
171     // Not all stacking contexts are CSS stacking contexts.
172     bool isStackingContext() const { return isCSSStackingContext() || m_isOpportunisticStackingContext; }
173
174     // isCSSStackingContext is true for layers that are stacking contexts from a CSS perspective.
175     // isCSSStackingContext() => isStackingContext().
176     // FIXME: m_forcedStackingContext should affect isStackingContext(), not isCSSStackingContext(), but doing so breaks media control mix-blend-mode.
177     bool isCSSStackingContext() const { return m_isCSSStackingContext || m_forcedStackingContext; }
178
179     // Gets the enclosing stacking context for this layer, excluding this layer itself.
180     RenderLayer* stackingContext() const;
181
182     // Gets the enclosing stacking container for this layer, possibly the layer
183     // itself, if it is a stacking container.
184     RenderLayer* enclosingStackingContext() { return isStackingContext() ? this : stackingContext(); }
185
186     RenderLayer* paintOrderParent() const;
187
188     void dirtyNormalFlowList();
189     void dirtyZOrderLists();
190     void dirtyStackingContextZOrderLists();
191
192     bool normalFlowListDirty() const { return m_normalFlowListDirty; }
193     bool zOrderListsDirty() const { return m_zOrderListsDirty; }
194
195 #if !ASSERT_DISABLED
196     bool layerListMutationAllowed() const { return m_layerListMutationAllowed; }
197     void setLayerListMutationAllowed(bool flag) { m_layerListMutationAllowed = flag; }
198 #endif
199
200 private:
201     // These flags propagate in paint order (z-order tree).
202     enum class Compositing {
203         HasDescendantNeedingRequirementsTraversal           = 1 << 0, // Need to do the overlap-testing tree walk because hierarchy or geometry changed.
204         HasDescendantNeedingBackingOrHierarchyTraversal     = 1 << 1, // Need to update geometry, configuration and update the GraphicsLayer tree.
205
206         // Things that trigger HasDescendantNeedingRequirementsTraversal
207         NeedsPaintOrderChildrenUpdate                       = 1 << 2, // The paint order children of this layer changed (gained/lost child, order change).
208         NeedsPostLayoutUpdate                               = 1 << 3, // Needs compositing to be re-evaluated after layout (it depends on geometry).
209         DescendantsNeedRequirementsTraversal                = 1 << 4, // Something changed that forces computeCompositingRequirements to traverse all descendant layers.
210         SubsequentLayersNeedRequirementsTraversal           = 1 << 5, // Something changed that forces computeCompositingRequirements to traverse all layers later in paint order.
211
212         // Things that trigger HasDescendantNeedingBackingOrHierarchyTraversal
213         NeedsGeometryUpdate                                 = 1 << 6, // This layer needs a geometry update.
214         NeedsConfigurationUpdate                            = 1 << 7, // This layer needs a configuration update (updating its internal compositing hierarchy).
215         NeedsScrollingTreeUpdate                            = 1 << 8, // Something changed that requires this layer's scrolling tree node to be updated.
216         NeedsLayerConnection                                = 1 << 9, // This layer needs hookup with its parents or children.
217         ChildrenNeedGeometryUpdate                          = 1 << 10, // This layer's composited children need a geometry update.
218         DescendantsNeedBackingAndHierarchyTraversal         = 1 << 11, // Something changed that forces us to traverse all descendant layers in updateBackingAndHierarchy.
219     };
220
221     static constexpr OptionSet<Compositing> computeCompositingRequirementsFlags()
222     {
223         return {
224             Compositing::NeedsPaintOrderChildrenUpdate,
225             Compositing::NeedsPostLayoutUpdate,
226             Compositing::DescendantsNeedRequirementsTraversal,
227             Compositing::SubsequentLayersNeedRequirementsTraversal,
228         };
229     }
230
231     static constexpr OptionSet<Compositing> updateBackingOrHierarchyFlags()
232     {
233         return {
234             Compositing::NeedsLayerConnection,
235             Compositing::NeedsGeometryUpdate,
236             Compositing::NeedsConfigurationUpdate,
237             Compositing::NeedsScrollingTreeUpdate,
238             Compositing::ChildrenNeedGeometryUpdate,
239             Compositing::DescendantsNeedBackingAndHierarchyTraversal,
240         };
241     }
242
243     void setAncestorsHaveCompositingDirtyFlag(Compositing);
244
245 public:
246     bool hasDescendantNeedingCompositingRequirementsTraversal() const { return m_compositingDirtyBits.contains(Compositing::HasDescendantNeedingRequirementsTraversal); }
247     bool hasDescendantNeedingUpdateBackingOrHierarchyTraversal() const { return m_compositingDirtyBits.contains(Compositing::HasDescendantNeedingBackingOrHierarchyTraversal); }
248
249     bool needsCompositingPaintOrderChildrenUpdate() const { return m_compositingDirtyBits.contains(Compositing::NeedsPaintOrderChildrenUpdate); }
250     bool needsPostLayoutCompositingUpdate() const { return m_compositingDirtyBits.contains(Compositing::NeedsPostLayoutUpdate); }
251     bool descendantsNeedCompositingRequirementsTraversal() const { return m_compositingDirtyBits.contains(Compositing::DescendantsNeedRequirementsTraversal); }
252     bool subsequentLayersNeedCompositingRequirementsTraversal() const { return m_compositingDirtyBits.contains(Compositing::SubsequentLayersNeedRequirementsTraversal); }
253
254     bool needsCompositingLayerConnection() const { return m_compositingDirtyBits.contains(Compositing::NeedsLayerConnection); }
255     bool needsCompositingGeometryUpdate() const { return m_compositingDirtyBits.contains(Compositing::NeedsGeometryUpdate); }
256     bool needsCompositingConfigurationUpdate() const { return m_compositingDirtyBits.contains(Compositing::NeedsConfigurationUpdate); }
257     bool needsScrollingTreeUpdate() const { return m_compositingDirtyBits.contains(Compositing::NeedsScrollingTreeUpdate); }
258     bool childrenNeedCompositingGeometryUpdate() const { return m_compositingDirtyBits.contains(Compositing::ChildrenNeedGeometryUpdate); }
259     bool descendantsNeedUpdateBackingAndHierarchyTraversal() const { return m_compositingDirtyBits.contains(Compositing::DescendantsNeedBackingAndHierarchyTraversal); }
260
261     template<Compositing V>
262     void setRequirementsTraversalDirtyBit()
263     {
264         m_compositingDirtyBits.add(V);
265         setAncestorsHaveCompositingDirtyFlag(Compositing::HasDescendantNeedingRequirementsTraversal);
266     }
267
268     void setNeedsCompositingPaintOrderChildrenUpdate() { setRequirementsTraversalDirtyBit<Compositing::NeedsPaintOrderChildrenUpdate>(); }
269     void setNeedsPostLayoutCompositingUpdate() { setRequirementsTraversalDirtyBit<Compositing::NeedsPostLayoutUpdate>(); }
270     void setDescendantsNeedCompositingRequirementsTraversal() { setRequirementsTraversalDirtyBit<Compositing::DescendantsNeedRequirementsTraversal>(); }
271     void setSubsequentLayersNeedCompositingRequirementsTraversal() { setRequirementsTraversalDirtyBit<Compositing::SubsequentLayersNeedRequirementsTraversal>(); }
272
273     void setNeedsPostLayoutCompositingUpdateOnAncestors() { setAncestorsHaveCompositingDirtyFlag(Compositing::NeedsPostLayoutUpdate); }
274
275     template<Compositing V>
276     void setBackingAndHierarchyTraversalDirtyBit()
277     {
278         m_compositingDirtyBits.add(V);
279         setAncestorsHaveCompositingDirtyFlag(Compositing::HasDescendantNeedingBackingOrHierarchyTraversal);
280     }
281
282     void setNeedsCompositingLayerConnection() { setBackingAndHierarchyTraversalDirtyBit<Compositing::NeedsLayerConnection>(); }
283     void setNeedsCompositingGeometryUpdate() { setBackingAndHierarchyTraversalDirtyBit<Compositing::NeedsGeometryUpdate>(); }
284     void setNeedsCompositingConfigurationUpdate() { setBackingAndHierarchyTraversalDirtyBit<Compositing::NeedsConfigurationUpdate>(); }
285     void setNeedsScrollingTreeUpdate() { setBackingAndHierarchyTraversalDirtyBit<Compositing::NeedsScrollingTreeUpdate>(); }
286     void setChildrenNeedCompositingGeometryUpdate() { setBackingAndHierarchyTraversalDirtyBit<Compositing::ChildrenNeedGeometryUpdate>(); }
287     void setDescendantsNeedUpdateBackingAndHierarchyTraversal() { setBackingAndHierarchyTraversalDirtyBit<Compositing::DescendantsNeedBackingAndHierarchyTraversal>(); }
288
289     void setNeedsCompositingGeometryUpdateOnAncestors() { setAncestorsHaveCompositingDirtyFlag(Compositing::NeedsGeometryUpdate); }
290
291     bool needsCompositingRequirementsTraversal() const { return m_compositingDirtyBits.containsAny(computeCompositingRequirementsFlags()); }
292     void clearCompositingRequirementsTraversalState()
293     {
294         m_compositingDirtyBits.remove(Compositing::HasDescendantNeedingRequirementsTraversal);
295         m_compositingDirtyBits.remove(computeCompositingRequirementsFlags());
296     }
297
298     bool needsUpdateBackingOrHierarchyTraversal() const { return m_compositingDirtyBits.containsAny(updateBackingOrHierarchyFlags()); }
299     void clearUpdateBackingOrHierarchyTraversalState()
300     {
301         m_compositingDirtyBits.remove(Compositing::HasDescendantNeedingBackingOrHierarchyTraversal);
302         m_compositingDirtyBits.remove(updateBackingOrHierarchyFlags());
303     }
304
305     bool needsAnyCompositingTraversal() const { return !m_compositingDirtyBits.isEmpty(); }
306     void clearCompositingPaintOrderState() { m_compositingDirtyBits = { }; }
307
308     class LayerList {
309         friend class RenderLayer;
310     public:
311         using iterator = RenderLayer**;
312         using const_iterator = RenderLayer * const *;
313         using reverse_iterator = std::reverse_iterator<iterator>;
314         using const_reverse_iterator = std::reverse_iterator<const_iterator>;
315
316         iterator begin() { return m_layerList ? m_layerList->begin() : nullptr; }
317         iterator end() { return m_layerList ? m_layerList->end() : nullptr; }
318
319         reverse_iterator rbegin() { return reverse_iterator(end()); }
320         reverse_iterator rend() { return reverse_iterator(begin()); }
321
322         const_iterator begin() const { return m_layerList ? m_layerList->begin() : nullptr; }
323         const_iterator end() const { return m_layerList ? m_layerList->end() : nullptr; }
324
325         const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
326         const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
327
328         size_t size() const { return m_layerList ? m_layerList->size() : 0; }
329
330     private:
331         LayerList(Vector<RenderLayer*>* layerList)
332             : m_layerList(layerList)
333         {
334         }
335         
336         Vector<RenderLayer*>* m_layerList;
337     };
338
339     LayerList normalFlowLayers() const
340     {
341         ASSERT(!m_normalFlowListDirty);
342         return LayerList(m_normalFlowList.get());
343     }
344
345     LayerList positiveZOrderLayers() const
346     {
347         ASSERT(!m_zOrderListsDirty);
348         ASSERT(isStackingContext() || !m_posZOrderList);
349         return LayerList(m_posZOrderList.get());
350     }
351
352     bool hasNegativeZOrderLayers() const
353     {
354         return m_negZOrderList && m_negZOrderList->size();
355     }
356
357     LayerList negativeZOrderLayers() const
358     {
359         ASSERT(!m_zOrderListsDirty);
360         ASSERT(isStackingContext() || !m_negZOrderList);
361         return LayerList(m_negZOrderList.get());
362     }
363
364     // Update our normal and z-index lists.
365     void updateLayerListsIfNeeded();
366     void updateDescendantDependentFlags();
367     bool descendantDependentFlagsAreDirty() const
368     {
369         return m_visibleDescendantStatusDirty || m_visibleContentStatusDirty || m_hasSelfPaintingLayerDescendantDirty
370 #if ENABLE(CSS_COMPOSITING)
371             || m_hasNotIsolatedBlendingDescendantsStatusDirty
372 #endif
373         ;
374     }
375
376     void repaintIncludingDescendants();
377
378     // Indicate that the layer contents need to be repainted. Only has an effect
379     // if layer compositing is being used.
380     void setBackingNeedsRepaint(GraphicsLayer::ShouldClipToLayer = GraphicsLayer::ClipToLayer);
381
382     // The rect is in the coordinate space of the layer's render object.
383     void setBackingNeedsRepaintInRect(const LayoutRect&, GraphicsLayer::ShouldClipToLayer = GraphicsLayer::ClipToLayer);
384     void repaintIncludingNonCompositingDescendants(RenderLayerModelObject* repaintContainer);
385
386     void styleChanged(StyleDifference, const RenderStyle* oldStyle);
387
388     RenderMarquee* marquee() const { return m_marquee.get(); }
389
390     bool isSelfPaintingLayer() const { return m_isSelfPaintingLayer; }
391
392     bool cannotBlitToWindow() const;
393
394     bool isTransparent() const { return renderer().isTransparent() || renderer().hasMask(); }
395
396     bool hasReflection() const { return renderer().hasReflection(); }
397     bool isReflection() const { return renderer().isReplica(); }
398     RenderReplica* reflection() const { return m_reflection.get(); }
399     RenderLayer* reflectionLayer() const;
400     bool isReflectionLayer(const RenderLayer&) const;
401
402     const LayoutPoint& location() const { return m_topLeft; }
403     void setLocation(const LayoutPoint& p) { m_topLeft = p; }
404
405     const IntSize& size() const { return m_layerSize; }
406     void setSize(const IntSize& size) { m_layerSize = size; } // Only public for RenderTreeAsText.
407
408     LayoutRect rect() const { return LayoutRect(location(), size()); }
409
410     IntSize visibleSize() const override;
411     IntSize contentsSize() const override;
412     IntSize reachableTotalContentsSize() const override;
413
414     int scrollWidth() const;
415     int scrollHeight() const;
416
417     void panScrollFromPoint(const IntPoint&);
418
419     // Scrolling methods for layers that can scroll their overflow.
420     void scrollByRecursively(const IntSize& delta, ScrollableArea** scrolledArea = nullptr);
421
422     WEBCORE_EXPORT void scrollToOffset(const ScrollOffset&, ScrollType = ScrollType::Programmatic, ScrollClamping = ScrollClamping::Clamped);
423
424     void scrollToXPosition(int x, ScrollType, ScrollClamping = ScrollClamping::Clamped);
425     void scrollToYPosition(int y, ScrollType, ScrollClamping = ScrollClamping::Clamped);
426
427     // These are only used by marquee.
428     void scrollToXOffset(int x) { scrollToOffset(ScrollOffset(x, scrollOffset().y()), ScrollType::Programmatic, ScrollClamping::Unclamped); }
429     void scrollToYOffset(int y) { scrollToOffset(ScrollOffset(scrollOffset().x(), y), ScrollType::Programmatic, ScrollClamping::Unclamped); }
430
431     void setPostLayoutScrollPosition(Optional<ScrollPosition>);
432     void applyPostLayoutScrollPositionIfNeeded();
433
434     ScrollOffset scrollOffset() const { return scrollOffsetFromPosition(m_scrollPosition); }
435
436     void availableContentSizeChanged(AvailableSizeChangeReason) override;
437
438     // "absoluteRect" is in scaled document coordinates.
439     void scrollRectToVisible(const LayoutRect& absoluteRect, bool insideFixed, const ScrollRectToVisibleOptions&);
440
441     bool scrollsOverflow() const;
442     bool hasScrollbars() const { return m_hBar || m_vBar; }
443     void setHasHorizontalScrollbar(bool);
444     void setHasVerticalScrollbar(bool);
445
446     Ref<Scrollbar> createScrollbar(ScrollbarOrientation);
447     void destroyScrollbar(ScrollbarOrientation);
448
449     bool hasHorizontalScrollbar() const { return horizontalScrollbar(); }
450     bool hasVerticalScrollbar() const { return verticalScrollbar(); }
451
452     bool horizontalScrollbarHiddenByStyle() const override;
453     bool verticalScrollbarHiddenByStyle() const override;
454
455     // ScrollableArea overrides
456     ScrollPosition scrollPosition() const override { return m_scrollPosition; }
457
458     Scrollbar* horizontalScrollbar() const override { return m_hBar.get(); }
459     Scrollbar* verticalScrollbar() const override { return m_vBar.get(); }
460     ScrollableArea* enclosingScrollableArea() const override;
461
462     bool isScrollableOrRubberbandable() override;
463     bool hasScrollableOrRubberbandableAncestor() override;
464     bool useDarkAppearance() const final;
465 #if ENABLE(CSS_SCROLL_SNAP)
466     void updateSnapOffsets() override;
467 #endif
468
469     bool requiresScrollPositionReconciliation() const { return m_requiresScrollPositionReconciliation; }
470     void setRequiresScrollPositionReconciliation(bool requiresReconciliation = true) { m_requiresScrollPositionReconciliation = requiresReconciliation; }
471
472 #if PLATFORM(IOS_FAMILY)
473 #if ENABLE(IOS_TOUCH_EVENTS)
474     bool handleTouchEvent(const PlatformTouchEvent&) override;
475 #endif
476     
477     void didStartScroll() override;
478     void didEndScroll() override;
479     void didUpdateScroll() override;
480 #endif
481
482     // Returns true when the layer could do touch scrolling, but doesn't look at whether there is actually scrollable overflow.
483     bool canUseCompositedScrolling() const;
484     // Returns true when there is actually scrollable overflow (requires layout to be up-to-date).
485     bool hasCompositedScrollableOverflow() const;
486
487     int verticalScrollbarWidth(OverlayScrollbarSizeRelevancy = IgnoreOverlayScrollbarSize) const;
488     int horizontalScrollbarHeight(OverlayScrollbarSizeRelevancy = IgnoreOverlayScrollbarSize) const;
489
490     bool hasOverflowControls() const;
491     bool isPointInResizeControl(const IntPoint& absolutePoint) const;
492     bool hitTestOverflowControls(HitTestResult&, const IntPoint& localPoint);
493     IntSize offsetFromResizeCorner(const IntPoint& absolutePoint) const;
494
495     void paintOverflowControls(GraphicsContext&, const IntPoint&, const IntRect& damageRect, bool paintingOverlayControls = false);
496     void paintScrollCorner(GraphicsContext&, const IntPoint&, const IntRect& damageRect);
497     void paintResizer(GraphicsContext&, const LayoutPoint&, const LayoutRect& damageRect);
498
499     void updateScrollInfoAfterLayout();
500
501     bool scroll(ScrollDirection, ScrollGranularity, float multiplier = 1);
502     void autoscroll(const IntPoint&);
503
504     bool canResize() const;
505     void resize(const PlatformMouseEvent&, const LayoutSize&);
506     bool inResizeMode() const { return m_inResizeMode; }
507     void setInResizeMode(bool b) { m_inResizeMode = b; }
508
509     bool isRenderViewLayer() const { return m_isRenderViewLayer; }
510     bool isForcedStackingContext() const { return m_forcedStackingContext; }
511     bool isOpportunisticStackingContext() const { return m_isOpportunisticStackingContext; }
512
513     RenderLayerCompositor& compositor() const;
514     
515     // Notification from the renderer that its content changed (e.g. current frame of image changed).
516     // Allows updates of layer content without repainting.
517     void contentChanged(ContentChangeType);
518
519     bool canRender3DTransforms() const;
520
521     enum UpdateLayerPositionsFlag {
522         CheckForRepaint                     = 1 << 0,
523         NeedsFullRepaintInBacking           = 1 << 1,
524         ContainingClippingLayerChangedSize  = 1 << 2,
525         UpdatePagination                    = 1 << 3,
526         SeenTransformedLayer                = 1 << 4,
527         Seen3DTransformedLayer              = 1 << 5,
528         SeenCompositedScrollingLayer        = 1 << 6,
529     };
530     static constexpr OptionSet<UpdateLayerPositionsFlag> updateLayerPositionsDefaultFlags() { return { CheckForRepaint }; }
531
532     void updateLayerPositionsAfterLayout(const RenderLayer* rootLayer, OptionSet<UpdateLayerPositionsFlag>);
533
534     void updateLayerPositionsAfterOverflowScroll();
535     void updateLayerPositionsAfterDocumentScroll();
536
537     bool hasCompositedLayerInEnclosingPaginationChain() const;
538     enum PaginationInclusionMode { ExcludeCompositedPaginatedLayers, IncludeCompositedPaginatedLayers };
539     RenderLayer* enclosingPaginationLayer(PaginationInclusionMode mode) const
540     {
541         if (mode == ExcludeCompositedPaginatedLayers && hasCompositedLayerInEnclosingPaginationChain())
542             return nullptr;
543         return m_enclosingPaginationLayer.get();
544     }
545
546     void updateTransform();
547     
548 #if ENABLE(CSS_COMPOSITING)
549     void updateBlendMode();
550 #endif
551
552     const LayoutSize& offsetForInFlowPosition() const { return m_offsetForInFlowPosition; }
553
554     void clearClipRectsIncludingDescendants(ClipRectsType typeToClear = AllClipRectTypes);
555     void clearClipRects(ClipRectsType typeToClear = AllClipRectTypes);
556
557     void addBlockSelectionGapsBounds(const LayoutRect&);
558     void clearBlockSelectionGapsBounds();
559     void repaintBlockSelectionGaps();
560
561     // FIXME: We should ASSERT(!m_visibleContentStatusDirty) here, but see https://bugs.webkit.org/show_bug.cgi?id=71044
562     // ditto for hasVisibleDescendant(), see https://bugs.webkit.org/show_bug.cgi?id=71277
563     bool hasVisibleContent() const { return m_hasVisibleContent; }
564     bool hasVisibleDescendant() const { return m_hasVisibleDescendant; }
565
566     void setHasVisibleContent();
567     void dirtyVisibleContentStatus();
568
569     bool hasVisibleBoxDecorationsOrBackground() const;
570     bool hasVisibleBoxDecorations() const;
571
572     struct PaintedContentRequest {
573         void makeStatesUndetermined()
574         {
575             if (hasPaintedContent == RequestState::Unknown)
576                 hasPaintedContent = RequestState::Undetermined;
577
578             if (hasSubpixelAntialiasedText == RequestState::Unknown)
579                 hasSubpixelAntialiasedText = RequestState::Undetermined;
580         }
581
582         void setHasPaintedContent() { hasPaintedContent = RequestState::True; }
583         void setHasSubpixelAntialiasedText() { hasSubpixelAntialiasedText = RequestState::True; }
584
585         bool needToDeterminePaintedContentState() const { return hasPaintedContent == RequestState::Unknown; }
586         bool needToDetermineSubpixelAntialiasedTextState() const { return hasSubpixelAntialiasedText == RequestState::Unknown; }
587
588         bool probablyHasPaintedContent() const { return hasPaintedContent == RequestState::True || hasPaintedContent == RequestState::Undetermined; }
589         bool probablyHasSubpixelAntialiasedText() const { return hasSubpixelAntialiasedText == RequestState::True || hasSubpixelAntialiasedText == RequestState::Undetermined; }
590         
591         bool isSatisfied() const { return hasPaintedContent != RequestState::Unknown && hasSubpixelAntialiasedText != RequestState::Unknown; }
592
593         RequestState hasPaintedContent { RequestState::Unknown };
594         RequestState hasSubpixelAntialiasedText { RequestState::DontCare };
595     };
596
597     // Returns true if this layer has visible content (ignoring any child layers).
598     bool isVisuallyNonEmpty(PaintedContentRequest* = nullptr) const;
599     // True if this layer container renderers that paint.
600     bool hasNonEmptyChildRenderers(PaintedContentRequest&) const;
601
602     // FIXME: We should ASSERT(!m_hasSelfPaintingLayerDescendantDirty); here but we hit the same bugs as visible content above.
603     // Part of the issue is with subtree relayout: we don't check if our ancestors have some descendant flags dirty, missing some updates.
604     bool hasSelfPaintingLayerDescendant() const { return m_hasSelfPaintingLayerDescendant; }
605
606     // Gets the nearest enclosing positioned ancestor layer (also includes
607     // the <html> layer and the root layer).
608     RenderLayer* enclosingAncestorForPosition(PositionType) const;
609
610     // Returns the nearest enclosing layer that is scrollable.
611     RenderLayer* enclosingScrollableLayer() const;
612
613     // The layer relative to which clipping rects for this layer are computed.
614     RenderLayer* clippingRootForPainting() const;
615
616     RenderLayer* enclosingOverflowClipLayer(IncludeSelfOrNot) const;
617
618     // Enclosing compositing layer; if includeSelf is true, may return this.
619     RenderLayer* enclosingCompositingLayer(IncludeSelfOrNot = IncludeSelf) const;
620     RenderLayer* enclosingCompositingLayerForRepaint(IncludeSelfOrNot = IncludeSelf) const;
621     // Ancestor compositing layer, excluding this.
622     RenderLayer* ancestorCompositingLayer() const { return enclosingCompositingLayer(ExcludeSelf); }
623
624     RenderLayer* enclosingFilterLayer(IncludeSelfOrNot = IncludeSelf) const;
625     RenderLayer* enclosingFilterRepaintLayer() const;
626     void setFilterBackendNeedsRepaintingInRect(const LayoutRect&);
627     bool hasAncestorWithFilterOutsets() const;
628
629     bool canUseConvertToLayerCoords() const
630     {
631         // These RenderObject have an impact on their layers' without them knowing about it.
632         return !renderer().hasTransform() && !renderer().isSVGRoot();
633     }
634
635     // FIXME: adjustForColumns allows us to position compositing layers in columns correctly, but eventually they need to be split across columns too.
636     enum ColumnOffsetAdjustment { DontAdjustForColumns, AdjustForColumns };
637     void convertToPixelSnappedLayerCoords(const RenderLayer* ancestorLayer, IntPoint& location, ColumnOffsetAdjustment adjustForColumns = DontAdjustForColumns) const;
638     LayoutPoint convertToLayerCoords(const RenderLayer* ancestorLayer, const LayoutPoint&, ColumnOffsetAdjustment adjustForColumns = DontAdjustForColumns) const;
639     LayoutSize offsetFromAncestor(const RenderLayer*, ColumnOffsetAdjustment = DontAdjustForColumns) const;
640
641     int zIndex() const { return renderer().style().zIndex(); }
642
643     enum PaintLayerFlag {
644         PaintLayerHaveTransparency                      = 1 << 0,
645         PaintLayerAppliedTransform                      = 1 << 1,
646         PaintLayerTemporaryClipRects                    = 1 << 2,
647         PaintLayerPaintingReflection                    = 1 << 3,
648         PaintLayerPaintingOverlayScrollbars             = 1 << 4,
649         PaintLayerPaintingCompositingBackgroundPhase    = 1 << 5,
650         PaintLayerPaintingCompositingForegroundPhase    = 1 << 6,
651         PaintLayerPaintingCompositingMaskPhase          = 1 << 7,
652         PaintLayerPaintingCompositingClipPathPhase      = 1 << 8,
653         PaintLayerPaintingCompositingScrollingPhase     = 1 << 9,
654         PaintLayerPaintingOverflowContents              = 1 << 10,
655         PaintLayerPaintingRootBackgroundOnly            = 1 << 11,
656         PaintLayerPaintingSkipRootBackground            = 1 << 12,
657         PaintLayerPaintingChildClippingMaskPhase        = 1 << 13,
658         PaintLayerCollectingEventRegion                 = 1 << 14,
659     };
660     static constexpr OptionSet<PaintLayerFlag> paintLayerPaintingCompositingAllPhasesFlags() { return { PaintLayerPaintingCompositingBackgroundPhase, PaintLayerPaintingCompositingForegroundPhase }; }
661
662     enum class SecurityOriginPaintPolicy { AnyOrigin, AccessibleOriginOnly };
663
664     // The two main functions that use the layer system.  The paint method
665     // paints the layers that intersect the damage rect from back to
666     // front.  The hitTest method looks for mouse events by walking
667     // layers that intersect the point from front to back.
668     void paint(GraphicsContext&, const LayoutRect& damageRect, const LayoutSize& subpixelOffset = LayoutSize(), OptionSet<PaintBehavior> = PaintBehavior::Normal,
669         RenderObject* subtreePaintRoot = nullptr, OptionSet<PaintLayerFlag> = { }, SecurityOriginPaintPolicy = SecurityOriginPaintPolicy::AnyOrigin);
670     bool hitTest(const HitTestRequest&, HitTestResult&);
671     bool hitTest(const HitTestRequest&, const HitTestLocation&, HitTestResult&);
672     void paintOverlayScrollbars(GraphicsContext&, const LayoutRect& damageRect, OptionSet<PaintBehavior>, RenderObject* subtreePaintRoot = nullptr);
673
674     struct ClipRectsContext {
675         ClipRectsContext(const RenderLayer* inRootLayer, ClipRectsType inClipRectsType, OverlayScrollbarSizeRelevancy inOverlayScrollbarSizeRelevancy = IgnoreOverlayScrollbarSize, ShouldRespectOverflowClip inRespectOverflowClip = RespectOverflowClip)
676             : rootLayer(inRootLayer)
677             , clipRectsType(inClipRectsType)
678             , overlayScrollbarSizeRelevancy(inOverlayScrollbarSizeRelevancy)
679             , respectOverflowClip(inRespectOverflowClip)
680         { }
681         const RenderLayer* rootLayer;
682         ClipRectsType clipRectsType;
683         OverlayScrollbarSizeRelevancy overlayScrollbarSizeRelevancy;
684         ShouldRespectOverflowClip respectOverflowClip;
685     };
686
687     // This method figures out our layerBounds in coordinates relative to
688     // |rootLayer}.  It also computes our background and foreground clip rects
689     // for painting/event handling.
690     // Pass offsetFromRoot if known.
691     void calculateRects(const ClipRectsContext&, const LayoutRect& paintDirtyRect, LayoutRect& layerBounds,
692         ClipRect& backgroundRect, ClipRect& foregroundRect, const LayoutSize& offsetFromRoot) const;
693
694     // Public just for RenderTreeAsText.
695     void collectFragments(LayerFragments&, const RenderLayer* rootLayer, const LayoutRect& dirtyRect,
696         PaginationInclusionMode,
697         ClipRectsType, OverlayScrollbarSizeRelevancy inOverlayScrollbarSizeRelevancy, ShouldRespectOverflowClip, const LayoutSize& offsetFromRoot,
698         const LayoutRect* layerBoundingBox = nullptr, ShouldApplyRootOffsetToFragments = IgnoreRootOffsetForFragments);
699         
700     LayoutRect childrenClipRect() const; // Returns the foreground clip rect of the layer in the document's coordinate space.
701     LayoutRect selfClipRect() const; // Returns the background clip rect of the layer in the document's coordinate space.
702     LayoutRect localClipRect(bool& clipExceedsBounds) const; // Returns the background clip rect of the layer in the local coordinate space.
703
704     // Pass offsetFromRoot if known.
705     bool intersectsDamageRect(const LayoutRect& layerBounds, const LayoutRect& damageRect, const RenderLayer* rootLayer, const LayoutSize& offsetFromRoot, const LayoutRect* cachedBoundingBox = nullptr) const;
706
707     enum CalculateLayerBoundsFlag {
708         IncludeSelfTransform                    = 1 << 0,
709         UseLocalClipRectIfPossible              = 1 << 1,
710         IncludeFilterOutsets                    = 1 << 2,
711         IncludePaintedFilterOutsets             = 1 << 3,
712         ExcludeHiddenDescendants                = 1 << 4,
713         DontConstrainForMask                    = 1 << 5,
714         IncludeCompositedDescendants            = 1 << 6,
715         UseFragmentBoxesExcludingCompositing    = 1 << 7,
716         UseFragmentBoxesIncludingCompositing    = 1 << 8,
717     };
718     static constexpr OptionSet<CalculateLayerBoundsFlag> defaultCalculateLayerBoundsFlags() { return { IncludeSelfTransform, UseLocalClipRectIfPossible, IncludePaintedFilterOutsets, UseFragmentBoxesExcludingCompositing }; }
719
720     // Bounding box relative to some ancestor layer. Pass offsetFromRoot if known.
721     LayoutRect boundingBox(const RenderLayer* rootLayer, const LayoutSize& offsetFromRoot = LayoutSize(), OptionSet<CalculateLayerBoundsFlag> = { }) const;
722     // Bounding box in the coordinates of this layer.
723     LayoutRect localBoundingBox(OptionSet<CalculateLayerBoundsFlag> = { }) const;
724     // Deprecated: Pixel snapped bounding box relative to the root.
725     WEBCORE_EXPORT IntRect absoluteBoundingBox() const;
726     // Device pixel snapped bounding box relative to the root. absoluteBoundingBox() callers will be directed to this.
727     FloatRect absoluteBoundingBoxForPainting() const;
728
729     // Bounds used for layer overlap testing in RenderLayerCompositor.
730     LayoutRect overlapBounds() const;
731     
732     // Takes transform animations into account, returning true if they could be cheaply computed.
733     // Unlike overlapBounds, these bounds include descendant layers.
734     bool getOverlapBoundsIncludingChildrenAccountingForTransformAnimations(LayoutRect&, OptionSet<CalculateLayerBoundsFlag> additionalFlags = { }) const;
735
736     // If true, this layer's children are included in its bounds for overlap testing.
737     // We can't rely on the children's positions if this layer has a filter that could have moved the children's pixels around.
738     bool overlapBoundsIncludeChildren() const { return hasFilter() && renderer().style().filter().hasFilterThatMovesPixels(); }
739
740     // Can pass offsetFromRoot if known.
741     LayoutRect calculateLayerBounds(const RenderLayer* ancestorLayer, const LayoutSize& offsetFromRoot, OptionSet<CalculateLayerBoundsFlag> = defaultCalculateLayerBoundsFlags()) const;
742     
743     // Return a cached repaint rect, computed relative to the layer renderer's containerForRepaint.
744     bool hasComputedRepaintRects() const { return renderer().hasRepaintLayoutRects(); }
745     LayoutRect repaintRectIncludingNonCompositingDescendants() const;
746
747     void setRepaintStatus(RepaintStatus status) { m_repaintStatus = status; }
748     RepaintStatus repaintStatus() const { return static_cast<RepaintStatus>(m_repaintStatus); }
749
750     LayoutUnit staticInlinePosition() const { return m_staticInlinePosition; }
751     LayoutUnit staticBlockPosition() const { return m_staticBlockPosition; }
752    
753     void setStaticInlinePosition(LayoutUnit position) { m_staticInlinePosition = position; }
754     void setStaticBlockPosition(LayoutUnit position) { m_staticBlockPosition = position; }
755
756 #if PLATFORM(IOS_FAMILY)
757     bool adjustForIOSCaretWhenScrolling() const { return m_adjustForIOSCaretWhenScrolling; }
758     void setAdjustForIOSCaretWhenScrolling(bool adjustForIOSCaretWhenScrolling) { m_adjustForIOSCaretWhenScrolling = adjustForIOSCaretWhenScrolling; }
759 #endif
760
761     bool hasTransform() const { return renderer().hasTransform(); }
762     // Note that this transform has the transform-origin baked in.
763     TransformationMatrix* transform() const { return m_transform.get(); }
764     // currentTransform computes a transform which takes accelerated animations into account. The
765     // resulting transform has transform-origin baked in. If the layer does not have a transform,
766     // returns the identity matrix.
767     TransformationMatrix currentTransform(RenderStyle::ApplyTransformOrigin = RenderStyle::IncludeTransformOrigin) const;
768     TransformationMatrix renderableTransform(OptionSet<PaintBehavior>) const;
769     
770     // Get the perspective transform, which is applied to transformed sublayers.
771     // Returns true if the layer has a -webkit-perspective.
772     // Note that this transform has the perspective-origin baked in.
773     TransformationMatrix perspectiveTransform() const;
774     FloatPoint perspectiveOrigin() const;
775     bool preserves3D() const { return renderer().style().transformStyle3D() == TransformStyle3D::Preserve3D; }
776     bool has3DTransform() const { return m_transform && !m_transform->isAffine(); }
777
778     void filterNeedsRepaint();
779     bool hasFilter() const { return renderer().hasFilter(); }
780     bool hasBackdropFilter() const
781     {
782 #if ENABLE(FILTERS_LEVEL_2)
783         return renderer().hasBackdropFilter();
784 #else
785         return false;
786 #endif
787     }
788
789 #if ENABLE(CSS_COMPOSITING)
790     bool hasBlendMode() const { return renderer().hasBlendMode(); }
791     BlendMode blendMode() const { return static_cast<BlendMode>(m_blendMode); }
792
793     bool isolatesCompositedBlending() const { return m_hasNotIsolatedCompositedBlendingDescendants && isCSSStackingContext(); }
794     bool hasNotIsolatedCompositedBlendingDescendants() const { return m_hasNotIsolatedCompositedBlendingDescendants; }
795     void setHasNotIsolatedCompositedBlendingDescendants(bool hasNotIsolatedCompositedBlendingDescendants)
796     {
797         m_hasNotIsolatedCompositedBlendingDescendants = hasNotIsolatedCompositedBlendingDescendants;
798     }
799
800     bool isolatesBlending() const { return hasNotIsolatedBlendingDescendants() && isCSSStackingContext(); }
801     
802     // FIXME: We should ASSERT(!m_hasNotIsolatedBlendingDescendantsStatusDirty); here but we hit the same bugs as visible content above.
803     bool hasNotIsolatedBlendingDescendants() const { return m_hasNotIsolatedBlendingDescendants; }
804     bool hasNotIsolatedBlendingDescendantsStatusDirty() const { return m_hasNotIsolatedBlendingDescendantsStatusDirty; }
805 #else
806     bool hasBlendMode() const { return false; }
807     bool isolatesCompositedBlending() const { return false; }
808     bool isolatesBlending() const { return false; }
809     bool hasNotIsolatedBlendingDescendantsStatusDirty() const { return false; }
810 #endif
811
812     bool isComposited() const { return m_backing != nullptr; }
813     bool hasCompositingDescendant() const { return m_hasCompositingDescendant; }
814     bool hasCompositedMask() const;
815
816     RenderLayerBacking* backing() const { return m_backing.get(); }
817     RenderLayerBacking* ensureBacking();
818     void clearBacking(bool layerBeingDestroyed = false);
819
820     GraphicsLayer* layerForHorizontalScrollbar() const override;
821     GraphicsLayer* layerForVerticalScrollbar() const override;
822     GraphicsLayer* layerForScrollCorner() const override;
823
824     bool usesCompositedScrolling() const override;
825     bool usesAsyncScrolling() const override;
826
827     bool hasCompositedScrollingAncestor() const { return m_hasCompositedScrollingAncestor; }
828     void setHasCompositedScrollingAncestor(bool hasCompositedScrollingAncestor) { m_hasCompositedScrollingAncestor = hasCompositedScrollingAncestor; }
829
830     bool paintsWithTransparency(OptionSet<PaintBehavior> paintBehavior) const
831     {
832         return (isTransparent() || hasBlendMode() || (isolatesBlending() && !renderer().isDocumentElementRenderer())) && ((paintBehavior & PaintBehavior::FlattenCompositingLayers) || !isComposited());
833     }
834
835     bool paintsWithTransform(OptionSet<PaintBehavior>) const;
836     bool shouldPaintMask(OptionSet<PaintBehavior>, OptionSet<PaintLayerFlag>) const;
837     bool shouldApplyClipPath(OptionSet<PaintBehavior>, OptionSet<PaintLayerFlag>) const;
838
839     // Returns true if background phase is painted opaque in the given rect.
840     // The query rect is given in local coordinates.
841     bool backgroundIsKnownToBeOpaqueInRect(const LayoutRect&) const;
842
843     bool scrollingMayRevealBackground() const;
844
845     bool containsDirtyOverlayScrollbars() const { return m_containsDirtyOverlayScrollbars; }
846     void setContainsDirtyOverlayScrollbars(bool dirtyScrollbars) { m_containsDirtyOverlayScrollbars = dirtyScrollbars; }
847
848     bool paintsWithFilters() const;
849     bool requiresFullLayerImageForFilters() const;
850
851     Element* enclosingElement() const;
852
853     enum ViewportConstrainedNotCompositedReason {
854         NoNotCompositedReason,
855         NotCompositedForBoundsOutOfView,
856         NotCompositedForNonViewContainer,
857         NotCompositedForNoVisibleContent,
858     };
859
860     void setViewportConstrainedNotCompositedReason(ViewportConstrainedNotCompositedReason reason) { m_viewportConstrainedNotCompositedReason = reason; }
861     ViewportConstrainedNotCompositedReason viewportConstrainedNotCompositedReason() const { return static_cast<ViewportConstrainedNotCompositedReason>(m_viewportConstrainedNotCompositedReason); }
862     
863     bool isRenderFragmentedFlow() const { return renderer().isRenderFragmentedFlow(); }
864     bool isOutOfFlowRenderFragmentedFlow() const { return renderer().isOutOfFlowRenderFragmentedFlow(); }
865     bool isInsideFragmentedFlow() const { return renderer().fragmentedFlowState() != RenderObject::NotInsideFragmentedFlow; }
866     bool isDirtyRenderFragmentedFlow() const
867     {
868         ASSERT(isRenderFragmentedFlow());
869         return zOrderListsDirty() || normalFlowListDirty();
870     }
871
872     RenderLayer* enclosingFragmentedFlowAncestor() const;
873
874     bool shouldPlaceBlockDirectionScrollbarOnLeft() const final { return renderer().shouldPlaceBlockDirectionScrollbarOnLeft(); }
875
876     void simulateFrequentPaint() { SinglePaintFrequencyTracking { m_paintFrequencyTracker }; }
877     bool paintingFrequently() const { return m_paintFrequencyTracker.paintingFrequently(); }
878
879     WEBCORE_EXPORT bool isTransparentOrFullyClippedRespectingParentFrames() const;
880
881     void invalidateEventRegion();
882
883 private:
884
885     void setNextSibling(RenderLayer* next) { m_next = next; }
886     void setPreviousSibling(RenderLayer* prev) { m_previous = prev; }
887     void setParent(RenderLayer*);
888     void setFirstChild(RenderLayer* first) { m_first = first; }
889     void setLastChild(RenderLayer* last) { m_last = last; }
890     
891     void dirtyPaintOrderListsOnChildChange(RenderLayer&);
892
893     bool shouldBeNormalFlowOnly() const;
894     bool shouldBeCSSStackingContext() const;
895
896     // Return true if changed.
897     bool setIsNormalFlowOnly(bool);
898
899     bool setIsOpportunisticStackingContext(bool);
900     bool setIsCSSStackingContext(bool);
901     
902     void isStackingContextChanged();
903
904     bool isDirtyStackingContext() const { return m_zOrderListsDirty && isStackingContext(); }
905
906     void updateZOrderLists();
907     void rebuildZOrderLists();
908     void rebuildZOrderLists(std::unique_ptr<Vector<RenderLayer*>>&, std::unique_ptr<Vector<RenderLayer*>>&);
909     void collectLayers(bool includeHiddenLayers, std::unique_ptr<Vector<RenderLayer*>>&, std::unique_ptr<Vector<RenderLayer*>>&);
910     void clearZOrderLists();
911
912     void updateNormalFlowList();
913
914     struct LayerPaintingInfo {
915         LayerPaintingInfo(RenderLayer* inRootLayer, const LayoutRect& inDirtyRect, OptionSet<PaintBehavior> inPaintBehavior, const LayoutSize& inSubpixelOffset, RenderObject* inSubtreePaintRoot = nullptr, OverlapTestRequestMap* inOverlapTestRequests = nullptr, bool inRequireSecurityOriginAccessForWidgets = false)
916             : rootLayer(inRootLayer)
917             , subtreePaintRoot(inSubtreePaintRoot)
918             , paintDirtyRect(inDirtyRect)
919             , subpixelOffset(inSubpixelOffset)
920             , overlapTestRequests(inOverlapTestRequests)
921             , paintBehavior(inPaintBehavior)
922             , requireSecurityOriginAccessForWidgets(inRequireSecurityOriginAccessForWidgets)
923         { }
924
925         RenderLayer* rootLayer;
926         RenderObject* subtreePaintRoot; // Only paint descendants of this object.
927         LayoutRect paintDirtyRect; // Relative to rootLayer;
928         LayoutSize subpixelOffset;
929         OverlapTestRequestMap* overlapTestRequests; // May be null.
930         OptionSet<PaintBehavior> paintBehavior;
931         bool requireSecurityOriginAccessForWidgets;
932         bool clipToDirtyRect { true };
933         EventRegion* eventRegion { nullptr };
934     };
935
936     // Compute, cache and return clip rects computed with the given layer as the root.
937     Ref<ClipRects> updateClipRects(const ClipRectsContext&);
938     // Compute and return the clip rects. If useCached is true, will used previously computed clip rects on ancestors
939     // (rather than computing them all from scratch up the parent chain).
940     void calculateClipRects(const ClipRectsContext&, ClipRects&) const;
941     ClipRects* clipRects(const ClipRectsContext&) const;
942
943     void setAncestorChainHasSelfPaintingLayerDescendant();
944     void dirtyAncestorChainHasSelfPaintingLayerDescendantStatus();
945
946     void computeRepaintRects(const RenderLayerModelObject* repaintContainer, const RenderGeometryMap* = nullptr);
947     void computeRepaintRectsIncludingDescendants();
948     void clearRepaintRects();
949
950     LayoutRect clipRectRelativeToAncestor(RenderLayer* ancestor, LayoutSize offsetFromAncestor, const LayoutRect& constrainingRect) const;
951
952     void clipToRect(GraphicsContext&, const LayerPaintingInfo&, const ClipRect&, BorderRadiusClippingRule = IncludeSelfForBorderRadius);
953     void restoreClip(GraphicsContext&, const LayerPaintingInfo&, const ClipRect&);
954
955     bool shouldRepaintAfterLayout() const;
956
957     void updateSelfPaintingLayer();
958
959     void updateScrollbarsAfterStyleChange(const RenderStyle* oldStyle);
960     void updateScrollbarsAfterLayout();
961
962     // Returns true if the position changed.
963     bool updateLayerPosition(OptionSet<UpdateLayerPositionsFlag>* = nullptr);
964
965     void updateLayerPositions(RenderGeometryMap* = nullptr, OptionSet<UpdateLayerPositionsFlag> = updateLayerPositionsDefaultFlags());
966
967     enum UpdateLayerPositionsAfterScrollFlag {
968         IsOverflowScroll                        = 1 << 0,
969         HasSeenViewportConstrainedAncestor      = 1 << 1,
970         HasSeenAncestorWithOverflowClip         = 1 << 2,
971         HasChangedAncestor                      = 1 << 3,
972     };
973     void updateLayerPositionsAfterScroll(RenderGeometryMap*, OptionSet<UpdateLayerPositionsAfterScrollFlag> = { });
974
975     ScrollOffset clampScrollOffset(const ScrollOffset&) const;
976
977     RenderLayer* enclosingPaginationLayerInSubtree(const RenderLayer* rootLayer, PaginationInclusionMode) const;
978
979     LayoutPoint renderBoxLocation() const { return is<RenderBox>(renderer()) ? downcast<RenderBox>(renderer()).location() : LayoutPoint(); }
980
981     bool setupFontSubpixelQuantization(GraphicsContext&, bool& didQuantizeFonts);
982
983     Path computeClipPath(const LayoutSize& offsetFromRoot, LayoutRect& rootRelativeBounds, WindRule&) const;
984
985     bool setupClipPath(GraphicsContext&, const LayerPaintingInfo&, const LayoutSize& offsetFromRoot, LayoutRect& rootRelativeBounds, bool& rootRelativeBoundsComputed);
986
987     void ensureLayerFilters();
988     void clearLayerFilters();
989
990     RenderLayerFilters* filtersForPainting(GraphicsContext&, OptionSet<PaintLayerFlag>) const;
991     GraphicsContext* setupFilters(GraphicsContext& destinationContext, LayerPaintingInfo&, OptionSet<PaintLayerFlag>, const LayoutSize& offsetFromRoot, LayoutRect& rootRelativeBounds, bool& rootRelativeBoundsComputed);
992     void applyFilters(GraphicsContext& originalContext, const LayerPaintingInfo&, const LayerFragments&);
993
994     void paintLayer(GraphicsContext&, const LayerPaintingInfo&, OptionSet<PaintLayerFlag>);
995     void paintLayerContentsAndReflection(GraphicsContext&, const LayerPaintingInfo&, OptionSet<PaintLayerFlag>);
996     void paintLayerByApplyingTransform(GraphicsContext&, const LayerPaintingInfo&, OptionSet<PaintLayerFlag>, const LayoutSize& translationOffset = LayoutSize());
997     void paintLayerContents(GraphicsContext&, const LayerPaintingInfo&, OptionSet<PaintLayerFlag>);
998     void paintList(LayerList, GraphicsContext&, const LayerPaintingInfo&, OptionSet<PaintLayerFlag>);
999
1000     void updatePaintingInfoForFragments(LayerFragments&, const LayerPaintingInfo&, OptionSet<PaintLayerFlag>, bool shouldPaintContent, const LayoutSize& offsetFromRoot);
1001     void paintBackgroundForFragments(const LayerFragments&, GraphicsContext&, GraphicsContext& transparencyLayerContext,
1002         const LayoutRect& transparencyPaintDirtyRect, bool haveTransparency, const LayerPaintingInfo&, OptionSet<PaintBehavior>, RenderObject* paintingRootForRenderer);
1003     void paintForegroundForFragments(const LayerFragments&, GraphicsContext&, GraphicsContext& transparencyLayerContext,
1004         const LayoutRect& transparencyPaintDirtyRect, bool haveTransparency, const LayerPaintingInfo&, OptionSet<PaintBehavior>, RenderObject* paintingRootForRenderer);
1005     void paintForegroundForFragmentsWithPhase(PaintPhase, const LayerFragments&, GraphicsContext&, const LayerPaintingInfo&, OptionSet<PaintBehavior>, RenderObject* paintingRootForRenderer);
1006     void paintOutlineForFragments(const LayerFragments&, GraphicsContext&, const LayerPaintingInfo&, OptionSet<PaintBehavior>, RenderObject* paintingRootForRenderer);
1007     void paintOverflowControlsForFragments(const LayerFragments&, GraphicsContext&, const LayerPaintingInfo&);
1008     void paintMaskForFragments(const LayerFragments&, GraphicsContext&, const LayerPaintingInfo&, OptionSet<PaintBehavior>, RenderObject* paintingRootForRenderer);
1009     void paintChildClippingMaskForFragments(const LayerFragments&, GraphicsContext&, const LayerPaintingInfo&, OptionSet<PaintBehavior>, RenderObject* paintingRootForRenderer);
1010     void paintTransformedLayerIntoFragments(GraphicsContext&, const LayerPaintingInfo&, OptionSet<PaintLayerFlag>);
1011     void collectEventRegionForFragments(const LayerFragments&, GraphicsContext&, const LayerPaintingInfo&);
1012
1013     RenderLayer* transparentPaintingAncestor();
1014     void beginTransparencyLayers(GraphicsContext&, const LayerPaintingInfo&, const LayoutRect& dirtyRect);
1015
1016     RenderLayer* hitTestLayer(RenderLayer* rootLayer, RenderLayer* containerLayer, const HitTestRequest&, HitTestResult&,
1017         const LayoutRect& hitTestRect, const HitTestLocation&, bool appliedTransform,
1018         const HitTestingTransformState* = nullptr, double* zOffset = nullptr);
1019     RenderLayer* hitTestLayerByApplyingTransform(RenderLayer* rootLayer, RenderLayer* containerLayer, const HitTestRequest&, HitTestResult&,
1020         const LayoutRect& hitTestRect, const HitTestLocation&, const HitTestingTransformState* = nullptr, double* zOffset = nullptr,
1021         const LayoutSize& translationOffset = LayoutSize());
1022     RenderLayer* hitTestList(LayerList, RenderLayer* rootLayer, const HitTestRequest&, HitTestResult&,
1023         const LayoutRect& hitTestRect, const HitTestLocation&,
1024         const HitTestingTransformState*, double* zOffsetForDescendants, double* zOffset,
1025         const HitTestingTransformState* unflattenedTransformState, bool depthSortDescendants);
1026
1027     Ref<HitTestingTransformState> createLocalTransformState(RenderLayer* rootLayer, RenderLayer* containerLayer,
1028         const LayoutRect& hitTestRect, const HitTestLocation&,
1029         const HitTestingTransformState* containerTransformState,
1030         const LayoutSize& translationOffset = LayoutSize()) const;
1031     
1032     bool hitTestContents(const HitTestRequest&, HitTestResult&, const LayoutRect& layerBounds, const HitTestLocation&, HitTestFilter) const;
1033     bool hitTestContentsForFragments(const LayerFragments&, const HitTestRequest&, HitTestResult&, const HitTestLocation&, HitTestFilter, bool& insideClipRect) const;
1034     bool hitTestResizerInFragments(const LayerFragments&, const HitTestLocation&) const;
1035     RenderLayer* hitTestTransformedLayerInFragments(RenderLayer* rootLayer, RenderLayer* containerLayer, const HitTestRequest&, HitTestResult&,
1036         const LayoutRect& hitTestRect, const HitTestLocation&, const HitTestingTransformState* = nullptr, double* zOffset = nullptr);
1037
1038     bool listBackgroundIsKnownToBeOpaqueInRect(const LayerList&, const LayoutRect&) const;
1039
1040     void computeScrollDimensions();
1041     bool hasHorizontalOverflow() const;
1042     bool hasVerticalOverflow() const;
1043     bool hasScrollableHorizontalOverflow() const;
1044     bool hasScrollableVerticalOverflow() const;
1045
1046     bool showsOverflowControls() const;
1047
1048     bool shouldBeSelfPaintingLayer() const;
1049
1050     int scrollOffset(ScrollbarOrientation) const override;
1051     
1052     // ScrollableArea interface
1053     void invalidateScrollbarRect(Scrollbar&, const IntRect&) override;
1054     void invalidateScrollCornerRect(const IntRect&) override;
1055     bool isActive() const override;
1056     bool isScrollCornerVisible() const override;
1057     IntRect scrollCornerRect() const override;
1058     IntRect convertFromScrollbarToContainingView(const Scrollbar&, const IntRect&) const override;
1059     IntRect convertFromContainingViewToScrollbar(const Scrollbar&, const IntRect&) const override;
1060     IntPoint convertFromScrollbarToContainingView(const Scrollbar&, const IntPoint&) const override;
1061     IntPoint convertFromContainingViewToScrollbar(const Scrollbar&, const IntPoint&) const override;
1062     int scrollSize(ScrollbarOrientation) const override;
1063     void setScrollOffset(const ScrollOffset&) override;
1064     ScrollingNodeID scrollingNodeID() const override;
1065
1066     IntRect visibleContentRectInternal(VisibleContentRectIncludesScrollbars, VisibleContentRectBehavior) const override;
1067     IntSize overhangAmount() const override;
1068     IntPoint lastKnownMousePosition() const override;
1069     bool isHandlingWheelEvent() const override;
1070     bool shouldSuspendScrollAnimations() const override;
1071     IntRect scrollableAreaBoundingBox(bool* isInsideFixed = nullptr) const override;
1072     bool isRubberBandInProgress() const override;
1073     bool forceUpdateScrollbarsOnMainThreadForPerformanceTesting() const override;
1074 #if ENABLE(CSS_SCROLL_SNAP)
1075     bool isScrollSnapInProgress() const override;
1076 #endif
1077     bool usesMockScrollAnimator() const override;
1078     void logMockScrollAnimatorMessage(const String&) const override;
1079
1080 #if ENABLE(IOS_TOUCH_EVENTS)
1081     void registerAsTouchEventListenerForScrolling();
1082     void unregisterAsTouchEventListenerForScrolling();
1083 #endif
1084
1085     // Rectangle encompassing the scroll corner and resizer rect.
1086     LayoutRect scrollCornerAndResizerRect() const;
1087
1088     // NOTE: This should only be called by the overridden setScrollOffset from ScrollableArea.
1089     void scrollTo(const ScrollPosition&);
1090     void updateCompositingLayersAfterScroll();
1091
1092     IntSize scrollbarOffset(const Scrollbar&) const;
1093     
1094     void updateScrollableAreaSet(bool hasOverflow);
1095     
1096     bool allowsCurrentScroll() const;
1097
1098     void dirtyAncestorChainVisibleDescendantStatus();
1099     void setAncestorChainHasVisibleDescendant();
1100
1101     bool has3DTransformedDescendant() const { return m_has3DTransformedDescendant; }
1102
1103     bool hasTransformedAncestor() const { return m_hasTransformedAncestor; }
1104     bool has3DTransformedAncestor() const { return m_has3DTransformedAncestor; }
1105
1106     void dirty3DTransformedDescendantStatus();
1107     // Both updates the status, and returns true if descendants of this have 3d.
1108     bool update3DTransformedDescendantStatus();
1109
1110     void createReflection();
1111     void removeReflection();
1112
1113     RenderStyle createReflectionStyle();
1114     bool paintingInsideReflection() const { return m_paintingInsideReflection; }
1115     void setPaintingInsideReflection(bool b) { m_paintingInsideReflection = b; }
1116
1117     void updateFiltersAfterStyleChange();
1118     void updateFilterPaintingStrategy();
1119
1120 #if ENABLE(CSS_COMPOSITING)
1121     void updateAncestorChainHasBlendingDescendants();
1122     void dirtyAncestorChainHasBlendingDescendants();
1123 #endif
1124
1125     Ref<ClipRects> parentClipRects(const ClipRectsContext&) const;
1126     ClipRect backgroundClipRect(const ClipRectsContext&) const;
1127
1128     RenderLayer* enclosingTransformedAncestor() const;
1129
1130     LayoutRect getRectToExpose(const LayoutRect& visibleRect, const LayoutRect& exposeRect, bool insideFixed, const ScrollAlignment& alignX, const ScrollAlignment& alignY) const;
1131
1132     // Convert a point in absolute coords into layer coords, taking transforms into account
1133     LayoutPoint absoluteToContents(const LayoutPoint&) const;
1134
1135     void positionOverflowControls(const IntSize&);
1136     void updateScrollCornerStyle();
1137     void clearScrollCorner();
1138     void updateResizerStyle();
1139     void clearResizer();
1140
1141     void drawPlatformResizerImage(GraphicsContext&, const LayoutRect& resizerCornerRect);
1142
1143     void updatePagination();
1144
1145     void setHasCompositingDescendant(bool b)  { m_hasCompositingDescendant = b; }
1146     
1147     enum class IndirectCompositingReason {
1148         None,
1149         Stacking,
1150         OverflowScrollPositioning,
1151         Overlap,
1152         BackgroundLayer,
1153         GraphicalEffect, // opacity, mask, filter, transform etc.
1154         Perspective,
1155         Preserve3D
1156     };
1157     
1158     void setIndirectCompositingReason(IndirectCompositingReason reason) { m_indirectCompositingReason = static_cast<unsigned>(reason); }
1159     IndirectCompositingReason indirectCompositingReason() const { return static_cast<IndirectCompositingReason>(m_indirectCompositingReason); }
1160     bool mustCompositeForIndirectReasons() const { return m_indirectCompositingReason; }
1161
1162     friend class RenderLayerBacking;
1163     friend class RenderLayerCompositor;
1164     friend class RenderLayerModelObject;
1165
1166     LayoutUnit overflowTop() const;
1167     LayoutUnit overflowBottom() const;
1168     LayoutUnit overflowLeft() const;
1169     LayoutUnit overflowRight() const;
1170
1171     IntRect rectForHorizontalScrollbar(const IntRect& borderBoxRect) const;
1172     IntRect rectForVerticalScrollbar(const IntRect& borderBoxRect) const;
1173
1174     LayoutUnit verticalScrollbarStart(int minX, int maxX) const;
1175     LayoutUnit horizontalScrollbarStart(int minX) const;
1176
1177     bool overflowControlsIntersectRect(const IntRect& localRect) const;
1178
1179     OptionSet<Compositing> m_compositingDirtyBits;
1180
1181     const bool m_isRenderViewLayer : 1;
1182     const bool m_forcedStackingContext : 1;
1183
1184     bool m_isNormalFlowOnly : 1;
1185     bool m_isCSSStackingContext : 1;
1186     bool m_isOpportunisticStackingContext : 1;
1187
1188     bool m_zOrderListsDirty : 1;
1189     bool m_normalFlowListDirty: 1;
1190     bool m_hadNegativeZOrderList : 1;
1191
1192     // Keeps track of whether the layer is currently resizing, so events can cause resizing to start and stop.
1193     bool m_inResizeMode : 1;
1194
1195     bool m_scrollDimensionsDirty : 1;
1196     bool m_isSelfPaintingLayer : 1;
1197
1198     // If have no self-painting descendants, we don't have to walk our children during painting. This can lead to
1199     // significant savings, especially if the tree has lots of non-self-painting layers grouped together (e.g. table cells).
1200     bool m_hasSelfPaintingLayerDescendant : 1;
1201     bool m_hasSelfPaintingLayerDescendantDirty : 1;
1202
1203     bool m_usedTransparency : 1; // Tracks whether we need to close a transparent layer, i.e., whether
1204                                  // we ended up painting this layer or any descendants (and therefore need to
1205                                  // blend).
1206     bool m_paintingInsideReflection : 1;  // A state bit tracking if we are painting inside a replica.
1207     bool m_inOverflowRelayout : 1;
1208     unsigned m_repaintStatus : 2; // RepaintStatus
1209
1210     bool m_visibleContentStatusDirty : 1;
1211     bool m_hasVisibleContent : 1;
1212     bool m_visibleDescendantStatusDirty : 1;
1213     bool m_hasVisibleDescendant : 1;
1214     bool m_registeredScrollableArea : 1;
1215     bool m_isFixedIntersectingViewport : 1;
1216
1217     bool m_3DTransformedDescendantStatusDirty : 1;
1218     bool m_has3DTransformedDescendant : 1;  // Set on a stacking context layer that has 3D descendants anywhere
1219                                             // in a preserves3D hierarchy. Hint to do 3D-aware hit testing.
1220     bool m_hasCompositingDescendant : 1; // In the z-order tree.
1221
1222     bool m_hasCompositedScrollingAncestor : 1; // In the layer-order tree.
1223
1224     bool m_hasTransformedAncestor : 1;
1225     bool m_has3DTransformedAncestor : 1;
1226
1227     unsigned m_indirectCompositingReason : 3;
1228     unsigned m_viewportConstrainedNotCompositedReason : 2;
1229
1230 #if PLATFORM(IOS_FAMILY)
1231 #if ENABLE(IOS_TOUCH_EVENTS)
1232     bool m_registeredAsTouchEventListenerForScrolling : 1;
1233 #endif
1234     bool m_adjustForIOSCaretWhenScrolling : 1;
1235 #endif
1236
1237     bool m_requiresScrollPositionReconciliation : 1;
1238     bool m_containsDirtyOverlayScrollbars : 1;
1239     bool m_updatingMarqueePosition : 1;
1240
1241 #if !ASSERT_DISABLED
1242     bool m_layerListMutationAllowed : 1;
1243 #endif
1244
1245 #if ENABLE(CSS_COMPOSITING)
1246     unsigned m_blendMode : 5;
1247     bool m_hasNotIsolatedCompositedBlendingDescendants : 1;
1248     bool m_hasNotIsolatedBlendingDescendants : 1;
1249     bool m_hasNotIsolatedBlendingDescendantsStatusDirty : 1;
1250 #endif
1251
1252     RenderLayerModelObject& m_renderer;
1253
1254     RenderLayer* m_parent { nullptr };
1255     RenderLayer* m_previous { nullptr };
1256     RenderLayer* m_next { nullptr };
1257     RenderLayer* m_first { nullptr };
1258     RenderLayer* m_last { nullptr };
1259
1260     // For layers that establish stacking contexts, m_posZOrderList holds a sorted list of all the
1261     // descendant layers within the stacking context that have z-indices of 0 or greater
1262     // (auto will count as 0). m_negZOrderList holds descendants within our stacking context with negative
1263     // z-indices.
1264     std::unique_ptr<Vector<RenderLayer*>> m_posZOrderList;
1265     std::unique_ptr<Vector<RenderLayer*>> m_negZOrderList;
1266
1267     // This list contains child layers that cannot create stacking contexts and appear in normal flow order.
1268     std::unique_ptr<Vector<RenderLayer*>> m_normalFlowList;
1269
1270     // Our current relative position offset.
1271     LayoutSize m_offsetForInFlowPosition;
1272
1273     // Our (x,y) coordinates are in our parent layer's coordinate space.
1274     LayoutPoint m_topLeft;
1275
1276     // The layer's width/height
1277     IntSize m_layerSize;
1278
1279     ScrollPosition m_scrollPosition;
1280     Optional<ScrollPosition> m_postLayoutScrollPosition;
1281
1282     // The width/height of our scrolled area.
1283     IntSize m_scrollSize;
1284
1285     // For layers with overflow, we have a pair of scrollbars.
1286     RefPtr<Scrollbar> m_hBar;
1287     RefPtr<Scrollbar> m_vBar;
1288
1289     std::unique_ptr<ClipRectsCache> m_clipRectsCache;
1290     
1291     IntPoint m_cachedOverlayScrollbarOffset;
1292
1293     std::unique_ptr<RenderMarquee> m_marquee; // Used for <marquee>.
1294     
1295     // Cached normal flow values for absolute positioned elements with static left/top values.
1296     LayoutUnit m_staticInlinePosition;
1297     LayoutUnit m_staticBlockPosition;
1298
1299     std::unique_ptr<TransformationMatrix> m_transform;
1300     
1301     // May ultimately be extended to many replicas (with their own paint order).
1302     RenderPtr<RenderReplica> m_reflection;
1303
1304     // Renderers to hold our custom scroll corner and resizer.
1305     RenderPtr<RenderScrollbarPart> m_scrollCorner;
1306     RenderPtr<RenderScrollbarPart> m_resizer;
1307
1308     // Pointer to the enclosing RenderLayer that caused us to be paginated. It is 0 if we are not paginated.
1309     WeakPtr<RenderLayer> m_enclosingPaginationLayer;
1310
1311     IntRect m_blockSelectionGapsBounds;
1312
1313     std::unique_ptr<RenderLayerFilters> m_filters;
1314     std::unique_ptr<RenderLayerBacking> m_backing;
1315     
1316     PaintFrequencyTracker m_paintFrequencyTracker;
1317 };
1318
1319 inline void RenderLayer::clearZOrderLists()
1320 {
1321     ASSERT(!isStackingContext());
1322     ASSERT(layerListMutationAllowed());
1323
1324     m_posZOrderList = nullptr;
1325     m_negZOrderList = nullptr;
1326 }
1327
1328 inline void RenderLayer::updateZOrderLists()
1329 {
1330     if (!m_zOrderListsDirty)
1331         return;
1332
1333     if (!isStackingContext()) {
1334         clearZOrderLists();
1335         m_zOrderListsDirty = false;
1336         return;
1337     }
1338
1339     rebuildZOrderLists();
1340 }
1341
1342 inline RenderLayer* RenderLayer::paintOrderParent() const
1343 {
1344     return m_isNormalFlowOnly ? m_parent : stackingContext();
1345 }
1346
1347 #if !ASSERT_DISABLED
1348 class LayerListMutationDetector {
1349 public:
1350     LayerListMutationDetector(RenderLayer& layer)
1351         : m_layer(layer)
1352         , m_previousMutationAllowedState(layer.layerListMutationAllowed())
1353     {
1354         m_layer.setLayerListMutationAllowed(false);
1355     }
1356     
1357     ~LayerListMutationDetector()
1358     {
1359         m_layer.setLayerListMutationAllowed(m_previousMutationAllowedState);
1360     }
1361
1362 private:
1363     RenderLayer& m_layer;
1364     bool m_previousMutationAllowedState;
1365 };
1366 #endif
1367
1368 void makeMatrixRenderable(TransformationMatrix&, bool has3DRendering);
1369
1370 bool compositedWithOwnBackingStore(const RenderLayer&);
1371
1372 WTF::TextStream& operator<<(WTF::TextStream&, const RenderLayer&);
1373
1374 } // namespace WebCore
1375
1376 #if ENABLE(TREE_DEBUGGING)
1377 // Outside the WebCore namespace for ease of invocation from lldb.
1378 void showLayerTree(const WebCore::RenderLayer*);
1379 void showPaintOrderTree(const WebCore::RenderLayer*);
1380 void showLayerTree(const WebCore::RenderObject*);
1381 #endif