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