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