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