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