4feede88ce51123556dbedb5b71443b0f89b9fba
[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);
206
207     bool hasReflection() const { return renderer()->hasReflection(); }
208     RenderReplica* reflection() const { return m_reflection; }
209     RenderLayer* reflectionLayer() const;
210
211     const RenderLayer* root() const
212     {
213         const RenderLayer* curr = this;
214         while (curr->parent())
215             curr = curr->parent();
216         return curr;
217     }
218     
219     int x() const { return m_x; }
220     int y() const { return m_y; }
221     void setLocation(int x, int y)
222     {
223         m_x = x;
224         m_y = y;
225     }
226
227     int width() const { return m_width; }
228     int height() const { return m_height; }
229     void setWidth(int w) { m_width = w; }
230     void setHeight(int h) { m_height = h; }
231
232     int scrollWidth();
233     int scrollHeight();
234
235     void panScrollFromPoint(const IntPoint&);
236
237     // Scrolling methods for layers that can scroll their overflow.
238     void scrollByRecursively(int xDelta, int yDelta);
239     void addScrolledContentOffset(int& x, int& y) const;
240     void subtractScrolledContentOffset(int& x, int& y) const;
241     IntSize scrolledContentOffset() const { return IntSize(scrollXOffset() + m_scrollLeftOverflow, scrollYOffset()); }
242
243     int scrollXOffset() const { return m_scrollX + m_scrollOriginX; }
244     int scrollYOffset() const { return m_scrollY; }
245
246     void scrollToOffset(int x, int y, bool updateScrollbars = true, bool repaint = true);
247     void scrollToXOffset(int x) { scrollToOffset(x, m_scrollY); }
248     void scrollToYOffset(int y) { scrollToOffset(m_scrollX + m_scrollOriginX, y); }
249     void scrollRectToVisible(const IntRect&, bool scrollToAnchor = false, const ScrollAlignment& alignX = ScrollAlignment::alignCenterIfNeeded, const ScrollAlignment& alignY = ScrollAlignment::alignCenterIfNeeded);
250
251     IntRect getRectToExpose(const IntRect& visibleRect, const IntRect& exposeRect, const ScrollAlignment& alignX, const ScrollAlignment& alignY);
252
253     void setHasHorizontalScrollbar(bool);
254     void setHasVerticalScrollbar(bool);
255
256     PassRefPtr<Scrollbar> createScrollbar(ScrollbarOrientation);
257     void destroyScrollbar(ScrollbarOrientation);
258
259     Scrollbar* horizontalScrollbar() const { return m_hBar.get(); }
260     Scrollbar* verticalScrollbar() const { return m_vBar.get(); }
261
262     int verticalScrollbarWidth() const;
263     int horizontalScrollbarHeight() const;
264
265     void positionOverflowControls(int tx, int ty);
266     bool isPointInResizeControl(const IntPoint& absolutePoint) const;
267     bool hitTestOverflowControls(HitTestResult&);
268     IntSize offsetFromResizeCorner(const IntPoint& absolutePoint) const;
269
270     void paintOverflowControls(GraphicsContext*, int tx, int ty, const IntRect& damageRect);
271     void paintScrollCorner(GraphicsContext*, int tx, int ty, const IntRect& damageRect);
272     void paintResizer(GraphicsContext*, int tx, int ty, const IntRect& damageRect);
273
274     void updateScrollInfoAfterLayout();
275
276     bool scroll(ScrollDirection, ScrollGranularity, float multiplier = 1.0f);
277     void autoscroll();
278
279     void resize(const PlatformMouseEvent&, const IntSize&);
280     bool inResizeMode() const { return m_inResizeMode; }
281     void setInResizeMode(bool b) { m_inResizeMode = b; }
282
283     bool isRootLayer() const { return renderer()->isRenderView(); }
284     
285 #if USE(ACCELERATED_COMPOSITING)
286     RenderLayerCompositor* compositor() const;
287     
288     // Notification from the renderer that its content changed (e.g. current frame of image changed).
289     // Allows updates of layer content without repainting.
290     void rendererContentChanged();
291 #endif
292
293     // Returns true if the accelerated compositing is enabled
294     bool hasAcceleratedCompositing() const;
295     
296     void updateLayerPosition();
297     void updateLayerPositions(bool doFullRepaint = false, bool checkForRepaint = true);
298
299     void updateTransform();
300
301     void relativePositionOffset(int& relX, int& relY) const { relX += m_relX; relY += m_relY; }
302     IntSize relativePositionOffset() const { return IntSize(m_relX, m_relY); }
303
304     void clearClipRectsIncludingDescendants();
305     void clearClipRects();
306
307     // Get the enclosing stacking context for this layer.  A stacking context is a layer
308     // that has a non-auto z-index.
309     RenderLayer* stackingContext() const;
310     bool isStackingContext() const { return !hasAutoZIndex() || renderer()->isRenderView(); }
311
312     void dirtyZOrderLists();
313     void dirtyStackingContextZOrderLists();
314     void updateZOrderLists();
315     Vector<RenderLayer*>* posZOrderList() const { return m_posZOrderList; }
316     Vector<RenderLayer*>* negZOrderList() const { return m_negZOrderList; }
317
318     void dirtyNormalFlowList();
319     void updateNormalFlowList();
320     Vector<RenderLayer*>* normalFlowList() const { return m_normalFlowList; }
321
322     bool hasVisibleContent() const { return m_hasVisibleContent; }
323     void setHasVisibleContent(bool);
324     void dirtyVisibleContentStatus();
325
326     // Gets the nearest enclosing positioned ancestor layer (also includes
327     // the <html> layer and the root layer).
328     RenderLayer* enclosingPositionedAncestor() const;
329
330 #if USE(ACCELERATED_COMPOSITING)
331     // Enclosing compositing layer; if includeSelf is true, may return this.
332     RenderLayer* enclosingCompositingLayer(bool includeSelf = true) const;
333     // Ancestor compositing layer, excluding this.
334     RenderLayer* ancestorCompositingLayer() const { return enclosingCompositingLayer(false); }
335 #endif
336
337     void convertToLayerCoords(const RenderLayer* ancestorLayer, int& x, int& y) const;
338
339     bool hasAutoZIndex() const { return renderer()->style()->hasAutoZIndex(); }
340     int zIndex() const { return renderer()->style()->zIndex(); }
341
342     // The two main functions that use the layer system.  The paint method
343     // paints the layers that intersect the damage rect from back to
344     // front.  The hitTest method looks for mouse events by walking
345     // layers that intersect the point from front to back.
346     void paint(GraphicsContext*, const IntRect& damageRect, PaintRestriction = PaintRestrictionNone, RenderObject* paintingRoot = 0);
347     bool hitTest(const HitTestRequest&, HitTestResult&);
348
349     // This method figures out our layerBounds in coordinates relative to
350     // |rootLayer}.  It also computes our background and foreground clip rects
351     // for painting/event handling.
352     void calculateRects(const RenderLayer* rootLayer, const IntRect& paintDirtyRect, IntRect& layerBounds,
353                         IntRect& backgroundRect, IntRect& foregroundRect, IntRect& outlineRect, bool temporaryClipRects = false) const;
354
355     // Compute and cache clip rects computed with the given layer as the root
356     void updateClipRects(const RenderLayer* rootLayer);
357     // Compute and return the clip rects. If useCached is true, will used previously computed clip rects on ancestors
358     // (rather than computing them all from scratch up the parent chain).
359     void calculateClipRects(const RenderLayer* rootLayer, ClipRects&, bool useCached = false) const;
360     ClipRects* clipRects() const { return m_clipRects; }
361
362     IntRect childrenClipRect() const; // Returns the foreground clip rect of the layer in the document's coordinate space.
363     IntRect selfClipRect() const; // Returns the background clip rect of the layer in the document's coordinate space.
364
365     bool intersectsDamageRect(const IntRect& layerBounds, const IntRect& damageRect, const RenderLayer* rootLayer) const;
366
367     // Bounding box relative to some ancestor layer.
368     IntRect boundingBox(const RenderLayer* rootLayer) const;
369     // Bounding box in the coordinates of this layer.
370     IntRect localBoundingBox() const;
371     // Bounding box relative to the root.
372     IntRect absoluteBoundingBox() const;
373
374     void updateHoverActiveState(const HitTestRequest&, HitTestResult&);
375
376     // Return a cached repaint rect, computed relative to the layer renderer's containerForRepaint.
377     IntRect repaintRect() const { return m_repaintRect; }
378     void setNeedsFullRepaint(bool f = true) { m_needsFullRepaint = f; }
379     
380     int staticX() const { return m_staticX; }
381     int staticY() const { return m_staticY; }
382     void setStaticX(int staticX) { m_staticX = staticX; }
383     void setStaticY(int staticY);
384
385     bool hasTransform() const { return renderer()->hasTransform(); }
386     // Note that this transform has the transform-origin baked in.
387     TransformationMatrix* transform() const { return m_transform.get(); }
388     // currentTransform computes a transform which takes accelerated animations into account. The
389     // resulting transform has transform-origin baked in. If the layer does not have a transform,
390     // returns the identity matrix.
391     TransformationMatrix currentTransform() const;
392     
393     // Get the perspective transform, which is applied to transformed sublayers.
394     // Returns true if the layer has a -webkit-perspective.
395     // Note that this transform has the perspective-origin baked in.
396     TransformationMatrix perspectiveTransform() const;
397     FloatPoint perspectiveOrigin() const;
398     bool preserves3D() const { return renderer()->style()->transformStyle3D() == TransformStyle3DPreserve3D; }
399     bool has3DTransform() const { return m_transform && !m_transform->isAffine(); }
400
401      // Overloaded new operator.  Derived classes must override operator new
402     // in order to allocate out of the RenderArena.
403     void* operator new(size_t, RenderArena*) throw();
404
405     // Overridden to prevent the normal delete from being called.
406     void operator delete(void*, size_t);
407
408 #if USE(ACCELERATED_COMPOSITING)
409     bool isComposited() const { return m_backing != 0; }
410     RenderLayerBacking* backing() const { return m_backing.get(); }
411     RenderLayerBacking* ensureBacking();
412     void clearBacking();
413 #else
414     bool isComposited() const { return false; }
415 #endif
416
417     bool paintsWithTransparency() const
418     {
419         return isTransparent() && !isComposited();
420     }
421
422     bool paintsWithTransform() const
423     {
424         return transform() && !isComposited();
425     }
426
427 private:
428     // The normal operator new is disallowed on all render objects.
429     void* operator new(size_t) throw();
430
431 private:
432     void setNextSibling(RenderLayer* next) { m_next = next; }
433     void setPreviousSibling(RenderLayer* prev) { m_previous = prev; }
434     void setParent(RenderLayer* parent);
435     void setFirstChild(RenderLayer* first) { m_first = first; }
436     void setLastChild(RenderLayer* last) { m_last = last; }
437
438     int renderBoxX() const { return renderer()->isBox() ? toRenderBox(renderer())->x() : 0; }
439     int renderBoxY() const { return renderer()->isBox() ? toRenderBox(renderer())->y() : 0; }
440
441     void collectLayers(Vector<RenderLayer*>*&, Vector<RenderLayer*>*&);
442
443     void updateLayerListsIfNeeded();
444     
445     enum PaintLayerFlag {
446         PaintLayerHaveTransparency = 1,
447         PaintLayerAppliedTransform = 1 << 1,
448         PaintLayerTemporaryClipRects = 1 << 2,
449         PaintLayerPaintingReflection = 1 << 3
450     };
451     
452     typedef unsigned PaintLayerFlags;
453
454     void paintLayer(RenderLayer* rootLayer, GraphicsContext*, const IntRect& paintDirtyRect,
455                     PaintRestriction, RenderObject* paintingRoot, RenderObject::OverlapTestRequestMap* = 0,
456                     PaintLayerFlags paintFlags = 0);
457
458     RenderLayer* hitTestLayer(RenderLayer* rootLayer, RenderLayer* containerLayer, const HitTestRequest& request, HitTestResult& result,
459                             const IntRect& hitTestRect, const IntPoint& hitTestPoint, bool appliedTransform,
460                             const HitTestingTransformState* transformState = 0, double* zOffset = 0);
461
462     PassRefPtr<HitTestingTransformState> createLocalTransformState(RenderLayer* rootLayer, RenderLayer* containerLayer,
463                             const IntRect& hitTestRect, const IntPoint& hitTestPoint,
464                             const HitTestingTransformState* containerTransformState) const;
465     
466     bool hitTestContents(const HitTestRequest&, HitTestResult&, const IntRect& layerBounds, const IntPoint& hitTestPoint, HitTestFilter) const;
467     
468     void computeScrollDimensions(bool* needHBar = 0, bool* needVBar = 0);
469
470     bool shouldBeNormalFlowOnly() const; 
471
472     virtual void valueChanged(Scrollbar*);
473     virtual void invalidateScrollbarRect(Scrollbar*, const IntRect&);
474     virtual bool isActive() const;
475     virtual bool scrollbarCornerPresent() const;
476
477     void updateOverflowStatus(bool horizontalOverflow, bool verticalOverflow);
478
479     void childVisibilityChanged(bool newVisibility);
480     void dirtyVisibleDescendantStatus();
481     void updateVisibilityStatus();
482
483     // This flag is computed by RenderLayerCompositor, which knows more about 3d hierarchies than we do.
484     void setHas3DTransformedDescendant(bool b) { m_has3DTransformedDescendant = b; }
485     bool has3DTransformedDescendant() const { return m_has3DTransformedDescendant; }
486     
487     void dirty3DTransformedDescendantStatus();
488     // Both updates the status, and returns true if descendants of this have 3d.
489     bool update3DTransformedDescendantStatus();
490
491     Node* enclosingElement() const;
492
493     void createReflection();
494     void updateReflectionStyle();
495     bool paintingInsideReflection() const { return m_paintingInsideReflection; }
496     void setPaintingInsideReflection(bool b) { m_paintingInsideReflection = b; }
497     
498     void parentClipRects(const RenderLayer* rootLayer, ClipRects&, bool temporaryClipRects = false) const;
499
500     RenderLayer* enclosingTransformedAncestor() const;
501
502     // Convert a point in absolute coords into layer coords, taking transforms into account
503     IntPoint absoluteToContents(const IntPoint&) const;
504
505     void updateScrollCornerStyle();
506     void updateResizerStyle();
507
508 #if USE(ACCELERATED_COMPOSITING)    
509     bool hasCompositingDescendant() const { return m_hasCompositingDescendant; }
510     void setHasCompositingDescendant(bool b)  { m_hasCompositingDescendant = b; }
511     
512     bool mustOverlayCompositedLayers() const { return m_mustOverlayCompositedLayers; }
513     void setMustOverlayCompositedLayers(bool b) { m_mustOverlayCompositedLayers = b; }
514 #endif
515
516 private:
517     friend class RenderLayerBacking;
518     friend class RenderLayerCompositor;
519     friend class RenderBoxModelObject;
520
521     // Only safe to call from RenderBoxModelObject::destroyLayer(RenderArena*)
522     void destroy(RenderArena*);
523
524 protected:
525     RenderBoxModelObject* m_renderer;
526
527     RenderLayer* m_parent;
528     RenderLayer* m_previous;
529     RenderLayer* m_next;
530     RenderLayer* m_first;
531     RenderLayer* m_last;
532
533     IntRect m_repaintRect; // Cached repaint rects. Used by layout.
534     IntRect m_outlineBox;
535
536     // Our current relative position offset.
537     int m_relX;
538     int m_relY;
539
540     // Our (x,y) coordinates are in our parent layer's coordinate space.
541     int m_x;
542     int m_y;
543
544     // The layer's width/height
545     int m_width;
546     int m_height;
547
548     // Our scroll offsets if the view is scrolled.
549     int m_scrollX;
550     int m_scrollY;
551     int m_scrollOriginX;        // only non-zero for rtl content
552     int m_scrollLeftOverflow;   // only non-zero for rtl content
553
554     // The width/height of our scrolled area.
555     int m_scrollWidth;
556     int m_scrollHeight;
557
558     // For layers with overflow, we have a pair of scrollbars.
559     RefPtr<Scrollbar> m_hBar;
560     RefPtr<Scrollbar> m_vBar;
561
562     // Keeps track of whether the layer is currently resizing, so events can cause resizing to start and stop.
563     bool m_inResizeMode;
564
565     // For layers that establish stacking contexts, m_posZOrderList holds a sorted list of all the
566     // descendant layers within the stacking context that have z-indices of 0 or greater
567     // (auto will count as 0).  m_negZOrderList holds descendants within our stacking context with negative
568     // z-indices.
569     Vector<RenderLayer*>* m_posZOrderList;
570     Vector<RenderLayer*>* m_negZOrderList;
571
572     // This list contains child layers that cannot create stacking contexts.  For now it is just
573     // overflow layers, but that may change in the future.
574     Vector<RenderLayer*>* m_normalFlowList;
575
576     ClipRects* m_clipRects;      // Cached clip rects used when painting and hit testing.
577 #ifndef NDEBUG
578     const RenderLayer* m_clipRectsRoot;   // Root layer used to compute clip rects.
579 #endif
580
581     bool m_scrollDimensionsDirty : 1;
582     bool m_zOrderListsDirty : 1;
583     bool m_normalFlowListDirty: 1;
584     bool m_isNormalFlowOnly : 1;
585
586     bool m_usedTransparency : 1; // Tracks whether we need to close a transparent layer, i.e., whether
587                                  // we ended up painting this layer or any descendants (and therefore need to
588                                  // blend).
589     bool m_paintingInsideReflection : 1;  // A state bit tracking if we are painting inside a replica.
590     bool m_inOverflowRelayout : 1;
591     bool m_needsFullRepaint : 1;
592
593     bool m_overflowStatusDirty : 1;
594     bool m_horizontalOverflow : 1;
595     bool m_verticalOverflow : 1;
596     bool m_visibleContentStatusDirty : 1;
597     bool m_hasVisibleContent : 1;
598     bool m_visibleDescendantStatusDirty : 1;
599     bool m_hasVisibleDescendant : 1;
600
601     bool m_3DTransformedDescendantStatusDirty : 1;
602     bool m_has3DTransformedDescendant : 1;  // Set on a stacking context layer that has 3D descendants anywhere
603                                             // in a preserves3D hierarchy. Hint to do 3D-aware hit testing.
604 #if USE(ACCELERATED_COMPOSITING)
605     bool m_hasCompositingDescendant : 1;
606     bool m_mustOverlayCompositedLayers : 1;
607 #endif
608
609     RenderMarquee* m_marquee; // Used by layers with overflow:marquee
610     
611     // Cached normal flow values for absolute positioned elements with static left/top values.
612     int m_staticX;
613     int m_staticY;
614     
615     OwnPtr<TransformationMatrix> m_transform;
616     
617     // May ultimately be extended to many replicas (with their own paint order).
618     RenderReplica* m_reflection;
619     
620     // Renderers to hold our custom scroll corner and resizer.
621     RenderScrollbarPart* m_scrollCorner;
622     RenderScrollbarPart* m_resizer;
623
624 #if USE(ACCELERATED_COMPOSITING)
625     OwnPtr<RenderLayerBacking> m_backing;
626 #endif
627 };
628
629 } // namespace WebCore
630
631 #endif // RenderLayer_h