2010-04-01 James Robinson <jamesr@chromium.org>
[WebKit-https.git] / WebCore / rendering / RenderLayer.h
1 /*
2  * Copyright (C) 2003, 2009 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 "RenderBox.h"
48 #include "ScrollBehavior.h"
49 #include "ScrollbarClient.h"
50 #include "Timer.h"
51 #include <wtf/OwnPtr.h>
52
53 namespace WebCore {
54
55 class CachedResource;
56 class HitTestRequest;
57 class HitTestResult;
58 class HitTestingTransformState;
59 class RenderFrameSet;
60 class RenderMarquee;
61 class RenderReplica;
62 class RenderScrollbarPart;
63 class RenderStyle;
64 class RenderTable;
65 class RenderText;
66 class RenderView;
67 class Scrollbar;
68 class TransformationMatrix;
69
70 #if USE(ACCELERATED_COMPOSITING)
71 class RenderLayerBacking;
72 class RenderLayerCompositor;
73 #endif
74
75 class ClipRects {
76 public:
77     ClipRects()
78         : m_refCnt(0)
79         , m_fixed(false)
80     {
81     }
82
83     ClipRects(const IntRect& r)
84         : m_overflowClipRect(r)
85         , m_fixedClipRect(r)
86         , m_posClipRect(r)
87         , m_refCnt(0)
88         , m_fixed(false)
89     {
90     }
91
92     ClipRects(const ClipRects& other)
93         : m_overflowClipRect(other.overflowClipRect())
94         , m_fixedClipRect(other.fixedClipRect())
95         , m_posClipRect(other.posClipRect())
96         , m_refCnt(0)
97         , m_fixed(other.fixed())
98     {
99     }
100
101     void reset(const IntRect& r)
102     {
103         m_overflowClipRect = r;
104         m_fixedClipRect = r;
105         m_posClipRect = r;
106         m_fixed = false;
107     }
108     
109     const IntRect& overflowClipRect() const { return m_overflowClipRect; }
110     void setOverflowClipRect(const IntRect& r) { m_overflowClipRect = r; }
111
112     const IntRect& fixedClipRect() const { return m_fixedClipRect; }
113     void setFixedClipRect(const IntRect&r) { m_fixedClipRect = r; }
114
115     const IntRect& posClipRect() const { return m_posClipRect; }
116     void setPosClipRect(const IntRect& r) { m_posClipRect = r; }
117
118     bool fixed() const { return m_fixed; }
119     void setFixed(bool fixed) { m_fixed = fixed; }
120
121     void ref() { m_refCnt++; }
122     void deref(RenderArena* renderArena) { if (--m_refCnt == 0) destroy(renderArena); }
123
124     void destroy(RenderArena*);
125
126     // Overloaded new operator.
127     void* operator new(size_t, RenderArena*) throw();
128
129     // Overridden to prevent the normal delete from being called.
130     void operator delete(void*, size_t);
131
132     bool operator==(const ClipRects& other) const
133     {
134         return m_overflowClipRect == other.overflowClipRect() &&
135                m_fixedClipRect == other.fixedClipRect() &&
136                m_posClipRect == other.posClipRect() &&
137                m_fixed == other.fixed();
138     }
139
140     ClipRects& operator=(const ClipRects& other)
141     {
142         m_overflowClipRect = other.overflowClipRect();
143         m_fixedClipRect = other.fixedClipRect();
144         m_posClipRect = other.posClipRect();
145         m_fixed = other.fixed();
146         return *this;
147     }
148     
149     static IntRect infiniteRect() { return IntRect(INT_MIN/2, INT_MIN/2, INT_MAX, INT_MAX); }
150
151 private:
152     // The normal operator new is disallowed on all render objects.
153     void* operator new(size_t) throw();
154
155 private:
156     IntRect m_overflowClipRect;
157     IntRect m_fixedClipRect;
158     IntRect m_posClipRect;
159     unsigned m_refCnt : 31;
160     bool m_fixed : 1;
161 };
162
163 class RenderLayer : public ScrollbarClient {
164 public:
165     friend class RenderReplica;
166
167     RenderLayer(RenderBoxModelObject*);
168     ~RenderLayer();
169
170     RenderBoxModelObject* renderer() const { return m_renderer; }
171     RenderBox* renderBox() const { return m_renderer && m_renderer->isBox() ? toRenderBox(m_renderer) : 0; }
172     RenderLayer* parent() const { return m_parent; }
173     RenderLayer* previousSibling() const { return m_previous; }
174     RenderLayer* nextSibling() const { return m_next; }
175     RenderLayer* firstChild() const { return m_first; }
176     RenderLayer* lastChild() const { return m_last; }
177
178     void addChild(RenderLayer* newChild, RenderLayer* beforeChild = 0);
179     RenderLayer* removeChild(RenderLayer*);
180
181     void removeOnlyThisLayer();
182     void insertOnlyThisLayer();
183
184     void repaintIncludingDescendants();
185
186 #if USE(ACCELERATED_COMPOSITING)
187     // Indicate that the layer contents need to be repainted. Only has an effect
188     // if layer compositing is being used,
189     void setBackingNeedsRepaint();
190     void setBackingNeedsRepaintInRect(const IntRect& r); // r is in the coordinate space of the layer's render object
191     void repaintIncludingNonCompositingDescendants(RenderBoxModelObject* repaintContainer);
192 #endif
193
194     void styleChanged(StyleDifference, const RenderStyle*);
195
196     RenderMarquee* marquee() const { return m_marquee; }
197
198     bool isNormalFlowOnly() const { return m_isNormalFlowOnly; }
199     bool isSelfPaintingLayer() const;
200
201     bool requiresSlowRepaints() const;
202
203     bool isTransparent() const;
204     RenderLayer* transparentPaintingAncestor();
205     void beginTransparencyLayers(GraphicsContext*, const RenderLayer* rootLayer, PaintBehavior);
206
207     bool hasReflection() const { return renderer()->hasReflection(); }
208     bool isReflection() const { return renderer()->isReplica(); }
209     RenderReplica* reflection() const { return m_reflection; }
210     RenderLayer* reflectionLayer() const;
211
212     const RenderLayer* root() const
213     {
214         const RenderLayer* curr = this;
215         while (curr->parent())
216             curr = curr->parent();
217         return curr;
218     }
219     
220     int x() const { return m_x; }
221     int y() const { return m_y; }
222     void setLocation(int x, int y)
223     {
224         m_x = x;
225         m_y = y;
226     }
227
228     int width() const { return m_width; }
229     int height() const { return m_height; }
230     IntSize size() const { return IntSize(m_width, m_height); }
231     
232     void setWidth(int w) { m_width = w; }
233     void setHeight(int h) { m_height = h; }
234
235     int scrollWidth();
236     int scrollHeight();
237
238     void panScrollFromPoint(const IntPoint&);
239
240     // Scrolling methods for layers that can scroll their overflow.
241     void scrollByRecursively(int xDelta, int yDelta);
242
243     IntSize scrolledContentOffset() const { return IntSize(scrollXOffset() + m_scrollLeftOverflow, scrollYOffset()); }
244
245     int scrollXOffset() const { return m_scrollX + m_scrollOriginX; }
246     int scrollYOffset() const { return m_scrollY; }
247
248     void scrollToOffset(int x, int y, bool updateScrollbars = true, bool repaint = true);
249     void scrollToXOffset(int x) { scrollToOffset(x, m_scrollY); }
250     void scrollToYOffset(int y) { scrollToOffset(m_scrollX + m_scrollOriginX, y); }
251     void scrollRectToVisible(const IntRect&, bool scrollToAnchor = false, const ScrollAlignment& alignX = ScrollAlignment::alignCenterIfNeeded, const ScrollAlignment& alignY = ScrollAlignment::alignCenterIfNeeded);
252
253     IntRect getRectToExpose(const IntRect& visibleRect, const IntRect& exposeRect, const ScrollAlignment& alignX, const ScrollAlignment& alignY);
254
255     void setHasHorizontalScrollbar(bool);
256     void setHasVerticalScrollbar(bool);
257
258     PassRefPtr<Scrollbar> createScrollbar(ScrollbarOrientation);
259     void destroyScrollbar(ScrollbarOrientation);
260
261     Scrollbar* horizontalScrollbar() const { return m_hBar.get(); }
262     Scrollbar* verticalScrollbar() const { return m_vBar.get(); }
263
264     int verticalScrollbarWidth() const;
265     int horizontalScrollbarHeight() const;
266
267     bool hasOverflowControls() const;
268     void positionOverflowControls(int tx, int ty);
269     bool isPointInResizeControl(const IntPoint& absolutePoint) const;
270     bool hitTestOverflowControls(HitTestResult&, const IntPoint& localPoint);
271     IntSize offsetFromResizeCorner(const IntPoint& absolutePoint) const;
272
273     void paintOverflowControls(GraphicsContext*, int tx, int ty, const IntRect& damageRect);
274     void paintScrollCorner(GraphicsContext*, int tx, int ty, const IntRect& damageRect);
275     void paintResizer(GraphicsContext*, int tx, int ty, const IntRect& damageRect);
276
277     void updateScrollInfoAfterLayout();
278
279     bool scroll(ScrollDirection, ScrollGranularity, float multiplier = 1.0f);
280     void autoscroll();
281
282     void resize(const PlatformMouseEvent&, const IntSize&);
283     bool inResizeMode() const { return m_inResizeMode; }
284     void setInResizeMode(bool b) { m_inResizeMode = b; }
285
286     bool isRootLayer() const { return renderer()->isRenderView(); }
287     
288 #if USE(ACCELERATED_COMPOSITING)
289     RenderLayerCompositor* compositor() const;
290     
291     // Notification from the renderer that its content changed (e.g. current frame of image changed).
292     // Allows updates of layer content without repainting.
293     void rendererContentChanged();
294 #endif
295
296     // Returns true if the accelerated compositing is enabled
297     bool hasAcceleratedCompositing() const;
298     
299     void updateLayerPosition();
300     
301     enum UpdateLayerPositionsFlag {
302         DoFullRepaint = 1,
303         CheckForRepaint = 1 << 1,
304         IsCompositingUpdateRoot = 1 << 2,
305         UpdateCompositingLayers = 1 << 3,
306     };
307     typedef unsigned UpdateLayerPositionsFlags;
308     void updateLayerPositions(UpdateLayerPositionsFlags = DoFullRepaint | IsCompositingUpdateRoot | UpdateCompositingLayers, IntPoint* cachedOffset = 0);
309
310     void updateTransform();
311
312     void relativePositionOffset(int& relX, int& relY) const { relX += m_relX; relY += m_relY; }
313     IntSize relativePositionOffset() const { return IntSize(m_relX, m_relY); }
314
315     void clearClipRectsIncludingDescendants();
316     void clearClipRects();
317
318     void addBlockSelectionGapsBounds(const IntRect&);
319     void clearBlockSelectionGapsBounds();
320     void repaintBlockSelectionGaps();
321
322     // Get the enclosing stacking context for this layer.  A stacking context is a layer
323     // that has a non-auto z-index.
324     RenderLayer* stackingContext() const;
325     bool isStackingContext() const { return !hasAutoZIndex() || renderer()->isRenderView(); }
326
327     void dirtyZOrderLists();
328     void dirtyStackingContextZOrderLists();
329     void updateZOrderLists();
330     Vector<RenderLayer*>* posZOrderList() const { return m_posZOrderList; }
331     Vector<RenderLayer*>* negZOrderList() const { return m_negZOrderList; }
332
333     void dirtyNormalFlowList();
334     void updateNormalFlowList();
335     Vector<RenderLayer*>* normalFlowList() const { return m_normalFlowList; }
336
337     bool hasVisibleContent() const { return m_hasVisibleContent; }
338     bool hasVisibleDescendant() const { return m_hasVisibleDescendant; }
339     void setHasVisibleContent(bool);
340     void dirtyVisibleContentStatus();
341
342     // Gets the nearest enclosing positioned ancestor layer (also includes
343     // the <html> layer and the root layer).
344     RenderLayer* enclosingPositionedAncestor() const;
345
346     // The layer relative to which clipping rects for this layer are computed.
347     RenderLayer* clippingRoot() const;
348
349 #if USE(ACCELERATED_COMPOSITING)
350     // Enclosing compositing layer; if includeSelf is true, may return this.
351     RenderLayer* enclosingCompositingLayer(bool includeSelf = true) const;
352     // Ancestor compositing layer, excluding this.
353     RenderLayer* ancestorCompositingLayer() const { return enclosingCompositingLayer(false); }
354 #endif
355
356     void convertToLayerCoords(const RenderLayer* ancestorLayer, int& x, int& y) const;
357
358     bool hasAutoZIndex() const { return renderer()->style()->hasAutoZIndex(); }
359     int zIndex() const { return renderer()->style()->zIndex(); }
360
361     // The two main functions that use the layer system.  The paint method
362     // paints the layers that intersect the damage rect from back to
363     // front.  The hitTest method looks for mouse events by walking
364     // layers that intersect the point from front to back.
365     void paint(GraphicsContext*, const IntRect& damageRect, PaintBehavior = PaintBehaviorNormal, RenderObject* paintingRoot = 0);
366     bool hitTest(const HitTestRequest&, HitTestResult&);
367
368     // This method figures out our layerBounds in coordinates relative to
369     // |rootLayer}.  It also computes our background and foreground clip rects
370     // for painting/event handling.
371     void calculateRects(const RenderLayer* rootLayer, const IntRect& paintDirtyRect, IntRect& layerBounds,
372                         IntRect& backgroundRect, IntRect& foregroundRect, IntRect& outlineRect, bool temporaryClipRects = false) const;
373
374     // Compute and cache clip rects computed with the given layer as the root
375     void updateClipRects(const RenderLayer* rootLayer);
376     // Compute and return the clip rects. If useCached is true, will used previously computed clip rects on ancestors
377     // (rather than computing them all from scratch up the parent chain).
378     void calculateClipRects(const RenderLayer* rootLayer, ClipRects&, bool useCached = false) const;
379     ClipRects* clipRects() const { return m_clipRects; }
380
381     IntRect childrenClipRect() const; // Returns the foreground clip rect of the layer in the document's coordinate space.
382     IntRect selfClipRect() const; // Returns the background clip rect of the layer in the document's coordinate space.
383
384     bool intersectsDamageRect(const IntRect& layerBounds, const IntRect& damageRect, const RenderLayer* rootLayer) const;
385
386     // Bounding box relative to some ancestor layer.
387     IntRect boundingBox(const RenderLayer* rootLayer) const;
388     // Bounding box in the coordinates of this layer.
389     IntRect localBoundingBox() const;
390     // Bounding box relative to the root.
391     IntRect absoluteBoundingBox() const;
392
393     void updateHoverActiveState(const HitTestRequest&, HitTestResult&);
394
395     // Return a cached repaint rect, computed relative to the layer renderer's containerForRepaint.
396     IntRect repaintRect() const { return m_repaintRect; }
397     void computeRepaintRects();
398     void setNeedsFullRepaint(bool f = true) { m_needsFullRepaint = f; }
399     
400     int staticX() const { return m_staticX; }
401     int staticY() const { return m_staticY; }
402     void setStaticX(int staticX) { m_staticX = staticX; }
403     void setStaticY(int staticY) { m_staticY = staticY; }
404
405     bool hasTransform() const { return renderer()->hasTransform(); }
406     // Note that this transform has the transform-origin baked in.
407     TransformationMatrix* transform() const { return m_transform.get(); }
408     // currentTransform computes a transform which takes accelerated animations into account. The
409     // resulting transform has transform-origin baked in. If the layer does not have a transform,
410     // returns the identity matrix.
411     TransformationMatrix currentTransform() const;
412     TransformationMatrix renderableTransform(PaintBehavior) const;
413     
414     // Get the perspective transform, which is applied to transformed sublayers.
415     // Returns true if the layer has a -webkit-perspective.
416     // Note that this transform has the perspective-origin baked in.
417     TransformationMatrix perspectiveTransform() const;
418     FloatPoint perspectiveOrigin() const;
419     bool preserves3D() const { return renderer()->style()->transformStyle3D() == TransformStyle3DPreserve3D; }
420     bool has3DTransform() const { return m_transform && !m_transform->isAffine(); }
421
422      // Overloaded new operator.  Derived classes must override operator new
423     // in order to allocate out of the RenderArena.
424     void* operator new(size_t, RenderArena*) throw();
425
426     // Overridden to prevent the normal delete from being called.
427     void operator delete(void*, size_t);
428
429 #if USE(ACCELERATED_COMPOSITING)
430     bool isComposited() const { return m_backing != 0; }
431     bool hasCompositedMask() const;
432     RenderLayerBacking* backing() const { return m_backing.get(); }
433     RenderLayerBacking* ensureBacking();
434     void clearBacking();
435 #else
436     bool isComposited() const { return false; }
437     bool hasCompositedMask() const { return false; }
438 #endif
439
440     bool paintsWithTransparency(PaintBehavior paintBehavior) const
441     {
442         return isTransparent() && ((paintBehavior & PaintBehaviorFlattenCompositingLayers) || !isComposited());
443     }
444
445     bool paintsWithTransform(PaintBehavior paintBehavior) const
446     {
447         return transform() && ((paintBehavior & PaintBehaviorFlattenCompositingLayers) || !isComposited());
448     }
449
450 private:
451     // The normal operator new is disallowed on all render objects.
452     void* operator new(size_t) throw();
453
454 private:
455     void setNextSibling(RenderLayer* next) { m_next = next; }
456     void setPreviousSibling(RenderLayer* prev) { m_previous = prev; }
457     void setParent(RenderLayer* parent);
458     void setFirstChild(RenderLayer* first) { m_first = first; }
459     void setLastChild(RenderLayer* last) { m_last = last; }
460
461     int renderBoxX() const { return renderer()->isBox() ? toRenderBox(renderer())->x() : 0; }
462     int renderBoxY() const { return renderer()->isBox() ? toRenderBox(renderer())->y() : 0; }
463
464     void collectLayers(Vector<RenderLayer*>*&, Vector<RenderLayer*>*&);
465
466     void updateLayerListsIfNeeded();
467     void updateCompositingAndLayerListsIfNeeded();
468     
469     enum PaintLayerFlag {
470         PaintLayerHaveTransparency = 1,
471         PaintLayerAppliedTransform = 1 << 1,
472         PaintLayerTemporaryClipRects = 1 << 2,
473         PaintLayerPaintingReflection = 1 << 3
474     };
475     
476     typedef unsigned PaintLayerFlags;
477
478     void paintLayer(RenderLayer* rootLayer, GraphicsContext*, const IntRect& paintDirtyRect,
479                     PaintBehavior, RenderObject* paintingRoot, RenderObject::OverlapTestRequestMap* = 0,
480                     PaintLayerFlags paintFlags = 0);
481
482     RenderLayer* hitTestLayer(RenderLayer* rootLayer, RenderLayer* containerLayer, const HitTestRequest& request, HitTestResult& result,
483                             const IntRect& hitTestRect, const IntPoint& hitTestPoint, bool appliedTransform,
484                             const HitTestingTransformState* transformState = 0, double* zOffset = 0);
485
486     PassRefPtr<HitTestingTransformState> createLocalTransformState(RenderLayer* rootLayer, RenderLayer* containerLayer,
487                             const IntRect& hitTestRect, const IntPoint& hitTestPoint,
488                             const HitTestingTransformState* containerTransformState) const;
489     
490     bool hitTestContents(const HitTestRequest&, HitTestResult&, const IntRect& layerBounds, const IntPoint& hitTestPoint, HitTestFilter) const;
491     
492     void computeScrollDimensions(bool* needHBar = 0, bool* needVBar = 0);
493
494     bool shouldBeNormalFlowOnly() const; 
495
496     // ScrollBarClient interface
497     virtual void valueChanged(Scrollbar*);
498     virtual void invalidateScrollbarRect(Scrollbar*, const IntRect&);
499     virtual bool isActive() const;
500     virtual bool scrollbarCornerPresent() const;
501     virtual IntRect convertFromScrollbarToContainingView(const Scrollbar*, const IntRect&) const;
502     virtual IntRect convertFromContainingViewToScrollbar(const Scrollbar*, const IntRect&) const;
503     virtual IntPoint convertFromScrollbarToContainingView(const Scrollbar*, const IntPoint&) const;
504     virtual IntPoint convertFromContainingViewToScrollbar(const Scrollbar*, const IntPoint&) const;
505     
506     IntSize scrollbarOffset(const Scrollbar*) const;
507     
508     void updateOverflowStatus(bool horizontalOverflow, bool verticalOverflow);
509
510     void childVisibilityChanged(bool newVisibility);
511     void dirtyVisibleDescendantStatus();
512     void updateVisibilityStatus();
513
514     // This flag is computed by RenderLayerCompositor, which knows more about 3d hierarchies than we do.
515     void setHas3DTransformedDescendant(bool b) { m_has3DTransformedDescendant = b; }
516     bool has3DTransformedDescendant() const { return m_has3DTransformedDescendant; }
517     
518     void dirty3DTransformedDescendantStatus();
519     // Both updates the status, and returns true if descendants of this have 3d.
520     bool update3DTransformedDescendantStatus();
521
522     Node* enclosingElement() const;
523
524     void createReflection();
525     void removeReflection();
526
527     void updateReflectionStyle();
528     bool paintingInsideReflection() const { return m_paintingInsideReflection; }
529     void setPaintingInsideReflection(bool b) { m_paintingInsideReflection = b; }
530     
531     void parentClipRects(const RenderLayer* rootLayer, ClipRects&, bool temporaryClipRects = false) const;
532     IntRect backgroundClipRect(const RenderLayer* rootLayer, bool temporaryClipRects) const;
533
534     RenderLayer* enclosingTransformedAncestor() const;
535
536     // Convert a point in absolute coords into layer coords, taking transforms into account
537     IntPoint absoluteToContents(const IntPoint&) const;
538
539     void updateScrollCornerStyle();
540     void updateResizerStyle();
541
542 #if USE(ACCELERATED_COMPOSITING)    
543     bool hasCompositingDescendant() const { return m_hasCompositingDescendant; }
544     void setHasCompositingDescendant(bool b)  { m_hasCompositingDescendant = b; }
545     
546     bool mustOverlapCompositedLayers() const { return m_mustOverlapCompositedLayers; }
547     void setMustOverlapCompositedLayers(bool b) { m_mustOverlapCompositedLayers = b; }
548 #endif
549
550 private:
551     friend class RenderLayerBacking;
552     friend class RenderLayerCompositor;
553     friend class RenderBoxModelObject;
554
555     // Only safe to call from RenderBoxModelObject::destroyLayer(RenderArena*)
556     void destroy(RenderArena*);
557
558 protected:
559     RenderBoxModelObject* m_renderer;
560
561     RenderLayer* m_parent;
562     RenderLayer* m_previous;
563     RenderLayer* m_next;
564     RenderLayer* m_first;
565     RenderLayer* m_last;
566
567     IntRect m_repaintRect; // Cached repaint rects. Used by layout.
568     IntRect m_outlineBox;
569
570     // Our current relative position offset.
571     int m_relX;
572     int m_relY;
573
574     // Our (x,y) coordinates are in our parent layer's coordinate space.
575     int m_x;
576     int m_y;
577
578     // The layer's width/height
579     int m_width;
580     int m_height;
581
582     // Our scroll offsets if the view is scrolled.
583     int m_scrollX;
584     int m_scrollY;
585     int m_scrollOriginX;        // only non-zero for rtl content
586     int m_scrollLeftOverflow;   // only non-zero for rtl content
587
588     // The width/height of our scrolled area.
589     int m_scrollWidth;
590     int m_scrollHeight;
591
592     // For layers with overflow, we have a pair of scrollbars.
593     RefPtr<Scrollbar> m_hBar;
594     RefPtr<Scrollbar> m_vBar;
595
596     // Keeps track of whether the layer is currently resizing, so events can cause resizing to start and stop.
597     bool m_inResizeMode;
598
599     // For layers that establish stacking contexts, m_posZOrderList holds a sorted list of all the
600     // descendant layers within the stacking context that have z-indices of 0 or greater
601     // (auto will count as 0).  m_negZOrderList holds descendants within our stacking context with negative
602     // z-indices.
603     Vector<RenderLayer*>* m_posZOrderList;
604     Vector<RenderLayer*>* m_negZOrderList;
605
606     // This list contains child layers that cannot create stacking contexts.  For now it is just
607     // overflow layers, but that may change in the future.
608     Vector<RenderLayer*>* m_normalFlowList;
609
610     ClipRects* m_clipRects;      // Cached clip rects used when painting and hit testing.
611 #ifndef NDEBUG
612     const RenderLayer* m_clipRectsRoot;   // Root layer used to compute clip rects.
613 #endif
614
615     bool m_scrollDimensionsDirty : 1;
616     bool m_zOrderListsDirty : 1;
617     bool m_normalFlowListDirty: 1;
618     bool m_isNormalFlowOnly : 1;
619
620     bool m_usedTransparency : 1; // Tracks whether we need to close a transparent layer, i.e., whether
621                                  // we ended up painting this layer or any descendants (and therefore need to
622                                  // blend).
623     bool m_paintingInsideReflection : 1;  // A state bit tracking if we are painting inside a replica.
624     bool m_inOverflowRelayout : 1;
625     bool m_needsFullRepaint : 1;
626
627     bool m_overflowStatusDirty : 1;
628     bool m_horizontalOverflow : 1;
629     bool m_verticalOverflow : 1;
630     bool m_visibleContentStatusDirty : 1;
631     bool m_hasVisibleContent : 1;
632     bool m_visibleDescendantStatusDirty : 1;
633     bool m_hasVisibleDescendant : 1;
634
635     bool m_3DTransformedDescendantStatusDirty : 1;
636     bool m_has3DTransformedDescendant : 1;  // Set on a stacking context layer that has 3D descendants anywhere
637                                             // in a preserves3D hierarchy. Hint to do 3D-aware hit testing.
638 #if USE(ACCELERATED_COMPOSITING)
639     bool m_hasCompositingDescendant : 1;
640     bool m_mustOverlapCompositedLayers : 1;
641 #endif
642
643     RenderMarquee* m_marquee; // Used by layers with overflow:marquee
644     
645     // Cached normal flow values for absolute positioned elements with static left/top values.
646     int m_staticX;
647     int m_staticY;
648     
649     OwnPtr<TransformationMatrix> m_transform;
650     
651     // May ultimately be extended to many replicas (with their own paint order).
652     RenderReplica* m_reflection;
653     
654     // Renderers to hold our custom scroll corner and resizer.
655     RenderScrollbarPart* m_scrollCorner;
656     RenderScrollbarPart* m_resizer;
657
658 private:
659     IntRect m_blockSelectionGapsBounds;
660
661 #if USE(ACCELERATED_COMPOSITING)
662     OwnPtr<RenderLayerBacking> m_backing;
663 #endif
664 };
665
666 } // namespace WebCore
667
668 #ifndef NDEBUG
669 // Outside the WebCore namespace for ease of invocation from gdb.
670 void showLayerTree(const WebCore::RenderLayer* layer);
671 #endif
672
673 #endif // RenderLayer_h