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