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