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