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