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