2009-03-04 Simon Fraser <simon.fraser@apple.com>
[WebKit-https.git] / WebCore / rendering / RenderLayer.cpp
1 /*
2  * Copyright (C) 2006, 2007, 2008 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 #include "config.h"
45 #include "RenderLayer.h"
46
47 #include "CString.h"
48 #include "CSSPropertyNames.h"
49 #include "CSSStyleSelector.h"
50 #include "Document.h"
51 #include "EventHandler.h"
52 #include "EventNames.h"
53 #include "FloatPoint3D.h"
54 #include "FloatRect.h"
55 #include "FocusController.h"
56 #include "Frame.h"
57 #include "FrameTree.h"
58 #include "FrameView.h"
59 #include "Gradient.h"
60 #include "GraphicsContext.h"
61 #include "HTMLNames.h"
62 #include "HitTestRequest.h"
63 #include "HitTestResult.h"
64 #include "OverflowEvent.h"
65 #include "Page.h"
66 #include "PlatformMouseEvent.h"
67 #include "RenderArena.h"
68 #include "RenderInline.h"
69 #include "RenderMarquee.h"
70 #include "RenderReplica.h"
71 #include "RenderScrollbar.h"
72 #include "RenderScrollbarPart.h"
73 #include "RenderTheme.h"
74 #include "RenderView.h"
75 #include "ScaleTransformOperation.h"
76 #include "Scrollbar.h"
77 #include "ScrollbarTheme.h"
78 #include "SelectionController.h"
79 #include "TransformationMatrix.h"
80 #include "TransformState.h"
81 #include "TranslateTransformOperation.h"
82 #include <wtf/StdLibExtras.h>
83 #include <wtf/UnusedParam.h>
84
85 #if USE(ACCELERATED_COMPOSITING)
86 #include "RenderLayerBacking.h"
87 #include "RenderLayerCompositor.h"
88 #endif
89
90 #if ENABLE(SVG)
91 #include "SVGNames.h"
92 #endif
93
94 #define MIN_INTERSECT_FOR_REVEAL 32
95
96 using namespace std;
97
98 namespace WebCore {
99
100 using namespace HTMLNames;
101
102 const RenderLayer::ScrollAlignment RenderLayer::gAlignCenterIfNeeded = { RenderLayer::noScroll, RenderLayer::alignCenter, RenderLayer::alignToClosestEdge };
103 const RenderLayer::ScrollAlignment RenderLayer::gAlignToEdgeIfNeeded = { RenderLayer::noScroll, RenderLayer::alignToClosestEdge, RenderLayer::alignToClosestEdge };
104 const RenderLayer::ScrollAlignment RenderLayer::gAlignCenterAlways = { RenderLayer::alignCenter, RenderLayer::alignCenter, RenderLayer::alignCenter };
105 const RenderLayer::ScrollAlignment RenderLayer::gAlignTopAlways = { RenderLayer::alignTop, RenderLayer::alignTop, RenderLayer::alignTop };
106 const RenderLayer::ScrollAlignment RenderLayer::gAlignBottomAlways = { RenderLayer::alignBottom, RenderLayer::alignBottom, RenderLayer::alignBottom };
107
108 const int MinimumWidthWhileResizing = 100;
109 const int MinimumHeightWhileResizing = 40;
110
111 void* ClipRects::operator new(size_t sz, RenderArena* renderArena) throw()
112 {
113     return renderArena->allocate(sz);
114 }
115
116 void ClipRects::operator delete(void* ptr, size_t sz)
117 {
118     // Stash size where destroy can find it.
119     *(size_t *)ptr = sz;
120 }
121
122 void ClipRects::destroy(RenderArena* renderArena)
123 {
124     delete this;
125     
126     // Recover the size left there for us by operator delete and free the memory.
127     renderArena->free(*(size_t *)this, this);
128 }
129
130 RenderLayer::RenderLayer(RenderBoxModelObject* renderer)
131     : m_renderer(renderer)
132     , m_parent(0)
133     , m_previous(0)
134     , m_next(0)
135     , m_first(0)
136     , m_last(0)
137     , m_relX(0)
138     , m_relY(0)
139     , m_x(0)
140     , m_y(0)
141     , m_width(0)
142     , m_height(0)
143     , m_scrollX(0)
144     , m_scrollY(0)
145     , m_scrollOriginX(0)
146     , m_scrollLeftOverflow(0)
147     , m_scrollWidth(0)
148     , m_scrollHeight(0)
149     , m_inResizeMode(false)
150     , m_posZOrderList(0)
151     , m_negZOrderList(0)
152     , m_normalFlowList(0)
153     , m_clipRects(0) 
154 #ifndef NDEBUG    
155     , m_clipRectsRoot(0)
156 #endif
157     , m_scrollDimensionsDirty(true)
158     , m_zOrderListsDirty(true)
159     , m_normalFlowListDirty(true)
160     , m_isNormalFlowOnly(shouldBeNormalFlowOnly())
161     , m_usedTransparency(false)
162     , m_paintingInsideReflection(false)
163     , m_inOverflowRelayout(false)
164     , m_needsFullRepaint(false)
165     , m_overflowStatusDirty(true)
166     , m_visibleContentStatusDirty(true)
167     , m_hasVisibleContent(false)
168     , m_visibleDescendantStatusDirty(false)
169     , m_hasVisibleDescendant(false)
170     , m_3DTransformedDescendantStatusDirty(true)
171     , m_has3DTransformedDescendant(false)
172 #if USE(ACCELERATED_COMPOSITING)
173     , m_hasCompositingDescendant(false)
174 #endif
175     , m_marquee(0)
176     , m_staticX(0)
177     , m_staticY(0)
178     , m_reflection(0)
179     , m_scrollCorner(0)
180     , m_resizer(0)
181 {
182     if (!renderer->firstChild() && renderer->style()) {
183         m_visibleContentStatusDirty = false;
184         m_hasVisibleContent = renderer->style()->visibility() == VISIBLE;
185     }
186 }
187
188 RenderLayer::~RenderLayer()
189 {
190     if (inResizeMode() && !renderer()->documentBeingDestroyed()) {
191         if (Frame* frame = renderer()->document()->frame())
192             frame->eventHandler()->resizeLayerDestroyed();
193     }
194
195     destroyScrollbar(HorizontalScrollbar);
196     destroyScrollbar(VerticalScrollbar);
197
198     // Child layers will be deleted by their corresponding render objects, so
199     // we don't need to delete them ourselves.
200
201     delete m_posZOrderList;
202     delete m_negZOrderList;
203     delete m_normalFlowList;
204     delete m_marquee;
205
206 #if USE(ACCELERATED_COMPOSITING)
207     clearBacking();
208 #endif
209     
210     // Make sure we have no lingering clip rects.
211     ASSERT(!m_clipRects);
212     
213     if (m_reflection) {
214         if (!m_reflection->documentBeingDestroyed())
215             m_reflection->removeLayers(this);
216         m_reflection->setParent(0);
217         m_reflection->destroy();
218     }
219     
220     if (m_scrollCorner)
221         m_scrollCorner->destroy();
222     if (m_resizer)
223         m_resizer->destroy();
224 }
225
226 #if USE(ACCELERATED_COMPOSITING)
227 RenderLayerCompositor* RenderLayer::compositor() const
228 {
229     ASSERT(renderer()->view());
230     return renderer()->view()->compositor();
231 }
232 #endif // USE(ACCELERATED_COMPOSITING)
233
234 void RenderLayer::setStaticY(int staticY)
235 {
236     if (m_staticY == staticY)
237         return;
238     m_staticY = staticY;
239     renderer()->setChildNeedsLayout(true, false);
240 }
241
242 void RenderLayer::updateLayerPositions(bool doFullRepaint, bool checkForRepaint)
243 {
244     if (doFullRepaint) {
245         renderer()->repaint();
246 #if USE(ACCELERATED_COMPOSITING)
247         checkForRepaint = false;
248         // We need the full repaint to propagate to child layers if we are hardware compositing.
249         if (!compositor()->inCompositingMode())
250             doFullRepaint = false;
251 #else
252         checkForRepaint = doFullRepaint = false;
253 #endif
254     }
255     
256     updateLayerPosition(); // For relpositioned layers or non-positioned layers,
257                            // we need to keep in sync, since we may have shifted relative
258                            // to our parent layer.
259
260     int x = 0;
261     int y = 0;
262     convertToLayerCoords(root(), x, y);
263     positionOverflowControls(x, y);
264
265     updateVisibilityStatus();
266
267     updateTransform();
268      
269     if (m_hasVisibleContent) {
270         RenderView* view = renderer()->view();
271         ASSERT(view);
272         // FIXME: Optimize using LayoutState and remove the disableLayoutState() call
273         // from updateScrollInfoAfterLayout().
274         ASSERT(!view->layoutStateEnabled());
275
276         RenderBoxModelObject* repaintContainer = renderer()->containerForRepaint();
277         IntRect newRect = renderer()->clippedOverflowRectForRepaint(repaintContainer);
278         IntRect newOutlineBox = renderer()->outlineBoundsForRepaint(repaintContainer);
279         if (checkForRepaint) {
280             if (view && !view->printing()) {
281                 if (m_needsFullRepaint) {
282                     renderer()->repaintUsingContainer(repaintContainer, m_repaintRect);
283                     if (newRect != m_repaintRect)
284                         renderer()->repaintUsingContainer(repaintContainer, newRect);
285                 } else
286                     renderer()->repaintAfterLayoutIfNeeded(repaintContainer, m_repaintRect, m_outlineBox);
287             }
288         }
289         m_repaintRect = newRect;
290         m_outlineBox = newOutlineBox;
291     } else {
292         m_repaintRect = IntRect();
293         m_outlineBox = IntRect();
294     }
295
296     m_needsFullRepaint = false;
297
298     // Go ahead and update the reflection's position and size.
299     if (m_reflection)
300         m_reflection->layout();
301
302     for (RenderLayer* child = firstChild(); child; child = child->nextSibling())
303         child->updateLayerPositions(doFullRepaint, checkForRepaint);
304
305 #if USE(ACCELERATED_COMPOSITING)
306     if (!parent())
307         compositor()->updateRootLayerPosition();
308
309     if (isComposited())
310         backing()->updateAfterLayout();
311 #endif
312         
313     // With all our children positioned, now update our marquee if we need to.
314     if (m_marquee)
315         m_marquee->updateMarqueePosition();
316 }
317
318 void RenderLayer::updateTransform()
319 {
320     // hasTransform() on the renderer is also true when there is transform-style: preserve-3d or perspective set,
321     // so check style too.
322     bool hasTransform = renderer()->hasTransform() && renderer()->style()->hasTransform();
323     bool had3DTransform = has3DTransform();
324
325     bool hadTransform = m_transform;
326     if (hasTransform != hadTransform) {
327         if (hasTransform)
328             m_transform.set(new TransformationMatrix);
329         else
330             m_transform.clear();
331     }
332     
333     if (hasTransform) {
334         RenderBox* box = renderBox();
335         ASSERT(box);
336         m_transform->makeIdentity();
337         box->style()->applyTransform(*m_transform, box->borderBoxRect().size(), RenderStyle::IncludeTransformOrigin);
338     }
339
340     if (had3DTransform != has3DTransform())
341         dirty3DTransformedDescendantStatus();
342 }
343
344 void RenderLayer::setHasVisibleContent(bool b)
345
346     if (m_hasVisibleContent == b && !m_visibleContentStatusDirty)
347         return;
348     m_visibleContentStatusDirty = false; 
349     m_hasVisibleContent = b;
350     if (m_hasVisibleContent) {
351         RenderBoxModelObject* repaintContainer = renderer()->containerForRepaint();
352         m_repaintRect = renderer()->clippedOverflowRectForRepaint(repaintContainer);
353         m_outlineBox = renderer()->outlineBoundsForRepaint(repaintContainer);
354         if (!isNormalFlowOnly())
355             dirtyStackingContextZOrderLists();
356     }
357     if (parent())
358         parent()->childVisibilityChanged(m_hasVisibleContent);
359 }
360
361 void RenderLayer::dirtyVisibleContentStatus() 
362
363     m_visibleContentStatusDirty = true; 
364     if (parent())
365         parent()->dirtyVisibleDescendantStatus();
366 }
367
368 void RenderLayer::childVisibilityChanged(bool newVisibility) 
369
370     if (m_hasVisibleDescendant == newVisibility || m_visibleDescendantStatusDirty)
371         return;
372     if (newVisibility) {
373         RenderLayer* l = this;
374         while (l && !l->m_visibleDescendantStatusDirty && !l->m_hasVisibleDescendant) {
375             l->m_hasVisibleDescendant = true;
376             l = l->parent();
377         }
378     } else 
379         dirtyVisibleDescendantStatus();
380 }
381
382 void RenderLayer::dirtyVisibleDescendantStatus()
383 {
384     RenderLayer* l = this;
385     while (l && !l->m_visibleDescendantStatusDirty) {
386         l->m_visibleDescendantStatusDirty = true;
387         l = l->parent();
388     }
389 }
390
391 void RenderLayer::updateVisibilityStatus()
392 {
393     if (m_visibleDescendantStatusDirty) {
394         m_hasVisibleDescendant = false;
395         for (RenderLayer* child = firstChild(); child; child = child->nextSibling()) {
396             child->updateVisibilityStatus();        
397             if (child->m_hasVisibleContent || child->m_hasVisibleDescendant) {
398                 m_hasVisibleDescendant = true;
399                 break;
400             }
401         }
402         m_visibleDescendantStatusDirty = false;
403     }
404
405     if (m_visibleContentStatusDirty) {
406         if (renderer()->style()->visibility() == VISIBLE)
407             m_hasVisibleContent = true;
408         else {
409             // layer may be hidden but still have some visible content, check for this
410             m_hasVisibleContent = false;
411             RenderObject* r = renderer()->firstChild();
412             while (r) {
413                 if (r->style()->visibility() == VISIBLE && !r->hasLayer()) {
414                     m_hasVisibleContent = true;
415                     break;
416                 }
417                 if (r->firstChild() && !r->hasLayer())
418                     r = r->firstChild();
419                 else if (r->nextSibling())
420                     r = r->nextSibling();
421                 else {
422                     do {
423                         r = r->parent();
424                         if (r==renderer())
425                             r = 0;
426                     } while (r && !r->nextSibling());
427                     if (r)
428                         r = r->nextSibling();
429                 }
430             }
431         }    
432         m_visibleContentStatusDirty = false; 
433     }
434 }
435
436 void RenderLayer::dirty3DTransformedDescendantStatus()
437 {
438     RenderLayer* curr = stackingContext();
439     if (curr)
440         curr->m_3DTransformedDescendantStatusDirty = true;
441         
442     // This propagates up through preserve-3d hierarchies to the enclosing flattening layer.
443     // Note that preserves3D() creates stacking context, so we can just run up the stacking contexts.
444     while (curr && curr->preserves3D()) {
445         curr->m_3DTransformedDescendantStatusDirty = true;
446         curr = curr->stackingContext();
447     }
448 }
449
450 // Return true if this layer or any preserve-3d descendants have 3d.
451 bool RenderLayer::update3DTransformedDescendantStatus()
452 {
453     if (m_3DTransformedDescendantStatusDirty) {
454         m_has3DTransformedDescendant = false;
455
456         // Transformed or preserve-3d descendants can only be in the z-order lists, not
457         // in the normal flow list, so we only need to check those.
458         if (m_posZOrderList) {
459             for (unsigned i = 0; i < m_posZOrderList->size(); ++i)
460                 m_has3DTransformedDescendant |= m_posZOrderList->at(i)->update3DTransformedDescendantStatus();
461         }
462
463         // Now check our negative z-index children.
464         if (m_negZOrderList) {
465             for (unsigned i = 0; i < m_negZOrderList->size(); ++i)
466                 m_has3DTransformedDescendant |= m_negZOrderList->at(i)->update3DTransformedDescendantStatus();
467         }
468     }
469     
470     // If we live in a 3d hierarchy, then the layer at the root of that hierarchy needs
471     // the m_has3DTransformedDescendant set.
472     if (preserves3D())
473         return has3DTransform() || m_has3DTransformedDescendant;
474
475     return has3DTransform();
476 }
477
478 void RenderLayer::updateLayerPosition()
479 {
480     // Clear our cached clip rect information.
481     clearClipRects();
482
483     RenderBox* rendererBox = renderBox();
484     
485     int x = rendererBox ? rendererBox->x() : 0;
486     int y = rendererBox ? rendererBox->y() : 0;
487
488     if (!renderer()->isPositioned() && renderer()->parent()) {
489         // We must adjust our position by walking up the render tree looking for the
490         // nearest enclosing object with a layer.
491         RenderObject* curr = renderer()->parent();
492         while (curr && !curr->hasLayer()) {
493             if (curr->isBox() && !curr->isTableRow()) {
494                 // Rows and cells share the same coordinate space (that of the section).
495                 // Omit them when computing our xpos/ypos.
496                 RenderBox* currBox = toRenderBox(curr);
497                 x += currBox->x();
498                 y += currBox->y();
499             }
500             curr = curr->parent();
501         }
502         if (curr->isBox() && curr->isTableRow()) {
503             // Put ourselves into the row coordinate space.
504             RenderBox* currBox = toRenderBox(curr);
505             x -= currBox->x();
506             y -= currBox->y();
507         }
508     }
509
510     m_relX = m_relY = 0;
511     if (renderer()->isRelPositioned()) {
512         m_relX = renderer()->relativePositionOffsetX();
513         m_relY = renderer()->relativePositionOffsetY();
514         x += m_relX; y += m_relY;
515     }
516     
517     // Subtract our parent's scroll offset.
518     if (renderer()->isPositioned() && enclosingPositionedAncestor()) {
519         RenderLayer* positionedParent = enclosingPositionedAncestor();
520
521         // For positioned layers, we subtract out the enclosing positioned layer's scroll offset.
522         positionedParent->subtractScrolledContentOffset(x, y);
523         
524         if (renderer()->isPositioned() && positionedParent->renderer()->isRelPositioned() && positionedParent->renderer()->isRenderInline()) {
525             IntSize offset = toRenderInline(positionedParent->renderer())->relativePositionedInlineOffset(toRenderBox(renderer()));
526             x += offset.width();
527             y += offset.height();
528         }
529     } else if (parent())
530         parent()->subtractScrolledContentOffset(x, y);
531     
532     // FIXME: We'd really like to just get rid of the concept of a layer rectangle and rely on the renderers.
533
534     setLocation(x, y);
535
536     if (renderer()->isRenderInline()) {
537         RenderInline* inlineFlow = toRenderInline(renderer());
538         IntRect lineBox = inlineFlow->linesBoundingBox();
539         setWidth(lineBox.width());
540         setHeight(lineBox.height());
541     } else if (RenderBox* box = renderBox()) {
542         setWidth(box->width());
543         setHeight(box->height());
544
545         if (!box->hasOverflowClip()) {
546             if (box->overflowWidth() > box->width())
547                 setWidth(box->overflowWidth());
548             if (box->overflowHeight() > box->height())
549                 setHeight(box->overflowHeight());
550         }
551     }
552 }
553
554 TransformationMatrix RenderLayer::perspectiveTransform() const
555 {
556     if (!renderer()->hasTransform())
557         return TransformationMatrix();
558
559     RenderStyle* style = renderer()->style();
560     if (!style->hasPerspective())
561         return TransformationMatrix();
562
563     // Maybe fetch the perspective from the backing?
564     const IntRect borderBox = toRenderBox(renderer())->borderBoxRect();
565     const float boxWidth = borderBox.width();
566     const float boxHeight = borderBox.height();
567
568     float perspectiveOriginX = style->perspectiveOriginX().calcFloatValue(boxWidth);
569     float perspectiveOriginY = style->perspectiveOriginY().calcFloatValue(boxHeight);
570
571     // A perspective origin of 0,0 makes the vanishing point in the center of the element.
572     // We want it to be in the top-left, so subtract half the height and width.
573     perspectiveOriginX -= boxWidth / 2.0f;
574     perspectiveOriginY -= boxHeight / 2.0f;
575     
576     TransformationMatrix t;
577     t.translate(perspectiveOriginX, perspectiveOriginY);
578     t.applyPerspective(style->perspective());
579     t.translate(-perspectiveOriginX, -perspectiveOriginY);
580     
581     return t;
582 }
583
584 FloatPoint RenderLayer::perspectiveOrigin() const
585 {
586     if (!renderer()->hasTransform())
587         return FloatPoint();
588
589     const IntRect borderBox = toRenderBox(renderer())->borderBoxRect();
590     RenderStyle* style = renderer()->style();
591
592     return FloatPoint(style->perspectiveOriginX().calcFloatValue(borderBox.width()),
593                       style->perspectiveOriginY().calcFloatValue(borderBox.height()));
594 }
595
596 RenderLayer *RenderLayer::stackingContext() const
597 {
598     RenderLayer* curr = parent();
599     for ( ; curr && !curr->renderer()->isRenderView() && !curr->renderer()->isRoot() &&
600           curr->renderer()->style()->hasAutoZIndex();
601           curr = curr->parent()) { }
602     return curr;
603 }
604
605 RenderLayer* RenderLayer::enclosingPositionedAncestor() const
606 {
607     RenderLayer* curr = parent();
608     for ( ; curr && !curr->renderer()->isRenderView() && !curr->renderer()->isPositioned() && !curr->renderer()->isRelPositioned() && !curr->hasTransform();
609          curr = curr->parent()) { }
610     return curr;
611 }
612
613 RenderLayer* RenderLayer::enclosingTransformedAncestor() const
614 {
615     RenderLayer* curr = parent();
616     for ( ; curr && !curr->renderer()->isRenderView() && !curr->transform(); curr = curr->parent())
617         { }
618     return curr;
619 }
620
621 #if USE(ACCELERATED_COMPOSITING)
622 RenderLayer* RenderLayer::enclosingCompositingLayer(bool includeSelf) const
623 {
624     if (includeSelf && isComposited())
625         return const_cast<RenderLayer*>(this);
626
627     // Compositing layers are parented according to stacking order and overflow list,
628     // so we have to check whether the parent is a stacking context, or whether 
629     // the child is overflow-only.
630     bool inNormalFlowList = isNormalFlowOnly();
631     for (RenderLayer* curr = parent(); curr; curr = curr->parent()) {
632         if (curr->isComposited() && (inNormalFlowList || curr->isStackingContext()))
633             return curr;
634         
635         inNormalFlowList = curr->isNormalFlowOnly();
636     }
637          
638     return 0;
639 }
640 #endif
641
642 IntPoint RenderLayer::absoluteToContents(const IntPoint& absolutePoint) const
643 {
644     // We don't use convertToLayerCoords because it doesn't know about transforms
645     return roundedIntPoint(renderer()->absoluteToLocal(absolutePoint, false, true));
646 }
647
648 bool RenderLayer::requiresSlowRepaints() const
649 {
650     if (isTransparent() || hasReflection() || hasTransform())
651         return true;
652     if (!parent())
653         return false;
654     return parent()->requiresSlowRepaints();
655 }
656
657 bool RenderLayer::isTransparent() const
658 {
659 #if ENABLE(SVG)
660     if (renderer()->node() && renderer()->node()->namespaceURI() == SVGNames::svgNamespaceURI)
661         return false;
662 #endif
663     return renderer()->isTransparent() || renderer()->hasMask();
664 }
665
666 RenderLayer* RenderLayer::transparentPaintingAncestor()
667 {
668     if (isComposited())
669         return 0;
670
671     for (RenderLayer* curr = parent(); curr; curr = curr->parent()) {
672         if (curr->isComposited())
673             return 0;
674         if (curr->isTransparent())
675             return curr;
676     }
677     return 0;
678 }
679
680 static IntRect transparencyClipBox(const TransformationMatrix& enclosingTransform, const RenderLayer* l, const RenderLayer* rootLayer)
681 {
682     // FIXME: Although this function completely ignores CSS-imposed clipping, we did already intersect with the
683     // paintDirtyRect, and that should cut down on the amount we have to paint.  Still it
684     // would be better to respect clips.
685     
686     if (rootLayer != l && l->paintsWithTransform()) {
687         // The best we can do here is to use enclosed bounding boxes to establish a "fuzzy" enough clip to encompass
688         // the transformed layer and all of its children.
689         int x = 0;
690         int y = 0;
691         l->convertToLayerCoords(rootLayer, x, y);
692
693         TransformationMatrix transform;
694         transform.translate(x, y);
695         transform = *l->transform() * transform;
696         transform = transform * enclosingTransform;
697
698         // We now have a transform that will produce a rectangle in our view's space.
699         IntRect clipRect = transform.mapRect(l->boundingBox(l));
700         
701         // Now shift the root layer to be us and pass down the new enclosing transform.
702         for (RenderLayer* curr = l->firstChild(); curr; curr = curr->nextSibling()) {
703             if (!l->reflection() || l->reflectionLayer() != curr)
704                 clipRect.unite(transparencyClipBox(transform, curr, l));
705         }
706             
707         return clipRect;
708     }
709     
710     // Note: we don't have to walk z-order lists since transparent elements always establish
711     // a stacking context.  This means we can just walk the layer tree directly.
712     IntRect clipRect = l->boundingBox(rootLayer);
713     
714     // If we have a mask, then the clip is limited to the border box area (and there is
715     // no need to examine child layers).
716     if (!l->renderer()->hasMask()) {
717         for (RenderLayer* curr = l->firstChild(); curr; curr = curr->nextSibling()) {
718             if (!l->reflection() || l->reflectionLayer() != curr)
719                 clipRect.unite(transparencyClipBox(enclosingTransform, curr, rootLayer));
720         }
721     }
722
723     // Now map the clipRect via the enclosing transform
724     return enclosingTransform.mapRect(clipRect);
725 }
726
727 void RenderLayer::beginTransparencyLayers(GraphicsContext* p, const RenderLayer* rootLayer)
728 {
729     if (p->paintingDisabled() || (paintsWithTransparency() && m_usedTransparency))
730         return;
731     
732     RenderLayer* ancestor = transparentPaintingAncestor();
733     if (ancestor)
734         ancestor->beginTransparencyLayers(p, rootLayer);
735     
736     if (paintsWithTransparency()) {
737         m_usedTransparency = true;
738         p->save();
739         p->clip(transparencyClipBox(TransformationMatrix(), this, rootLayer));
740         p->beginTransparencyLayer(renderer()->opacity());
741     }
742 }
743
744 void* RenderLayer::operator new(size_t sz, RenderArena* renderArena) throw()
745 {
746     return renderArena->allocate(sz);
747 }
748
749 void RenderLayer::operator delete(void* ptr, size_t sz)
750 {
751     // Stash size where destroy can find it.
752     *(size_t *)ptr = sz;
753 }
754
755 void RenderLayer::destroy(RenderArena* renderArena)
756 {    
757     delete this;
758
759     // Recover the size left there for us by operator delete and free the memory.
760     renderArena->free(*(size_t *)this, this);
761 }
762
763 void RenderLayer::addChild(RenderLayer* child, RenderLayer* beforeChild)
764 {
765     RenderLayer* prevSibling = beforeChild ? beforeChild->previousSibling() : lastChild();
766     if (prevSibling) {
767         child->setPreviousSibling(prevSibling);
768         prevSibling->setNextSibling(child);
769     } else
770         setFirstChild(child);
771
772     if (beforeChild) {
773         beforeChild->setPreviousSibling(child);
774         child->setNextSibling(beforeChild);
775     } else
776         setLastChild(child);
777
778     child->setParent(this);
779
780     if (child->isNormalFlowOnly())
781         dirtyNormalFlowList();
782
783     if (!child->isNormalFlowOnly() || child->firstChild()) {
784         // Dirty the z-order list in which we are contained.  The stackingContext() can be null in the
785         // case where we're building up generated content layers.  This is ok, since the lists will start
786         // off dirty in that case anyway.
787         child->dirtyStackingContextZOrderLists();
788     }
789
790     child->updateVisibilityStatus();
791     if (child->m_hasVisibleContent || child->m_hasVisibleDescendant)
792         childVisibilityChanged(true);
793     
794 #if USE(ACCELERATED_COMPOSITING)
795     compositor()->layerWasAdded(this, child);
796 #endif
797 }
798
799 RenderLayer* RenderLayer::removeChild(RenderLayer* oldChild)
800 {
801 #if USE(ACCELERATED_COMPOSITING)
802     if (!renderer()->documentBeingDestroyed())
803         compositor()->layerWillBeRemoved(this, oldChild);
804 #endif
805
806     // remove the child
807     if (oldChild->previousSibling())
808         oldChild->previousSibling()->setNextSibling(oldChild->nextSibling());
809     if (oldChild->nextSibling())
810         oldChild->nextSibling()->setPreviousSibling(oldChild->previousSibling());
811
812     if (m_first == oldChild)
813         m_first = oldChild->nextSibling();
814     if (m_last == oldChild)
815         m_last = oldChild->previousSibling();
816
817     if (oldChild->isNormalFlowOnly())
818         dirtyNormalFlowList();
819     if (!oldChild->isNormalFlowOnly() || oldChild->firstChild()) { 
820         // Dirty the z-order list in which we are contained.  When called via the
821         // reattachment process in removeOnlyThisLayer, the layer may already be disconnected
822         // from the main layer tree, so we need to null-check the |stackingContext| value.
823         oldChild->dirtyStackingContextZOrderLists();
824     }
825
826     oldChild->setPreviousSibling(0);
827     oldChild->setNextSibling(0);
828     oldChild->setParent(0);
829     
830     oldChild->updateVisibilityStatus();
831     if (oldChild->m_hasVisibleContent || oldChild->m_hasVisibleDescendant)
832         childVisibilityChanged(false);
833     
834     return oldChild;
835 }
836
837 void RenderLayer::removeOnlyThisLayer()
838 {
839     if (!m_parent)
840         return;
841     
842 #if USE(ACCELERATED_COMPOSITING)
843     compositor()->layerWillBeRemoved(m_parent, this);
844 #endif
845
846     // Dirty the clip rects.
847     clearClipRectsIncludingDescendants();
848
849     // Remove us from the parent.
850     RenderLayer* parent = m_parent;
851     RenderLayer* nextSib = nextSibling();
852     parent->removeChild(this);
853     
854     if (reflection())
855         removeChild(reflectionLayer());
856
857     // Now walk our kids and reattach them to our parent.
858     RenderLayer* current = m_first;
859     while (current) {
860         RenderLayer* next = current->nextSibling();
861         removeChild(current);
862         parent->addChild(current, nextSib);
863         current->updateLayerPositions();
864         current = next;
865     }
866     
867     destroy(renderer()->renderArena());
868 }
869
870 void RenderLayer::insertOnlyThisLayer()
871 {
872     if (!m_parent && renderer()->parent()) {
873         // We need to connect ourselves when our renderer() has a parent.
874         // Find our enclosingLayer and add ourselves.
875         RenderLayer* parentLayer = renderer()->parent()->enclosingLayer();
876         RenderLayer* beforeChild = parentLayer->reflectionLayer() != this ? renderer()->parent()->findNextLayer(parentLayer, renderer()) : 0;
877         if (parentLayer)
878             parentLayer->addChild(this, beforeChild);
879     }
880     
881     // Remove all descendant layers from the hierarchy and add them to the new position.
882     for (RenderObject* curr = renderer()->firstChild(); curr; curr = curr->nextSibling())
883         curr->moveLayers(m_parent, this);
884         
885     // Clear out all the clip rects.
886     clearClipRectsIncludingDescendants();
887 }
888
889 void 
890 RenderLayer::convertToLayerCoords(const RenderLayer* ancestorLayer, int& xPos, int& yPos) const
891 {
892     if (ancestorLayer == this)
893         return;
894         
895     if (renderer()->style()->position() == FixedPosition) {
896         // Add in the offset of the view.  We can obtain this by calling
897         // localToAbsolute() on the RenderView.
898         FloatPoint absPos = renderer()->localToAbsolute(FloatPoint(), true);
899         xPos += absPos.x();
900         yPos += absPos.y();
901         return;
902     }
903  
904     RenderLayer* parentLayer;
905     if (renderer()->style()->position() == AbsolutePosition)
906         parentLayer = enclosingPositionedAncestor();
907     else
908         parentLayer = parent();
909     
910     if (!parentLayer) return;
911     
912     parentLayer->convertToLayerCoords(ancestorLayer, xPos, yPos);
913
914     xPos += x();
915     yPos += y();
916 }
917
918 void RenderLayer::panScrollFromPoint(const IntPoint& sourcePoint) 
919 {
920     // We want to reduce the speed if we're close from the original point to improve the handleability of the scroll
921     const int shortDistanceLimit = 100;  // We delimit a 200 pixels long square enclosing the original point
922     const int speedReducer = 2;          // Within this square we divide the scrolling speed by 2
923     
924     const int iconRadius = 10;
925     Frame* frame = renderer()->document()->frame();
926     if (!frame)
927         return;
928     
929     IntPoint currentMousePosition = frame->eventHandler()->currentMousePosition();
930     
931     // We need to check if the current mouse position is out of the window. When the mouse is out of the window, the position is incoherent
932     static IntPoint previousMousePosition;
933     if (currentMousePosition.x() < 0 || currentMousePosition.y() < 0)
934         currentMousePosition = previousMousePosition;
935     else
936         previousMousePosition = currentMousePosition;
937
938     int xDelta = currentMousePosition.x() - sourcePoint.x();
939     int yDelta = currentMousePosition.y() - sourcePoint.y();
940
941     if (abs(xDelta) < iconRadius) // at the center we let the space for the icon
942         xDelta = 0;
943     if (abs(yDelta) < iconRadius)
944         yDelta = 0;
945
946     // Let's attenuate the speed for the short distances
947     if (abs(xDelta) < shortDistanceLimit)
948         xDelta /= speedReducer;
949     if (abs(yDelta) < shortDistanceLimit)
950         yDelta /= speedReducer;
951
952     scrollByRecursively(xDelta, yDelta);
953 }
954
955 void RenderLayer::scrollByRecursively(int xDelta, int yDelta)
956 {
957     bool restrictedByLineClamp = false;
958     if (renderer()->parent())
959         restrictedByLineClamp = renderer()->parent()->style()->lineClamp() >= 0;
960
961     if (renderer()->hasOverflowClip() && !restrictedByLineClamp) {
962         int newOffsetX = scrollXOffset() + xDelta;
963         int newOffsetY = scrollYOffset() + yDelta;
964         scrollToOffset(newOffsetX, newOffsetY);
965
966         // If this layer can't do the scroll we ask its parent
967         int leftToScrollX = newOffsetX - scrollXOffset();
968         int leftToScrollY = newOffsetY - scrollYOffset();
969         if ((leftToScrollX || leftToScrollY) && renderer()->parent()) {
970             renderer()->parent()->enclosingLayer()->scrollByRecursively(leftToScrollX, leftToScrollY);
971             Frame* frame = renderer()->document()->frame();
972             if (frame)
973                 frame->eventHandler()->updateAutoscrollRenderer();
974         }
975     } else if (renderer()->view()->frameView())
976         renderer()->view()->frameView()->scrollBy(IntSize(xDelta, yDelta));
977 }
978
979
980 void
981 RenderLayer::addScrolledContentOffset(int& x, int& y) const
982 {
983     x += scrollXOffset() + m_scrollLeftOverflow;
984     y += scrollYOffset();
985 }
986
987 void
988 RenderLayer::subtractScrolledContentOffset(int& x, int& y) const
989 {
990     x -= scrollXOffset() + m_scrollLeftOverflow;
991     y -= scrollYOffset();
992 }
993
994 void RenderLayer::scrollToOffset(int x, int y, bool updateScrollbars, bool repaint)
995 {
996     RenderBox* box = renderBox();
997     if (!box)
998         return;
999
1000     if (box->style()->overflowX() != OMARQUEE) {
1001         if (x < 0) x = 0;
1002         if (y < 0) y = 0;
1003     
1004         // Call the scrollWidth/Height functions so that the dimensions will be computed if they need
1005         // to be (for overflow:hidden blocks).
1006         int maxX = scrollWidth() - box->clientWidth();
1007         int maxY = scrollHeight() - box->clientHeight();
1008         
1009         if (x > maxX) x = maxX;
1010         if (y > maxY) y = maxY;
1011     }
1012     
1013     // FIXME: Eventually, we will want to perform a blit.  For now never
1014     // blit, since the check for blitting is going to be very
1015     // complicated (since it will involve testing whether our layer
1016     // is either occluded by another layer or clipped by an enclosing
1017     // layer or contains fixed backgrounds, etc.).
1018     int newScrollX = x - m_scrollOriginX;
1019     if (m_scrollY == y && m_scrollX == newScrollX)
1020         return;
1021     m_scrollX = newScrollX;
1022     m_scrollY = y;
1023
1024     // Update the positions of our child layers.
1025     for (RenderLayer* child = firstChild(); child; child = child->nextSibling())
1026         child->updateLayerPositions(false, false);
1027
1028 #if USE(ACCELERATED_COMPOSITING)
1029     if (isComposited())
1030         m_backing->updateGraphicsLayerGeometry();
1031 #endif
1032     
1033     RenderView* view = renderer()->view();
1034     
1035     // We should have a RenderView if we're trying to scroll.
1036     ASSERT(view);
1037     if (view) {
1038 #if ENABLE(DASHBOARD_SUPPORT)
1039         // Update dashboard regions, scrolling may change the clip of a
1040         // particular region.
1041         view->frameView()->updateDashboardRegions();
1042 #endif
1043
1044         view->updateWidgetPositions();
1045     }
1046
1047     // The caret rect needs to be invalidated after scrolling
1048     Frame* frame = renderer()->document()->frame();
1049     if (frame)
1050         frame->invalidateSelection();
1051
1052     // Just schedule a full repaint of our object.
1053     if (repaint)
1054         renderer()->repaint();
1055     
1056     if (updateScrollbars) {
1057         if (m_hBar)
1058             m_hBar->setValue(scrollXOffset());
1059         if (m_vBar)
1060             m_vBar->setValue(m_scrollY);
1061     }
1062
1063     // Schedule the scroll DOM event.
1064     if (view) {
1065         if (FrameView* frameView = view->frameView())
1066             frameView->scheduleEvent(Event::create(eventNames().scrollEvent, false, false), renderer()->node());
1067     }
1068 }
1069
1070 void RenderLayer::scrollRectToVisible(const IntRect &rect, bool scrollToAnchor, const ScrollAlignment& alignX, const ScrollAlignment& alignY)
1071 {
1072     RenderLayer* parentLayer = 0;
1073     IntRect newRect = rect;
1074     int xOffset = 0, yOffset = 0;
1075
1076     // We may end up propagating a scroll event. It is important that we suspend events until 
1077     // the end of the function since they could delete the layer or the layer's renderer().
1078     FrameView* frameView = renderer()->document()->view();
1079     if (frameView)
1080         frameView->pauseScheduledEvents();
1081
1082     bool restrictedByLineClamp = false;
1083     if (renderer()->parent()) {
1084         parentLayer = renderer()->parent()->enclosingLayer();
1085         restrictedByLineClamp = renderer()->parent()->style()->lineClamp() >= 0;
1086     }
1087
1088     if (renderer()->hasOverflowClip() && !restrictedByLineClamp) {
1089         // Don't scroll to reveal an overflow layer that is restricted by the -webkit-line-clamp property.
1090         // This will prevent us from revealing text hidden by the slider in Safari RSS.
1091         RenderBox* box = renderBox();
1092         ASSERT(box);
1093         FloatPoint absPos = box->localToAbsolute();
1094         absPos.move(box->borderLeft(), box->borderTop());
1095
1096         IntRect layerBounds = IntRect(absPos.x() + scrollXOffset(), absPos.y() + scrollYOffset(), box->clientWidth(), box->clientHeight());
1097         IntRect exposeRect = IntRect(rect.x() + scrollXOffset(), rect.y() + scrollYOffset(), rect.width(), rect.height());
1098         IntRect r = getRectToExpose(layerBounds, exposeRect, alignX, alignY);
1099         
1100         xOffset = r.x() - absPos.x();
1101         yOffset = r.y() - absPos.y();
1102         // Adjust offsets if they're outside of the allowable range.
1103         xOffset = max(0, min(scrollWidth() - layerBounds.width(), xOffset));
1104         yOffset = max(0, min(scrollHeight() - layerBounds.height(), yOffset));
1105         
1106         if (xOffset != scrollXOffset() || yOffset != scrollYOffset()) {
1107             int diffX = scrollXOffset();
1108             int diffY = scrollYOffset();
1109             scrollToOffset(xOffset, yOffset);
1110             diffX = scrollXOffset() - diffX;
1111             diffY = scrollYOffset() - diffY;
1112             newRect.setX(rect.x() - diffX);
1113             newRect.setY(rect.y() - diffY);
1114         }
1115     } else if (!parentLayer && renderer()->isBox() && renderBox()->canBeProgramaticallyScrolled(scrollToAnchor)) {
1116         if (frameView) {
1117             if (renderer()->document() && renderer()->document()->ownerElement() && renderer()->document()->ownerElement()->renderer()) {
1118                 IntRect viewRect = frameView->visibleContentRect();
1119                 IntRect r = getRectToExpose(viewRect, rect, alignX, alignY);
1120                 
1121                 xOffset = r.x();
1122                 yOffset = r.y();
1123                 // Adjust offsets if they're outside of the allowable range.
1124                 xOffset = max(0, min(frameView->contentsWidth(), xOffset));
1125                 yOffset = max(0, min(frameView->contentsHeight(), yOffset));
1126
1127                 frameView->setScrollPosition(IntPoint(xOffset, yOffset));
1128                 parentLayer = renderer()->document()->ownerElement()->renderer()->enclosingLayer();
1129                 newRect.setX(rect.x() - frameView->scrollX() + frameView->x());
1130                 newRect.setY(rect.y() - frameView->scrollY() + frameView->y());
1131             } else {
1132                 IntRect viewRect = frameView->visibleContentRect(true);
1133                 IntRect r = getRectToExpose(viewRect, rect, alignX, alignY);
1134                 
1135                 // If this is the outermost view that RenderLayer needs to scroll, then we should scroll the view recursively
1136                 // Other apps, like Mail, rely on this feature.
1137                 frameView->scrollRectIntoViewRecursively(r);
1138             }
1139         }
1140     }
1141     
1142     if (parentLayer)
1143         parentLayer->scrollRectToVisible(newRect, scrollToAnchor, alignX, alignY);
1144
1145     if (frameView)
1146         frameView->resumeScheduledEvents();
1147 }
1148
1149 IntRect RenderLayer::getRectToExpose(const IntRect &visibleRect, const IntRect &exposeRect, const ScrollAlignment& alignX, const ScrollAlignment& alignY)
1150 {
1151     // Determine the appropriate X behavior.
1152     ScrollBehavior scrollX;
1153     IntRect exposeRectX(exposeRect.x(), visibleRect.y(), exposeRect.width(), visibleRect.height());
1154     int intersectWidth = intersection(visibleRect, exposeRectX).width();
1155     if (intersectWidth == exposeRect.width() || intersectWidth >= MIN_INTERSECT_FOR_REVEAL)
1156         // If the rectangle is fully visible, use the specified visible behavior.
1157         // If the rectangle is partially visible, but over a certain threshold,
1158         // then treat it as fully visible to avoid unnecessary horizontal scrolling
1159         scrollX = getVisibleBehavior(alignX);
1160     else if (intersectWidth == visibleRect.width()) {
1161         // If the rect is bigger than the visible area, don't bother trying to center. Other alignments will work.
1162         scrollX = getVisibleBehavior(alignX);
1163         if (scrollX == alignCenter)
1164             scrollX = noScroll;
1165     } else if (intersectWidth > 0)
1166         // If the rectangle is partially visible, but not above the minimum threshold, use the specified partial behavior
1167         scrollX = getPartialBehavior(alignX);
1168     else
1169         scrollX = getHiddenBehavior(alignX);
1170     // If we're trying to align to the closest edge, and the exposeRect is further right
1171     // than the visibleRect, and not bigger than the visible area, then align with the right.
1172     if (scrollX == alignToClosestEdge && exposeRect.right() > visibleRect.right() && exposeRect.width() < visibleRect.width())
1173         scrollX = alignRight;
1174
1175     // Given the X behavior, compute the X coordinate.
1176     int x;
1177     if (scrollX == noScroll) 
1178         x = visibleRect.x();
1179     else if (scrollX == alignRight)
1180         x = exposeRect.right() - visibleRect.width();
1181     else if (scrollX == alignCenter)
1182         x = exposeRect.x() + (exposeRect.width() - visibleRect.width()) / 2;
1183     else
1184         x = exposeRect.x();
1185
1186     // Determine the appropriate Y behavior.
1187     ScrollBehavior scrollY;
1188     IntRect exposeRectY(visibleRect.x(), exposeRect.y(), visibleRect.width(), exposeRect.height());
1189     int intersectHeight = intersection(visibleRect, exposeRectY).height();
1190     if (intersectHeight == exposeRect.height())
1191         // If the rectangle is fully visible, use the specified visible behavior.
1192         scrollY = getVisibleBehavior(alignY);
1193     else if (intersectHeight == visibleRect.height()) {
1194         // If the rect is bigger than the visible area, don't bother trying to center. Other alignments will work.
1195         scrollY = getVisibleBehavior(alignY);
1196         if (scrollY == alignCenter)
1197             scrollY = noScroll;
1198     } else if (intersectHeight > 0)
1199         // If the rectangle is partially visible, use the specified partial behavior
1200         scrollY = getPartialBehavior(alignY);
1201     else
1202         scrollY = getHiddenBehavior(alignY);
1203     // If we're trying to align to the closest edge, and the exposeRect is further down
1204     // than the visibleRect, and not bigger than the visible area, then align with the bottom.
1205     if (scrollY == alignToClosestEdge && exposeRect.bottom() > visibleRect.bottom() && exposeRect.height() < visibleRect.height())
1206         scrollY = alignBottom;
1207
1208     // Given the Y behavior, compute the Y coordinate.
1209     int y;
1210     if (scrollY == noScroll) 
1211         y = visibleRect.y();
1212     else if (scrollY == alignBottom)
1213         y = exposeRect.bottom() - visibleRect.height();
1214     else if (scrollY == alignCenter)
1215         y = exposeRect.y() + (exposeRect.height() - visibleRect.height()) / 2;
1216     else
1217         y = exposeRect.y();
1218
1219     return IntRect(IntPoint(x, y), visibleRect.size());
1220 }
1221
1222 void RenderLayer::autoscroll()
1223 {
1224     Frame* frame = renderer()->document()->frame();
1225     if (!frame)
1226         return;
1227
1228     FrameView* frameView = frame->view();
1229     if (!frameView)
1230         return;
1231
1232     frame->eventHandler()->updateSelectionForMouseDrag();
1233
1234     IntPoint currentDocumentPosition = frameView->windowToContents(frame->eventHandler()->currentMousePosition());
1235     scrollRectToVisible(IntRect(currentDocumentPosition, IntSize(1, 1)), false, gAlignToEdgeIfNeeded, gAlignToEdgeIfNeeded);    
1236 }
1237
1238 void RenderLayer::resize(const PlatformMouseEvent& evt, const IntSize& oldOffset)
1239 {
1240     // FIXME: This should be possible on generated content but is not right now.
1241     if (!inResizeMode() || !renderer()->hasOverflowClip() || !renderer()->node())
1242         return;
1243
1244     // Set the width and height of the shadow ancestor node if there is one.
1245     // This is necessary for textarea elements since the resizable layer is in the shadow content.
1246     Element* element = static_cast<Element*>(renderer()->node()->shadowAncestorNode());
1247     RenderBox* renderer = toRenderBox(element->renderer());
1248
1249     EResize resize = renderer->style()->resize();
1250     if (resize == RESIZE_NONE)
1251         return;
1252
1253     Document* document = element->document();
1254     if (!document->frame()->eventHandler()->mousePressed())
1255         return;
1256
1257     float zoomFactor = renderer->style()->effectiveZoom();
1258
1259     IntSize newOffset = offsetFromResizeCorner(document->view()->windowToContents(evt.pos()));
1260     newOffset.setWidth(newOffset.width() / zoomFactor);
1261     newOffset.setHeight(newOffset.height() / zoomFactor);
1262     
1263     IntSize currentSize = IntSize(renderer->width() / zoomFactor, renderer->height() / zoomFactor);
1264     IntSize minimumSize = element->minimumSizeForResizing().shrunkTo(currentSize);
1265     element->setMinimumSizeForResizing(minimumSize);
1266     
1267     IntSize adjustedOldOffset = IntSize(oldOffset.width() / zoomFactor, oldOffset.height() / zoomFactor);
1268     
1269     IntSize difference = (currentSize + newOffset - adjustedOldOffset).expandedTo(minimumSize) - currentSize;
1270
1271     CSSStyleDeclaration* style = element->style();
1272     bool isBoxSizingBorder = renderer->style()->boxSizing() == BORDER_BOX;
1273
1274     ExceptionCode ec;
1275
1276     if (difference.width()) {
1277         if (element && element->isFormControlElement()) {
1278             // Make implicit margins from the theme explicit (see <http://bugs.webkit.org/show_bug.cgi?id=9547>).
1279             style->setProperty(CSSPropertyMarginLeft, String::number(renderer->marginLeft() / zoomFactor) + "px", false, ec);
1280             style->setProperty(CSSPropertyMarginRight, String::number(renderer->marginRight() / zoomFactor) + "px", false, ec);
1281         }
1282         int baseWidth = renderer->width() - (isBoxSizingBorder ? 0
1283             : renderer->borderLeft() + renderer->paddingLeft() + renderer->borderRight() + renderer->paddingRight());
1284         baseWidth = baseWidth / zoomFactor;
1285         style->setProperty(CSSPropertyWidth, String::number(baseWidth + difference.width()) + "px", false, ec);
1286     }
1287
1288     if (difference.height()) {
1289         if (element && element->isFormControlElement()) {
1290             // Make implicit margins from the theme explicit (see <http://bugs.webkit.org/show_bug.cgi?id=9547>).
1291             style->setProperty(CSSPropertyMarginTop, String::number(renderer->marginTop() / zoomFactor) + "px", false, ec);
1292             style->setProperty(CSSPropertyMarginBottom, String::number(renderer->marginBottom() / zoomFactor) + "px", false, ec);
1293         }
1294         int baseHeight = renderer->height() - (isBoxSizingBorder ? 0
1295             : renderer->borderTop() + renderer->paddingTop() + renderer->borderBottom() + renderer->paddingBottom());
1296         baseHeight = baseHeight / zoomFactor;
1297         style->setProperty(CSSPropertyHeight, String::number(baseHeight + difference.height()) + "px", false, ec);
1298     }
1299
1300     document->updateLayout();
1301
1302     // FIXME (Radar 4118564): We should also autoscroll the window as necessary to keep the point under the cursor in view.
1303 }
1304
1305 void RenderLayer::valueChanged(Scrollbar*)
1306 {
1307     // Update scroll position from scrollbars.
1308
1309     bool needUpdate = false;
1310     int newX = scrollXOffset();
1311     int newY = m_scrollY;
1312     
1313     if (m_hBar) {
1314         newX = m_hBar->value();
1315         if (newX != scrollXOffset())
1316            needUpdate = true;
1317     }
1318
1319     if (m_vBar) {
1320         newY = m_vBar->value();
1321         if (newY != m_scrollY)
1322            needUpdate = true;
1323     }
1324
1325     if (needUpdate)
1326         scrollToOffset(newX, newY, false);
1327 }
1328
1329 bool RenderLayer::isActive() const
1330 {
1331     Page* page = renderer()->document()->frame()->page();
1332     return page && page->focusController()->isActive();
1333 }
1334
1335
1336 static IntRect cornerRect(const RenderLayer* layer, const IntRect& bounds)
1337 {
1338     int horizontalThickness;
1339     int verticalThickness;
1340     if (!layer->verticalScrollbar() && !layer->horizontalScrollbar()) {
1341         // FIXME: This isn't right.  We need to know the thickness of custom scrollbars
1342         // even when they don't exist in order to set the resizer square size properly.
1343         horizontalThickness = ScrollbarTheme::nativeTheme()->scrollbarThickness();
1344         verticalThickness = horizontalThickness;
1345     } else if (layer->verticalScrollbar() && !layer->horizontalScrollbar()) {
1346         horizontalThickness = layer->verticalScrollbar()->width();
1347         verticalThickness = horizontalThickness;
1348     } else if (layer->horizontalScrollbar() && !layer->verticalScrollbar()) {
1349         verticalThickness = layer->horizontalScrollbar()->height();
1350         horizontalThickness = verticalThickness;
1351     } else {
1352         horizontalThickness = layer->verticalScrollbar()->width();
1353         verticalThickness = layer->horizontalScrollbar()->height();
1354     }
1355     return IntRect(bounds.right() - horizontalThickness - layer->renderer()->style()->borderRightWidth(), 
1356                    bounds.bottom() - verticalThickness - layer->renderer()->style()->borderBottomWidth(),
1357                    horizontalThickness, verticalThickness);
1358 }
1359
1360 static IntRect scrollCornerRect(const RenderLayer* layer, const IntRect& bounds)
1361 {
1362     // We have a scrollbar corner when a scrollbar is visible and not filling the entire length of the box.
1363     // This happens when:
1364     // (a) A resizer is present and at least one scrollbar is present
1365     // (b) Both scrollbars are present.
1366     bool hasHorizontalBar = layer->horizontalScrollbar();
1367     bool hasVerticalBar = layer->verticalScrollbar();
1368     bool hasResizer = layer->renderer()->style()->resize() != RESIZE_NONE;
1369     if ((hasHorizontalBar && hasVerticalBar) || (hasResizer && (hasHorizontalBar || hasVerticalBar)))
1370         return cornerRect(layer, bounds);
1371     return IntRect();
1372 }
1373
1374 static IntRect resizerCornerRect(const RenderLayer* layer, const IntRect& bounds)
1375 {
1376     ASSERT(layer->renderer()->isBox());
1377     if (layer->renderer()->style()->resize() == RESIZE_NONE)
1378         return IntRect();
1379     return cornerRect(layer, bounds);
1380 }
1381
1382 bool RenderLayer::scrollbarCornerPresent() const
1383 {
1384     ASSERT(renderer()->isBox());
1385     return !scrollCornerRect(this, renderBox()->borderBoxRect()).isEmpty();
1386 }
1387
1388 void RenderLayer::invalidateScrollbarRect(Scrollbar* scrollbar, const IntRect& rect)
1389 {
1390     IntRect scrollRect = rect;
1391     RenderBox* box = renderBox();
1392     ASSERT(box);
1393     if (scrollbar == m_vBar.get())
1394         scrollRect.move(box->width() - box->borderRight() - box->width(), box->borderTop());
1395     else
1396         scrollRect.move(box->borderLeft(), box->height() - box->borderBottom() - scrollbar->height());
1397     renderer()->repaintRectangle(scrollRect);
1398 }
1399
1400 PassRefPtr<Scrollbar> RenderLayer::createScrollbar(ScrollbarOrientation orientation)
1401 {
1402     RefPtr<Scrollbar> widget;
1403     RenderObject* actualRenderer = renderer()->node() ? renderer()->node()->shadowAncestorNode()->renderer() : renderer();
1404     bool hasCustomScrollbarStyle = actualRenderer->isBox() && actualRenderer->style()->hasPseudoStyle(SCROLLBAR);
1405     if (hasCustomScrollbarStyle)
1406         widget = RenderScrollbar::createCustomScrollbar(this, orientation, toRenderBox(actualRenderer));
1407     else
1408         widget = Scrollbar::createNativeScrollbar(this, orientation, RegularScrollbar);
1409     renderer()->document()->view()->addChild(widget.get());        
1410     return widget.release();
1411 }
1412
1413 void RenderLayer::destroyScrollbar(ScrollbarOrientation orientation)
1414 {
1415     RefPtr<Scrollbar>& scrollbar = orientation == HorizontalScrollbar ? m_hBar : m_vBar;
1416     if (scrollbar) {
1417         scrollbar->removeFromParent();
1418         scrollbar->setClient(0);
1419         scrollbar = 0;
1420     }
1421 }
1422
1423 void RenderLayer::setHasHorizontalScrollbar(bool hasScrollbar)
1424 {
1425     if (hasScrollbar == (m_hBar != 0))
1426         return;
1427
1428     if (hasScrollbar)
1429         m_hBar = createScrollbar(HorizontalScrollbar);
1430     else
1431         destroyScrollbar(HorizontalScrollbar);
1432
1433     // Destroying or creating one bar can cause our scrollbar corner to come and go.  We need to update the opposite scrollbar's style.
1434     if (m_hBar)
1435         m_hBar->styleChanged();
1436     if (m_vBar)
1437         m_vBar->styleChanged();
1438
1439 #if ENABLE(DASHBOARD_SUPPORT)
1440     // Force an update since we know the scrollbars have changed things.
1441     if (renderer()->document()->hasDashboardRegions())
1442         renderer()->document()->setDashboardRegionsDirty(true);
1443 #endif
1444 }
1445
1446 void RenderLayer::setHasVerticalScrollbar(bool hasScrollbar)
1447 {
1448     if (hasScrollbar == (m_vBar != 0))
1449         return;
1450
1451     if (hasScrollbar)
1452         m_vBar = createScrollbar(VerticalScrollbar);
1453     else
1454         destroyScrollbar(VerticalScrollbar);
1455
1456      // Destroying or creating one bar can cause our scrollbar corner to come and go.  We need to update the opposite scrollbar's style.
1457     if (m_hBar)
1458         m_hBar->styleChanged();
1459     if (m_vBar)
1460         m_vBar->styleChanged();
1461
1462 #if ENABLE(DASHBOARD_SUPPORT)
1463     // Force an update since we know the scrollbars have changed things.
1464     if (renderer()->document()->hasDashboardRegions())
1465         renderer()->document()->setDashboardRegionsDirty(true);
1466 #endif
1467 }
1468
1469 int RenderLayer::verticalScrollbarWidth() const
1470 {
1471     if (!m_vBar)
1472         return 0;
1473     return m_vBar->width();
1474 }
1475
1476 int RenderLayer::horizontalScrollbarHeight() const
1477 {
1478     if (!m_hBar)
1479         return 0;
1480     return m_hBar->height();
1481 }
1482
1483 IntSize RenderLayer::offsetFromResizeCorner(const IntPoint& absolutePoint) const
1484 {
1485     // Currently the resize corner is always the bottom right corner
1486     IntPoint bottomRight(width(), height());
1487     IntPoint localPoint = absoluteToContents(absolutePoint);
1488     return localPoint - bottomRight;
1489 }
1490
1491 void RenderLayer::positionOverflowControls(int tx, int ty)
1492 {
1493     if (!m_hBar && !m_vBar && (!renderer()->hasOverflowClip() || renderer()->style()->resize() == RESIZE_NONE))
1494         return;
1495     
1496     RenderBox* box = renderBox();
1497     if (!box)
1498         return;
1499
1500     IntRect borderBox = box->borderBoxRect();
1501     IntRect scrollCorner(scrollCornerRect(this, borderBox));
1502     IntRect absBounds(borderBox.x() + tx, borderBox.y() + ty, borderBox.width(), borderBox.height());
1503     if (m_vBar)
1504         m_vBar->setFrameRect(IntRect(absBounds.right() - box->borderRight() - m_vBar->width(),
1505                                      absBounds.y() + box->borderTop(),
1506                                      m_vBar->width(),
1507                                      absBounds.height() - (box->borderTop() + box->borderBottom()) - scrollCorner.height()));
1508
1509     if (m_hBar)
1510         m_hBar->setFrameRect(IntRect(absBounds.x() + box->borderLeft(),
1511                                      absBounds.bottom() - box->borderBottom() - m_hBar->height(),
1512                                      absBounds.width() - (box->borderLeft() + box->borderRight()) - scrollCorner.width(),
1513                                      m_hBar->height()));
1514     
1515     if (m_scrollCorner)
1516         m_scrollCorner->setFrameRect(scrollCorner);
1517     if (m_resizer)
1518         m_resizer->setFrameRect(resizerCornerRect(this, borderBox));
1519 }
1520
1521 int RenderLayer::scrollWidth()
1522 {
1523     if (m_scrollDimensionsDirty)
1524         computeScrollDimensions();
1525     return m_scrollWidth;
1526 }
1527
1528 int RenderLayer::scrollHeight()
1529 {
1530     if (m_scrollDimensionsDirty)
1531         computeScrollDimensions();
1532     return m_scrollHeight;
1533 }
1534
1535 void RenderLayer::computeScrollDimensions(bool* needHBar, bool* needVBar)
1536 {
1537     RenderBox* box = renderBox();
1538     ASSERT(box);
1539     
1540     m_scrollDimensionsDirty = false;
1541     
1542     bool ltr = renderer()->style()->direction() == LTR;
1543
1544     int clientWidth = box->clientWidth();
1545     int clientHeight = box->clientHeight();
1546
1547     m_scrollLeftOverflow = ltr ? 0 : min(0, box->leftmostPosition(true, false) - box->borderLeft());
1548
1549     int rightPos = ltr ?
1550                     box->rightmostPosition(true, false) - box->borderLeft() :
1551                     clientWidth - m_scrollLeftOverflow;
1552     int bottomPos = box->lowestPosition(true, false) - box->borderTop();
1553
1554     m_scrollWidth = max(rightPos, clientWidth);
1555     m_scrollHeight = max(bottomPos, clientHeight);
1556     
1557     m_scrollOriginX = ltr ? 0 : m_scrollWidth - clientWidth;
1558
1559     if (needHBar)
1560         *needHBar = rightPos > clientWidth;
1561     if (needVBar)
1562         *needVBar = bottomPos > clientHeight;
1563 }
1564
1565 void RenderLayer::updateOverflowStatus(bool horizontalOverflow, bool verticalOverflow)
1566 {
1567     if (m_overflowStatusDirty) {
1568         m_horizontalOverflow = horizontalOverflow;
1569         m_verticalOverflow = verticalOverflow;
1570         m_overflowStatusDirty = false;
1571         
1572         return;
1573     }
1574     
1575     bool horizontalOverflowChanged = (m_horizontalOverflow != horizontalOverflow);
1576     bool verticalOverflowChanged = (m_verticalOverflow != verticalOverflow);
1577     
1578     if (horizontalOverflowChanged || verticalOverflowChanged) {
1579         m_horizontalOverflow = horizontalOverflow;
1580         m_verticalOverflow = verticalOverflow;
1581         
1582         if (FrameView* frameView = renderer()->document()->view()) {
1583             frameView->scheduleEvent(OverflowEvent::create(horizontalOverflowChanged, horizontalOverflow, verticalOverflowChanged, verticalOverflow),
1584                 renderer()->node());
1585         }
1586     }
1587 }
1588
1589 void
1590 RenderLayer::updateScrollInfoAfterLayout()
1591 {
1592     RenderBox* box = renderBox();
1593     if (!box)
1594         return;
1595
1596     m_scrollDimensionsDirty = true;
1597
1598     bool horizontalOverflow, verticalOverflow;
1599     computeScrollDimensions(&horizontalOverflow, &verticalOverflow);
1600
1601     if (box->style()->overflowX() != OMARQUEE) {
1602         // Layout may cause us to be in an invalid scroll position.  In this case we need
1603         // to pull our scroll offsets back to the max (or push them up to the min).
1604         int newX = max(0, min(scrollXOffset(), scrollWidth() - box->clientWidth()));
1605         int newY = max(0, min(m_scrollY, scrollHeight() - box->clientHeight()));
1606         if (newX != scrollXOffset() || newY != m_scrollY) {
1607             RenderView* view = renderer()->view();
1608             ASSERT(view);
1609             // scrollToOffset() may call updateLayerPositions(), which doesn't work
1610             // with LayoutState.
1611             // FIXME: Remove the disableLayoutState/enableLayoutState if the above changes.
1612             if (view)
1613                 view->disableLayoutState();
1614             scrollToOffset(newX, newY);
1615             if (view)
1616                 view->enableLayoutState();
1617         }
1618     }
1619
1620     bool haveHorizontalBar = m_hBar;
1621     bool haveVerticalBar = m_vBar;
1622     
1623     // overflow:scroll should just enable/disable.
1624     if (renderer()->style()->overflowX() == OSCROLL)
1625         m_hBar->setEnabled(horizontalOverflow);
1626     if (renderer()->style()->overflowY() == OSCROLL)
1627         m_vBar->setEnabled(verticalOverflow);
1628
1629     // A dynamic change from a scrolling overflow to overflow:hidden means we need to get rid of any
1630     // scrollbars that may be present.
1631     if (renderer()->style()->overflowX() == OHIDDEN && haveHorizontalBar)
1632         setHasHorizontalScrollbar(false);
1633     if (renderer()->style()->overflowY() == OHIDDEN && haveVerticalBar)
1634         setHasVerticalScrollbar(false);
1635     
1636     // overflow:auto may need to lay out again if scrollbars got added/removed.
1637     bool scrollbarsChanged = (box->hasAutoHorizontalScrollbar() && haveHorizontalBar != horizontalOverflow) || 
1638                              (box->hasAutoVerticalScrollbar() && haveVerticalBar != verticalOverflow);    
1639     if (scrollbarsChanged) {
1640         if (box->hasAutoHorizontalScrollbar())
1641             setHasHorizontalScrollbar(horizontalOverflow);
1642         if (box->hasAutoVerticalScrollbar())
1643             setHasVerticalScrollbar(verticalOverflow);
1644
1645 #if ENABLE(DASHBOARD_SUPPORT)
1646         // Force an update since we know the scrollbars have changed things.
1647         if (renderer()->document()->hasDashboardRegions())
1648             renderer()->document()->setDashboardRegionsDirty(true);
1649 #endif
1650
1651         renderer()->repaint();
1652
1653         if (renderer()->style()->overflowX() == OAUTO || renderer()->style()->overflowY() == OAUTO) {
1654             if (!m_inOverflowRelayout) {
1655                 // Our proprietary overflow: overlay value doesn't trigger a layout.
1656                 m_inOverflowRelayout = true;
1657                 renderer()->setNeedsLayout(true, false);
1658                 if (renderer()->isRenderBlock())
1659                     toRenderBlock(renderer())->layoutBlock(true);
1660                 else
1661                     renderer()->layout();
1662                 m_inOverflowRelayout = false;
1663             }
1664         }
1665     }
1666     
1667     // If overflow:scroll is turned into overflow:auto a bar might still be disabled (Bug 11985).
1668     if (m_hBar && box->hasAutoHorizontalScrollbar())
1669         m_hBar->setEnabled(true);
1670     if (m_vBar && box->hasAutoVerticalScrollbar())
1671         m_vBar->setEnabled(true);
1672
1673     // Set up the range (and page step/line step).
1674     if (m_hBar) {
1675         int clientWidth = box->clientWidth();
1676         int pageStep = (clientWidth - cAmountToKeepWhenPaging);
1677         if (pageStep < 0) pageStep = clientWidth;
1678         m_hBar->setSteps(cScrollbarPixelsPerLineStep, pageStep);
1679         m_hBar->setProportion(clientWidth, m_scrollWidth);
1680         m_hBar->setValue(scrollXOffset());
1681     }
1682     if (m_vBar) {
1683         int clientHeight = box->clientHeight();
1684         int pageStep = (clientHeight - cAmountToKeepWhenPaging);
1685         if (pageStep < 0) pageStep = clientHeight;
1686         m_vBar->setSteps(cScrollbarPixelsPerLineStep, pageStep);
1687         m_vBar->setProportion(clientHeight, m_scrollHeight);
1688     }
1689  
1690     if (renderer()->node() && renderer()->document()->hasListenerType(Document::OVERFLOWCHANGED_LISTENER))
1691         updateOverflowStatus(horizontalOverflow, verticalOverflow);
1692 }
1693
1694 void RenderLayer::paintOverflowControls(GraphicsContext* context, int tx, int ty, const IntRect& damageRect)
1695 {
1696     // Don't do anything if we have no overflow.
1697     if (!renderer()->hasOverflowClip())
1698         return;
1699     
1700     // Move the scrollbar widgets if necessary.  We normally move and resize widgets during layout, but sometimes
1701     // widgets can move without layout occurring (most notably when you scroll a document that
1702     // contains fixed positioned elements).
1703     positionOverflowControls(tx, ty);
1704
1705     // Now that we're sure the scrollbars are in the right place, paint them.
1706     if (m_hBar)
1707         m_hBar->paint(context, damageRect);
1708     if (m_vBar)
1709         m_vBar->paint(context, damageRect);
1710
1711     // We fill our scroll corner with white if we have a scrollbar that doesn't run all the way up to the
1712     // edge of the box.
1713     paintScrollCorner(context, tx, ty, damageRect);
1714     
1715     // Paint our resizer last, since it sits on top of the scroll corner.
1716     paintResizer(context, tx, ty, damageRect);
1717 }
1718
1719 void RenderLayer::paintScrollCorner(GraphicsContext* context, int tx, int ty, const IntRect& damageRect)
1720 {
1721     RenderBox* box = renderBox();
1722     ASSERT(box);
1723
1724     IntRect cornerRect = scrollCornerRect(this, box->borderBoxRect());
1725     IntRect absRect = IntRect(cornerRect.x() + tx, cornerRect.y() + ty, cornerRect.width(), cornerRect.height());
1726     if (!absRect.intersects(damageRect))
1727         return;
1728
1729     if (context->updatingControlTints()) {
1730         updateScrollCornerStyle();
1731         return;
1732     }
1733
1734     if (m_scrollCorner) {
1735         m_scrollCorner->paintIntoRect(context, tx, ty, absRect);
1736         return;
1737     }
1738     
1739     context->fillRect(absRect, Color::white);
1740 }
1741
1742 void RenderLayer::paintResizer(GraphicsContext* context, int tx, int ty, const IntRect& damageRect)
1743 {
1744     if (renderer()->style()->resize() == RESIZE_NONE)
1745         return;
1746
1747     RenderBox* box = renderBox();
1748     ASSERT(box);
1749
1750     IntRect cornerRect = resizerCornerRect(this, box->borderBoxRect());
1751     IntRect absRect = IntRect(cornerRect.x() + tx, cornerRect.y() + ty, cornerRect.width(), cornerRect.height());
1752     if (!absRect.intersects(damageRect))
1753         return;
1754
1755     if (context->updatingControlTints()) {
1756         updateResizerStyle();
1757         return;
1758     }
1759     
1760     if (m_resizer) {
1761         m_resizer->paintIntoRect(context, tx, ty, absRect);
1762         return;
1763     }
1764
1765     // Paint the resizer control.
1766     DEFINE_STATIC_LOCAL(RefPtr<Image>, resizeCornerImage, (Image::loadPlatformResource("textAreaResizeCorner")));
1767     IntPoint imagePoint(absRect.right() - resizeCornerImage->width(), absRect.bottom() - resizeCornerImage->height());
1768     context->drawImage(resizeCornerImage.get(), imagePoint);
1769
1770     // Draw a frame around the resizer (1px grey line) if there are any scrollbars present.
1771     // Clipping will exclude the right and bottom edges of this frame.
1772     if (m_hBar || m_vBar) {
1773         context->save();
1774         IntRect largerCorner = absRect;
1775         largerCorner.setSize(IntSize(largerCorner.width() + 1, largerCorner.height() + 1));
1776         context->setStrokeColor(Color(makeRGB(217, 217, 217)));
1777         context->setStrokeThickness(1.0f);
1778         context->setFillColor(Color::transparent);
1779         context->drawRect(largerCorner);
1780         context->restore();
1781     }
1782 }
1783
1784 bool RenderLayer::isPointInResizeControl(const IntPoint& absolutePoint) const
1785 {
1786     if (!renderer()->hasOverflowClip() || renderer()->style()->resize() == RESIZE_NONE)
1787         return false;
1788     
1789     RenderBox* box = renderBox();
1790     ASSERT(box);
1791
1792     IntPoint localPoint = absoluteToContents(absolutePoint);
1793
1794     IntRect localBounds(0, 0, box->width(), box->height());
1795     return resizerCornerRect(this, localBounds).contains(localPoint);
1796 }
1797     
1798 bool RenderLayer::hitTestOverflowControls(HitTestResult& result)
1799 {
1800     if (!m_hBar && !m_vBar && (!renderer()->hasOverflowClip() || renderer()->style()->resize() == RESIZE_NONE))
1801         return false;
1802
1803     RenderBox* box = renderBox();
1804     ASSERT(box);
1805
1806     int x = 0;
1807     int y = 0;
1808     convertToLayerCoords(root(), x, y);
1809     IntRect absBounds(x, y, box->width(), box->height());
1810     
1811     IntRect resizeControlRect;
1812     if (renderer()->style()->resize() != RESIZE_NONE) {
1813         resizeControlRect = resizerCornerRect(this, absBounds);
1814         if (resizeControlRect.contains(result.point()))
1815             return true;
1816     }
1817
1818     int resizeControlSize = max(resizeControlRect.height(), 0);
1819
1820     if (m_vBar) {
1821         IntRect vBarRect(absBounds.right() - box->borderRight() - m_vBar->width(), 
1822                          absBounds.y() + box->borderTop(),
1823                          m_vBar->width(),
1824                          absBounds.height() - (box->borderTop() + box->borderBottom()) - (m_hBar ? m_hBar->height() : resizeControlSize));
1825         if (vBarRect.contains(result.point())) {
1826             result.setScrollbar(m_vBar.get());
1827             return true;
1828         }
1829     }
1830
1831     resizeControlSize = max(resizeControlRect.width(), 0);
1832     if (m_hBar) {
1833         IntRect hBarRect(absBounds.x() + box->borderLeft(),
1834                          absBounds.bottom() - box->borderBottom() - m_hBar->height(),
1835                          absBounds.width() - (box->borderLeft() + box->borderRight()) - (m_vBar ? m_vBar->width() : resizeControlSize),
1836                          m_hBar->height());
1837         if (hBarRect.contains(result.point())) {
1838             result.setScrollbar(m_hBar.get());
1839             return true;
1840         }
1841     }
1842
1843     return false;
1844 }
1845
1846 bool RenderLayer::scroll(ScrollDirection direction, ScrollGranularity granularity, float multiplier)
1847 {
1848     bool didHorizontalScroll = false;
1849     bool didVerticalScroll = false;
1850     
1851     if (m_hBar) {
1852         if (granularity == ScrollByDocument) {
1853             // Special-case for the ScrollByDocument granularity. A document scroll can only be up 
1854             // or down and in both cases the horizontal bar goes all the way to the left.
1855             didHorizontalScroll = m_hBar->scroll(ScrollLeft, ScrollByDocument, multiplier);
1856         } else
1857             didHorizontalScroll = m_hBar->scroll(direction, granularity, multiplier);
1858     }
1859
1860     if (m_vBar)
1861         didVerticalScroll = m_vBar->scroll(direction, granularity, multiplier);
1862
1863     return (didHorizontalScroll || didVerticalScroll);
1864 }
1865
1866 void
1867 RenderLayer::paint(GraphicsContext* p, const IntRect& damageRect, PaintRestriction paintRestriction, RenderObject *paintingRoot)
1868 {
1869     paintLayer(this, p, damageRect, false, paintRestriction, paintingRoot);
1870 }
1871
1872 static void setClip(GraphicsContext* p, const IntRect& paintDirtyRect, const IntRect& clipRect)
1873 {
1874     if (paintDirtyRect == clipRect)
1875         return;
1876     p->save();
1877     p->clip(clipRect);
1878 }
1879
1880 static void restoreClip(GraphicsContext* p, const IntRect& paintDirtyRect, const IntRect& clipRect)
1881 {
1882     if (paintDirtyRect == clipRect)
1883         return;
1884     p->restore();
1885 }
1886
1887 void
1888 RenderLayer::paintLayer(RenderLayer* rootLayer, GraphicsContext* p,
1889                         const IntRect& paintDirtyRect, bool haveTransparency, PaintRestriction paintRestriction,
1890                         RenderObject* paintingRoot, bool appliedTransform, bool temporaryClipRects)
1891 {
1892 #if USE(ACCELERATED_COMPOSITING)
1893     // Composited RenderLayers are painted via the backing's paintIntoLayer().
1894     if (isComposited() && !backing()->paintingGoesToWindow())
1895         return;
1896 #endif
1897
1898     // Avoid painting layers when stylesheets haven't loaded.  This eliminates FOUC.
1899     // It's ok not to draw, because later on, when all the stylesheets do load, updateStyleSelector on the Document
1900     // will do a full repaint().
1901     if (renderer()->document()->didLayoutWithPendingStylesheets() && !renderer()->isRenderView() && !renderer()->isRoot())
1902         return;
1903     
1904     // If this layer is totally invisible then there is nothing to paint.
1905     if (!renderer()->opacity())
1906         return;
1907
1908     if (paintsWithTransparency())
1909         haveTransparency = true;
1910
1911     // Apply a transform if we have one.  A reflection is considered to be a transform, since it is a flip and a translate.
1912     if (paintsWithTransform() && !appliedTransform) {
1913         // If the transform can't be inverted, then don't paint anything.
1914         if (!m_transform->isInvertible())
1915             return;
1916
1917         // If we have a transparency layer enclosing us and we are the root of a transform, then we need to establish the transparency
1918         // layer from the parent now.
1919         if (haveTransparency)
1920             parent()->beginTransparencyLayers(p, rootLayer);
1921   
1922         // Make sure the parent's clip rects have been calculated.
1923         IntRect clipRect = paintDirtyRect;
1924         if (parent()) {
1925             if (temporaryClipRects) {
1926                 ClipRects parentClipRects;
1927                 parent()->calculateClipRects(rootLayer, parentClipRects);
1928                 clipRect = parentClipRects.overflowClipRect();
1929             } else {
1930                 parent()->updateClipRects(rootLayer);
1931                 clipRect = parent()->clipRects()->overflowClipRect();
1932             }
1933             clipRect.intersect(paintDirtyRect);
1934         }
1935         
1936         // Push the parent coordinate space's clip.
1937         setClip(p, paintDirtyRect, clipRect);
1938
1939         // Adjust the transform such that the renderer's upper left corner will paint at (0,0) in user space.
1940         // This involves subtracting out the position of the layer in our current coordinate space.
1941         int x = 0;
1942         int y = 0;
1943         convertToLayerCoords(rootLayer, x, y);
1944         TransformationMatrix transform;
1945         transform.translate(x, y);
1946         transform = *m_transform * transform;
1947         
1948         // Apply the transform.
1949         p->save();
1950         p->concatCTM(transform);
1951
1952         // Now do a paint with the root layer shifted to be us.
1953         paintLayer(this, p, transform.inverse().mapRect(paintDirtyRect), haveTransparency, paintRestriction, paintingRoot, true, temporaryClipRects);
1954
1955         p->restore();
1956         
1957         // Restore the clip.
1958         restoreClip(p, paintDirtyRect, clipRect);
1959         
1960         return;
1961     }
1962
1963     // Paint the reflection first if we have one.
1964     if (m_reflection && !m_paintingInsideReflection && (!m_transform || appliedTransform)) {
1965         // Mark that we are now inside replica painting.
1966         m_paintingInsideReflection = true;
1967         reflectionLayer()->paintLayer(rootLayer, p, paintDirtyRect, haveTransparency, paintRestriction, paintingRoot, false, temporaryClipRects);
1968         m_paintingInsideReflection = false;
1969     }
1970
1971     // Calculate the clip rects we should use.
1972     IntRect layerBounds, damageRect, clipRectToApply, outlineRect;
1973     calculateRects(rootLayer, paintDirtyRect, layerBounds, damageRect, clipRectToApply, outlineRect, temporaryClipRects);
1974     int x = layerBounds.x();
1975     int y = layerBounds.y();
1976     int tx = x - renderBoxX();
1977     int ty = y - renderBoxY();
1978                              
1979     // Ensure our lists are up-to-date.
1980     updateLayerListsIfNeeded();
1981
1982     bool selectionOnly = paintRestriction == PaintRestrictionSelectionOnly || paintRestriction == PaintRestrictionSelectionOnlyBlackText;
1983     bool forceBlackText = paintRestriction == PaintRestrictionSelectionOnlyBlackText;
1984     
1985     // If this layer's renderer is a child of the paintingRoot, we render unconditionally, which
1986     // is done by passing a nil paintingRoot down to our renderer (as if no paintingRoot was ever set).
1987     // Else, our renderer tree may or may not contain the painting root, so we pass that root along
1988     // so it will be tested against as we decend through the renderers.
1989     RenderObject* paintingRootForRenderer = 0;
1990     if (paintingRoot && !renderer()->isDescendantOf(paintingRoot))
1991         paintingRootForRenderer = paintingRoot;
1992
1993     // We want to paint our layer, but only if we intersect the damage rect.
1994     bool shouldPaint = intersectsDamageRect(layerBounds, damageRect, rootLayer) && m_hasVisibleContent;
1995     if (shouldPaint && !selectionOnly && !damageRect.isEmpty()) {
1996         // Begin transparency layers lazily now that we know we have to paint something.
1997         if (haveTransparency)
1998             beginTransparencyLayers(p, rootLayer);
1999         
2000         // Paint our background first, before painting any child layers.
2001         // Establish the clip used to paint our background.
2002         setClip(p, paintDirtyRect, damageRect);
2003
2004         // Paint the background.
2005         RenderObject::PaintInfo paintInfo(p, damageRect, PaintPhaseBlockBackground, false, paintingRootForRenderer, 0);
2006         renderer()->paint(paintInfo, tx, ty);
2007
2008         // Restore the clip.
2009         restoreClip(p, paintDirtyRect, damageRect);
2010     }
2011
2012     // Now walk the sorted list of children with negative z-indices.
2013     if (m_negZOrderList)
2014         for (Vector<RenderLayer*>::iterator it = m_negZOrderList->begin(); it != m_negZOrderList->end(); ++it)
2015             it[0]->paintLayer(rootLayer, p, paintDirtyRect, haveTransparency, paintRestriction, paintingRoot, false, temporaryClipRects);
2016     
2017     // Now establish the appropriate clip and paint our child RenderObjects.
2018     if (shouldPaint && !clipRectToApply.isEmpty()) {
2019         // Begin transparency layers lazily now that we know we have to paint something.
2020         if (haveTransparency)
2021             beginTransparencyLayers(p, rootLayer);
2022
2023         // Set up the clip used when painting our children.
2024         setClip(p, paintDirtyRect, clipRectToApply);
2025         RenderObject::PaintInfo paintInfo(p, clipRectToApply, 
2026                                           selectionOnly ? PaintPhaseSelection : PaintPhaseChildBlockBackgrounds,
2027                                           forceBlackText, paintingRootForRenderer, 0);
2028         renderer()->paint(paintInfo, tx, ty);
2029         if (!selectionOnly) {
2030             paintInfo.phase = PaintPhaseFloat;
2031             renderer()->paint(paintInfo, tx, ty);
2032             paintInfo.phase = PaintPhaseForeground;
2033             renderer()->paint(paintInfo, tx, ty);
2034             paintInfo.phase = PaintPhaseChildOutlines;
2035             renderer()->paint(paintInfo, tx, ty);
2036         }
2037
2038         // Now restore our clip.
2039         restoreClip(p, paintDirtyRect, clipRectToApply);
2040     }
2041     
2042     if (!outlineRect.isEmpty()) {
2043         // Paint our own outline
2044         RenderObject::PaintInfo paintInfo(p, outlineRect, PaintPhaseSelfOutline, false, paintingRootForRenderer, 0);
2045         setClip(p, paintDirtyRect, outlineRect);
2046         renderer()->paint(paintInfo, tx, ty);
2047         restoreClip(p, paintDirtyRect, outlineRect);
2048     }
2049     
2050     // Paint any child layers that have overflow.
2051     if (m_normalFlowList)
2052         for (Vector<RenderLayer*>::iterator it = m_normalFlowList->begin(); it != m_normalFlowList->end(); ++it) {
2053             if (it[0]->isSelfPaintingLayer())
2054                 it[0]->paintLayer(rootLayer, p, paintDirtyRect, haveTransparency, paintRestriction, paintingRoot, false, temporaryClipRects);
2055         }
2056
2057     // Now walk the sorted list of children with positive z-indices.
2058     if (m_posZOrderList)
2059         for (Vector<RenderLayer*>::iterator it = m_posZOrderList->begin(); it != m_posZOrderList->end(); ++it)
2060             it[0]->paintLayer(rootLayer, p, paintDirtyRect, haveTransparency, paintRestriction, paintingRoot, false, temporaryClipRects);
2061     
2062     if (renderer()->hasMask() && shouldPaint && !selectionOnly && !damageRect.isEmpty()) {
2063         setClip(p, paintDirtyRect, damageRect);
2064
2065         // Paint the mask.
2066         RenderObject::PaintInfo paintInfo(p, damageRect, PaintPhaseMask, false, paintingRootForRenderer, 0);
2067         renderer()->paint(paintInfo, tx, ty);
2068         
2069         // Restore the clip.
2070         restoreClip(p, paintDirtyRect, damageRect);
2071     }
2072
2073     // End our transparency layer
2074     if (haveTransparency && m_usedTransparency && !m_paintingInsideReflection) {
2075         p->endTransparencyLayer();
2076         p->restore();
2077         m_usedTransparency = false;
2078     }
2079 }
2080
2081 static inline IntRect frameVisibleRect(RenderObject* renderer)
2082 {
2083     FrameView* frameView = renderer->document()->view();
2084     if (!frameView)
2085         return IntRect();
2086
2087     return frameView->visibleContentRect();
2088 }
2089
2090 bool RenderLayer::hitTest(const HitTestRequest& request, HitTestResult& result)
2091 {
2092     renderer()->document()->updateLayout();
2093     
2094     IntRect boundsRect(m_x, m_y, width(), height());
2095     if (!request.ignoreClipping())
2096         boundsRect.intersect(frameVisibleRect(renderer()));
2097
2098     RenderLayer* insideLayer = hitTestLayer(this, 0, request, result, boundsRect, result.point(), false);
2099     if (!insideLayer) {
2100         // We didn't hit any layer. If we are the root layer and the mouse is -- or just was -- down, 
2101         // return ourselves. We do this so mouse events continue getting delivered after a drag has 
2102         // exited the WebView, and so hit testing over a scrollbar hits the content document.
2103         if ((request.active() || request.mouseUp()) && renderer()->isRenderView()) {
2104             renderer()->updateHitTestResult(result, result.point());
2105             insideLayer = this;
2106         }
2107     }
2108
2109     // Now determine if the result is inside an anchor; make sure an image map wins if
2110     // it already set URLElement and only use the innermost.
2111     Node* node = result.innerNode();
2112     while (node) {
2113         // for imagemaps, URLElement is the associated area element not the image itself
2114         if (node->isLink() && !result.URLElement() && !node->hasTagName(imgTag))
2115             result.setURLElement(static_cast<Element*>(node));
2116         node = node->eventParentNode();
2117     }
2118
2119     // Next set up the correct :hover/:active state along the new chain.
2120     updateHoverActiveState(request, result);
2121     
2122     // Now return whether we were inside this layer (this will always be true for the root
2123     // layer).
2124     return insideLayer;
2125 }
2126
2127 Node* RenderLayer::enclosingElement() const
2128 {
2129     for (RenderObject* r = renderer(); r; r = r->parent()) {
2130         if (Node* e = r->node())
2131             return e;
2132     }
2133     ASSERT_NOT_REACHED();
2134     return 0;
2135 }
2136
2137 // Compute the z-offset of the point in the transformState.
2138 // This is effectively projecting a ray normal to the plane of ancestor, finding where that
2139 // ray intersects target, and computing the z delta between those two points.
2140 static double computeZOffset(const HitTestingTransformState& transformState)
2141 {
2142     // We got an affine transform, so no z-offset
2143     if (transformState.m_accumulatedTransform.isAffine())
2144         return 0;
2145
2146     // Flatten the point into the target plane
2147     FloatPoint targetPoint = transformState.mappedPoint();
2148     
2149     // Now map the point back through the transform, which computes Z.
2150     FloatPoint3D backmappedPoint = transformState.m_accumulatedTransform.mapPoint(FloatPoint3D(targetPoint));
2151     return backmappedPoint.z();
2152 }
2153
2154 PassRefPtr<HitTestingTransformState> RenderLayer::createLocalTransformState(RenderLayer* rootLayer, RenderLayer* containerLayer,
2155                                         const IntRect& hitTestRect, const IntPoint& hitTestPoint,
2156                                         const HitTestingTransformState* containerTransformState) const
2157 {
2158     RefPtr<HitTestingTransformState> transformState;
2159     int offsetX = 0;
2160     int offsetY = 0;
2161     if (containerTransformState) {
2162         // If we're already computing transform state, then it's relative to the container (which we know is non-null).
2163         transformState = HitTestingTransformState::create(*containerTransformState);
2164         convertToLayerCoords(containerLayer, offsetX, offsetY);
2165     } else {
2166         // If this is the first time we need to make transform state, then base it off of hitTestPoint,
2167         // which is relative to rootLayer.
2168         transformState = HitTestingTransformState::create(hitTestPoint, FloatQuad(hitTestRect));
2169         convertToLayerCoords(rootLayer, offsetX, offsetY);
2170     }
2171     
2172     // FIXME: need to have transformFromContainer be able to use getAnimatedStyleForRenderer()
2173     // when doing accelerated animations.
2174     TransformationMatrix containerTransform = renderer()->transformFromContainer(containerLayer ? containerLayer->renderer() : 0, IntSize(offsetX, offsetY));
2175     transformState->applyTransform(containerTransform, true);
2176     return transformState;
2177 }
2178
2179 // hitTestPoint and hitTestRect are relative to rootLayer.
2180 // A 'flattening' layer is one preserves3D() == false.
2181 // transformState.m_accumulatedTransform holds the transform from the containing flattening layer.
2182 // transformState.m_lastPlanarPoint is the hitTestPoint in the plane of the containing flattening layer.
2183 // transformState.m_lastPlanarQuad is the hitTestRect as a quad in the plane of the containing flattening layer.
2184 // 
2185 // If zOffset is non-null (which indicates that the caller wants z offset information), 
2186 //  *zOffset on return is the z offset of the hit point relative to the containing flattening layer.
2187 RenderLayer* RenderLayer::hitTestLayer(RenderLayer* rootLayer, RenderLayer* containerLayer, const HitTestRequest& request, HitTestResult& result,
2188                                                 const IntRect& hitTestRect, const IntPoint& hitTestPoint, bool appliedTransform,
2189                                                 const HitTestingTransformState* transformState, double* zOffset)
2190 {
2191     // The natural thing would be to keep HitTestingTransformState on the stack, but it's big, so we heap-allocate.
2192     
2193     // Apply a transform if we have one.
2194     if (transform() && !appliedTransform) {
2195         // Make sure the parent's clip rects have been calculated.
2196         if (parent()) {
2197             parent()->updateClipRects(rootLayer);
2198         
2199             // Go ahead and test the enclosing clip now.
2200             IntRect clipRect = parent()->clipRects()->overflowClipRect();
2201             if (!clipRect.contains(hitTestPoint))
2202                 return 0;
2203         }
2204
2205         // Create a transform state to accumulate this transform.
2206         RefPtr<HitTestingTransformState> newTransformState = createLocalTransformState(rootLayer, containerLayer, hitTestRect, hitTestPoint, transformState);
2207
2208         // If the transform can't be inverted, then don't hit test this layer at all.
2209         if (!newTransformState->m_accumulatedTransform.isInvertible())
2210             return 0;
2211
2212         // Check for hit test on backface if backface-visibility is 'hidden'
2213         if (renderer()->style()->backfaceVisibility() == BackfaceVisibilityHidden) {
2214             TransformationMatrix invertedMatrix = newTransformState->m_accumulatedTransform.inverse();
2215             // If the z-vector of the matrix is negative, the back is facing towards the viewer.
2216             if (invertedMatrix.m33() < 0)
2217                 return 0;
2218         }
2219
2220         // Compute the point and the hit test rect in the coords of this layer by using the values
2221         // from the transformState, which store the point and quad in the coords of the last flattened
2222         // layer, and the accumulated transform which lets up map through preserve-3d layers.
2223         //
2224         // We can't just map hitTestPoint and hitTestRect because they may have been flattened (losing z)
2225         // by our container.
2226         IntPoint localPoint = roundedIntPoint(newTransformState->mappedPoint());
2227         IntRect localHitTestRect = newTransformState->mappedQuad().enclosingBoundingBox();
2228
2229         // Now do a hit test with the root layer shifted to be us.
2230         return hitTestLayer(this, containerLayer, request, result, localHitTestRect, localPoint, true, newTransformState.get(), zOffset);
2231     }
2232     
2233     RefPtr<HitTestingTransformState> localTransformState;
2234     if (appliedTransform) {
2235         // We computed the correct state in the caller (above code), so just reference it.
2236         ASSERT(transformState);
2237         localTransformState = const_cast<HitTestingTransformState*>(transformState);
2238     } else if (transformState || m_has3DTransformedDescendant) {
2239         // We need transform state for the first time, or to offset the container state, so create it here.
2240         localTransformState = createLocalTransformState(rootLayer, containerLayer, hitTestRect, hitTestPoint, transformState);
2241     }
2242
2243     RefPtr<HitTestingTransformState> unflattenedTransformState = localTransformState;
2244     if (localTransformState && !preserves3D()) {
2245         // Keep a copy of the pre-flattening state, for computing z-offsets for the container
2246         unflattenedTransformState = HitTestingTransformState::create(*localTransformState);
2247         // This layer is flattening, so flatten the state passed to descendants.
2248         localTransformState->flatten();
2249     }
2250     
2251     // Calculate the clip rects we should use.
2252     IntRect layerBounds;
2253     IntRect bgRect;
2254     IntRect fgRect;
2255     IntRect outlineRect;
2256     calculateRects(rootLayer, hitTestRect, layerBounds, bgRect, fgRect, outlineRect);
2257     
2258     // Ensure our lists and 3d status are up-to-date.
2259     updateLayerListsIfNeeded();
2260     update3DTransformedDescendantStatus();
2261
2262     // The following are used for keeping track of the z-depth of the hit point of 3d-transformed
2263     // descendants.
2264     double localZOffset = -numeric_limits<double>::infinity();
2265     double* zOffsetForDescendantsPtr = 0;
2266     double* zOffsetForContentsPtr = 0;
2267     
2268     bool depthSortDescendants = false;
2269     if (preserves3D()) {
2270         depthSortDescendants = true;
2271         // Our layers can depth-test with our container, so share the z depth pointer with the container, if it passed one down.
2272         zOffsetForDescendantsPtr = zOffset ? zOffset : &localZOffset;
2273         zOffsetForContentsPtr = zOffset ? zOffset : &localZOffset;
2274     } else if (m_has3DTransformedDescendant) {
2275         // Flattening layer with 3d children; use a local zOffset pointer to depth-test children and foreground.
2276         depthSortDescendants = true;
2277         zOffsetForDescendantsPtr = zOffset ? zOffset : &localZOffset;
2278         zOffsetForContentsPtr = zOffset ? zOffset : &localZOffset;
2279     } else if (zOffset) {
2280         zOffsetForDescendantsPtr = 0;
2281         // Container needs us to give back a z offset for the hit layer.
2282         zOffsetForContentsPtr = zOffset;
2283     }
2284     
2285     // This variable tracks which layer the mouse ends up being inside. 
2286     RenderLayer* candidateLayer = 0;
2287
2288     // Begin by walking our list of positive layers from highest z-index down to the lowest z-index.
2289     if (m_posZOrderList) {
2290         for (int i = m_posZOrderList->size() - 1; i >= 0; --i) {
2291             RenderLayer* hitLayer = m_posZOrderList->at(i)->hitTestLayer(rootLayer, this, request, result, hitTestRect, hitTestPoint, false, localTransformState.get(), zOffsetForDescendantsPtr);
2292             if (hitLayer) {
2293                 if (depthSortDescendants) {
2294                     // Don't return yet. Keep a ref to the frontmost layer, and keep looking.
2295                     candidateLayer = hitLayer;
2296                 } else {
2297                     // Our container needs to know the z of the hit layer. This is actually computing our z, but that's OK because the hitLayer is coplanar with us.
2298                     if (zOffset && !zOffsetForDescendantsPtr)
2299                         *zOffset = computeZOffset(*unflattenedTransformState);
2300                     return hitLayer;
2301                 }
2302             }
2303         }
2304     }
2305
2306     // Now check our overflow objects.
2307     if (m_normalFlowList) {
2308         for (int i = m_normalFlowList->size() - 1; i >= 0; --i) {
2309             RenderLayer* currLayer = m_normalFlowList->at(i);
2310             if (!currLayer->isSelfPaintingLayer())
2311                 continue;
2312             RenderLayer* hitLayer = currLayer->hitTestLayer(rootLayer, this, request, result, hitTestRect, hitTestPoint, false, localTransformState.get(), zOffsetForDescendantsPtr);
2313             if (depthSortDescendants) {
2314                 // Don't return yet. Keep a ref to the frontmost layer, and keep looking.
2315                 candidateLayer = hitLayer;
2316             } else {
2317                 // Our container needs to know the z of the hit layer. This is actually computing our z, but that's OK because the hitLayer is coplanar with us.
2318                 if (zOffset && !zOffsetForDescendantsPtr)
2319                     *zOffset = computeZOffset(*unflattenedTransformState);
2320                 return hitLayer;
2321             }
2322         }
2323     }
2324
2325     // Next we want to see if the mouse pos is inside the child RenderObjects of the layer.
2326     if (fgRect.contains(hitTestPoint)) {
2327         // Hit test with a temporary HitTestResult, because we onlyl want to commit to 'result' if we know we're frontmost.
2328         HitTestResult tempResult(result.point());
2329         if (hitTestContents(request, tempResult, layerBounds, hitTestPoint, HitTestDescendants)) {
2330             if (zOffsetForContentsPtr) {
2331                 double foregroundZOffset = computeZOffset(*unflattenedTransformState);
2332                 if (foregroundZOffset > *zOffsetForContentsPtr) {
2333                     *zOffsetForContentsPtr = foregroundZOffset;
2334                     result = tempResult;
2335                     if (depthSortDescendants)
2336                         candidateLayer = this;
2337                     else
2338                         return this;
2339                 }
2340             } else {
2341                 result = tempResult;
2342                 return this;
2343             }
2344         }
2345     }
2346
2347     // Now check our negative z-index children.
2348     if (m_negZOrderList) {
2349         for (int i = m_negZOrderList->size() - 1; i >= 0; --i) {
2350             RenderLayer* hitLayer = m_negZOrderList->at(i)->hitTestLayer(rootLayer, this, request, result, hitTestRect, hitTestPoint, false, localTransformState.get(), zOffsetForDescendantsPtr);
2351             if (hitLayer) {
2352                 if (depthSortDescendants) {
2353                     // Don't return yet. Keep a ref to the frontmost layer, and keep looking.
2354                     candidateLayer = hitLayer;
2355                 } else {
2356                     // Our container needs to know the z of the hit layer. This is actually computing our z, but that's OK because the hitLayer is coplanar with us.
2357                     if (zOffset && !zOffsetForDescendantsPtr)
2358                         *zOffset = computeZOffset(*unflattenedTransformState);
2359                     return hitLayer;
2360                 }
2361             }
2362         }
2363     }
2364     
2365     // If we found a layer, return. Child layers, and foreground always render in front of background.
2366     if (candidateLayer)
2367         return candidateLayer;
2368
2369     if (bgRect.contains(hitTestPoint)) {
2370         HitTestResult tempResult(result.point());
2371         if (hitTestContents(request, tempResult, layerBounds, hitTestPoint, HitTestSelf)) {
2372             if (zOffsetForContentsPtr) {
2373                 double backgroundZOffset = computeZOffset(*unflattenedTransformState);
2374                 if (backgroundZOffset > *zOffsetForContentsPtr) {
2375                     *zOffsetForContentsPtr = backgroundZOffset;
2376                     result = tempResult;
2377                     return this;
2378                 }
2379             } else {
2380                 result = tempResult;
2381                 return this;
2382             }
2383         }
2384     }
2385     
2386     return 0;
2387 }
2388
2389 bool RenderLayer::hitTestContents(const HitTestRequest& request, HitTestResult& result, const IntRect& layerBounds, const IntPoint& hitTestPoint, HitTestFilter hitTestFilter) const
2390 {
2391     if (!renderer()->hitTest(request, result, hitTestPoint,
2392                             layerBounds.x() - renderBoxX(),
2393                             layerBounds.y() - renderBoxY(), 
2394                             hitTestFilter))
2395         return false;
2396
2397     // For positioned generated content, we might still not have a
2398     // node by the time we get to the layer level, since none of
2399     // the content in the layer has an element. So just walk up
2400     // the tree.
2401     if (!result.innerNode() || !result.innerNonSharedNode()) {
2402         Node* e = enclosingElement();
2403         if (!result.innerNode())
2404             result.setInnerNode(e);
2405         if (!result.innerNonSharedNode())
2406             result.setInnerNonSharedNode(e);
2407     }
2408         
2409     return true;
2410 }
2411
2412 void RenderLayer::updateClipRects(const RenderLayer* rootLayer)
2413 {
2414     if (m_clipRects) {
2415         ASSERT(rootLayer == m_clipRectsRoot);
2416         return; // We have the correct cached value.
2417     }
2418     
2419     // For transformed layers, the root layer was shifted to be us, so there is no need to
2420     // examine the parent.  We want to cache clip rects with us as the root.
2421     RenderLayer* parentLayer = rootLayer != this ? parent() : 0;
2422     if (parentLayer)
2423         parentLayer->updateClipRects(rootLayer);
2424
2425     ClipRects clipRects;
2426     calculateClipRects(rootLayer, clipRects, true);
2427
2428     if (parentLayer && parentLayer->clipRects() && clipRects == *parentLayer->clipRects())
2429         m_clipRects = parentLayer->clipRects();
2430     else
2431         m_clipRects = new (renderer()->renderArena()) ClipRects(clipRects);
2432     m_clipRects->ref();
2433 #ifndef NDEBUG
2434     m_clipRectsRoot = rootLayer;
2435 #endif
2436 }
2437
2438 void RenderLayer::calculateClipRects(const RenderLayer* rootLayer, ClipRects& clipRects, bool useCached) const
2439 {
2440     IntRect infiniteRect(INT_MIN/2, INT_MIN/2, INT_MAX, INT_MAX);
2441     if (!parent()) {
2442         // The root layer's clip rect is always infinite.
2443         clipRects.reset(infiniteRect);
2444         return;
2445     }
2446
2447     // For transformed layers, the root layer was shifted to be us, so there is no need to
2448     // examine the parent.  We want to cache clip rects with us as the root.
2449     RenderLayer* parentLayer = rootLayer != this ? parent() : 0;
2450     
2451     // Ensure that our parent's clip has been calculated so that we can examine the values.
2452     if (parentLayer) {
2453         if (useCached && parentLayer->clipRects())
2454             clipRects = *parentLayer->clipRects();
2455         else
2456             parentLayer->calculateClipRects(rootLayer, clipRects);
2457     }
2458     else
2459         clipRects.reset(infiniteRect);
2460
2461     // A fixed object is essentially the root of its containing block hierarchy, so when
2462     // we encounter such an object, we reset our clip rects to the fixedClipRect.
2463     if (renderer()->style()->position() == FixedPosition) {
2464         clipRects.setPosClipRect(clipRects.fixedClipRect());
2465         clipRects.setOverflowClipRect(clipRects.fixedClipRect());
2466         clipRects.setFixed(true);
2467     }
2468     else if (renderer()->style()->position() == RelativePosition)
2469         clipRects.setPosClipRect(clipRects.overflowClipRect());
2470     else if (renderer()->style()->position() == AbsolutePosition)
2471         clipRects.setOverflowClipRect(clipRects.posClipRect());
2472     
2473     // Update the clip rects that will be passed to child layers.
2474     if (renderer()->hasOverflowClip() || renderer()->hasClip()) {
2475         // This layer establishes a clip of some kind.
2476         int x = 0;
2477         int y = 0;
2478         convertToLayerCoords(rootLayer, x, y);
2479         RenderView* view = renderer()->view();
2480         ASSERT(view);
2481         if (view && clipRects.fixed() && rootLayer->renderer() == view) {
2482             x -= view->frameView()->scrollX();
2483             y -= view->frameView()->scrollY();
2484         }
2485         
2486         if (renderer()->hasOverflowClip()) {
2487             IntRect newOverflowClip = toRenderBox(renderer())->overflowClipRect(x,y);
2488             clipRects.setOverflowClipRect(intersection(newOverflowClip, clipRects.overflowClipRect()));
2489             if (renderer()->isPositioned() || renderer()->isRelPositioned())
2490                 clipRects.setPosClipRect(intersection(newOverflowClip, clipRects.posClipRect()));
2491         }
2492         if (renderer()->hasClip()) {
2493             IntRect newPosClip = toRenderBox(renderer())->clipRect(x,y);
2494             clipRects.setPosClipRect(intersection(newPosClip, clipRects.posClipRect()));
2495             clipRects.setOverflowClipRect(intersection(newPosClip, clipRects.overflowClipRect()));
2496             clipRects.setFixedClipRect(intersection(newPosClip, clipRects.fixedClipRect()));
2497         }
2498     }
2499 }
2500
2501 void RenderLayer::calculateRects(const RenderLayer* rootLayer, const IntRect& paintDirtyRect, IntRect& layerBounds,
2502                                  IntRect& backgroundRect, IntRect& foregroundRect, IntRect& outlineRect, bool temporaryClipRects) const
2503 {
2504     if (rootLayer != this && parent()) {
2505         ClipRects parentClipRects;
2506         if (temporaryClipRects)
2507             parent()->calculateClipRects(rootLayer, parentClipRects);
2508         else {
2509             parent()->updateClipRects(rootLayer);
2510             parentClipRects = *parent()->clipRects();
2511         }
2512
2513         backgroundRect = renderer()->style()->position() == FixedPosition ? parentClipRects.fixedClipRect() :
2514                          (renderer()->isPositioned() ? parentClipRects.posClipRect() : 
2515                                                      parentClipRects.overflowClipRect());
2516         RenderView* view = renderer()->view();
2517         ASSERT(view);
2518         if (view && parentClipRects.fixed() && rootLayer->renderer() == view)
2519             backgroundRect.move(view->frameView()->scrollX(), view->frameView()->scrollY());
2520
2521         backgroundRect.intersect(paintDirtyRect);
2522     } else
2523         backgroundRect = paintDirtyRect;
2524
2525     foregroundRect = backgroundRect;
2526     outlineRect = backgroundRect;
2527     
2528     int x = 0;
2529     int y = 0;
2530     convertToLayerCoords(rootLayer, x, y);
2531     layerBounds = IntRect(x, y, width(), height());
2532     
2533     // Update the clip rects that will be passed to child layers.
2534     if (renderer()->hasOverflowClip() || renderer()->hasClip()) {
2535         // This layer establishes a clip of some kind.
2536         if (renderer()->hasOverflowClip())
2537             foregroundRect.intersect(toRenderBox(renderer())->overflowClipRect(x,y));
2538         if (renderer()->hasClip()) {
2539             // Clip applies to *us* as well, so go ahead and update the damageRect.
2540             IntRect newPosClip = toRenderBox(renderer())->clipRect(x,y);
2541             backgroundRect.intersect(newPosClip);
2542             foregroundRect.intersect(newPosClip);
2543             outlineRect.intersect(newPosClip);
2544         }
2545
2546         // If we establish a clip at all, then go ahead and make sure our background
2547         // rect is intersected with our layer's bounds.
2548         if (ShadowData* boxShadow = renderer()->style()->boxShadow()) {
2549             IntRect overflow = layerBounds;
2550             do {
2551                 IntRect shadowRect = layerBounds;
2552                 shadowRect.move(boxShadow->x, boxShadow->y);
2553                 shadowRect.inflate(boxShadow->blur);
2554                 overflow.unite(shadowRect);
2555                 boxShadow = boxShadow->next;
2556             } while (boxShadow);
2557             backgroundRect.intersect(overflow);
2558         } else
2559             backgroundRect.intersect(layerBounds);
2560     }
2561 }
2562
2563 IntRect RenderLayer::childrenClipRect() const
2564 {
2565     RenderLayer* rootLayer = renderer()->view()->layer();
2566     IntRect layerBounds, backgroundRect, foregroundRect, outlineRect;
2567     calculateRects(rootLayer, rootLayer->boundingBox(rootLayer), layerBounds, backgroundRect, foregroundRect, outlineRect);
2568     return foregroundRect;
2569 }
2570
2571 IntRect RenderLayer::selfClipRect() const
2572 {
2573     RenderLayer* rootLayer = renderer()->view()->layer();
2574     IntRect layerBounds, backgroundRect, foregroundRect, outlineRect;
2575     calculateRects(rootLayer, rootLayer->boundingBox(rootLayer), layerBounds, backgroundRect, foregroundRect, outlineRect);
2576     return backgroundRect;
2577 }
2578
2579 bool RenderLayer::intersectsDamageRect(const IntRect& layerBounds, const IntRect& damageRect, const RenderLayer* rootLayer) const
2580 {
2581     // Always examine the canvas and the root.
2582     // FIXME: Could eliminate the isRoot() check if we fix background painting so that the RenderView
2583     // paints the root's background.
2584     if (renderer()->isRenderView() || renderer()->isRoot())
2585         return true;
2586
2587     // If we aren't an inline flow, and our layer bounds do intersect the damage rect, then we 
2588     // can go ahead and return true.
2589     RenderView* view = renderer()->view();
2590     ASSERT(view);
2591     if (view && !renderer()->isRenderInline()) {
2592         IntRect b = layerBounds;
2593         b.inflate(view->maximalOutlineSize());
2594         if (b.intersects(damageRect))
2595             return true;
2596     }
2597         
2598     // Otherwise we need to compute the bounding box of this single layer and see if it intersects
2599     // the damage rect.
2600     return boundingBox(rootLayer).intersects(damageRect);
2601 }
2602
2603 IntRect RenderLayer::localBoundingBox() const
2604 {
2605     // There are three special cases we need to consider.
2606     // (1) Inline Flows.  For inline flows we will create a bounding box that fully encompasses all of the lines occupied by the
2607     // inline.  In other words, if some <span> wraps to three lines, we'll create a bounding box that fully encloses the root
2608     // line boxes of all three lines (including overflow on those lines).
2609     // (2) Left/Top Overflow.  The width/height of layers already includes right/bottom overflow.  However, in the case of left/top
2610     // overflow, we have to create a bounding box that will extend to include this overflow.
2611     // (3) Floats.  When a layer has overhanging floats that it paints, we need to make sure to include these overhanging floats
2612     // as part of our bounding box.  We do this because we are the responsible layer for both hit testing and painting those
2613     // floats.
2614     IntRect result;
2615     if (renderer()->isRenderInline()) {
2616         // Go from our first line box to our last line box.
2617         RenderInline* inlineFlow = toRenderInline(renderer());
2618         InlineFlowBox* firstBox = inlineFlow->firstLineBox();
2619         if (!firstBox)
2620             return result;
2621         int top = firstBox->root()->topOverflow();
2622         int bottom = inlineFlow->lastLineBox()->root()->bottomOverflow();
2623         int left = firstBox->x();
2624         for (InlineRunBox* curr = firstBox->nextLineBox(); curr; curr = curr->nextLineBox())
2625             left = min(left, curr->x());
2626         result = IntRect(left, top, width(), bottom - top);
2627     } else if (renderer()->isTableRow()) {
2628         // Our bounding box is just the union of all of our cells' border/overflow rects.
2629         for (RenderObject* child = renderer()->firstChild(); child; child = child->nextSibling()) {
2630             if (child->isTableCell()) {
2631                 IntRect bbox = toRenderBox(child)->borderBoxRect();
2632                 result.unite(bbox);
2633                 IntRect overflowRect = renderBox()->overflowRect(false);
2634                 if (bbox != overflowRect)
2635                     result.unite(overflowRect);
2636             }
2637         }
2638     } else {
2639         RenderBox* box = renderBox();
2640         ASSERT(box);
2641         if (box->hasMask())
2642             result = box->maskClipRect();
2643         else {
2644             IntRect bbox = box->borderBoxRect();
2645             result = bbox;
2646             IntRect overflowRect = box->overflowRect(false);
2647             if (bbox != overflowRect)
2648                 result.unite(overflowRect);
2649         }
2650     }
2651
2652     RenderView* view = renderer()->view();
2653     ASSERT(view);
2654     if (view)
2655         result.inflate(view->maximalOutlineSize()); // Used to apply a fudge factor to dirty-rect checks on blocks/tables.
2656
2657     return result;
2658 }
2659
2660 IntRect RenderLayer::boundingBox(const RenderLayer* ancestorLayer) const
2661 {    
2662     IntRect result = localBoundingBox();
2663
2664     int deltaX = 0, deltaY = 0;
2665     convertToLayerCoords(ancestorLayer, deltaX, deltaY);
2666     result.move(deltaX, deltaY);
2667     return result;
2668 }
2669
2670 IntRect RenderLayer::absoluteBoundingBox() const
2671 {
2672     return boundingBox(root());
2673 }
2674
2675 void RenderLayer::clearClipRectsIncludingDescendants()
2676 {
2677     if (!m_clipRects)
2678         return;
2679
2680     clearClipRects();
2681     
2682     for (RenderLayer* l = firstChild(); l; l = l->nextSibling())
2683         l->clearClipRectsIncludingDescendants();
2684 }
2685
2686 void RenderLayer::clearClipRects()
2687 {
2688     if (m_clipRects) {
2689         m_clipRects->deref(renderer()->renderArena());
2690         m_clipRects = 0;
2691 #ifndef NDEBUG
2692         m_clipRectsRoot = 0;
2693 #endif    
2694     }
2695 }
2696
2697 #if USE(ACCELERATED_COMPOSITING)
2698 RenderLayerBacking* RenderLayer::ensureBacking()
2699 {
2700     if (!m_backing)
2701         m_backing.set(new RenderLayerBacking(this));
2702     return m_backing.get();
2703 }
2704
2705 void RenderLayer::clearBacking()
2706 {
2707     m_backing.clear();
2708 }
2709 #endif
2710
2711 void RenderLayer::setParent(RenderLayer* parent)
2712 {
2713     if (parent == m_parent)
2714         return;
2715
2716 #if USE(ACCELERATED_COMPOSITING)
2717     if (m_parent && !renderer()->documentBeingDestroyed())
2718         compositor()->layerWillBeRemoved(m_parent, this);
2719 #endif
2720     
2721     m_parent = parent;
2722     
2723 #if USE(ACCELERATED_COMPOSITING)
2724     if (m_parent && !renderer()->documentBeingDestroyed())
2725         compositor()->layerWasAdded(m_parent, this);
2726 #endif
2727 }
2728
2729 static RenderObject* commonAncestor(RenderObject* obj1, RenderObject* obj2)
2730 {
2731     if (!obj1 || !obj2)
2732         return 0;
2733
2734     for (RenderObject* currObj1 = obj1; currObj1; currObj1 = currObj1->hoverAncestor())
2735         for (RenderObject* currObj2 = obj2; currObj2; currObj2 = currObj2->hoverAncestor())
2736             if (currObj1 == currObj2)
2737                 return currObj1;
2738
2739     return 0;
2740 }
2741
2742 void RenderLayer::updateHoverActiveState(const HitTestRequest& request, HitTestResult& result)
2743 {
2744     // We don't update :hover/:active state when the result is marked as readOnly.
2745     if (request.readOnly())
2746         return;
2747
2748     Document* doc = renderer()->document();
2749
2750     Node* activeNode = doc->activeNode();
2751     if (activeNode && !request.active()) {
2752         // We are clearing the :active chain because the mouse has been released.
2753         for (RenderObject* curr = activeNode->renderer(); curr; curr = curr->parent()) {
2754             if (curr->node() && !curr->isText())
2755                 curr->node()->setInActiveChain(false);
2756         }
2757         doc->setActiveNode(0);
2758     } else {
2759         Node* newActiveNode = result.innerNode();
2760         if (!activeNode && newActiveNode && request.active()) {
2761             // We are setting the :active chain and freezing it. If future moves happen, they
2762             // will need to reference this chain.
2763             for (RenderObject* curr = newActiveNode->renderer(); curr; curr = curr->parent()) {
2764                 if (curr->node() && !curr->isText()) {
2765                     curr->node()->setInActiveChain(true);
2766                 }
2767             }
2768             doc->setActiveNode(newActiveNode);
2769         }
2770     }
2771
2772     // If the mouse is down and if this is a mouse move event, we want to restrict changes in 
2773     // :hover/:active to only apply to elements that are in the :active chain that we froze
2774     // at the time the mouse went down.
2775     bool mustBeInActiveChain = request.active() && request.mouseMove();
2776
2777     // Check to see if the hovered node has changed.  If not, then we don't need to
2778     // do anything.  
2779     RefPtr<Node> oldHoverNode = doc->hoverNode();
2780     Node* newHoverNode = result.innerNode();
2781
2782     // Update our current hover node.
2783     doc->setHoverNode(newHoverNode);
2784
2785     // We have two different objects.  Fetch their renderers.
2786     RenderObject* oldHoverObj = oldHoverNode ? oldHoverNode->renderer() : 0;
2787     RenderObject* newHoverObj = newHoverNode ? newHoverNode->renderer() : 0;
2788     
2789     // Locate the common ancestor render object for the two renderers.
2790     RenderObject* ancestor = commonAncestor(oldHoverObj, newHoverObj);
2791
2792     if (oldHoverObj != newHoverObj) {
2793         // The old hover path only needs to be cleared up to (and not including) the common ancestor;
2794         for (RenderObject* curr = oldHoverObj; curr && curr != ancestor; curr = curr->hoverAncestor()) {
2795             if (curr->node() && !curr->isText() && (!mustBeInActiveChain || curr->node()->inActiveChain())) {
2796                 curr->node()->setActive(false);
2797                 curr->node()->setHovered(false);
2798             }
2799         }
2800     }
2801
2802     // Now set the hover state for our new object up to the root.
2803     for (RenderObject* curr = newHoverObj; curr; curr = curr->hoverAncestor()) {
2804         if (curr->node() && !curr->isText() && (!mustBeInActiveChain || curr->node()->inActiveChain())) {
2805             curr->node()->setActive(request.active());
2806             curr->node()->setHovered(true);
2807         }
2808     }
2809 }
2810
2811 // Helper for the sorting of layers by z-index.
2812 static inline bool compareZIndex(RenderLayer* first, RenderLayer* second)
2813 {
2814     return first->zIndex() < second->zIndex();
2815 }
2816
2817 void RenderLayer::dirtyZOrderLists()
2818 {
2819     if (m_posZOrderList)
2820         m_posZOrderList->clear();
2821     if (m_negZOrderList)
2822         m_negZOrderList->clear();
2823     m_zOrderListsDirty = true;
2824
2825 #if USE(ACCELERATED_COMPOSITING)
2826     if (!renderer()->documentBeingDestroyed())
2827         compositor()->setCompositingLayersNeedUpdate();
2828 #endif
2829 }
2830
2831 void RenderLayer::dirtyStackingContextZOrderLists()
2832 {
2833     RenderLayer* sc = stackingContext();
2834     if (sc)
2835         sc->dirtyZOrderLists();
2836 }
2837
2838 void RenderLayer::dirtyNormalFlowList()
2839 {
2840     if (m_normalFlowList)
2841         m_normalFlowList->clear();
2842     m_normalFlowListDirty = true;
2843
2844 #if USE(ACCELERATED_COMPOSITING)
2845     if (!renderer()->documentBeingDestroyed())
2846         compositor()->setCompositingLayersNeedUpdate();
2847 #endif
2848 }
2849
2850 void RenderLayer::updateZOrderLists()
2851 {
2852     if (!isStackingContext() || !m_zOrderListsDirty)
2853         return;
2854
2855     for (RenderLayer* child = firstChild(); child; child = child->nextSibling())
2856         if (!m_reflection || reflectionLayer() != child)
2857             child->collectLayers(m_posZOrderList, m_negZOrderList);
2858
2859     // Sort the two lists.
2860     if (m_posZOrderList)
2861         std::stable_sort(m_posZOrderList->begin(), m_posZOrderList->end(), compareZIndex);
2862
2863     if (m_negZOrderList)
2864         std::stable_sort(m_negZOrderList->begin(), m_negZOrderList->end(), compareZIndex);
2865
2866     m_zOrderListsDirty = false;
2867 }
2868
2869 void RenderLayer::updateNormalFlowList()
2870 {
2871     if (!m_normalFlowListDirty)
2872         return;
2873         
2874     for (RenderLayer* child = firstChild(); child; child = child->nextSibling()) {
2875         // Ignore non-overflow layers and reflections.
2876         if (child->isNormalFlowOnly() && (!m_reflection || reflectionLayer() != child)) {
2877             if (!m_normalFlowList)
2878                 m_normalFlowList = new Vector<RenderLayer*>;
2879             m_normalFlowList->append(child);
2880         }
2881     }
2882     
2883     m_normalFlowListDirty = false;
2884 }
2885
2886 void RenderLayer::collectLayers(Vector<RenderLayer*>*& posBuffer, Vector<RenderLayer*>*& negBuffer)
2887 {
2888     updateVisibilityStatus();
2889
2890     // Overflow layers are just painted by their enclosing layers, so they don't get put in zorder lists.
2891     if ((m_hasVisibleContent || (m_hasVisibleDescendant && isStackingContext())) && !isNormalFlowOnly()) {
2892         // Determine which buffer the child should be in.
2893         Vector<RenderLayer*>*& buffer = (zIndex() >= 0) ? posBuffer : negBuffer;
2894
2895         // Create the buffer if it doesn't exist yet.
2896         if (!buffer)
2897             buffer = new Vector<RenderLayer*>;
2898         
2899         // Append ourselves at the end of the appropriate buffer.
2900         buffer->append(this);
2901     }
2902
2903     // Recur into our children to collect more layers, but only if we don't establish
2904     // a stacking context.
2905     if (m_hasVisibleDescendant && !isStackingContext()) {
2906         for (RenderLayer* child = firstChild(); child; child = child->nextSibling()) {
2907             // Ignore reflections.
2908             if (!m_reflection || reflectionLayer() != child)
2909                 child->collectLayers(posBuffer, negBuffer);
2910         }
2911     }
2912 }
2913
2914 void RenderLayer::updateLayerListsIfNeeded()
2915 {
2916 #if USE(ACCELERATED_COMPOSITING)
2917     if (compositor()->inCompositingMode()) {
2918         if ((isStackingContext() && m_zOrderListsDirty) || m_normalFlowListDirty)
2919             compositor()->updateCompositingLayers(this);
2920         return;
2921     }
2922 #endif
2923     updateZOrderLists();
2924     updateNormalFlowList();
2925 }
2926
2927 void RenderLayer::repaintIncludingDescendants()
2928 {
2929     renderer()->repaint();
2930     for (RenderLayer* curr = firstChild(); curr; curr = curr->nextSibling())
2931         curr->repaintIncludingDescendants();
2932 }
2933
2934 #if USE(ACCELERATED_COMPOSITING)
2935 void RenderLayer::setBackingNeedsRepaint()
2936 {
2937     ASSERT(isComposited());
2938     if (backing()->paintingGoesToWindow()) {
2939         // If we're trying to repaint the placeholder document layer, propagate the
2940         // repaint to the native view system.
2941         RenderView* view = renderer()->view();
2942         if (view)
2943             view->repaintViewRectangle(absoluteBoundingBox());
2944     } else
2945         backing()->setContentsNeedDisplay();
2946 }
2947
2948 void RenderLayer::setBackingNeedsRepaintInRect(const IntRect& r)
2949 {
2950     ASSERT(isComposited());
2951     if (backing()->paintingGoesToWindow()) {
2952         // If we're trying to repaint the placeholder document layer, propagate the
2953         // repaint to the native view system.
2954         IntRect absRect(r);
2955         int x = 0;
2956         int y = 0;
2957         convertToLayerCoords(root(), x, y);
2958         absRect.move(x, y);
2959
2960         RenderView* view = renderer()->view();
2961         if (view)
2962             view->repaintViewRectangle(absRect);
2963     } else
2964         backing()->setContentsNeedDisplayInRect(r);
2965 }
2966 #endif
2967
2968 bool RenderLayer::shouldBeNormalFlowOnly() const
2969 {
2970     return (renderer()->hasOverflowClip() || renderer()->hasReflection() || renderer()->hasMask()) &&
2971            !renderer()->isPositioned() &&
2972            !renderer()->isRelPositioned() &&
2973            !renderer()->hasTransform() &&
2974            !isTransparent();
2975 }
2976
2977 bool RenderLayer::isSelfPaintingLayer() const
2978 {
2979     return !isNormalFlowOnly() || renderer()->hasReflection() || renderer()->hasMask() || renderer()->isTableRow();
2980 }
2981
2982 void RenderLayer::styleChanged(StyleDifference diff, const RenderStyle*)
2983 {
2984     bool isNormalFlowOnly = shouldBeNormalFlowOnly();
2985     if (isNormalFlowOnly != m_isNormalFlowOnly) {
2986         m_isNormalFlowOnly = isNormalFlowOnly;
2987         RenderLayer* p = parent();
2988         if (p)
2989             p->dirtyNormalFlowList();
2990         dirtyStackingContextZOrderLists();
2991     }
2992
2993     if (renderer()->style()->overflowX() == OMARQUEE && renderer()->style()->marqueeBehavior() != MNONE) {
2994         if (!m_marquee)
2995             m_marquee = new RenderMarquee(this);
2996         m_marquee->updateMarqueeStyle();
2997     }
2998     else if (m_marquee) {
2999         delete m_marquee;
3000         m_marquee = 0;
3001     }
3002     
3003     if (!hasReflection() && m_reflection) {
3004         m_reflection->destroy();
3005         m_reflection = 0;
3006     } else if (hasReflection()) {
3007         if (!m_reflection)
3008             createReflection();
3009         updateReflectionStyle();
3010     }
3011     
3012     // FIXME: Need to detect a swap from custom to native scrollbars (and vice versa).
3013     if (m_hBar)
3014         m_hBar->styleChanged();
3015     if (m_vBar)
3016         m_vBar->styleChanged();
3017     
3018     updateScrollCornerStyle();
3019     updateResizerStyle();
3020
3021 #if USE(ACCELERATED_COMPOSITING)
3022     updateTransform();
3023
3024     if (compositor()->updateLayerCompositingState(this, diff))
3025         compositor()->setCompositingLayersNeedUpdate();
3026 #else
3027     UNUSED_PARAM(diff);
3028 #endif
3029 }
3030
3031 void RenderLayer::updateScrollCornerStyle()
3032 {
3033     RenderObject* actualRenderer = renderer()->node() ? renderer()->node()->shadowAncestorNode()->renderer() : renderer();
3034     RefPtr<RenderStyle> corner = renderer()->hasOverflowClip() ? actualRenderer->getUncachedPseudoStyle(SCROLLBAR_CORNER, actualRenderer->style()) : 0;
3035     if (corner) {
3036         if (!m_scrollCorner) {
3037             m_scrollCorner = new (renderer()->renderArena()) RenderScrollbarPart(renderer()->document());
3038             m_scrollCorner->setParent(renderer());
3039         }
3040         m_scrollCorner->setStyle(corner.release());
3041     } else if (m_scrollCorner) {
3042         m_scrollCorner->destroy();
3043         m_scrollCorner = 0;
3044     }
3045 }
3046
3047 void RenderLayer::updateResizerStyle()
3048 {
3049     RenderObject* actualRenderer = renderer()->node() ? renderer()->node()->shadowAncestorNode()->renderer() : renderer();
3050     RefPtr<RenderStyle> resizer = renderer()->hasOverflowClip() ? actualRenderer->getUncachedPseudoStyle(RESIZER, actualRenderer->style()) : 0;
3051     if (resizer) {
3052         if (!m_resizer) {
3053             m_resizer = new (renderer()->renderArena()) RenderScrollbarPart(renderer()->document());
3054             m_resizer->setParent(renderer());
3055         }
3056         m_resizer->setStyle(resizer.release());
3057     } else if (m_resizer) {
3058         m_resizer->destroy();
3059         m_resizer = 0;
3060     }
3061 }
3062
3063 RenderLayer* RenderLayer::reflectionLayer() const
3064 {
3065     return m_reflection ? m_reflection->layer() : 0;
3066 }
3067
3068 void RenderLayer::createReflection()
3069 {
3070     ASSERT(!m_reflection);
3071     m_reflection = new (renderer()->renderArena()) RenderReplica(renderer()->document());
3072     m_reflection->setParent(renderer()); // We create a 1-way connection.
3073 }
3074
3075 void RenderLayer::updateReflectionStyle()
3076 {
3077     RefPtr<RenderStyle> newStyle = RenderStyle::create();
3078     newStyle->inheritFrom(renderer()->style());
3079     
3080     // Map in our transform.
3081     TransformOperations transform;
3082     switch (renderer()->style()->boxReflect()->direction()) {
3083         case ReflectionBelow:
3084             transform.operations().append(TranslateTransformOperation::create(Length(0, Fixed), Length(100., Percent), TransformOperation::TRANSLATE));
3085             transform.operations().append(TranslateTransformOperation::create(Length(0, Fixed), renderer()->style()->boxReflect()->offset(), TransformOperation::TRANSLATE));
3086             transform.operations().append(ScaleTransformOperation::create(1.0, -1.0, ScaleTransformOperation::SCALE));
3087             break;
3088         case ReflectionAbove:
3089             transform.operations().append(ScaleTransformOperation::create(1.0, -1.0, ScaleTransformOperation::SCALE));
3090             transform.operations().append(TranslateTransformOperation::create(Length(0, Fixed), Length(100., Percent), TransformOperation::TRANSLATE));
3091             transform.operations().append(TranslateTransformOperation::create(Length(0, Fixed), renderer()->style()->boxReflect()->offset(), TransformOperation::TRANSLATE));
3092             break;
3093         case ReflectionRight:
3094             transform.operations().append(TranslateTransformOperation::create(Length(100., Percent), Length(0, Fixed), TransformOperation::TRANSLATE));
3095             transform.operations().append(TranslateTransformOperation::create(renderer()->style()->boxReflect()->offset(), Length(0, Fixed), TransformOperation::TRANSLATE));
3096             transform.operations().append(ScaleTransformOperation::create(-1.0, 1.0, ScaleTransformOperation::SCALE));
3097             break;
3098         case ReflectionLeft:
3099             transform.operations().append(ScaleTransformOperation::create(-1.0, 1.0, ScaleTransformOperation::SCALE));
3100             transform.operations().append(TranslateTransformOperation::create(Length(100., Percent), Length(0, Fixed), TransformOperation::TRANSLATE));
3101             transform.operations().append(TranslateTransformOperation::create(renderer()->style()->boxReflect()->offset(), Length(0, Fixed), TransformOperation::TRANSLATE));
3102             break;
3103     }
3104     newStyle->setTransform(transform);
3105
3106     // Map in our mask.
3107     newStyle->setMaskBoxImage(renderer()->style()->boxReflect()->mask());
3108     
3109     m_reflection->setStyle(newStyle.release());
3110 }
3111
3112 void RenderLayer::suspendMarquees()
3113 {
3114     if (m_marquee)
3115         m_marquee->suspend();
3116     
3117     for (RenderLayer* curr = firstChild(); curr; curr = curr->nextSibling())
3118         curr->suspendMarquees();
3119 }
3120
3121 } // namespace WebCore