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