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