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