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