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