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