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