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