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