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