Fix repaint issues when resizing a window with centered content, for platforms with...
[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 "PaintInfo.h"
48 #include "RenderBox.h"
49 #include "ScrollableArea.h"
50 #include <wtf/OwnPtr.h>
51
52 #if ENABLE(CSS_FILTERS)
53 #include "RenderLayerFilterInfo.h"
54 #endif
55
56 namespace WebCore {
57
58 #if ENABLE(CSS_FILTERS)
59 class FilterEffectRenderer;
60 class FilterOperations;
61 #endif
62 class HitTestRequest;
63 class HitTestResult;
64 class HitTestingTransformState;
65 class RenderGeometryMap;
66 class RenderMarquee;
67 class RenderReplica;
68 class RenderScrollbarPart;
69 class RenderStyle;
70 class RenderView;
71 class Scrollbar;
72 class TransformationMatrix;
73
74 #if USE(ACCELERATED_COMPOSITING)
75 class RenderLayerBacking;
76 class RenderLayerCompositor;
77 #endif
78
79 enum BorderRadiusClippingRule { IncludeSelfForBorderRadius, DoNotIncludeSelfForBorderRadius };
80
81 enum RepaintStatus {
82     NeedsNormalRepaint = 0,
83     NeedsFullRepaint = 1 << 0,
84     NeedsFullRepaintForPositionedMovementLayout = 1 << 1
85 };
86
87 class ClipRect {
88 public:
89     ClipRect()
90     : m_hasRadius(false)
91     { }
92     
93     ClipRect(const LayoutRect& rect)
94     : m_rect(rect)
95     , m_hasRadius(false)
96     { }
97     
98     const LayoutRect& rect() const { return m_rect; }
99     void setRect(const LayoutRect& rect) { m_rect = rect; }
100
101     bool hasRadius() const { return m_hasRadius; }
102     void setHasRadius(bool hasRadius) { m_hasRadius = hasRadius; }
103
104     bool operator==(const ClipRect& other) const { return rect() == other.rect() && hasRadius() == other.hasRadius(); }
105     bool operator!=(const ClipRect& other) const { return rect() != other.rect() || hasRadius() != other.hasRadius(); }
106     bool operator!=(const LayoutRect& otherRect) const { return rect() != otherRect; }
107
108     void intersect(const LayoutRect& other) { m_rect.intersect(other); }
109     void intersect(const ClipRect& other)
110     {
111         m_rect.intersect(other.rect());
112         if (other.hasRadius())
113             m_hasRadius = true;
114     }
115     void move(LayoutUnit x, LayoutUnit y) { m_rect.move(x, y); }
116     void move(const LayoutSize& size) { m_rect.move(size); }
117
118     bool isEmpty() const { return m_rect.isEmpty(); }
119     bool intersects(const LayoutRect& rect) { return m_rect.intersects(rect); }
120     bool intersects(const HitTestLocation&);
121
122 private:
123     LayoutRect m_rect;
124     bool m_hasRadius;
125 };
126
127 inline ClipRect intersection(const ClipRect& a, const ClipRect& b)
128 {
129     ClipRect c = a;
130     c.intersect(b);
131     return c;
132 }
133
134 class ClipRects {
135     WTF_MAKE_FAST_ALLOCATED;
136 public:
137     static PassRefPtr<ClipRects> create()
138     {
139         return adoptRef(new ClipRects);
140     }
141
142     static PassRefPtr<ClipRects> create(const ClipRects& other)
143     {
144         return adoptRef(new ClipRects(other));
145     }
146
147     ClipRects()
148         : m_refCnt(1)
149         , m_fixed(false)
150     {
151     }
152
153     void reset(const LayoutRect& r)
154     {
155         m_overflowClipRect = r;
156         m_fixedClipRect = r;
157         m_posClipRect = r;
158         m_fixed = false;
159     }
160     
161     const ClipRect& overflowClipRect() const { return m_overflowClipRect; }
162     void setOverflowClipRect(const ClipRect& r) { m_overflowClipRect = r; }
163
164     const ClipRect& fixedClipRect() const { return m_fixedClipRect; }
165     void setFixedClipRect(const ClipRect&r) { m_fixedClipRect = r; }
166
167     const ClipRect& posClipRect() const { return m_posClipRect; }
168     void setPosClipRect(const ClipRect& r) { m_posClipRect = r; }
169
170     bool fixed() const { return m_fixed; }
171     void setFixed(bool fixed) { m_fixed = fixed; }
172
173     void ref() { m_refCnt++; }
174     void deref()
175     {
176         if (!--m_refCnt)
177             delete this;
178     }
179
180     bool operator==(const ClipRects& other) const
181     {
182         return m_overflowClipRect == other.overflowClipRect() &&
183                m_fixedClipRect == other.fixedClipRect() &&
184                m_posClipRect == other.posClipRect() &&
185                m_fixed == other.fixed();
186     }
187
188     ClipRects& operator=(const ClipRects& other)
189     {
190         m_overflowClipRect = other.overflowClipRect();
191         m_fixedClipRect = other.fixedClipRect();
192         m_posClipRect = other.posClipRect();
193         m_fixed = other.fixed();
194         return *this;
195     }
196
197 private:
198     ClipRects(const LayoutRect& r)
199         : m_overflowClipRect(r)
200         , m_fixedClipRect(r)
201         , m_posClipRect(r)
202         , m_refCnt(1)
203         , m_fixed(false)
204     {
205     }
206
207     ClipRects(const ClipRects& other)
208         : m_overflowClipRect(other.overflowClipRect())
209         , m_fixedClipRect(other.fixedClipRect())
210         , m_posClipRect(other.posClipRect())
211         , m_refCnt(1)
212         , m_fixed(other.fixed())
213     {
214     }
215
216     ClipRect m_overflowClipRect;
217     ClipRect m_fixedClipRect;
218     ClipRect m_posClipRect;
219     unsigned m_refCnt : 31;
220     bool m_fixed : 1;
221 };
222
223 enum ClipRectsType {
224     PaintingClipRects, // Relative to painting ancestor. Used for painting.
225     RootRelativeClipRects, // Relative to the ancestor treated as the root (e.g. transformed layer). Used for hit testing.
226     AbsoluteClipRects, // Relative to the RenderView's layer. Used for compositing overlap testing.
227     NumCachedClipRectsTypes,
228     AllClipRectTypes,
229     TemporaryClipRects
230 };
231
232 struct ClipRectsCache {
233     WTF_MAKE_FAST_ALLOCATED;
234 public:
235     ClipRectsCache()
236     {
237 #ifndef NDEBUG
238         for (int i = 0; i < NumCachedClipRectsTypes; ++i) {
239             m_clipRectsRoot[i] = 0;
240             m_respectingOverflowClip[i] = false;
241             m_scrollbarRelevancy[i] = IgnoreOverlayScrollbarSize;
242         }
243 #endif
244     }
245
246     RefPtr<ClipRects> m_clipRects[NumCachedClipRectsTypes];
247 #ifndef NDEBUG
248     const RenderLayer* m_clipRectsRoot[NumCachedClipRectsTypes];
249     bool m_respectingOverflowClip[NumCachedClipRectsTypes];
250     OverlayScrollbarSizeRelevancy m_scrollbarRelevancy[NumCachedClipRectsTypes];
251 #endif
252 };
253
254 class RenderLayer : public ScrollableArea {
255 public:
256     friend class RenderReplica;
257
258     RenderLayer(RenderLayerModelObject*);
259     ~RenderLayer();
260
261     RenderLayerModelObject* renderer() const { return m_renderer; }
262     RenderBox* renderBox() const { return m_renderer && m_renderer->isBox() ? toRenderBox(m_renderer) : 0; }
263     RenderLayer* parent() const { return m_parent; }
264     RenderLayer* previousSibling() const { return m_previous; }
265     RenderLayer* nextSibling() const { return m_next; }
266     RenderLayer* firstChild() const { return m_first; }
267     RenderLayer* lastChild() const { return m_last; }
268
269     void addChild(RenderLayer* newChild, RenderLayer* beforeChild = 0);
270     RenderLayer* removeChild(RenderLayer*);
271
272     void removeOnlyThisLayer();
273     void insertOnlyThisLayer();
274
275     void repaintIncludingDescendants();
276
277 #if USE(ACCELERATED_COMPOSITING)
278     // Indicate that the layer contents need to be repainted. Only has an effect
279     // if layer compositing is being used,
280     void setBackingNeedsRepaint();
281     void setBackingNeedsRepaintInRect(const LayoutRect&); // r is in the coordinate space of the layer's render object
282     void repaintIncludingNonCompositingDescendants(RenderLayerModelObject* repaintContainer);
283 #endif
284
285     void styleChanged(StyleDifference, const RenderStyle* oldStyle);
286
287     RenderMarquee* marquee() const { return m_marquee.get(); }
288
289     bool isNormalFlowOnly() const { return m_isNormalFlowOnly; }
290     bool isSelfPaintingLayer() const { return m_isSelfPaintingLayer; }
291
292     bool cannotBlitToWindow() const;
293
294     bool isTransparent() const;
295     RenderLayer* transparentPaintingAncestor();
296     void beginTransparencyLayers(GraphicsContext*, const RenderLayer* rootLayer, const LayoutRect& paintDirtyRect, PaintBehavior);
297
298     bool hasReflection() const { return renderer()->hasReflection(); }
299     bool isReflection() const { return renderer()->isReplica(); }
300     RenderReplica* reflection() const { return m_reflection; }
301     RenderLayer* reflectionLayer() const;
302
303     const RenderLayer* root() const
304     {
305         const RenderLayer* curr = this;
306         while (curr->parent())
307             curr = curr->parent();
308         return curr;
309     }
310     
311     const LayoutPoint& location() const { return m_topLeft; }
312     void setLocation(const LayoutPoint& p) { m_topLeft = p; }
313
314     const IntSize& size() const { return m_layerSize; }
315     void setSize(const IntSize& size) { m_layerSize = size; }
316
317     LayoutRect rect() const { return LayoutRect(location(), size()); }
318
319     int scrollWidth() const;
320     int scrollHeight() const;
321
322     void panScrollFromPoint(const IntPoint&);
323
324     enum ScrollOffsetClamping {
325         ScrollOffsetUnclamped,
326         ScrollOffsetClamped
327     };
328
329     // Scrolling methods for layers that can scroll their overflow.
330     void scrollByRecursively(const IntSize&, ScrollOffsetClamping = ScrollOffsetUnclamped);
331     void scrollToOffset(const IntSize&, ScrollOffsetClamping = ScrollOffsetUnclamped);
332     void scrollToXOffset(int x, ScrollOffsetClamping clamp = ScrollOffsetUnclamped) { scrollToOffset(IntSize(x, scrollYOffset()), clamp); }
333     void scrollToYOffset(int y, ScrollOffsetClamping clamp = ScrollOffsetUnclamped) { scrollToOffset(IntSize(scrollXOffset(), y), clamp); }
334
335     int scrollXOffset() const { return m_scrollOffset.width() + scrollOrigin().x(); }
336     int scrollYOffset() const { return m_scrollOffset.height() + scrollOrigin().y(); }
337     IntSize scrollOffset() const { return IntSize(scrollXOffset(), scrollYOffset()); }
338
339     void scrollRectToVisible(const LayoutRect&, const ScrollAlignment& alignX, const ScrollAlignment& alignY);
340
341     LayoutRect getRectToExpose(const LayoutRect& visibleRect, const LayoutRect& exposeRect, const ScrollAlignment& alignX, const ScrollAlignment& alignY);
342
343     bool scrollsOverflow() const;
344     bool allowsScrolling() const; // Returns true if at least one scrollbar is visible and enabled.
345     bool hasScrollbars() const { return m_hBar || m_vBar; }
346     void setHasHorizontalScrollbar(bool);
347     void setHasVerticalScrollbar(bool);
348
349     PassRefPtr<Scrollbar> createScrollbar(ScrollbarOrientation);
350     void destroyScrollbar(ScrollbarOrientation);
351
352     bool hasHorizontalScrollbar() const { return horizontalScrollbar(); }
353     bool hasVerticalScrollbar() const { return verticalScrollbar(); }
354
355     // ScrollableArea overrides
356     virtual Scrollbar* horizontalScrollbar() const { return m_hBar.get(); }
357     virtual Scrollbar* verticalScrollbar() const { return m_vBar.get(); }
358     virtual ScrollableArea* enclosingScrollableArea() const;
359
360     int verticalScrollbarWidth(OverlayScrollbarSizeRelevancy = IgnoreOverlayScrollbarSize) const;
361     int horizontalScrollbarHeight(OverlayScrollbarSizeRelevancy = IgnoreOverlayScrollbarSize) const;
362
363     bool hasOverflowControls() const;
364     bool isPointInResizeControl(const IntPoint& absolutePoint) const;
365     bool hitTestOverflowControls(HitTestResult&, const IntPoint& localPoint);
366     IntSize offsetFromResizeCorner(const IntPoint& absolutePoint) const;
367
368     void paintOverflowControls(GraphicsContext*, const IntPoint&, const IntRect& damageRect, bool paintingOverlayControls = false);
369     void paintScrollCorner(GraphicsContext*, const IntPoint&, const IntRect& damageRect);
370     void paintResizer(GraphicsContext*, const IntPoint&, const IntRect& damageRect);
371
372     void updateScrollInfoAfterLayout();
373
374     bool scroll(ScrollDirection, ScrollGranularity, float multiplier = 1);
375     void autoscroll();
376
377     void resize(const PlatformMouseEvent&, const LayoutSize&);
378     bool inResizeMode() const { return m_inResizeMode; }
379     void setInResizeMode(bool b) { m_inResizeMode = b; }
380
381     bool isRootLayer() const { return m_isRootLayer; }
382
383 #if USE(ACCELERATED_COMPOSITING)
384     RenderLayerCompositor* compositor() const;
385     
386     // Notification from the renderer that its content changed (e.g. current frame of image changed).
387     // Allows updates of layer content without repainting.
388     void contentChanged(ContentChangeType);
389 #endif
390
391     bool canRender3DTransforms() const;
392
393     enum UpdateLayerPositionsFlag {
394         CheckForRepaint = 1 << 0,
395         NeedsFullRepaintInBacking = 1 << 1,
396         IsCompositingUpdateRoot = 1 << 2,
397         UpdateCompositingLayers = 1 << 3,
398         UpdatePagination = 1 << 4
399     };
400     typedef unsigned UpdateLayerPositionsFlags;
401     static const UpdateLayerPositionsFlags defaultFlags = CheckForRepaint | IsCompositingUpdateRoot | UpdateCompositingLayers;
402
403     void updateLayerPositionsAfterLayout(const RenderLayer* rootLayer, UpdateLayerPositionsFlags);
404
405     void updateLayerPositionsAfterOverflowScroll();
406     void updateLayerPositionsAfterDocumentScroll();
407     
408     bool isPaginated() const { return m_isPaginated; }
409
410     void updateTransform();
411     
412 #if ENABLE(CSS_COMPOSITING)
413     void updateBlendMode();
414 #endif
415
416     const LayoutSize& offsetForInFlowPosition() const { return m_offsetForInFlowPosition; }
417
418     void clearClipRectsIncludingDescendants(ClipRectsType typeToClear = AllClipRectTypes);
419     void clearClipRects(ClipRectsType typeToClear = AllClipRectTypes);
420
421     void addBlockSelectionGapsBounds(const LayoutRect&);
422     void clearBlockSelectionGapsBounds();
423     void repaintBlockSelectionGaps();
424
425     // Get the enclosing stacking context for this layer.  A stacking context is a layer
426     // that has a non-auto z-index.
427     RenderLayer* stackingContext() const;
428     bool isStackingContext() const { return isStackingContext(renderer()->style()); }
429
430     void dirtyZOrderLists();
431     void dirtyStackingContextZOrderLists();
432
433     Vector<RenderLayer*>* posZOrderList() const
434     {
435         ASSERT(!m_zOrderListsDirty);
436         ASSERT(isStackingContext() || !m_posZOrderList);
437         return m_posZOrderList.get();
438     }
439
440     bool hasNegativeZOrderList() const { return negZOrderList() && negZOrderList()->size(); }
441
442     Vector<RenderLayer*>* negZOrderList() const
443     {
444         ASSERT(!m_zOrderListsDirty);
445         ASSERT(isStackingContext() || !m_negZOrderList);
446         return m_negZOrderList.get();
447     }
448
449     void dirtyNormalFlowList();
450     Vector<RenderLayer*>* normalFlowList() const { ASSERT(!m_normalFlowListDirty); return m_normalFlowList.get(); }
451
452     // Update our normal and z-index lists.
453     void updateLayerListsIfNeeded();
454
455     // FIXME: We should ASSERT(!m_visibleContentStatusDirty) here, but see https://bugs.webkit.org/show_bug.cgi?id=71044
456     // ditto for hasVisibleDescendant(), see https://bugs.webkit.org/show_bug.cgi?id=71277
457     bool hasVisibleContent() const { return m_hasVisibleContent; }
458     bool hasVisibleDescendant() const { return m_hasVisibleDescendant; }
459
460     void setHasVisibleContent();
461     void dirtyVisibleContentStatus();
462
463     // FIXME: We should ASSERT(!m_hasSelfPaintingLayerDescendantDirty); here but we hit the same bugs as visible content above.
464     // Part of the issue is with subtree relayout: we don't check if our ancestors have some descendant flags dirty, missing some updates.
465     bool hasSelfPaintingLayerDescendant() const { return m_hasSelfPaintingLayerDescendant; }
466
467     // Gets the nearest enclosing positioned ancestor layer (also includes
468     // the <html> layer and the root layer).
469     RenderLayer* enclosingPositionedAncestor() const;
470
471     // Returns the nearest enclosing layer that is scrollable.
472     RenderLayer* enclosingScrollableLayer() const;
473
474     // The layer relative to which clipping rects for this layer are computed.
475     RenderLayer* clippingRootForPainting() const;
476
477 #if USE(ACCELERATED_COMPOSITING)
478     // Enclosing compositing layer; if includeSelf is true, may return this.
479     RenderLayer* enclosingCompositingLayer(bool includeSelf = true) const;
480     RenderLayer* enclosingCompositingLayerForRepaint(bool includeSelf = true) const;
481     // Ancestor compositing layer, excluding this.
482     RenderLayer* ancestorCompositingLayer() const { return enclosingCompositingLayer(false); }
483 #endif
484
485 #if ENABLE(CSS_FILTERS)
486     RenderLayer* enclosingFilterLayer(bool includeSelf = true) const;
487     RenderLayer* enclosingFilterRepaintLayer() const;
488     void setFilterBackendNeedsRepaintingInRect(const LayoutRect&, bool immediate);
489     bool hasAncestorWithFilterOutsets() const;
490 #endif
491
492     bool canUseConvertToLayerCoords() const
493     {
494         // These RenderObject have an impact on their layers' without them knowing about it.
495         return !renderer()->hasColumns() && !renderer()->hasTransform()
496 #if ENABLE(SVG)
497             && !renderer()->isSVGRoot()
498 #endif
499             ;
500     }
501
502     void convertToPixelSnappedLayerCoords(const RenderLayer* ancestorLayer, IntPoint& location) const;
503     void convertToPixelSnappedLayerCoords(const RenderLayer* ancestorLayer, IntRect&) const;
504     void convertToLayerCoords(const RenderLayer* ancestorLayer, LayoutPoint& location) const;
505     void convertToLayerCoords(const RenderLayer* ancestorLayer, LayoutRect&) const;
506
507     int zIndex() const { return renderer()->style()->zIndex(); }
508
509     enum PaintLayerFlag {
510         PaintLayerHaveTransparency = 1,
511         PaintLayerAppliedTransform = 1 << 1,
512         PaintLayerTemporaryClipRects = 1 << 2,
513         PaintLayerPaintingReflection = 1 << 3,
514         PaintLayerPaintingOverlayScrollbars = 1 << 4,
515         PaintLayerPaintingCompositingBackgroundPhase = 1 << 5,
516         PaintLayerPaintingCompositingForegroundPhase = 1 << 6,
517         PaintLayerPaintingCompositingMaskPhase = 1 << 7,
518         PaintLayerPaintingOverflowContents = 1 << 8,
519         PaintLayerPaintingCompositingAllPhases = (PaintLayerPaintingCompositingBackgroundPhase | PaintLayerPaintingCompositingForegroundPhase | PaintLayerPaintingCompositingMaskPhase)
520     };
521     
522     typedef unsigned PaintLayerFlags;
523
524     // The two main functions that use the layer system.  The paint method
525     // paints the layers that intersect the damage rect from back to
526     // front.  The hitTest method looks for mouse events by walking
527     // layers that intersect the point from front to back.
528     void paint(GraphicsContext*, const LayoutRect& damageRect, PaintBehavior = PaintBehaviorNormal, RenderObject* paintingRoot = 0,
529         RenderRegion* = 0, PaintLayerFlags = 0);
530     bool hitTest(const HitTestRequest&, HitTestResult&);
531     bool hitTest(const HitTestRequest&, const HitTestLocation&, HitTestResult&);
532     void paintOverlayScrollbars(GraphicsContext*, const LayoutRect& damageRect, PaintBehavior, RenderObject* paintingRoot = 0);
533
534     enum ShouldRespectOverflowClip { IgnoreOverflowClip, RespectOverflowClip };
535
536     struct ClipRectsContext {
537         ClipRectsContext(const RenderLayer* inRootLayer, RenderRegion* inRegion, ClipRectsType inClipRectsType, OverlayScrollbarSizeRelevancy inOverlayScrollbarSizeRelevancy = IgnoreOverlayScrollbarSize, ShouldRespectOverflowClip inRespectOverflowClip = RespectOverflowClip)
538             : rootLayer(inRootLayer)
539             , region(inRegion)
540             , clipRectsType(inClipRectsType)
541             , overlayScrollbarSizeRelevancy(inOverlayScrollbarSizeRelevancy)
542             , respectOverflowClip(inRespectOverflowClip)
543         { }
544         const RenderLayer* rootLayer;
545         RenderRegion* region;
546         ClipRectsType clipRectsType;
547         OverlayScrollbarSizeRelevancy overlayScrollbarSizeRelevancy;
548         ShouldRespectOverflowClip respectOverflowClip;
549     };
550
551     // This method figures out our layerBounds in coordinates relative to
552     // |rootLayer}.  It also computes our background and foreground clip rects
553     // for painting/event handling.
554     // Pass offsetFromRoot if known.
555     void calculateRects(const ClipRectsContext&, const LayoutRect& paintDirtyRect, LayoutRect& layerBounds,
556         ClipRect& backgroundRect, ClipRect& foregroundRect, ClipRect& outlineRect, const LayoutPoint* offsetFromRoot = 0) const;
557
558     // Compute and cache clip rects computed with the given layer as the root
559     void updateClipRects(const ClipRectsContext&);
560     // Compute and return the clip rects. If useCached is true, will used previously computed clip rects on ancestors
561     // (rather than computing them all from scratch up the parent chain).
562     void calculateClipRects(const ClipRectsContext&, ClipRects&) const;
563
564     ClipRects* clipRects(ClipRectsType type) const
565     {
566         ASSERT(type < NumCachedClipRectsTypes);
567         return m_clipRectsCache ? m_clipRectsCache->m_clipRects[type].get() : 0;
568     }
569
570     LayoutRect childrenClipRect() const; // Returns the foreground clip rect of the layer in the document's coordinate space.
571     LayoutRect selfClipRect() const; // Returns the background clip rect of the layer in the document's coordinate space.
572     LayoutRect localClipRect() const; // Returns the background clip rect of the layer in the local coordinate space.
573
574     // Pass offsetFromRoot if known.
575     bool intersectsDamageRect(const LayoutRect& layerBounds, const LayoutRect& damageRect, const RenderLayer* rootLayer, const LayoutPoint* offsetFromRoot = 0) const;
576
577     enum CalculateLayerBoundsFlag {
578         IncludeSelfTransform = 1 << 0,
579         UseLocalClipRectIfPossible = 1 << 1,
580         IncludeLayerFilterOutsets = 1 << 2,
581         ExcludeHiddenDescendants = 1 << 3,
582         DontConstrainForMask = 1 << 4,
583         IncludeCompositedDescendants = 1 << 5,
584         DefaultCalculateLayerBoundsFlags =  IncludeSelfTransform | UseLocalClipRectIfPossible | IncludeLayerFilterOutsets
585     };
586     typedef unsigned CalculateLayerBoundsFlags;
587
588     // Bounding box relative to some ancestor layer. Pass offsetFromRoot if known.
589     LayoutRect boundingBox(const RenderLayer* rootLayer, const LayoutPoint* offsetFromRoot = 0) const;
590     // Bounding box in the coordinates of this layer.
591     LayoutRect localBoundingBox(CalculateLayerBoundsFlags = 0) const;
592     // Pixel snapped bounding box relative to the root.
593     IntRect absoluteBoundingBox() const;
594
595     // Can pass offsetFromRoot if known.
596     IntRect calculateLayerBounds(const RenderLayer* ancestorLayer, const LayoutPoint* offsetFromRoot = 0, CalculateLayerBoundsFlags = DefaultCalculateLayerBoundsFlags) const;
597     
598     // WARNING: This method returns the offset for the parent as this is what updateLayerPositions expects.
599     LayoutPoint computeOffsetFromRoot(bool& hasLayerOffset) const;
600
601     // Return a cached repaint rect, computed relative to the layer renderer's containerForRepaint.
602     LayoutRect repaintRect() const { return m_repaintRect; }
603     LayoutRect repaintRectIncludingNonCompositingDescendants() const;
604
605     void setRepaintStatus(RepaintStatus status) { m_repaintStatus = status; }
606
607     LayoutUnit staticInlinePosition() const { return m_staticInlinePosition; }
608     LayoutUnit staticBlockPosition() const { return m_staticBlockPosition; }
609    
610     void setStaticInlinePosition(LayoutUnit position) { m_staticInlinePosition = position; }
611     void setStaticBlockPosition(LayoutUnit position) { m_staticBlockPosition = position; }
612
613     bool hasTransform() const { return renderer()->hasTransform(); }
614     // Note that this transform has the transform-origin baked in.
615     TransformationMatrix* transform() const { return m_transform.get(); }
616     // currentTransform computes a transform which takes accelerated animations into account. The
617     // resulting transform has transform-origin baked in. If the layer does not have a transform,
618     // returns the identity matrix.
619     TransformationMatrix currentTransform(RenderStyle::ApplyTransformOrigin = RenderStyle::IncludeTransformOrigin) const;
620     TransformationMatrix renderableTransform(PaintBehavior) const;
621     
622     // Get the perspective transform, which is applied to transformed sublayers.
623     // Returns true if the layer has a -webkit-perspective.
624     // Note that this transform has the perspective-origin baked in.
625     TransformationMatrix perspectiveTransform() const;
626     FloatPoint perspectiveOrigin() const;
627     bool preserves3D() const { return renderer()->style()->transformStyle3D() == TransformStyle3DPreserve3D; }
628     bool has3DTransform() const { return m_transform && !m_transform->isAffine(); }
629
630 #if ENABLE(CSS_FILTERS)
631     virtual void filterNeedsRepaint();
632     bool hasFilter() const { return renderer()->hasFilter(); }
633 #else
634     bool hasFilter() const { return false; }
635 #endif
636
637 #if ENABLE(CSS_COMPOSITING)
638     bool hasBlendMode() const { return renderer()->hasBlendMode(); }
639 #else
640     bool hasBlendMode() const { return false; }
641 #endif
642
643     // Overloaded new operator. Derived classes must override operator new
644     // in order to allocate out of the RenderArena.
645     void* operator new(size_t, RenderArena*);
646
647     // Overridden to prevent the normal delete from being called.
648     void operator delete(void*, size_t);
649
650 #if USE(ACCELERATED_COMPOSITING)
651     bool isComposited() const { return m_backing != 0; }
652     bool hasCompositedMask() const;
653     RenderLayerBacking* backing() const { return m_backing.get(); }
654     RenderLayerBacking* ensureBacking();
655     void clearBacking(bool layerBeingDestroyed = false);
656     virtual GraphicsLayer* layerForHorizontalScrollbar() const;
657     virtual GraphicsLayer* layerForVerticalScrollbar() const;
658     virtual GraphicsLayer* layerForScrollCorner() const;
659     virtual bool usesCompositedScrolling() const OVERRIDE;
660 #else
661     bool isComposited() const { return false; }
662     bool hasCompositedMask() const { return false; }
663     bool usesCompositedScrolling() const { return false; }
664 #endif
665
666     bool paintsWithTransparency(PaintBehavior paintBehavior) const
667     {
668         return isTransparent() && ((paintBehavior & PaintBehaviorFlattenCompositingLayers) || !isComposited());
669     }
670
671     bool paintsWithTransform(PaintBehavior) const;
672
673     bool containsDirtyOverlayScrollbars() const { return m_containsDirtyOverlayScrollbars; }
674     void setContainsDirtyOverlayScrollbars(bool dirtyScrollbars) { m_containsDirtyOverlayScrollbars = dirtyScrollbars; }
675
676 #if ENABLE(CSS_SHADERS)
677     bool isCSSCustomFilterEnabled() const;
678 #endif
679
680 #if ENABLE(CSS_FILTERS)
681     FilterOperations computeFilterOperations(const RenderStyle*);
682     bool paintsWithFilters() const;
683     bool requiresFullLayerImageForFilters() const;
684     FilterEffectRenderer* filterRenderer() const 
685     {
686         RenderLayerFilterInfo* filterInfo = this->filterInfo();
687         return filterInfo ? filterInfo->renderer() : 0;
688     }
689     
690     RenderLayerFilterInfo* filterInfo() const { return hasFilterInfo() ? RenderLayerFilterInfo::filterInfoForRenderLayer(this) : 0; }
691     RenderLayerFilterInfo* ensureFilterInfo() { return RenderLayerFilterInfo::createFilterInfoForRenderLayerIfNeeded(this); }
692     void removeFilterInfoIfNeeded() 
693     {
694         if (hasFilterInfo())
695             RenderLayerFilterInfo::removeFilterInfoForRenderLayer(this); 
696     }
697     
698     bool hasFilterInfo() const { return m_hasFilterInfo; }
699     void setHasFilterInfo(bool hasFilterInfo) { m_hasFilterInfo = hasFilterInfo; }
700 #endif
701
702 #if !ASSERT_DISABLED
703     bool layerListMutationAllowed() const { return m_layerListMutationAllowed; }
704     void setLayerListMutationAllowed(bool flag) { m_layerListMutationAllowed = flag; }
705 #endif
706
707     Node* enclosingElement() const;
708
709 #if ENABLE(DIALOG_ELEMENT)
710     bool isInTopLayer() const;
711     bool isInTopLayerSubtree() const;
712 #endif
713
714     virtual void reportMemoryUsage(MemoryObjectInfo*) const OVERRIDE;
715
716 private:
717     void updateZOrderLists();
718     void rebuildZOrderLists();
719     void clearZOrderLists();
720
721     void updateNormalFlowList();
722
723     bool isStackingContext(const RenderStyle* style) const { return !style->hasAutoZIndex() || isRootLayer(); }
724     bool isDirtyStackingContext() const { return m_zOrderListsDirty && isStackingContext(); }
725
726     void setAncestorChainHasSelfPaintingLayerDescendant();
727     void dirtyAncestorChainHasSelfPaintingLayerDescendantStatus();
728
729     void computeRepaintRects(const RenderLayerModelObject* repaintContainer, const RenderGeometryMap* = 0);
730     void computeRepaintRectsIncludingDescendants();
731     void clearRepaintRects();
732
733     void clipToRect(RenderLayer* rootLayer, GraphicsContext*, const LayoutRect& paintDirtyRect, const ClipRect&,
734                     BorderRadiusClippingRule = IncludeSelfForBorderRadius);
735     void restoreClip(GraphicsContext*, const LayoutRect& paintDirtyRect, const ClipRect&);
736
737     bool shouldRepaintAfterLayout() const;
738
739     void updateSelfPaintingLayer();
740     void updateStackingContextsAfterStyleChange(const RenderStyle* oldStyle);
741
742     void updateScrollbarsAfterStyleChange(const RenderStyle* oldStyle);
743     void updateScrollbarsAfterLayout();
744
745     // Returns true if the position changed.
746     bool updateLayerPosition();
747
748     void updateLayerPositions(RenderGeometryMap* = 0, UpdateLayerPositionsFlags = defaultFlags);
749
750     enum UpdateLayerPositionsAfterScrollFlag {
751         NoFlag = 0,
752         IsOverflowScroll = 1 << 0,
753         HasSeenViewportConstrainedAncestor = 1 << 1,
754         HasSeenAncestorWithOverflowClip = 1 << 2,
755         HasChangedAncestor = 1 << 3
756     };
757     typedef unsigned UpdateLayerPositionsAfterScrollFlags;
758     void updateLayerPositionsAfterScroll(RenderGeometryMap*, UpdateLayerPositionsAfterScrollFlags = NoFlag);
759
760     friend IntSize RenderBox::scrolledContentOffset() const;
761     IntSize scrolledContentOffset() const { return m_scrollOffset; }
762
763     IntSize clampScrollOffset(const IntSize&) const;
764
765     // The normal operator new is disallowed on all render objects.
766     void* operator new(size_t) throw();
767
768     void setNextSibling(RenderLayer* next) { m_next = next; }
769     void setPreviousSibling(RenderLayer* prev) { m_previous = prev; }
770     void setParent(RenderLayer* parent);
771     void setFirstChild(RenderLayer* first) { m_first = first; }
772     void setLastChild(RenderLayer* last) { m_last = last; }
773
774     LayoutPoint renderBoxLocation() const { return renderer()->isBox() ? toRenderBox(renderer())->location() : LayoutPoint(); }
775     LayoutUnit renderBoxX() const { return renderBoxLocation().x(); }
776     LayoutUnit renderBoxY() const { return renderBoxLocation().y(); }
777
778     void collectLayers(bool includeHiddenLayers, OwnPtr<Vector<RenderLayer*> >&, OwnPtr<Vector<RenderLayer*> >&);
779
780     void updateCompositingAndLayerListsIfNeeded();
781
782     struct LayerPaintingInfo {
783         LayerPaintingInfo(RenderLayer* inRootLayer, const LayoutRect& inDirtyRect, PaintBehavior inPaintBehavior, const LayoutSize& inSubPixelAccumulation, RenderObject* inPaintingRoot = 0, RenderRegion*inRegion = 0, OverlapTestRequestMap* inOverlapTestRequests = 0)
784             : rootLayer(inRootLayer)
785             , paintingRoot(inPaintingRoot)
786             , paintDirtyRect(inDirtyRect)
787             , subPixelAccumulation(inSubPixelAccumulation)
788             , region(inRegion)
789             , overlapTestRequests(inOverlapTestRequests)
790             , paintBehavior(inPaintBehavior)
791         { }
792         RenderLayer* rootLayer;
793         RenderObject* paintingRoot; // only paint descendants of this object
794         LayoutRect paintDirtyRect; // relative to rootLayer;
795         LayoutSize subPixelAccumulation;
796         RenderRegion* region; // May be null.
797         OverlapTestRequestMap* overlapTestRequests; // May be null.
798         PaintBehavior paintBehavior;
799     };
800         
801     void paintLayer(GraphicsContext*, const LayerPaintingInfo&, PaintLayerFlags);
802     void paintLayerContentsAndReflection(GraphicsContext*, const LayerPaintingInfo&, PaintLayerFlags);
803     void paintLayerContents(GraphicsContext*, const LayerPaintingInfo&, PaintLayerFlags);
804     void paintList(Vector<RenderLayer*>*, GraphicsContext*, const LayerPaintingInfo&, PaintLayerFlags);
805     void paintPaginatedChildLayer(RenderLayer* childLayer, GraphicsContext*, const LayerPaintingInfo&, PaintLayerFlags);
806     void paintChildLayerIntoColumns(RenderLayer* childLayer, GraphicsContext*, const LayerPaintingInfo&, PaintLayerFlags, const Vector<RenderLayer*>& columnLayers, size_t columnIndex);
807
808     RenderLayer* hitTestLayer(RenderLayer* rootLayer, RenderLayer* containerLayer, const HitTestRequest& request, HitTestResult& result,
809                               const LayoutRect& hitTestRect, const HitTestLocation&, bool appliedTransform,
810                               const HitTestingTransformState* transformState = 0, double* zOffset = 0);
811     RenderLayer* hitTestList(Vector<RenderLayer*>*, RenderLayer* rootLayer, const HitTestRequest& request, HitTestResult& result,
812                              const LayoutRect& hitTestRect, const HitTestLocation&,
813                              const HitTestingTransformState* transformState, double* zOffsetForDescendants, double* zOffset,
814                              const HitTestingTransformState* unflattenedTransformState, bool depthSortDescendants);
815     RenderLayer* hitTestPaginatedChildLayer(RenderLayer* childLayer, RenderLayer* rootLayer, const HitTestRequest& request, HitTestResult& result,
816                                             const LayoutRect& hitTestRect, const HitTestLocation&,
817                                             const HitTestingTransformState* transformState, double* zOffset);
818     RenderLayer* hitTestChildLayerColumns(RenderLayer* childLayer, RenderLayer* rootLayer, const HitTestRequest& request, HitTestResult& result,
819                                           const LayoutRect& hitTestRect, const HitTestLocation&,
820                                           const HitTestingTransformState* transformState, double* zOffset,
821                                           const Vector<RenderLayer*>& columnLayers, size_t columnIndex);
822
823     PassRefPtr<HitTestingTransformState> createLocalTransformState(RenderLayer* rootLayer, RenderLayer* containerLayer,
824                             const LayoutRect& hitTestRect, const HitTestLocation&,
825                             const HitTestingTransformState* containerTransformState) const;
826     
827     bool hitTestContents(const HitTestRequest&, HitTestResult&, const LayoutRect& layerBounds, const HitTestLocation&, HitTestFilter) const;
828
829     void computeScrollDimensions();
830     bool hasHorizontalOverflow() const;
831     bool hasVerticalOverflow() const;
832     bool hasScrollableHorizontalOverflow() const;
833     bool hasScrollableVerticalOverflow() const;
834
835     bool shouldBeNormalFlowOnly() const;
836
837     bool shouldBeSelfPaintingLayer() const;
838
839     int scrollPosition(Scrollbar*) const;
840     
841     // ScrollableArea interface
842     virtual void invalidateScrollbarRect(Scrollbar*, const IntRect&);
843     virtual void invalidateScrollCornerRect(const IntRect&);
844     virtual bool isActive() const;
845     virtual bool isScrollCornerVisible() const;
846     virtual IntRect scrollCornerRect() const;
847     virtual IntRect convertFromScrollbarToContainingView(const Scrollbar*, const IntRect&) const;
848     virtual IntRect convertFromContainingViewToScrollbar(const Scrollbar*, const IntRect&) const;
849     virtual IntPoint convertFromScrollbarToContainingView(const Scrollbar*, const IntPoint&) const;
850     virtual IntPoint convertFromContainingViewToScrollbar(const Scrollbar*, const IntPoint&) const;
851     virtual int scrollSize(ScrollbarOrientation) const;
852     virtual void setScrollOffset(const IntPoint&);
853     virtual IntPoint scrollPosition() const;
854     virtual IntPoint minimumScrollPosition() const;
855     virtual IntPoint maximumScrollPosition() const;
856     virtual IntRect visibleContentRect(bool includeScrollbars) const;
857     virtual int visibleHeight() const;
858     virtual int visibleWidth() const;
859     virtual IntSize contentsSize() const;
860     virtual IntSize overhangAmount() const;
861     virtual IntPoint lastKnownMousePosition() const;
862     virtual bool shouldSuspendScrollAnimations() const;
863     virtual bool scrollbarsCanBeActive() const;
864     virtual IntRect scrollableAreaBoundingBox() const OVERRIDE;
865
866     // Rectangle encompassing the scroll corner and resizer rect.
867     IntRect scrollCornerAndResizerRect() const;
868
869     // NOTE: This should only be called by the overriden setScrollOffset from ScrollableArea.
870     void scrollTo(int, int);
871     void updateCompositingLayersAfterScroll();
872
873     IntSize scrollbarOffset(const Scrollbar*) const;
874     
875     void updateScrollableAreaSet(bool hasOverflow);
876
877     void dirtyAncestorChainVisibleDescendantStatus();
878     void setAncestorChainHasVisibleDescendant();
879
880     void updateDescendantDependentFlags();
881
882     // This flag is computed by RenderLayerCompositor, which knows more about 3d hierarchies than we do.
883     void setHas3DTransformedDescendant(bool b) { m_has3DTransformedDescendant = b; }
884     bool has3DTransformedDescendant() const { return m_has3DTransformedDescendant; }
885     
886     void dirty3DTransformedDescendantStatus();
887     // Both updates the status, and returns true if descendants of this have 3d.
888     bool update3DTransformedDescendantStatus();
889
890     void createReflection();
891     void removeReflection();
892
893     void updateReflectionStyle();
894     bool paintingInsideReflection() const { return m_paintingInsideReflection; }
895     void setPaintingInsideReflection(bool b) { m_paintingInsideReflection = b; }
896
897 #if ENABLE(CSS_FILTERS)
898     void updateOrRemoveFilterClients();
899     void updateOrRemoveFilterEffectRenderer();
900 #endif
901
902     void parentClipRects(const ClipRectsContext&, ClipRects&) const;
903     ClipRect backgroundClipRect(const ClipRectsContext&) const;
904
905     LayoutRect paintingExtent(const RenderLayer* rootLayer, const LayoutRect& paintDirtyRect, PaintBehavior);
906
907     RenderLayer* enclosingTransformedAncestor() const;
908
909     // Convert a point in absolute coords into layer coords, taking transforms into account
910     LayoutPoint absoluteToContents(const LayoutPoint&) const;
911
912     void positionOverflowControls(const IntSize&);
913     void updateScrollCornerStyle();
914     void updateResizerStyle();
915
916     void drawPlatformResizerImage(GraphicsContext*, IntRect resizerCornerRect);
917
918     void updatePagination();
919     
920 #if USE(ACCELERATED_COMPOSITING)    
921     bool hasCompositingDescendant() const { return m_hasCompositingDescendant; }
922     void setHasCompositingDescendant(bool b)  { m_hasCompositingDescendant = b; }
923     
924     enum IndirectCompositingReason {
925         NoIndirectCompositingReason,
926         IndirectCompositingForStacking,
927         IndirectCompositingForOverlap,
928         IndirectCompositingForBackgroundLayer,
929         IndirectCompositingForGraphicalEffect, // opacity, mask, filter, transform etc.
930         IndirectCompositingForPerspective,
931         IndirectCompositingForPreserve3D
932     };
933     
934     void setIndirectCompositingReason(IndirectCompositingReason reason) { m_indirectCompositingReason = reason; }
935     IndirectCompositingReason indirectCompositingReason() const { return static_cast<IndirectCompositingReason>(m_indirectCompositingReason); }
936     bool mustCompositeForIndirectReasons() const { return m_indirectCompositingReason; }
937 #endif
938
939     friend class RenderLayerBacking;
940     friend class RenderLayerCompositor;
941     friend class RenderLayerModelObject;
942
943     // Only safe to call from RenderBoxModelObject::destroyLayer(RenderArena*)
944     void destroy(RenderArena*);
945
946     LayoutUnit overflowTop() const;
947     LayoutUnit overflowBottom() const;
948     LayoutUnit overflowLeft() const;
949     LayoutUnit overflowRight() const;
950
951     IntRect rectForHorizontalScrollbar(const IntRect& borderBoxRect) const;
952     IntRect rectForVerticalScrollbar(const IntRect& borderBoxRect) const;
953
954     LayoutUnit verticalScrollbarStart(int minX, int maxX) const;
955     LayoutUnit horizontalScrollbarStart(int minX) const;
956
957     bool overflowControlsIntersectRect(const IntRect& localRect) const;
958
959 protected:
960     // The bitfields are up here so they will fall into the padding from ScrollableArea on 64-bit.
961
962     // Keeps track of whether the layer is currently resizing, so events can cause resizing to start and stop.
963     bool m_inResizeMode : 1;
964
965     bool m_scrollDimensionsDirty : 1;
966     bool m_zOrderListsDirty : 1;
967     bool m_normalFlowListDirty: 1;
968     bool m_isNormalFlowOnly : 1;
969
970     bool m_isSelfPaintingLayer : 1;
971
972     // If have no self-painting descendants, we don't have to walk our children during painting. This can lead to
973     // significant savings, especially if the tree has lots of non-self-painting layers grouped together (e.g. table cells).
974     bool m_hasSelfPaintingLayerDescendant : 1;
975     bool m_hasSelfPaintingLayerDescendantDirty : 1;
976
977     const bool m_isRootLayer : 1;
978
979     bool m_usedTransparency : 1; // Tracks whether we need to close a transparent layer, i.e., whether
980                                  // we ended up painting this layer or any descendants (and therefore need to
981                                  // blend).
982     bool m_paintingInsideReflection : 1;  // A state bit tracking if we are painting inside a replica.
983     bool m_inOverflowRelayout : 1;
984     unsigned m_repaintStatus : 2; // RepaintStatus
985
986     bool m_visibleContentStatusDirty : 1;
987     bool m_hasVisibleContent : 1;
988     bool m_visibleDescendantStatusDirty : 1;
989     bool m_hasVisibleDescendant : 1;
990
991     bool m_isPaginated : 1; // If we think this layer is split by a multi-column ancestor, then this bit will be set.
992
993     bool m_3DTransformedDescendantStatusDirty : 1;
994     bool m_has3DTransformedDescendant : 1;  // Set on a stacking context layer that has 3D descendants anywhere
995                                             // in a preserves3D hierarchy. Hint to do 3D-aware hit testing.
996 #if USE(ACCELERATED_COMPOSITING)
997     bool m_hasCompositingDescendant : 1; // In the z-order tree.
998     unsigned m_indirectCompositingReason : 3;
999 #endif
1000
1001     bool m_containsDirtyOverlayScrollbars : 1;
1002     bool m_updatingMarqueePosition : 1;
1003
1004 #if !ASSERT_DISABLED
1005     bool m_layerListMutationAllowed : 1;
1006 #endif
1007     // This is an optimization added for <table>.
1008     // Currently cells do not need to update their repaint rectangles when scrolling. This also
1009     // saves a lot of time when scrolling on a table.
1010     const bool m_canSkipRepaintRectsUpdateOnScroll : 1;
1011
1012 #if ENABLE(CSS_FILTERS)
1013     bool m_hasFilterInfo : 1;
1014 #endif
1015
1016 #if ENABLE(CSS_COMPOSITING)
1017     BlendMode m_blendMode;
1018 #endif
1019
1020     RenderLayerModelObject* m_renderer;
1021
1022     RenderLayer* m_parent;
1023     RenderLayer* m_previous;
1024     RenderLayer* m_next;
1025     RenderLayer* m_first;
1026     RenderLayer* m_last;
1027
1028     LayoutRect m_repaintRect; // Cached repaint rects. Used by layout.
1029     LayoutRect m_outlineBox;
1030
1031     // Our current relative position offset.
1032     LayoutSize m_offsetForInFlowPosition;
1033
1034     // Our (x,y) coordinates are in our parent layer's coordinate space.
1035     LayoutPoint m_topLeft;
1036
1037     // The layer's width/height
1038     IntSize m_layerSize;
1039
1040     // This is the (scroll) offset from scrollOrigin().
1041     IntSize m_scrollOffset;
1042
1043     // The width/height of our scrolled area.
1044     LayoutSize m_scrollSize;
1045
1046     // For layers with overflow, we have a pair of scrollbars.
1047     RefPtr<Scrollbar> m_hBar;
1048     RefPtr<Scrollbar> m_vBar;
1049
1050     // For layers that establish stacking contexts, m_posZOrderList holds a sorted list of all the
1051     // descendant layers within the stacking context that have z-indices of 0 or greater
1052     // (auto will count as 0).  m_negZOrderList holds descendants within our stacking context with negative
1053     // z-indices.
1054     OwnPtr<Vector<RenderLayer*> > m_posZOrderList;
1055     OwnPtr<Vector<RenderLayer*> > m_negZOrderList;
1056
1057     // This list contains child layers that cannot create stacking contexts.  For now it is just
1058     // overflow layers, but that may change in the future.
1059     OwnPtr<Vector<RenderLayer*> > m_normalFlowList;
1060
1061     OwnPtr<ClipRectsCache> m_clipRectsCache;
1062     
1063     IntPoint m_cachedOverlayScrollbarOffset;
1064
1065     OwnPtr<RenderMarquee> m_marquee; // Used by layers with overflow:marquee
1066     
1067     // Cached normal flow values for absolute positioned elements with static left/top values.
1068     LayoutUnit m_staticInlinePosition;
1069     LayoutUnit m_staticBlockPosition;
1070
1071     OwnPtr<TransformationMatrix> m_transform;
1072     
1073     // May ultimately be extended to many replicas (with their own paint order).
1074     RenderReplica* m_reflection;
1075         
1076     // Renderers to hold our custom scroll corner and resizer.
1077     RenderScrollbarPart* m_scrollCorner;
1078     RenderScrollbarPart* m_resizer;
1079
1080 private:
1081     IntRect m_blockSelectionGapsBounds;
1082
1083 #if USE(ACCELERATED_COMPOSITING)
1084     OwnPtr<RenderLayerBacking> m_backing;
1085 #endif
1086 };
1087
1088 inline void RenderLayer::clearZOrderLists()
1089 {
1090     ASSERT(!isStackingContext());
1091
1092     m_posZOrderList.clear();
1093     m_negZOrderList.clear();
1094 }
1095
1096 inline void RenderLayer::updateZOrderLists()
1097 {
1098     if (!m_zOrderListsDirty)
1099         return;
1100
1101     if (!isStackingContext()) {
1102         clearZOrderLists();
1103         m_zOrderListsDirty = false;
1104         return;
1105     }
1106
1107     rebuildZOrderLists();
1108 }
1109
1110 #if !ASSERT_DISABLED
1111 class LayerListMutationDetector {
1112 public:
1113     LayerListMutationDetector(RenderLayer* layer)
1114         : m_layer(layer)
1115         , m_previousMutationAllowedState(layer->layerListMutationAllowed())
1116     {
1117         m_layer->setLayerListMutationAllowed(false);
1118     }
1119     
1120     ~LayerListMutationDetector()
1121     {
1122         m_layer->setLayerListMutationAllowed(m_previousMutationAllowedState);
1123     }
1124
1125 private:
1126     RenderLayer* m_layer;
1127     bool m_previousMutationAllowedState;
1128 };
1129 #endif
1130
1131
1132 } // namespace WebCore
1133
1134 #ifndef NDEBUG
1135 // Outside the WebCore namespace for ease of invocation from gdb.
1136 void showLayerTree(const WebCore::RenderLayer*);
1137 void showLayerTree(const WebCore::RenderObject*);
1138 #endif
1139
1140 #endif // RenderLayer_h