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