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