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