6f6992aee6731b6aaaad3dc9b5724083f4e5161f
[WebKit-https.git] / Source / WebCore / rendering / RenderLayer.cpp
1 /*
2  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 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 "AnimationController.h"
48 #include "BoxShape.h"
49 #include "ColumnInfo.h"
50 #include "CSSPropertyNames.h"
51 #include "Chrome.h"
52 #include "Document.h"
53 #include "DocumentEventQueue.h"
54 #include "Element.h"
55 #include "EventHandler.h"
56 #include "FloatConversion.h"
57 #include "FloatPoint3D.h"
58 #include "FloatRect.h"
59 #include "FloatRoundedRect.h"
60 #include "FlowThreadController.h"
61 #include "FocusController.h"
62 #include "Frame.h"
63 #include "FrameLoader.h"
64 #include "FrameLoaderClient.h"
65 #include "FrameSelection.h"
66 #include "FrameTree.h"
67 #include "FrameView.h"
68 #include "Gradient.h"
69 #include "GraphicsContext.h"
70 #include "HTMLFrameElement.h"
71 #include "HTMLFrameOwnerElement.h"
72 #include "HTMLNames.h"
73 #include "HistogramSupport.h"
74 #include "HitTestingTransformState.h"
75 #include "HitTestRequest.h"
76 #include "HitTestResult.h"
77 #include "InspectorInstrumentation.h"
78 #include "OverflowEvent.h"
79 #include "OverlapTestRequestClient.h"
80 #include "Page.h"
81 #include "PlatformMouseEvent.h"
82 #include "RenderFlowThread.h"
83 #include "RenderGeometryMap.h"
84 #include "RenderInline.h"
85 #include "RenderIterator.h"
86 #include "RenderLayerBacking.h"
87 #include "RenderLayerCompositor.h"
88 #include "RenderMarquee.h"
89 #include "RenderMultiColumnFlowThread.h"
90 #include "RenderNamedFlowFragment.h"
91 #include "RenderNamedFlowThread.h"
92 #include "RenderRegion.h"
93 #include "RenderReplica.h"
94 #include "RenderSVGResourceClipper.h"
95 #include "RenderScrollbar.h"
96 #include "RenderScrollbarPart.h"
97 #include "RenderTableCell.h"
98 #include "RenderTableRow.h"
99 #include "RenderTheme.h"
100 #include "RenderTreeAsText.h"
101 #include "RenderView.h"
102 #include "SVGNames.h"
103 #include "ScaleTransformOperation.h"
104 #include "ScrollAnimator.h"
105 #include "Scrollbar.h"
106 #include "ScrollbarTheme.h"
107 #include "ScrollingCoordinator.h"
108 #include "Settings.h"
109 #include "ShadowRoot.h"
110 #include "SourceGraphic.h"
111 #include "StyleProperties.h"
112 #include "StyleResolver.h"
113 #include "TextStream.h"
114 #include "TransformationMatrix.h"
115 #include "TranslateTransformOperation.h"
116 #include <stdio.h>
117 #include <wtf/StdLibExtras.h>
118 #include <wtf/text/CString.h>
119
120 #if ENABLE(CSS_FILTERS)
121 #include "FEColorMatrix.h"
122 #include "FEMerge.h"
123 #include "FilterEffectRenderer.h"
124 #include "RenderLayerFilterInfo.h"
125 #endif
126
127 #define MIN_INTERSECT_FOR_REVEAL 32
128
129 namespace WebCore {
130
131 using namespace HTMLNames;
132
133 bool ClipRect::intersects(const HitTestLocation& hitTestLocation) const
134 {
135     return hitTestLocation.intersects(m_rect);
136 }
137
138 void makeMatrixRenderable(TransformationMatrix& matrix, bool has3DRendering)
139 {
140 #if !ENABLE(3D_RENDERING)
141     UNUSED_PARAM(has3DRendering);
142     matrix.makeAffine();
143 #else
144     if (!has3DRendering)
145         matrix.makeAffine();
146 #endif
147 }
148
149 RenderLayer::RenderLayer(RenderLayerModelObject& rendererLayerModelObject)
150     : m_inResizeMode(false)
151     , m_scrollDimensionsDirty(true)
152     , m_normalFlowListDirty(true)
153     , m_hasSelfPaintingLayerDescendant(false)
154     , m_hasSelfPaintingLayerDescendantDirty(false)
155     , m_hasOutOfFlowPositionedDescendant(false)
156     , m_hasOutOfFlowPositionedDescendantDirty(true)
157     , m_needsCompositedScrolling(false)
158     , m_descendantsAreContiguousInStackingOrder(false)
159     , m_isRootLayer(rendererLayerModelObject.isRenderView())
160     , m_usedTransparency(false)
161     , m_paintingInsideReflection(false)
162     , m_inOverflowRelayout(false)
163     , m_repaintStatus(NeedsNormalRepaint)
164     , m_visibleContentStatusDirty(true)
165     , m_hasVisibleContent(false)
166     , m_visibleDescendantStatusDirty(false)
167     , m_hasVisibleDescendant(false)
168     , m_isPaginated(false)
169     , m_3DTransformedDescendantStatusDirty(true)
170     , m_has3DTransformedDescendant(false)
171     , m_hasCompositingDescendant(false)
172     , m_hasTransformedAncestor(false)
173     , m_has3DTransformedAncestor(false)
174     , m_indirectCompositingReason(NoIndirectCompositingReason)
175     , m_viewportConstrainedNotCompositedReason(NoNotCompositedReason)
176 #if PLATFORM(IOS)
177     , m_adjustForIOSCaretWhenScrolling(false)
178     , m_registeredAsTouchEventListenerForScrolling(false)
179     , m_inUserScroll(false)
180     , m_requiresScrollBoundsOriginUpdate(false)
181 #endif
182     , m_containsDirtyOverlayScrollbars(false)
183     , m_updatingMarqueePosition(false)
184 #if !ASSERT_DISABLED
185     , m_layerListMutationAllowed(true)
186 #endif
187 #if ENABLE(CSS_FILTERS)
188     , m_hasFilterInfo(false)
189 #endif
190 #if ENABLE(CSS_COMPOSITING)
191     , m_blendMode(BlendModeNormal)
192     , m_hasUnisolatedCompositedBlendingDescendants(false)
193     , m_hasUnisolatedBlendingDescendants(false)
194     , m_hasUnisolatedBlendingDescendantsStatusDirty(false)
195 #endif
196     , m_renderer(rendererLayerModelObject)
197     , m_parent(0)
198     , m_previous(0)
199     , m_next(0)
200     , m_first(0)
201     , m_last(0)
202     , m_staticInlinePosition(0)
203     , m_staticBlockPosition(0)
204     , m_enclosingPaginationLayer(0)
205 {
206     m_isNormalFlowOnly = shouldBeNormalFlowOnly();
207     m_isSelfPaintingLayer = shouldBeSelfPaintingLayer();
208
209     // Non-stacking containers should have empty z-order lists. As this is already the case,
210     // there is no need to dirty / recompute these lists.
211     m_zOrderListsDirty = isStackingContainer();
212
213     ScrollableArea::setConstrainsScrollingToContentEdge(false);
214
215     if (!renderer().firstChild()) {
216         m_visibleContentStatusDirty = false;
217         m_hasVisibleContent = renderer().style().visibility() == VISIBLE;
218     }
219
220     if (Element* element = renderer().element()) {
221         // We save and restore only the scrollOffset as the other scroll values are recalculated.
222         m_scrollOffset = element->savedLayerScrollOffset();
223         if (!m_scrollOffset.isZero())
224             scrollAnimator()->setCurrentPosition(FloatPoint(m_scrollOffset.width(), m_scrollOffset.height()));
225         element->setSavedLayerScrollOffset(IntSize());
226     }
227 }
228
229 RenderLayer::~RenderLayer()
230 {
231     if (inResizeMode() && !renderer().documentBeingDestroyed())
232         renderer().frame().eventHandler().resizeLayerDestroyed();
233
234     renderer().view().frameView().removeScrollableArea(this);
235
236     if (!renderer().documentBeingDestroyed()) {
237 #if PLATFORM(IOS)
238         unregisterAsTouchEventListenerForScrolling();
239 #endif
240         if (Element* element = renderer().element())
241             element->setSavedLayerScrollOffset(m_scrollOffset);
242     }
243
244     destroyScrollbar(HorizontalScrollbar);
245     destroyScrollbar(VerticalScrollbar);
246
247     if (renderer().frame().page()) {
248         if (ScrollingCoordinator* scrollingCoordinator = renderer().frame().page()->scrollingCoordinator())
249             scrollingCoordinator->willDestroyScrollableArea(this);
250     }
251
252     if (m_reflection)
253         removeReflection();
254     
255 #if ENABLE(CSS_FILTERS)
256     FilterInfo::remove(*this);
257 #endif
258
259     // Child layers will be deleted by their corresponding render objects, so
260     // we don't need to delete them ourselves.
261
262     clearBacking(true);
263 }
264
265 String RenderLayer::name() const
266 {
267     StringBuilder name;
268     name.append(renderer().renderName());
269
270     if (Element* element = renderer().element()) {
271         name.append(' ');
272         name.append(element->tagName());
273
274         if (element->hasID()) {
275             name.appendLiteral(" id=\'");
276             name.append(element->getIdAttribute());
277             name.append('\'');
278         }
279
280         if (element->hasClass()) {
281             name.appendLiteral(" class=\'");
282             for (size_t i = 0; i < element->classNames().size(); ++i) {
283                 if (i > 0)
284                     name.append(' ');
285                 name.append(element->classNames()[i]);
286             }
287             name.append('\'');
288         }
289     }
290
291     if (isReflection())
292         name.appendLiteral(" (reflection)");
293
294     return name.toString();
295 }
296
297 RenderLayerCompositor& RenderLayer::compositor() const
298 {
299     return renderer().view().compositor();
300 }
301
302 void RenderLayer::contentChanged(ContentChangeType changeType)
303 {
304     // This can get called when video becomes accelerated, so the layers may change.
305     if ((changeType == CanvasChanged || changeType == VideoChanged || changeType == FullScreenChanged) && compositor().updateLayerCompositingState(*this))
306         compositor().setCompositingLayersNeedRebuild();
307
308     if (m_backing)
309         m_backing->contentChanged(changeType);
310 }
311
312 bool RenderLayer::canRender3DTransforms() const
313 {
314     return compositor().canRender3DTransforms();
315 }
316
317 #if ENABLE(CSS_FILTERS)
318
319 bool RenderLayer::paintsWithFilters() const
320 {
321     // FIXME: Eventually there will be cases where we paint with filters even without accelerated compositing,
322     // and this whole function won't be inside the #if below.
323
324     if (!renderer().hasFilter())
325         return false;
326         
327     if (!isComposited())
328         return true;
329
330     if (!m_backing || !m_backing->canCompositeFilters())
331         return true;
332
333     return false;
334 }
335
336 bool RenderLayer::requiresFullLayerImageForFilters() const 
337 {
338     if (!paintsWithFilters())
339         return false;
340     FilterEffectRenderer* renderer = filterRenderer();
341     return renderer && renderer->hasFilterThatMovesPixels();
342 }
343
344 FilterEffectRenderer* RenderLayer::filterRenderer() const
345 {
346     FilterInfo* filterInfo = FilterInfo::getIfExists(*this);
347     return filterInfo ? filterInfo->renderer() : 0;
348 }
349
350 #endif
351
352 LayoutPoint RenderLayer::computeOffsetFromRoot(bool& hasLayerOffset) const
353 {
354     hasLayerOffset = true;
355
356     if (!parent())
357         return LayoutPoint();
358
359     // This is similar to root() but we check if an ancestor layer would
360     // prevent the optimization from working.
361     const RenderLayer* rootLayer = 0;
362     for (const RenderLayer* parentLayer = parent(); parentLayer; rootLayer = parentLayer, parentLayer = parentLayer->parent()) {
363         hasLayerOffset = parentLayer->canUseConvertToLayerCoords();
364         if (!hasLayerOffset)
365             return LayoutPoint();
366     }
367     ASSERT(rootLayer == root());
368
369     LayoutPoint offset;
370     parent()->convertToLayerCoords(rootLayer, offset);
371     return offset;
372 }
373
374 void RenderLayer::updateLayerPositionsAfterLayout(const RenderLayer* rootLayer, UpdateLayerPositionsFlags flags)
375 {
376     RenderGeometryMap geometryMap(UseTransforms);
377     if (this != rootLayer)
378         geometryMap.pushMappingsToAncestor(parent(), 0);
379     updateLayerPositions(&geometryMap, flags);
380 }
381
382 void RenderLayer::updateLayerPositions(RenderGeometryMap* geometryMap, UpdateLayerPositionsFlags flags)
383 {
384     updateLayerPosition(); // For relpositioned layers or non-positioned layers,
385                            // we need to keep in sync, since we may have shifted relative
386                            // to our parent layer.
387     if (geometryMap)
388         geometryMap->pushMappingsToAncestor(this, parent());
389
390     // Clear our cached clip rect information.
391     clearClipRects();
392     
393     if (hasOverflowControls()) {
394         LayoutPoint offsetFromRoot;
395         if (geometryMap)
396             offsetFromRoot = LayoutPoint(geometryMap->absolutePoint(FloatPoint()));
397         else {
398             // FIXME: It looks suspicious to call convertToLayerCoords here
399             // as canUseConvertToLayerCoords may be true for an ancestor layer.
400             convertToLayerCoords(root(), offsetFromRoot);
401         }
402         positionOverflowControls(toIntSize(roundedIntPoint(offsetFromRoot)));
403     }
404
405     updateDescendantDependentFlags();
406
407     if (flags & UpdatePagination)
408         updatePagination();
409     else {
410         m_isPaginated = false;
411         m_enclosingPaginationLayer = 0;
412     }
413
414     if (m_hasVisibleContent) {
415         // FIXME: LayoutState does not work with RenderLayers as there is not a 1-to-1
416         // mapping between them and the RenderObjects. It would be neat to enable
417         // LayoutState outside the layout() phase and use it here.
418         ASSERT(!renderer().view().layoutStateEnabled());
419
420         RenderLayerModelObject* repaintContainer = renderer().containerForRepaint();
421         LayoutRect oldRepaintRect = m_repaintRect;
422         LayoutRect oldOutlineBox = m_outlineBox;
423         computeRepaintRects(repaintContainer, geometryMap);
424
425         // FIXME: Should ASSERT that value calculated for m_outlineBox using the cached offset is the same
426         // as the value not using the cached offset, but we can't due to https://bugs.webkit.org/show_bug.cgi?id=37048
427         if (flags & CheckForRepaint) {
428             if (!renderer().view().printing()) {
429                 bool didRepaint = false;
430                 if (m_repaintStatus & NeedsFullRepaint) {
431                     renderer().repaintUsingContainer(repaintContainer, oldRepaintRect);
432                     if (m_repaintRect != oldRepaintRect) {
433                         renderer().repaintUsingContainer(repaintContainer, m_repaintRect);
434                         didRepaint = true;
435                     }
436                 } else if (shouldRepaintAfterLayout()) {
437                     renderer().repaintAfterLayoutIfNeeded(repaintContainer, oldRepaintRect, oldOutlineBox, &m_repaintRect, &m_outlineBox);
438                     didRepaint = true;
439                 }
440
441                 if (didRepaint && renderer().isRenderNamedFlowFragmentContainer()) {
442                     // If we just repainted a region, we must also repaint the flow thread since it is the one
443                     // doing the actual painting of the flowed content.
444                     RenderNamedFlowFragment* region = toRenderBlockFlow(&renderer())->renderNamedFlowFragment();
445                     if (region->isValid())
446                         region->flowThread()->layer()->repaintIncludingDescendants();
447                 }
448             }
449         }
450     } else
451         clearRepaintRects();
452
453     m_repaintStatus = NeedsNormalRepaint;
454     m_hasTransformedAncestor = flags & SeenTransformedLayer;
455     m_has3DTransformedAncestor = flags & Seen3DTransformedLayer;
456
457     // Go ahead and update the reflection's position and size.
458     if (m_reflection)
459         m_reflection->layout();
460
461     // Clear the IsCompositingUpdateRoot flag once we've found the first compositing layer in this update.
462     bool isUpdateRoot = (flags & IsCompositingUpdateRoot);
463     if (isComposited())
464         flags &= ~IsCompositingUpdateRoot;
465
466     if (useRegionBasedColumns() && renderer().isInFlowRenderFlowThread()) {
467         updatePagination();
468         flags |= UpdatePagination;
469     }
470     
471     if (renderer().hasColumns())
472         flags |= UpdatePagination;
473
474     if (transform()) {
475         flags |= SeenTransformedLayer;
476         if (!transform()->isAffine())
477             flags |= Seen3DTransformedLayer;
478     }
479
480     for (RenderLayer* child = firstChild(); child; child = child->nextSibling())
481         child->updateLayerPositions(geometryMap, flags);
482
483     if ((flags & UpdateCompositingLayers) && isComposited()) {
484         RenderLayerBacking::UpdateAfterLayoutFlags updateFlags = RenderLayerBacking::CompositingChildrenOnly;
485         if (flags & NeedsFullRepaintInBacking)
486             updateFlags |= RenderLayerBacking::NeedsFullRepaint;
487         if (isUpdateRoot)
488             updateFlags |= RenderLayerBacking::IsUpdateRoot;
489         backing()->updateAfterLayout(updateFlags);
490     }
491         
492     // With all our children positioned, now update our marquee if we need to.
493     if (m_marquee) {
494         // FIXME: would like to use TemporaryChange<> but it doesn't work with bitfields.
495         bool oldUpdatingMarqueePosition = m_updatingMarqueePosition;
496         m_updatingMarqueePosition = true;
497         m_marquee->updateMarqueePosition();
498         m_updatingMarqueePosition = oldUpdatingMarqueePosition;
499     }
500
501     if (geometryMap)
502         geometryMap->popMappingsToAncestor(parent());
503 }
504
505 LayoutRect RenderLayer::repaintRectIncludingNonCompositingDescendants() const
506 {
507     LayoutRect repaintRect = m_repaintRect;
508     for (RenderLayer* child = firstChild(); child; child = child->nextSibling()) {
509         // Don't include repaint rects for composited child layers; they will paint themselves and have a different origin.
510         if (child->isComposited())
511             continue;
512
513         repaintRect.unite(child->repaintRectIncludingNonCompositingDescendants());
514     }
515     return repaintRect;
516 }
517
518 void RenderLayer::setAncestorChainHasSelfPaintingLayerDescendant()
519 {
520     for (RenderLayer* layer = this; layer; layer = layer->parent()) {
521         if (!layer->m_hasSelfPaintingLayerDescendantDirty && layer->hasSelfPaintingLayerDescendant())
522             break;
523
524         layer->m_hasSelfPaintingLayerDescendantDirty = false;
525         layer->m_hasSelfPaintingLayerDescendant = true;
526     }
527 }
528
529 void RenderLayer::dirtyAncestorChainHasSelfPaintingLayerDescendantStatus()
530 {
531     for (RenderLayer* layer = this; layer; layer = layer->parent()) {
532         layer->m_hasSelfPaintingLayerDescendantDirty = true;
533         // If we have reached a self-painting layer, we know our parent should have a self-painting descendant
534         // in this case, there is no need to dirty our ancestors further.
535         if (layer->isSelfPaintingLayer()) {
536             ASSERT(!parent() || parent()->m_hasSelfPaintingLayerDescendantDirty || parent()->hasSelfPaintingLayerDescendant());
537             break;
538         }
539     }
540 }
541
542 bool RenderLayer::acceleratedCompositingForOverflowScrollEnabled() const
543 {
544     return renderer().frame().settings().acceleratedCompositingForOverflowScrollEnabled();
545 }
546
547 // If we are a stacking container, then this function will determine if our
548 // descendants for a contiguous block in stacking order. This is required in
549 // order for an element to be safely promoted to a stacking container. It is safe
550 // to become a stacking container if this change would not alter the stacking
551 // order of layers on the page. That can only happen if a non-descendant appear
552 // between us and our descendants in stacking order. Here's an example:
553 //
554 //                                 this
555 //                                /  |  \.
556 //                               A   B   C
557 //                              /\   |   /\.
558 //                             0 -8  D  2  7
559 //                                   |
560 //                                   5
561 //
562 // I've labeled our normal flow descendants A, B, C, and D, our stacking
563 // container descendants with their z indices, and us with 'this' (we're a
564 // stacking container and our zIndex doesn't matter here). These nodes appear in
565 // three lists: posZOrder, negZOrder, and normal flow (keep in mind that normal
566 // flow layers don't overlap). So if we arrange these lists in order we get our
567 // stacking order:
568 //
569 //                     [-8], [A-D], [0, 2, 5, 7]--> pos z-order.
570 //                       |     |
571 //        Neg z-order. <-+     +--> Normal flow descendants.
572 //
573 // We can then assign new, 'stacking' order indices to these elements as follows:
574 //
575 //                     [-8], [A-D], [0, 2, 5, 7]
576 // 'Stacking' indices:  -1     0     1  2  3  4
577 //
578 // Note that the normal flow descendants can share an index because they don't
579 // stack/overlap. Now our problem becomes very simple: a layer can safely become
580 // a stacking container if the stacking-order indices of it and its descendants
581 // appear in a contiguous block in the list of stacking indices. This problem
582 // can be solved very efficiently by calculating the min/max stacking indices in
583 // the subtree, and the number stacking container descendants. Once we have this
584 // information, we know that the subtree's indices form a contiguous block if:
585 //
586 //           maxStackIndex - minStackIndex == numSCDescendants
587 //
588 // So for node A in the example above we would have:
589 //   maxStackIndex = 1
590 //   minStackIndex = -1
591 //   numSCDecendants = 2
592 //
593 // and so,
594 //       maxStackIndex - minStackIndex == numSCDescendants
595 //  ===>                      1 - (-1) == 2
596 //  ===>                             2 == 2
597 //
598 //  Since this is true, A can safely become a stacking container.
599 //  Now, for node C we have:
600 //
601 //   maxStackIndex = 4
602 //   minStackIndex = 0 <-- because C has stacking index 0.
603 //   numSCDecendants = 2
604 //
605 // and so,
606 //       maxStackIndex - minStackIndex == numSCDescendants
607 //  ===>                         4 - 0 == 2
608 //  ===>                             4 == 2
609 //
610 // Since this is false, C cannot be safely promoted to a stacking container. This
611 // happened because of the elements with z-index 5 and 0. Now if 5 had been a
612 // child of C rather than D, and A had no child with Z index 0, we would have had:
613 //
614 //   maxStackIndex = 3
615 //   minStackIndex = 0 <-- because C has stacking index 0.
616 //   numSCDecendants = 3
617 //
618 // and so,
619 //       maxStackIndex - minStackIndex == numSCDescendants
620 //  ===>                         3 - 0 == 3
621 //  ===>                             3 == 3
622 //
623 //  And we would conclude that C could be promoted.
624 void RenderLayer::updateDescendantsAreContiguousInStackingOrder()
625 {
626     if (!isStackingContext() || !acceleratedCompositingForOverflowScrollEnabled())
627         return;
628
629     ASSERT(!m_normalFlowListDirty);
630     ASSERT(!m_zOrderListsDirty);
631
632     std::unique_ptr<Vector<RenderLayer*>> posZOrderList;
633     std::unique_ptr<Vector<RenderLayer*>> negZOrderList;
634     rebuildZOrderLists(StopAtStackingContexts, posZOrderList, negZOrderList);
635
636     // Create a reverse lookup.
637     HashMap<const RenderLayer*, int> lookup;
638
639     if (negZOrderList) {
640         int stackingOrderIndex = -1;
641         size_t listSize = negZOrderList->size();
642         for (size_t i = 0; i < listSize; ++i) {
643             RenderLayer* currentLayer = negZOrderList->at(listSize - i - 1);
644             if (!currentLayer->isStackingContext())
645                 continue;
646             lookup.set(currentLayer, stackingOrderIndex--);
647         }
648     }
649
650     if (posZOrderList) {
651         size_t listSize = posZOrderList->size();
652         int stackingOrderIndex = 1;
653         for (size_t i = 0; i < listSize; ++i) {
654             RenderLayer* currentLayer = posZOrderList->at(i);
655             if (!currentLayer->isStackingContext())
656                 continue;
657             lookup.set(currentLayer, stackingOrderIndex++);
658         }
659     }
660
661     int minIndex = 0;
662     int maxIndex = 0;
663     int count = 0;
664     bool firstIteration = true;
665     updateDescendantsAreContiguousInStackingOrderRecursive(lookup, minIndex, maxIndex, count, firstIteration);
666 }
667
668 void RenderLayer::updateDescendantsAreContiguousInStackingOrderRecursive(const HashMap<const RenderLayer*, int>& lookup, int& minIndex, int& maxIndex, int& count, bool firstIteration)
669 {
670     if (isStackingContext() && !firstIteration) {
671         if (lookup.contains(this)) {
672             minIndex = std::min(minIndex, lookup.get(this));
673             maxIndex = std::max(maxIndex, lookup.get(this));
674             count++;
675         }
676         return;
677     }
678
679     for (RenderLayer* child = firstChild(); child; child = child->nextSibling()) {
680         int childMinIndex = 0;
681         int childMaxIndex = 0;
682         int childCount = 0;
683         child->updateDescendantsAreContiguousInStackingOrderRecursive(lookup, childMinIndex, childMaxIndex, childCount, false);
684         if (childCount) {
685             count += childCount;
686             minIndex = std::min(minIndex, childMinIndex);
687             maxIndex = std::max(maxIndex, childMaxIndex);
688         }
689     }
690
691     if (!isStackingContext()) {
692         bool newValue = maxIndex - minIndex == count;
693         bool didUpdate = newValue != m_descendantsAreContiguousInStackingOrder;
694         m_descendantsAreContiguousInStackingOrder = newValue;
695         if (didUpdate)
696             updateNeedsCompositedScrolling();
697     }
698 }
699
700 void RenderLayer::computeRepaintRects(const RenderLayerModelObject* repaintContainer, const RenderGeometryMap* geometryMap)
701 {
702     ASSERT(!m_visibleContentStatusDirty);
703
704     m_repaintRect = renderer().clippedOverflowRectForRepaint(repaintContainer);
705     m_outlineBox = renderer().outlineBoundsForRepaint(repaintContainer, geometryMap);
706 }
707
708
709 void RenderLayer::computeRepaintRectsIncludingDescendants()
710 {
711     // FIXME: computeRepaintRects() has to walk up the parent chain for every layer to compute the rects.
712     // We should make this more efficient.
713     // FIXME: it's wrong to call this when layout is not up-to-date, which we do.
714     computeRepaintRects(renderer().containerForRepaint());
715
716     for (RenderLayer* layer = firstChild(); layer; layer = layer->nextSibling())
717         layer->computeRepaintRectsIncludingDescendants();
718 }
719
720 void RenderLayer::clearRepaintRects()
721 {
722     ASSERT(!m_hasVisibleContent);
723     ASSERT(!m_visibleContentStatusDirty);
724
725     m_repaintRect = LayoutRect();
726     m_outlineBox = LayoutRect();
727 }
728
729 void RenderLayer::updateLayerPositionsAfterDocumentScroll()
730 {
731     ASSERT(this == renderer().view().layer());
732
733     RenderGeometryMap geometryMap(UseTransforms);
734     updateLayerPositionsAfterScroll(&geometryMap);
735 }
736
737 void RenderLayer::updateLayerPositionsAfterOverflowScroll()
738 {
739     RenderGeometryMap geometryMap(UseTransforms);
740     if (this != renderer().view().layer())
741         geometryMap.pushMappingsToAncestor(parent(), 0);
742
743     // FIXME: why is it OK to not check the ancestors of this layer in order to
744     // initialize the HasSeenViewportConstrainedAncestor and HasSeenAncestorWithOverflowClip flags?
745     updateLayerPositionsAfterScroll(&geometryMap, IsOverflowScroll);
746 }
747
748 void RenderLayer::updateLayerPositionsAfterScroll(RenderGeometryMap* geometryMap, UpdateLayerPositionsAfterScrollFlags flags)
749 {
750     // FIXME: This shouldn't be needed, but there are some corner cases where
751     // these flags are still dirty. Update so that the check below is valid.
752     updateDescendantDependentFlags();
753
754     // If we have no visible content and no visible descendants, there is no point recomputing
755     // our rectangles as they will be empty. If our visibility changes, we are expected to
756     // recompute all our positions anyway.
757     if (!m_hasVisibleDescendant && !m_hasVisibleContent)
758         return;
759
760     bool positionChanged = updateLayerPosition();
761     if (positionChanged)
762         flags |= HasChangedAncestor;
763
764     if (geometryMap)
765         geometryMap->pushMappingsToAncestor(this, parent());
766
767     if (flags & HasChangedAncestor || flags & HasSeenViewportConstrainedAncestor || flags & IsOverflowScroll)
768         clearClipRects();
769
770     if (renderer().style().hasViewportConstrainedPosition())
771         flags |= HasSeenViewportConstrainedAncestor;
772
773     if (renderer().hasOverflowClip())
774         flags |= HasSeenAncestorWithOverflowClip;
775
776     if (flags & HasSeenViewportConstrainedAncestor
777         || (flags & IsOverflowScroll && flags & HasSeenAncestorWithOverflowClip)) {
778         // FIXME: We could track the repaint container as we walk down the tree.
779         computeRepaintRects(renderer().containerForRepaint(), geometryMap);
780     } else {
781         // Check that our cached rects are correct.
782         ASSERT(m_repaintRect == renderer().clippedOverflowRectForRepaint(renderer().containerForRepaint()));
783         ASSERT(m_outlineBox == renderer().outlineBoundsForRepaint(renderer().containerForRepaint(), geometryMap));
784     }
785     
786     for (RenderLayer* child = firstChild(); child; child = child->nextSibling())
787         child->updateLayerPositionsAfterScroll(geometryMap, flags);
788
789     // We don't update our reflection as scrolling is a translation which does not change the size()
790     // of an object, thus RenderReplica will still repaint itself properly as the layer position was
791     // updated above.
792
793     if (m_marquee) {
794         bool oldUpdatingMarqueePosition = m_updatingMarqueePosition;
795         m_updatingMarqueePosition = true;
796         m_marquee->updateMarqueePosition();
797         m_updatingMarqueePosition = oldUpdatingMarqueePosition;
798     }
799
800     if (geometryMap)
801         geometryMap->popMappingsToAncestor(parent());
802 }
803
804 void RenderLayer::positionNewlyCreatedOverflowControls()
805 {
806     if (!backing()->hasUnpositionedOverflowControlsLayers())
807         return;
808
809     RenderGeometryMap geometryMap(UseTransforms);
810     if (this != renderer().view().layer() && parent())
811         geometryMap.pushMappingsToAncestor(parent(), 0);
812
813     LayoutPoint offsetFromRoot = LayoutPoint(geometryMap.absolutePoint(FloatPoint()));
814     positionOverflowControls(toIntSize(roundedIntPoint(offsetFromRoot)));
815 }
816
817 #if ENABLE(CSS_COMPOSITING)
818
819 void RenderLayer::updateBlendMode()
820 {
821     bool hadBlendMode = m_blendMode != BlendModeNormal;
822     if (parent() && hadBlendMode != hasBlendMode()) {
823         if (hasBlendMode())
824             parent()->updateAncestorChainHasBlendingDescendants();
825         else
826             parent()->dirtyAncestorChainHasBlendingDescendants();
827     }
828
829     BlendMode newBlendMode = renderer().style().blendMode();
830     if (newBlendMode != m_blendMode)
831         m_blendMode = newBlendMode;
832 }
833
834 void RenderLayer::updateAncestorChainHasBlendingDescendants()
835 {
836     for (auto layer = this; layer; layer = layer->parent()) {
837         if (!layer->hasUnisolatedBlendingDescendantsStatusDirty() && layer->hasUnisolatedBlendingDescendants())
838             break;
839         layer->m_hasUnisolatedBlendingDescendants = true;
840         layer->m_hasUnisolatedBlendingDescendantsStatusDirty = false;
841
842         if (layer->isStackingContext())
843             break;
844     }
845 }
846
847 void RenderLayer::dirtyAncestorChainHasBlendingDescendants()
848 {
849     for (auto layer = this; layer; layer = layer->parent()) {
850         if (layer->hasUnisolatedBlendingDescendantsStatusDirty())
851             break;
852         
853         layer->m_hasUnisolatedBlendingDescendantsStatusDirty = true;
854
855         if (layer->isStackingContext())
856             break;
857     }
858 }
859 #endif
860
861 void RenderLayer::updateTransform()
862 {
863     // hasTransform() on the renderer is also true when there is transform-style: preserve-3d or perspective set,
864     // so check style too.
865     bool hasTransform = renderer().hasTransform() && renderer().style().hasTransform();
866     bool had3DTransform = has3DTransform();
867
868     bool hadTransform = !!m_transform;
869     if (hasTransform != hadTransform) {
870         if (hasTransform)
871             m_transform = std::make_unique<TransformationMatrix>();
872         else
873             m_transform = nullptr;
874         
875         // Layers with transforms act as clip rects roots, so clear the cached clip rects here.
876         clearClipRectsIncludingDescendants();
877     }
878     
879     if (hasTransform) {
880         RenderBox* box = renderBox();
881         ASSERT(box);
882         m_transform->makeIdentity();
883         box->style().applyTransform(*m_transform, pixelSnappedForPainting(box->borderBoxRect(), box->document().deviceScaleFactor()), RenderStyle::IncludeTransformOrigin);
884         makeMatrixRenderable(*m_transform, canRender3DTransforms());
885     }
886
887     if (had3DTransform != has3DTransform())
888         dirty3DTransformedDescendantStatus();
889 }
890
891 TransformationMatrix RenderLayer::currentTransform(RenderStyle::ApplyTransformOrigin applyOrigin) const
892 {
893     if (!m_transform)
894         return TransformationMatrix();
895
896     RenderBox* box = renderBox();
897     ASSERT(box);
898     FloatRect pixelSnappedBorderRect = pixelSnappedForPainting(box->borderBoxRect(), box->document().deviceScaleFactor());
899     if (renderer().style().isRunningAcceleratedAnimation()) {
900         TransformationMatrix currTransform;
901         RefPtr<RenderStyle> style = renderer().animation().getAnimatedStyleForRenderer(&renderer());
902         style->applyTransform(currTransform, pixelSnappedBorderRect, applyOrigin);
903         makeMatrixRenderable(currTransform, canRender3DTransforms());
904         return currTransform;
905     }
906
907     // m_transform includes transform-origin, so we need to recompute the transform here.
908     if (applyOrigin == RenderStyle::ExcludeTransformOrigin) {
909         TransformationMatrix currTransform;
910         box->style().applyTransform(currTransform, pixelSnappedBorderRect, RenderStyle::ExcludeTransformOrigin);
911         makeMatrixRenderable(currTransform, canRender3DTransforms());
912         return currTransform;
913     }
914
915     return *m_transform;
916 }
917
918 TransformationMatrix RenderLayer::renderableTransform(PaintBehavior paintBehavior) const
919 {
920     if (!m_transform)
921         return TransformationMatrix();
922     
923     if (paintBehavior & PaintBehaviorFlattenCompositingLayers) {
924         TransformationMatrix matrix = *m_transform;
925         makeMatrixRenderable(matrix, false /* flatten 3d */);
926         return matrix;
927     }
928
929     return *m_transform;
930 }
931
932 RenderLayer* RenderLayer::enclosingOverflowClipLayer(IncludeSelfOrNot includeSelf) const
933 {
934     const RenderLayer* layer = (includeSelf == IncludeSelf) ? this : parent();
935     while (layer) {
936         if (layer->renderer().hasOverflowClip())
937             return const_cast<RenderLayer*>(layer);
938
939         layer = layer->parent();
940     }
941     return 0;
942 }
943
944 static bool checkContainingBlockChainForPagination(RenderLayerModelObject* renderer, RenderBox* ancestorColumnsRenderer)
945 {
946     RenderLayerModelObject* prevBlock = renderer;
947     RenderBlock* containingBlock;
948     for (containingBlock = renderer->containingBlock();
949         containingBlock && containingBlock != &renderer->view() && containingBlock != ancestorColumnsRenderer;
950         containingBlock = containingBlock->containingBlock()) {
951         prevBlock = containingBlock;
952     }
953     
954     // If the columns block wasn't in our containing block chain, then we aren't paginated by it.
955     if (containingBlock != ancestorColumnsRenderer)
956         return false;
957         
958     // If the previous block is absolutely positioned, then we can't be paginated by the columns block.
959     if (prevBlock->isOutOfFlowPositioned())
960         return false;
961         
962     // Otherwise we are paginated by the columns block.
963     return true;
964 }
965
966 bool RenderLayer::useRegionBasedColumns() const
967 {
968     const Settings& settings = renderer().frame().settings();
969     return settings.regionBasedColumnsEnabled();
970 }
971
972 void RenderLayer::updatePagination()
973 {
974     m_isPaginated = false;
975     m_enclosingPaginationLayer = 0;
976
977     if (isComposited() || !parent())
978         return; // FIXME: We will have to deal with paginated compositing layers someday.
979                 // FIXME: For now the RenderView can't be paginated.  Eventually printing will move to a model where it is though.
980
981     // The main difference between the paginated booleans for the old column code and the new column code
982     // is that each paginated layer has to paint on its own with the new code. There is no
983     // recurring into child layers. This means that the m_isPaginated bits for the new column code can't just be set on
984     // "roots" that get split and paint all their descendants. Instead each layer has to be checked individually and
985     // genuinely know if it is going to have to split itself up when painting only its contents (and not any other descendant
986     // layers). We track an enclosingPaginationLayer instead of using a simple bit, since we want to be able to get back
987     // to that layer easily.
988     bool regionBasedColumnsUsed = useRegionBasedColumns();
989     if (regionBasedColumnsUsed && renderer().isInFlowRenderFlowThread()) {
990         m_enclosingPaginationLayer = this;
991         return;
992     }
993
994     if (isNormalFlowOnly()) {
995         if (regionBasedColumnsUsed) {
996             // Content inside a transform is not considered to be paginated, since we simply
997             // paint the transform multiple times in each column, so we don't have to use
998             // fragments for the transformed content.
999             m_enclosingPaginationLayer = parent()->enclosingPaginationLayer();
1000             if (m_enclosingPaginationLayer && m_enclosingPaginationLayer->hasTransform())
1001                 m_enclosingPaginationLayer = 0;
1002         } else
1003             m_isPaginated = parent()->renderer().hasColumns();
1004         return;
1005     }
1006
1007     // For the new columns code, we want to walk up our containing block chain looking for an enclosing layer. Once
1008     // we find one, then we just check its pagination status.
1009     if (regionBasedColumnsUsed) {
1010         RenderView* renderView = &renderer().view();
1011         RenderBlock* containingBlock;
1012         for (containingBlock = renderer().containingBlock();
1013             containingBlock && containingBlock != renderView;
1014             containingBlock = containingBlock->containingBlock()) {
1015             if (containingBlock->hasLayer()) {
1016                 // Content inside a transform is not considered to be paginated, since we simply
1017                 // paint the transform multiple times in each column, so we don't have to use
1018                 // fragments for the transformed content.
1019                 m_enclosingPaginationLayer = containingBlock->layer()->enclosingPaginationLayer();
1020                 if (m_enclosingPaginationLayer && m_enclosingPaginationLayer->hasTransform())
1021                     m_enclosingPaginationLayer = 0;
1022                 return;
1023             }
1024         }
1025         return;
1026     }
1027
1028     // If we're not normal flow, then we need to look for a multi-column object between us and our stacking container.
1029     RenderLayer* ancestorStackingContainer = stackingContainer();
1030     for (RenderLayer* curr = parent(); curr; curr = curr->parent()) {
1031         if (curr->renderer().hasColumns()) {
1032             m_isPaginated = checkContainingBlockChainForPagination(&renderer(), curr->renderBox());
1033             return;
1034         }
1035         if (curr == ancestorStackingContainer)
1036             return;
1037     }
1038 }
1039
1040 bool RenderLayer::canBeStackingContainer() const
1041 {
1042     if (isStackingContext() || !stackingContainer())
1043         return true;
1044
1045     return m_descendantsAreContiguousInStackingOrder;
1046 }
1047
1048 void RenderLayer::setHasVisibleContent()
1049
1050     if (m_hasVisibleContent && !m_visibleContentStatusDirty) {
1051         ASSERT(!parent() || parent()->hasVisibleDescendant());
1052         return;
1053     }
1054
1055     m_visibleContentStatusDirty = false; 
1056     m_hasVisibleContent = true;
1057     computeRepaintRects(renderer().containerForRepaint());
1058     if (!isNormalFlowOnly()) {
1059         // We don't collect invisible layers in z-order lists if we are not in compositing mode.
1060         // As we became visible, we need to dirty our stacking containers ancestors to be properly
1061         // collected. FIXME: When compositing, we could skip this dirtying phase.
1062         for (RenderLayer* sc = stackingContainer(); sc; sc = sc->stackingContainer()) {
1063             sc->dirtyZOrderLists();
1064             if (sc->hasVisibleContent())
1065                 break;
1066         }
1067     }
1068
1069     if (parent())
1070         parent()->setAncestorChainHasVisibleDescendant();
1071 }
1072
1073 void RenderLayer::dirtyVisibleContentStatus() 
1074
1075     m_visibleContentStatusDirty = true; 
1076     if (parent())
1077         parent()->dirtyAncestorChainVisibleDescendantStatus();
1078 }
1079
1080 void RenderLayer::dirtyAncestorChainVisibleDescendantStatus()
1081 {
1082     for (RenderLayer* layer = this; layer; layer = layer->parent()) {
1083         if (layer->m_visibleDescendantStatusDirty)
1084             break;
1085
1086         layer->m_visibleDescendantStatusDirty = true;
1087     }
1088 }
1089
1090 void RenderLayer::setAncestorChainHasVisibleDescendant()
1091 {
1092     for (RenderLayer* layer = this; layer; layer = layer->parent()) {
1093         if (!layer->m_visibleDescendantStatusDirty && layer->hasVisibleDescendant())
1094             break;
1095
1096         layer->m_hasVisibleDescendant = true;
1097         layer->m_visibleDescendantStatusDirty = false;
1098     }
1099 }
1100
1101 void RenderLayer::updateDescendantDependentFlags(HashSet<const RenderObject*>* outOfFlowDescendantContainingBlocks)
1102 {
1103     if (m_visibleDescendantStatusDirty || m_hasSelfPaintingLayerDescendantDirty || m_hasOutOfFlowPositionedDescendantDirty || hasUnisolatedBlendingDescendantsStatusDirty()) {
1104         m_hasVisibleDescendant = false;
1105         m_hasSelfPaintingLayerDescendant = false;
1106         m_hasOutOfFlowPositionedDescendant = false;
1107 #if ENABLE(CSS_COMPOSITING)
1108         m_hasUnisolatedBlendingDescendants = false;
1109 #endif
1110
1111         HashSet<const RenderObject*> childOutOfFlowDescendantContainingBlocks;
1112         for (RenderLayer* child = firstChild(); child; child = child->nextSibling()) {
1113             childOutOfFlowDescendantContainingBlocks.clear();
1114             child->updateDescendantDependentFlags(&childOutOfFlowDescendantContainingBlocks);
1115
1116             bool childIsOutOfFlowPositioned = child->renderer().isOutOfFlowPositioned();
1117             if (childIsOutOfFlowPositioned)
1118                 childOutOfFlowDescendantContainingBlocks.add(child->renderer().containingBlock());
1119
1120             if (outOfFlowDescendantContainingBlocks) {
1121                 HashSet<const RenderObject*>::const_iterator it = childOutOfFlowDescendantContainingBlocks.begin();
1122                 for (; it != childOutOfFlowDescendantContainingBlocks.end(); ++it)
1123                     outOfFlowDescendantContainingBlocks->add(*it);
1124             }
1125
1126             bool hasVisibleDescendant = child->m_hasVisibleContent || child->m_hasVisibleDescendant;
1127             bool hasSelfPaintingLayerDescendant = child->isSelfPaintingLayer() || child->hasSelfPaintingLayerDescendant();
1128             bool hasOutOfFlowPositionedDescendant = !childOutOfFlowDescendantContainingBlocks.isEmpty();
1129 #if ENABLE(CSS_COMPOSITING)
1130             bool hasUnisolatedBlendingDescendants = child->hasBlendMode() || (child->hasUnisolatedBlendingDescendants() && !child->isolatesBlending());
1131
1132             m_hasUnisolatedBlendingDescendants |= hasUnisolatedBlendingDescendants;
1133 #endif
1134             m_hasVisibleDescendant |= hasVisibleDescendant;
1135             m_hasSelfPaintingLayerDescendant |= hasSelfPaintingLayerDescendant;
1136             m_hasOutOfFlowPositionedDescendant |= hasOutOfFlowPositionedDescendant;
1137
1138             bool allFlagsSet = m_hasVisibleDescendant && m_hasSelfPaintingLayerDescendant && m_hasOutOfFlowPositionedDescendant;
1139 #if ENABLE(CSS_COMPOSITING)
1140             allFlagsSet &= m_hasUnisolatedBlendingDescendants;
1141 #endif
1142             if (allFlagsSet)
1143                 break;
1144         }
1145
1146         if (outOfFlowDescendantContainingBlocks)
1147             outOfFlowDescendantContainingBlocks->remove(&renderer());
1148
1149         m_visibleDescendantStatusDirty = false;
1150         m_hasSelfPaintingLayerDescendantDirty = false;
1151
1152         if (m_hasOutOfFlowPositionedDescendantDirty)
1153             updateNeedsCompositedScrolling();
1154
1155         m_hasOutOfFlowPositionedDescendantDirty = false;
1156 #if ENABLE(CSS_COMPOSITING)
1157         m_hasUnisolatedBlendingDescendantsStatusDirty = false;
1158 #endif
1159     }
1160
1161     if (m_visibleContentStatusDirty) {
1162         if (renderer().style().visibility() == VISIBLE)
1163             m_hasVisibleContent = true;
1164         else {
1165             // layer may be hidden but still have some visible content, check for this
1166             m_hasVisibleContent = false;
1167             RenderObject* r = renderer().firstChild();
1168             while (r) {
1169                 if (r->style().visibility() == VISIBLE && !r->hasLayer()) {
1170                     m_hasVisibleContent = true;
1171                     break;
1172                 }
1173                 RenderObject* child = nullptr;
1174                 if (!r->hasLayer() && (child = r->firstChildSlow()))
1175                     r = child;
1176                 else if (r->nextSibling())
1177                     r = r->nextSibling();
1178                 else {
1179                     do {
1180                         r = r->parent();
1181                         if (r == &renderer())
1182                             r = 0;
1183                     } while (r && !r->nextSibling());
1184                     if (r)
1185                         r = r->nextSibling();
1186                 }
1187             }
1188         }    
1189         m_visibleContentStatusDirty = false; 
1190     }
1191 }
1192
1193 // Return true if the new clipping behaviour requires layer update.
1194 bool RenderLayer::checkIfDescendantClippingContextNeedsUpdate(bool isClipping)
1195 {
1196     for (RenderLayer* child = firstChild(); child; child = child->nextSibling()) {
1197         RenderLayerBacking* backing = child->backing();
1198         // Layer subtree needs update when new clipping is added or existing clipping is removed.
1199         if (backing && (isClipping || backing->hasAncestorClippingLayer()))
1200             return true;
1201
1202         if (child->checkIfDescendantClippingContextNeedsUpdate(isClipping))
1203             return true;
1204     }
1205     return false;
1206 }
1207
1208 void RenderLayer::dirty3DTransformedDescendantStatus()
1209 {
1210     RenderLayer* curr = stackingContainer();
1211     if (curr)
1212         curr->m_3DTransformedDescendantStatusDirty = true;
1213         
1214     // This propagates up through preserve-3d hierarchies to the enclosing flattening layer.
1215     // Note that preserves3D() creates stacking context, so we can just run up the stacking containers.
1216     while (curr && curr->preserves3D()) {
1217         curr->m_3DTransformedDescendantStatusDirty = true;
1218         curr = curr->stackingContainer();
1219     }
1220 }
1221
1222 // Return true if this layer or any preserve-3d descendants have 3d.
1223 bool RenderLayer::update3DTransformedDescendantStatus()
1224 {
1225     if (m_3DTransformedDescendantStatusDirty) {
1226         m_has3DTransformedDescendant = false;
1227
1228         updateZOrderLists();
1229
1230         // Transformed or preserve-3d descendants can only be in the z-order lists, not
1231         // in the normal flow list, so we only need to check those.
1232         if (Vector<RenderLayer*>* positiveZOrderList = posZOrderList()) {
1233             for (unsigned i = 0; i < positiveZOrderList->size(); ++i)
1234                 m_has3DTransformedDescendant |= positiveZOrderList->at(i)->update3DTransformedDescendantStatus();
1235         }
1236
1237         // Now check our negative z-index children.
1238         if (Vector<RenderLayer*>* negativeZOrderList = negZOrderList()) {
1239             for (unsigned i = 0; i < negativeZOrderList->size(); ++i)
1240                 m_has3DTransformedDescendant |= negativeZOrderList->at(i)->update3DTransformedDescendantStatus();
1241         }
1242         
1243         m_3DTransformedDescendantStatusDirty = false;
1244     }
1245     
1246     // If we live in a 3d hierarchy, then the layer at the root of that hierarchy needs
1247     // the m_has3DTransformedDescendant set.
1248     if (preserves3D())
1249         return has3DTransform() || m_has3DTransformedDescendant;
1250
1251     return has3DTransform();
1252 }
1253
1254 bool RenderLayer::updateLayerPosition()
1255 {
1256     LayoutPoint localPoint;
1257     LayoutSize inlineBoundingBoxOffset; // We don't put this into the RenderLayer x/y for inlines, so we need to subtract it out when done.
1258     if (renderer().isInline() && renderer().isRenderInline()) {
1259         RenderInline& inlineFlow = toRenderInline(renderer());
1260         IntRect lineBox = inlineFlow.linesBoundingBox();
1261         setSize(lineBox.size());
1262         inlineBoundingBoxOffset = toLayoutSize(lineBox.location());
1263         localPoint += inlineBoundingBoxOffset;
1264     } else if (RenderBox* box = renderBox()) {
1265         // FIXME: Is snapping the size really needed here for the RenderBox case?
1266         setSize(pixelSnappedIntSize(box->size(), box->location()));
1267         localPoint += box->topLeftLocationOffset();
1268     }
1269
1270     if (!renderer().isOutOfFlowPositioned() && renderer().parent()) {
1271         // We must adjust our position by walking up the render tree looking for the
1272         // nearest enclosing object with a layer.
1273         RenderElement* curr = renderer().parent();
1274         while (curr && !curr->hasLayer()) {
1275             if (curr->isBox() && !curr->isTableRow()) {
1276                 // Rows and cells share the same coordinate space (that of the section).
1277                 // Omit them when computing our xpos/ypos.
1278                 localPoint += toRenderBox(curr)->topLeftLocationOffset();
1279             }
1280             curr = curr->parent();
1281         }
1282         if (curr->isBox() && curr->isTableRow()) {
1283             // Put ourselves into the row coordinate space.
1284             localPoint -= toRenderBox(curr)->topLeftLocationOffset();
1285         }
1286     }
1287     
1288     // Subtract our parent's scroll offset.
1289     if (renderer().isOutOfFlowPositioned() && enclosingPositionedAncestor()) {
1290         RenderLayer* positionedParent = enclosingPositionedAncestor();
1291
1292         // For positioned layers, we subtract out the enclosing positioned layer's scroll offset.
1293         if (positionedParent->renderer().hasOverflowClip()) {
1294             LayoutSize offset = positionedParent->scrolledContentOffset();
1295             localPoint -= offset;
1296         }
1297         
1298         if (renderer().isOutOfFlowPositioned() && positionedParent->renderer().isInFlowPositioned() && positionedParent->renderer().isRenderInline()) {
1299             LayoutSize offset = toRenderInline(positionedParent->renderer()).offsetForInFlowPositionedInline(&toRenderBox(renderer()));
1300             localPoint += offset;
1301         }
1302     } else if (parent()) {
1303         if (parent()->renderer().hasOverflowClip()) {
1304             IntSize scrollOffset = parent()->scrolledContentOffset();
1305             localPoint -= scrollOffset;
1306         }
1307     }
1308     
1309     bool positionOrOffsetChanged = false;
1310     if (renderer().isInFlowPositioned()) {
1311         LayoutSize newOffset = toRenderBoxModelObject(renderer()).offsetForInFlowPosition();
1312         positionOrOffsetChanged = newOffset != m_offsetForInFlowPosition;
1313         m_offsetForInFlowPosition = newOffset;
1314         localPoint.move(m_offsetForInFlowPosition);
1315     } else {
1316         m_offsetForInFlowPosition = LayoutSize();
1317     }
1318
1319     // FIXME: We'd really like to just get rid of the concept of a layer rectangle and rely on the renderers.
1320     localPoint -= inlineBoundingBoxOffset;
1321     
1322     positionOrOffsetChanged |= location() != localPoint;
1323     setLocation(localPoint);
1324     return positionOrOffsetChanged;
1325 }
1326
1327 TransformationMatrix RenderLayer::perspectiveTransform() const
1328 {
1329     if (!renderer().hasTransform())
1330         return TransformationMatrix();
1331
1332     const RenderStyle& style = renderer().style();
1333     if (!style.hasPerspective())
1334         return TransformationMatrix();
1335
1336     // Maybe fetch the perspective from the backing?
1337     const IntRect borderBox = toRenderBox(renderer()).pixelSnappedBorderBoxRect();
1338     const float boxWidth = borderBox.width();
1339     const float boxHeight = borderBox.height();
1340
1341     float perspectiveOriginX = floatValueForLength(style.perspectiveOriginX(), boxWidth);
1342     float perspectiveOriginY = floatValueForLength(style.perspectiveOriginY(), boxHeight);
1343
1344     // A perspective origin of 0,0 makes the vanishing point in the center of the element.
1345     // We want it to be in the top-left, so subtract half the height and width.
1346     perspectiveOriginX -= boxWidth / 2.0f;
1347     perspectiveOriginY -= boxHeight / 2.0f;
1348     
1349     TransformationMatrix t;
1350     t.translate(perspectiveOriginX, perspectiveOriginY);
1351     t.applyPerspective(style.perspective());
1352     t.translate(-perspectiveOriginX, -perspectiveOriginY);
1353     
1354     return t;
1355 }
1356
1357 FloatPoint RenderLayer::perspectiveOrigin() const
1358 {
1359     if (!renderer().hasTransform())
1360         return FloatPoint();
1361
1362     const LayoutRect borderBox = toRenderBox(renderer()).borderBoxRect();
1363     const RenderStyle& style = renderer().style();
1364
1365     return FloatPoint(floatValueForLength(style.perspectiveOriginX(), borderBox.width()),
1366                       floatValueForLength(style.perspectiveOriginY(), borderBox.height()));
1367 }
1368
1369 RenderLayer* RenderLayer::stackingContainer() const
1370 {
1371     RenderLayer* layer = parent();
1372     while (layer && !layer->isStackingContainer())
1373         layer = layer->parent();
1374
1375     ASSERT(!layer || layer->isStackingContainer());
1376     return layer;
1377 }
1378
1379 static inline bool isPositionedContainer(RenderLayer* layer)
1380 {
1381     return layer->isRootLayer() || layer->renderer().isPositioned() || layer->hasTransform();
1382 }
1383
1384 static inline bool isFixedPositionedContainer(RenderLayer* layer)
1385 {
1386     return layer->isRootLayer() || layer->hasTransform();
1387 }
1388
1389 RenderLayer* RenderLayer::enclosingPositionedAncestor() const
1390 {
1391     RenderLayer* curr = parent();
1392     while (curr && !isPositionedContainer(curr))
1393         curr = curr->parent();
1394
1395     return curr;
1396 }
1397
1398 static RenderLayer* parentLayerCrossFrame(const RenderLayer* layer)
1399 {
1400     ASSERT(layer);
1401     if (layer->parent())
1402         return layer->parent();
1403
1404     HTMLFrameOwnerElement* ownerElement = layer->renderer().document().ownerElement();
1405     if (!ownerElement)
1406         return 0;
1407
1408     RenderElement* ownerRenderer = ownerElement->renderer();
1409     if (!ownerRenderer)
1410         return 0;
1411
1412     return ownerRenderer->enclosingLayer();
1413 }
1414
1415 RenderLayer* RenderLayer::enclosingScrollableLayer() const
1416 {
1417     for (RenderLayer* nextLayer = parentLayerCrossFrame(this); nextLayer; nextLayer = parentLayerCrossFrame(nextLayer)) {
1418         if (nextLayer->renderer().isBox() && toRenderBox(nextLayer->renderer()).canBeScrolledAndHasScrollableArea())
1419             return nextLayer;
1420     }
1421
1422     return 0;
1423 }
1424
1425 IntRect RenderLayer::scrollableAreaBoundingBox() const
1426 {
1427     return renderer().absoluteBoundingBoxRect();
1428 }
1429
1430 RenderLayer* RenderLayer::enclosingTransformedAncestor() const
1431 {
1432     RenderLayer* curr = parent();
1433     while (curr && !curr->isRootLayer() && !curr->transform())
1434         curr = curr->parent();
1435
1436     return curr;
1437 }
1438
1439 static inline const RenderLayer* compositingContainer(const RenderLayer* layer)
1440 {
1441     return layer->isNormalFlowOnly() ? layer->parent() : layer->stackingContainer();
1442 }
1443
1444 inline bool RenderLayer::shouldRepaintAfterLayout() const
1445 {
1446     if (m_repaintStatus == NeedsNormalRepaint)
1447         return true;
1448
1449     // Composited layers that were moved during a positioned movement only
1450     // layout, don't need to be repainted. They just need to be recomposited.
1451     ASSERT(m_repaintStatus == NeedsFullRepaintForPositionedMovementLayout);
1452     return !isComposited() || backing()->paintsIntoCompositedAncestor();
1453 }
1454
1455 static bool compositedWithOwnBackingStore(const RenderLayer* layer)
1456 {
1457     return layer->isComposited() && !layer->backing()->paintsIntoCompositedAncestor();
1458 }
1459
1460 RenderLayer* RenderLayer::enclosingCompositingLayer(IncludeSelfOrNot includeSelf) const
1461 {
1462     if (includeSelf == IncludeSelf && isComposited())
1463         return const_cast<RenderLayer*>(this);
1464
1465     for (const RenderLayer* curr = compositingContainer(this); curr; curr = compositingContainer(curr)) {
1466         if (curr->isComposited())
1467             return const_cast<RenderLayer*>(curr);
1468     }
1469          
1470     return 0;
1471 }
1472
1473 RenderLayer* RenderLayer::enclosingCompositingLayerForRepaint(IncludeSelfOrNot includeSelf) const
1474 {
1475     if (includeSelf == IncludeSelf && isComposited() && !backing()->paintsIntoCompositedAncestor())
1476         return const_cast<RenderLayer*>(this);
1477
1478     for (const RenderLayer* curr = compositingContainer(this); curr; curr = compositingContainer(curr)) {
1479         if (compositedWithOwnBackingStore(curr))
1480             return const_cast<RenderLayer*>(curr);
1481     }
1482          
1483     return 0;
1484 }
1485
1486 #if ENABLE(CSS_FILTERS)
1487
1488 RenderLayer* RenderLayer::enclosingFilterLayer(IncludeSelfOrNot includeSelf) const
1489 {
1490     const RenderLayer* curr = (includeSelf == IncludeSelf) ? this : parent();
1491     for (; curr; curr = curr->parent()) {
1492         if (curr->requiresFullLayerImageForFilters())
1493             return const_cast<RenderLayer*>(curr);
1494     }
1495     
1496     return 0;
1497 }
1498
1499 RenderLayer* RenderLayer::enclosingFilterRepaintLayer() const
1500 {
1501     for (const RenderLayer* curr = this; curr; curr = curr->parent()) {
1502         if ((curr != this && curr->requiresFullLayerImageForFilters()) || compositedWithOwnBackingStore(curr) || curr->isRootLayer())
1503             return const_cast<RenderLayer*>(curr);
1504     }
1505     return 0;
1506 }
1507
1508 void RenderLayer::setFilterBackendNeedsRepaintingInRect(const LayoutRect& rect)
1509 {
1510     if (rect.isEmpty())
1511         return;
1512     
1513     LayoutRect rectForRepaint = rect;
1514     renderer().style().filterOutsets().expandRect(rectForRepaint);
1515
1516     FilterInfo& filterInfo = FilterInfo::get(*this);
1517     filterInfo.expandDirtySourceRect(rectForRepaint);
1518     
1519     RenderLayer* parentLayer = enclosingFilterRepaintLayer();
1520     ASSERT(parentLayer);
1521     FloatQuad repaintQuad(rectForRepaint);
1522     LayoutRect parentLayerRect = renderer().localToContainerQuad(repaintQuad, &parentLayer->renderer()).enclosingBoundingBox();
1523
1524     if (parentLayer->isComposited()) {
1525         if (!parentLayer->backing()->paintsIntoWindow()) {
1526             parentLayer->setBackingNeedsRepaintInRect(parentLayerRect);
1527             return;
1528         }
1529         // If the painting goes to window, redirect the painting to the parent RenderView.
1530         parentLayer = renderer().view().layer();
1531         parentLayerRect = renderer().localToContainerQuad(repaintQuad, &parentLayer->renderer()).enclosingBoundingBox();
1532     }
1533
1534     if (parentLayer->paintsWithFilters()) {
1535         parentLayer->setFilterBackendNeedsRepaintingInRect(parentLayerRect);
1536         return;        
1537     }
1538     
1539     if (parentLayer->isRootLayer()) {
1540         toRenderView(parentLayer->renderer()).repaintViewRectangle(parentLayerRect);
1541         return;
1542     }
1543     
1544     ASSERT_NOT_REACHED();
1545 }
1546
1547 bool RenderLayer::hasAncestorWithFilterOutsets() const
1548 {
1549     for (const RenderLayer* curr = this; curr; curr = curr->parent()) {
1550         if (curr->renderer().style().hasFilterOutsets())
1551             return true;
1552     }
1553     return false;
1554 }
1555
1556 #endif
1557
1558 RenderLayer* RenderLayer::clippingRootForPainting() const
1559 {
1560     if (isComposited())
1561         return const_cast<RenderLayer*>(this);
1562
1563     const RenderLayer* current = this;
1564     while (current) {
1565         if (current->isRootLayer())
1566             return const_cast<RenderLayer*>(current);
1567
1568         current = compositingContainer(current);
1569         ASSERT(current);
1570         if (current->transform() || compositedWithOwnBackingStore(current))
1571             return const_cast<RenderLayer*>(current);
1572     }
1573
1574     ASSERT_NOT_REACHED();
1575     return 0;
1576 }
1577
1578 LayoutPoint RenderLayer::absoluteToContents(const LayoutPoint& absolutePoint) const
1579 {
1580     // We don't use convertToLayerCoords because it doesn't know about transforms
1581     return roundedLayoutPoint(renderer().absoluteToLocal(absolutePoint, UseTransforms));
1582 }
1583
1584 bool RenderLayer::cannotBlitToWindow() const
1585 {
1586     if (isTransparent() || hasReflection() || hasTransform())
1587         return true;
1588     if (!parent())
1589         return false;
1590     return parent()->cannotBlitToWindow();
1591 }
1592
1593 bool RenderLayer::isTransparent() const
1594 {
1595     if (renderer().element() && renderer().element()->isSVGElement())
1596         return false;
1597     return renderer().isTransparent() || renderer().hasMask();
1598 }
1599
1600 RenderLayer* RenderLayer::transparentPaintingAncestor()
1601 {
1602     if (isComposited())
1603         return 0;
1604
1605     for (RenderLayer* curr = parent(); curr; curr = curr->parent()) {
1606         if (curr->isComposited())
1607             return 0;
1608         if (curr->isTransparent())
1609             return curr;
1610     }
1611     return 0;
1612 }
1613
1614 enum TransparencyClipBoxBehavior {
1615     PaintingTransparencyClipBox,
1616     HitTestingTransparencyClipBox
1617 };
1618
1619 enum TransparencyClipBoxMode {
1620     DescendantsOfTransparencyClipBox,
1621     RootOfTransparencyClipBox
1622 };
1623
1624 static LayoutRect transparencyClipBox(const RenderLayer*, const RenderLayer* rootLayer, TransparencyClipBoxBehavior, TransparencyClipBoxMode, PaintBehavior = 0);
1625
1626 static void expandClipRectForRegionAndReflection(LayoutRect& clipRect, const RenderLayer* layer, const RenderLayer* rootLayer,
1627     TransparencyClipBoxBehavior transparencyBehavior, PaintBehavior paintBehavior)
1628 {
1629     // If this is a region, then the painting is actually done by its flow thread's layer.
1630     if (layer->renderer().isRenderNamedFlowFragmentContainer()) {
1631         RenderBlockFlow* regionContainer = toRenderBlockFlow(&layer->renderer());
1632         RenderNamedFlowFragment* region = regionContainer->renderNamedFlowFragment();
1633         RenderLayer* flowThreadLayer = region->flowThread()->layer();
1634         if (!layer->reflection() || layer->reflectionLayer() != flowThreadLayer) {
1635             LayoutRect flowThreadClipRect = transparencyClipBox(flowThreadLayer, rootLayer, transparencyBehavior, DescendantsOfTransparencyClipBox, paintBehavior);
1636             
1637             LayoutPoint offsetFromRoot;
1638             layer->convertToLayerCoords(flowThreadLayer, offsetFromRoot);
1639
1640             LayoutSize moveOffset = (offsetFromRoot + regionContainer->contentBoxRect().location()) - region->flowThreadPortionRect().location();
1641             flowThreadClipRect.move(moveOffset);
1642             
1643             clipRect.unite(flowThreadClipRect);
1644         }
1645     }
1646 }
1647
1648 static void expandClipRectForDescendantsAndReflection(LayoutRect& clipRect, const RenderLayer* layer, const RenderLayer* rootLayer,
1649     TransparencyClipBoxBehavior transparencyBehavior, PaintBehavior paintBehavior)
1650 {
1651     // If we have a mask, then the clip is limited to the border box area (and there is
1652     // no need to examine child layers).
1653     if (!layer->renderer().hasMask()) {
1654         // Note: we don't have to walk z-order lists since transparent elements always establish
1655         // a stacking container. This means we can just walk the layer tree directly.
1656         for (RenderLayer* curr = layer->firstChild(); curr; curr = curr->nextSibling()) {
1657             if (!layer->reflection() || layer->reflectionLayer() != curr)
1658                 clipRect.unite(transparencyClipBox(curr, rootLayer, transparencyBehavior, DescendantsOfTransparencyClipBox, paintBehavior));
1659         }
1660     }
1661
1662     expandClipRectForRegionAndReflection(clipRect, layer, rootLayer, transparencyBehavior, paintBehavior);
1663
1664     // If we have a reflection, then we need to account for that when we push the clip.  Reflect our entire
1665     // current transparencyClipBox to catch all child layers.
1666     // FIXME: Accelerated compositing will eventually want to do something smart here to avoid incorporating this
1667     // size into the parent layer.
1668     if (layer->renderer().hasReflection()) {
1669         LayoutPoint delta;
1670         layer->convertToLayerCoords(rootLayer, delta);
1671         clipRect.move(-delta.x(), -delta.y());
1672         clipRect.unite(layer->renderBox()->reflectedRect(clipRect));
1673         clipRect.moveBy(delta);
1674     }
1675 }
1676
1677 static LayoutRect transparencyClipBox(const RenderLayer* layer, const RenderLayer* rootLayer, TransparencyClipBoxBehavior transparencyBehavior,
1678     TransparencyClipBoxMode transparencyMode, PaintBehavior paintBehavior)
1679 {
1680     // FIXME: Although this function completely ignores CSS-imposed clipping, we did already intersect with the
1681     // paintDirtyRect, and that should cut down on the amount we have to paint.  Still it
1682     // would be better to respect clips.
1683     
1684     if (rootLayer != layer && ((transparencyBehavior == PaintingTransparencyClipBox && layer->paintsWithTransform(paintBehavior))
1685         || (transparencyBehavior == HitTestingTransparencyClipBox && layer->hasTransform()))) {
1686         // The best we can do here is to use enclosed bounding boxes to establish a "fuzzy" enough clip to encompass
1687         // the transformed layer and all of its children.
1688         const RenderLayer* paginationLayer = transparencyMode == DescendantsOfTransparencyClipBox ? layer->enclosingPaginationLayer() : 0;
1689         const RenderLayer* rootLayerForTransform = paginationLayer ? paginationLayer : rootLayer;
1690         LayoutPoint delta;
1691         layer->convertToLayerCoords(rootLayerForTransform, delta);
1692
1693         TransformationMatrix transform;
1694         transform.translate(delta.x(), delta.y());
1695         transform = transform * *layer->transform();
1696
1697         // We don't use fragment boxes when collecting a transformed layer's bounding box, since it always
1698         // paints unfragmented.
1699         LayoutRect clipRect = layer->boundingBox(layer);
1700         expandClipRectForDescendantsAndReflection(clipRect, layer, layer, transparencyBehavior, paintBehavior);
1701 #if ENABLE(CSS_FILTERS)
1702         layer->renderer().style().filterOutsets().expandRect(clipRect);
1703 #endif
1704         LayoutRect result = transform.mapRect(clipRect);
1705         if (!paginationLayer)
1706             return result;
1707         
1708         // We have to break up the transformed extent across our columns.
1709         // Split our box up into the actual fragment boxes that render in the columns/pages and unite those together to
1710         // get our true bounding box.
1711         RenderFlowThread& enclosingFlowThread = toRenderFlowThread(paginationLayer->renderer());
1712         result = enclosingFlowThread.fragmentsBoundingBox(result);
1713         
1714         LayoutPoint rootLayerDelta;
1715         paginationLayer->convertToLayerCoords(rootLayer, rootLayerDelta);
1716         result.moveBy(rootLayerDelta);
1717         return result;
1718     }
1719     
1720     LayoutRect clipRect = layer->boundingBox(rootLayer, RenderLayer::UseFragmentBoxes);
1721     expandClipRectForDescendantsAndReflection(clipRect, layer, rootLayer, transparencyBehavior, paintBehavior);
1722 #if ENABLE(CSS_FILTERS)
1723     layer->renderer().style().filterOutsets().expandRect(clipRect);
1724 #endif
1725     return clipRect;
1726 }
1727
1728 LayoutRect RenderLayer::paintingExtent(const RenderLayer* rootLayer, const LayoutRect& paintDirtyRect, PaintBehavior paintBehavior)
1729 {
1730     return intersection(transparencyClipBox(this, rootLayer, PaintingTransparencyClipBox, RootOfTransparencyClipBox, paintBehavior), paintDirtyRect);
1731 }
1732
1733 void RenderLayer::beginTransparencyLayers(GraphicsContext* context, const RenderLayer* rootLayer, const LayoutRect& paintDirtyRect, PaintBehavior paintBehavior)
1734 {
1735     if (context->paintingDisabled() || (paintsWithTransparency(paintBehavior) && m_usedTransparency))
1736         return;
1737     
1738     RenderLayer* ancestor = transparentPaintingAncestor();
1739     if (ancestor)
1740         ancestor->beginTransparencyLayers(context, rootLayer, paintDirtyRect, paintBehavior);
1741     
1742     if (paintsWithTransparency(paintBehavior)) {
1743         m_usedTransparency = true;
1744         context->save();
1745         LayoutRect clipRect = paintingExtent(rootLayer, paintDirtyRect, paintBehavior);
1746         context->clip(clipRect);
1747
1748 #if ENABLE(CSS_COMPOSITING)
1749         if (hasBlendMode())
1750             context->setCompositeOperation(context->compositeOperation(), m_blendMode);
1751 #endif
1752
1753         context->beginTransparencyLayer(renderer().opacity());
1754
1755 #if ENABLE(CSS_COMPOSITING)
1756         if (hasBlendMode())
1757             context->setCompositeOperation(context->compositeOperation(), BlendModeNormal);
1758 #endif
1759
1760 #ifdef REVEAL_TRANSPARENCY_LAYERS
1761         context->setFillColor(Color(0.0f, 0.0f, 0.5f, 0.2f), ColorSpaceDeviceRGB);
1762         context->fillRect(clipRect);
1763 #endif
1764     }
1765 }
1766
1767 #if PLATFORM(IOS)
1768 void RenderLayer::willBeDestroyed()
1769 {
1770     if (RenderLayerBacking* layerBacking = backing())
1771         layerBacking->layerWillBeDestroyed();
1772 }
1773 #endif
1774
1775 void RenderLayer::addChild(RenderLayer* child, RenderLayer* beforeChild)
1776 {
1777     RenderLayer* prevSibling = beforeChild ? beforeChild->previousSibling() : lastChild();
1778     if (prevSibling) {
1779         child->setPreviousSibling(prevSibling);
1780         prevSibling->setNextSibling(child);
1781         ASSERT(prevSibling != child);
1782     } else
1783         setFirstChild(child);
1784
1785     if (beforeChild) {
1786         beforeChild->setPreviousSibling(child);
1787         child->setNextSibling(beforeChild);
1788         ASSERT(beforeChild != child);
1789     } else
1790         setLastChild(child);
1791
1792     child->setParent(this);
1793
1794     if (child->isNormalFlowOnly())
1795         dirtyNormalFlowList();
1796
1797     if (!child->isNormalFlowOnly() || child->firstChild()) {
1798         // Dirty the z-order list in which we are contained. The stackingContainer() can be null in the
1799         // case where we're building up generated content layers. This is ok, since the lists will start
1800         // off dirty in that case anyway.
1801         child->dirtyStackingContainerZOrderLists();
1802     }
1803
1804     child->updateDescendantDependentFlags();
1805     if (child->m_hasVisibleContent || child->m_hasVisibleDescendant)
1806         setAncestorChainHasVisibleDescendant();
1807
1808     if (child->isSelfPaintingLayer() || child->hasSelfPaintingLayerDescendant())
1809         setAncestorChainHasSelfPaintingLayerDescendant();
1810
1811     if (child->renderer().isOutOfFlowPositioned() || child->hasOutOfFlowPositionedDescendant())
1812         setAncestorChainHasOutOfFlowPositionedDescendant(child->renderer().containingBlock());
1813
1814 #if ENABLE(CSS_COMPOSITING)
1815     if (child->hasBlendMode() || (child->hasUnisolatedBlendingDescendants() && !child->isolatesBlending()))
1816         updateAncestorChainHasBlendingDescendants();
1817 #endif
1818
1819     compositor().layerWasAdded(*this, *child);
1820 }
1821
1822 RenderLayer* RenderLayer::removeChild(RenderLayer* oldChild)
1823 {
1824     if (!renderer().documentBeingDestroyed())
1825         compositor().layerWillBeRemoved(*this, *oldChild);
1826
1827     // remove the child
1828     if (oldChild->previousSibling())
1829         oldChild->previousSibling()->setNextSibling(oldChild->nextSibling());
1830     if (oldChild->nextSibling())
1831         oldChild->nextSibling()->setPreviousSibling(oldChild->previousSibling());
1832
1833     if (m_first == oldChild)
1834         m_first = oldChild->nextSibling();
1835     if (m_last == oldChild)
1836         m_last = oldChild->previousSibling();
1837
1838     if (oldChild->isNormalFlowOnly())
1839         dirtyNormalFlowList();
1840     if (!oldChild->isNormalFlowOnly() || oldChild->firstChild()) { 
1841         // Dirty the z-order list in which we are contained.  When called via the
1842         // reattachment process in removeOnlyThisLayer, the layer may already be disconnected
1843         // from the main layer tree, so we need to null-check the |stackingContainer| value.
1844         oldChild->dirtyStackingContainerZOrderLists();
1845     }
1846
1847     if (oldChild->renderer().isOutOfFlowPositioned() || oldChild->hasOutOfFlowPositionedDescendant())
1848         dirtyAncestorChainHasOutOfFlowPositionedDescendantStatus();
1849
1850     oldChild->setPreviousSibling(0);
1851     oldChild->setNextSibling(0);
1852     oldChild->setParent(0);
1853     
1854     oldChild->updateDescendantDependentFlags();
1855     if (oldChild->m_hasVisibleContent || oldChild->m_hasVisibleDescendant)
1856         dirtyAncestorChainVisibleDescendantStatus();
1857
1858     if (oldChild->isSelfPaintingLayer() || oldChild->hasSelfPaintingLayerDescendant())
1859         dirtyAncestorChainHasSelfPaintingLayerDescendantStatus();
1860
1861 #if ENABLE(CSS_COMPOSITING)
1862     if (oldChild->hasBlendMode() || (oldChild->hasUnisolatedBlendingDescendants() && !oldChild->isolatesBlending()))
1863         dirtyAncestorChainHasBlendingDescendants();
1864 #endif
1865
1866     return oldChild;
1867 }
1868
1869 void RenderLayer::removeOnlyThisLayer()
1870 {
1871     if (!m_parent)
1872         return;
1873
1874     // Mark that we are about to lose our layer. This makes render tree
1875     // walks ignore this layer while we're removing it.
1876     renderer().setHasLayer(false);
1877
1878     compositor().layerWillBeRemoved(*m_parent, *this);
1879
1880     // Dirty the clip rects.
1881     clearClipRectsIncludingDescendants();
1882
1883     RenderLayer* nextSib = nextSibling();
1884
1885     // Remove the child reflection layer before moving other child layers.
1886     // The reflection layer should not be moved to the parent.
1887     if (reflection())
1888         removeChild(reflectionLayer());
1889
1890     // Now walk our kids and reattach them to our parent.
1891     RenderLayer* current = m_first;
1892     while (current) {
1893         RenderLayer* next = current->nextSibling();
1894         removeChild(current);
1895         m_parent->addChild(current, nextSib);
1896         current->setRepaintStatus(NeedsFullRepaint);
1897         // updateLayerPositions depends on hasLayer() already being false for proper layout.
1898         ASSERT(!renderer().hasLayer());
1899         current->updateLayerPositions(0); // FIXME: use geometry map.
1900         current = next;
1901     }
1902
1903     // Remove us from the parent.
1904     m_parent->removeChild(this);
1905     renderer().destroyLayer();
1906 }
1907
1908 void RenderLayer::insertOnlyThisLayer()
1909 {
1910     if (!m_parent && renderer().parent()) {
1911         // We need to connect ourselves when our renderer() has a parent.
1912         // Find our enclosingLayer and add ourselves.
1913         RenderLayer* parentLayer = renderer().parent()->enclosingLayer();
1914         ASSERT(parentLayer);
1915         RenderLayer* beforeChild = parentLayer->reflectionLayer() != this ? renderer().parent()->findNextLayer(parentLayer, &renderer()) : 0;
1916         parentLayer->addChild(this, beforeChild);
1917     }
1918
1919     // Remove all descendant layers from the hierarchy and add them to the new position.
1920     for (auto& child : childrenOfType<RenderElement>(renderer()))
1921         child.moveLayers(m_parent, this);
1922
1923     // Clear out all the clip rects.
1924     clearClipRectsIncludingDescendants();
1925 }
1926
1927 void RenderLayer::convertToPixelSnappedLayerCoords(const RenderLayer* ancestorLayer, IntPoint& roundedLocation, ColumnOffsetAdjustment adjustForColumns) const
1928 {
1929     LayoutPoint location = roundedLocation;
1930     convertToLayerCoords(ancestorLayer, location, adjustForColumns);
1931     roundedLocation = roundedIntPoint(location);
1932 }
1933
1934 void RenderLayer::convertToPixelSnappedLayerCoords(const RenderLayer* ancestorLayer, IntRect& roundedRect, ColumnOffsetAdjustment adjustForColumns) const
1935 {
1936     LayoutRect rect = roundedRect;
1937     convertToLayerCoords(ancestorLayer, rect, adjustForColumns);
1938     roundedRect = pixelSnappedIntRect(rect);
1939 }
1940
1941 // Returns the layer reached on the walk up towards the ancestor.
1942 static inline const RenderLayer* accumulateOffsetTowardsAncestor(const RenderLayer* layer, const RenderLayer* ancestorLayer, LayoutPoint& location, RenderLayer::ColumnOffsetAdjustment adjustForColumns)
1943 {
1944     ASSERT(ancestorLayer != layer);
1945
1946     const RenderLayerModelObject& renderer = layer->renderer();
1947     EPosition position = renderer.style().position();
1948
1949     // FIXME: Special casing RenderFlowThread so much for fixed positioning here is not great.
1950     RenderFlowThread* fixedFlowThreadContainer = position == FixedPosition ? renderer.flowThreadContainingBlock() : 0;
1951     if (fixedFlowThreadContainer && !fixedFlowThreadContainer->isOutOfFlowPositioned())
1952         fixedFlowThreadContainer = 0;
1953
1954     // FIXME: Positioning of out-of-flow(fixed, absolute) elements collected in a RenderFlowThread
1955     // may need to be revisited in a future patch.
1956     // If the fixed renderer is inside a RenderFlowThread, we should not compute location using localToAbsolute,
1957     // since localToAbsolute maps the coordinates from named flow to regions coordinates and regions can be
1958     // positioned in a completely different place in the viewport (RenderView).
1959     if (position == FixedPosition && !fixedFlowThreadContainer && (!ancestorLayer || ancestorLayer == renderer.view().layer())) {
1960         // If the fixed layer's container is the root, just add in the offset of the view. We can obtain this by calling
1961         // localToAbsolute() on the RenderView.
1962         FloatPoint absPos = renderer.localToAbsolute(FloatPoint(), IsFixed);
1963         location += LayoutSize(absPos.x(), absPos.y());
1964         return ancestorLayer;
1965     }
1966
1967     // For the fixed positioned elements inside a render flow thread, we should also skip the code path below
1968     // Otherwise, for the case of ancestorLayer == rootLayer and fixed positioned element child of a transformed
1969     // element in render flow thread, we will hit the fixed positioned container before hitting the ancestor layer.
1970     if (position == FixedPosition && !fixedFlowThreadContainer) {
1971         // For a fixed layers, we need to walk up to the root to see if there's a fixed position container
1972         // (e.g. a transformed layer). It's an error to call convertToLayerCoords() across a layer with a transform,
1973         // so we should always find the ancestor at or before we find the fixed position container.
1974         RenderLayer* fixedPositionContainerLayer = 0;
1975         bool foundAncestor = false;
1976         for (RenderLayer* currLayer = layer->parent(); currLayer; currLayer = currLayer->parent()) {
1977             if (currLayer == ancestorLayer)
1978                 foundAncestor = true;
1979
1980             if (isFixedPositionedContainer(currLayer)) {
1981                 fixedPositionContainerLayer = currLayer;
1982                 ASSERT_UNUSED(foundAncestor, foundAncestor);
1983                 break;
1984             }
1985         }
1986         
1987         ASSERT(fixedPositionContainerLayer); // We should have hit the RenderView's layer at least.
1988
1989         if (fixedPositionContainerLayer != ancestorLayer) {
1990             LayoutPoint fixedContainerCoords;
1991             layer->convertToLayerCoords(fixedPositionContainerLayer, fixedContainerCoords);
1992
1993             LayoutPoint ancestorCoords;
1994             ancestorLayer->convertToLayerCoords(fixedPositionContainerLayer, ancestorCoords);
1995
1996             location += (fixedContainerCoords - ancestorCoords);
1997             return ancestorLayer;
1998         }
1999     }
2000
2001     if (position == FixedPosition && fixedFlowThreadContainer) {
2002         ASSERT(ancestorLayer);
2003         if (ancestorLayer->isOutOfFlowRenderFlowThread()) {
2004             location += toLayoutSize(layer->location());
2005             return ancestorLayer;
2006         }
2007
2008         if (ancestorLayer == renderer.view().layer()) {
2009             // Add location in flow thread coordinates.
2010             location += toLayoutSize(layer->location());
2011
2012             // Add flow thread offset in view coordinates since the view may be scrolled.
2013             FloatPoint absPos = renderer.view().localToAbsolute(FloatPoint(), IsFixed);
2014             location += LayoutSize(absPos.x(), absPos.y());
2015             return ancestorLayer;
2016         }
2017     }
2018
2019     RenderLayer* parentLayer;
2020     if (position == AbsolutePosition || position == FixedPosition) {
2021         // Do what enclosingPositionedAncestor() does, but check for ancestorLayer along the way.
2022         parentLayer = layer->parent();
2023         bool foundAncestorFirst = false;
2024         while (parentLayer) {
2025             // RenderFlowThread is a positioned container, child of RenderView, positioned at (0,0).
2026             // This implies that, for out-of-flow positioned elements inside a RenderFlowThread,
2027             // we are bailing out before reaching root layer.
2028             if (isPositionedContainer(parentLayer))
2029                 break;
2030
2031             if (parentLayer == ancestorLayer) {
2032                 foundAncestorFirst = true;
2033                 break;
2034             }
2035
2036             parentLayer = parentLayer->parent();
2037         }
2038
2039         // We should not reach RenderView layer past the RenderFlowThread layer for any
2040         // children of the RenderFlowThread.
2041         if (renderer.flowThreadContainingBlock() && !layer->isOutOfFlowRenderFlowThread())
2042             ASSERT(parentLayer != renderer.view().layer());
2043
2044         if (foundAncestorFirst) {
2045             // Found ancestorLayer before the abs. positioned container, so compute offset of both relative
2046             // to enclosingPositionedAncestor and subtract.
2047             RenderLayer* positionedAncestor = parentLayer->enclosingPositionedAncestor();
2048
2049             LayoutPoint thisCoords;
2050             layer->convertToLayerCoords(positionedAncestor, thisCoords);
2051             
2052             LayoutPoint ancestorCoords;
2053             ancestorLayer->convertToLayerCoords(positionedAncestor, ancestorCoords);
2054
2055             location += (thisCoords - ancestorCoords);
2056             return ancestorLayer;
2057         }
2058     } else
2059         parentLayer = layer->parent();
2060     
2061     if (!parentLayer)
2062         return 0;
2063
2064     location += toLayoutSize(layer->location());
2065
2066     if (adjustForColumns == RenderLayer::AdjustForColumns) {
2067         if (RenderLayer* parentLayer = layer->parent()) {
2068             LayoutSize layerColumnOffset;
2069             parentLayer->renderer().adjustForColumns(layerColumnOffset, location);
2070             location += layerColumnOffset;
2071             
2072             if (parentLayer->renderer().isRenderMultiColumnFlowThread()) {
2073                 RenderRegion* region = toRenderMultiColumnFlowThread(parentLayer->renderer()).physicalTranslationFromFlowToRegion(location);
2074                 if (region)
2075                     location.moveBy(region->topLeftLocation() + -parentLayer->renderBox()->topLeftLocation());
2076             }
2077         }
2078     }
2079
2080     return parentLayer;
2081 }
2082
2083 void RenderLayer::convertToLayerCoords(const RenderLayer* ancestorLayer, LayoutPoint& location, ColumnOffsetAdjustment adjustForColumns) const
2084 {
2085     if (ancestorLayer == this)
2086         return;
2087
2088     const RenderLayer* currLayer = this;
2089     while (currLayer && currLayer != ancestorLayer)
2090         currLayer = accumulateOffsetTowardsAncestor(currLayer, ancestorLayer, location, adjustForColumns);
2091 }
2092
2093 void RenderLayer::convertToLayerCoords(const RenderLayer* ancestorLayer, LayoutRect& rect, ColumnOffsetAdjustment adjustForColumns) const
2094 {
2095     LayoutPoint delta;
2096     convertToLayerCoords(ancestorLayer, delta, adjustForColumns);
2097     rect.move(-delta.x(), -delta.y());
2098 }
2099
2100 #if PLATFORM(IOS)
2101 bool RenderLayer::hasAcceleratedTouchScrolling() const
2102 {
2103 #if ENABLE(ACCELERATED_OVERFLOW_SCROLLING)
2104     if (!scrollsOverflow())
2105         return false;
2106
2107     Settings* settings = renderer().document().settings();
2108     // FIXME: settings should not be null at this point. If you find a reliable way to hit this assertion, please file a bug.
2109     // See <rdar://problem/10266101>.
2110     ASSERT(settings);
2111
2112     return renderer().style().useTouchOverflowScrolling() || (settings && settings->alwaysUseAcceleratedOverflowScroll());
2113 #else
2114     return false;
2115 #endif
2116 }
2117
2118 bool RenderLayer::hasTouchScrollableOverflow() const
2119 {
2120     return hasAcceleratedTouchScrolling() && (hasScrollableHorizontalOverflow() || hasScrollableVerticalOverflow());
2121 }
2122
2123 #if ENABLE(TOUCH_EVENTS)
2124 bool RenderLayer::handleTouchEvent(const PlatformTouchEvent& touchEvent)
2125 {
2126     // If we have accelerated scrolling, let the scrolling be handled outside of WebKit.
2127     if (hasTouchScrollableOverflow())
2128         return false;
2129
2130     return ScrollableArea::handleTouchEvent(touchEvent);
2131 }
2132 #endif
2133
2134 void RenderLayer::registerAsTouchEventListenerForScrolling()
2135 {
2136     if (!renderer().element() || m_registeredAsTouchEventListenerForScrolling)
2137         return;
2138     
2139     renderer().document().addTouchEventListener(renderer().element());
2140     m_registeredAsTouchEventListenerForScrolling = true;
2141 }
2142
2143 void RenderLayer::unregisterAsTouchEventListenerForScrolling()
2144 {
2145     if (!renderer().element() || !m_registeredAsTouchEventListenerForScrolling)
2146         return;
2147
2148     renderer().document().removeTouchEventListener(renderer().element());
2149     m_registeredAsTouchEventListenerForScrolling = false;
2150 }
2151 #endif // PLATFORM(IOS)
2152
2153 bool RenderLayer::usesCompositedScrolling() const
2154 {
2155     return isComposited() && backing()->scrollingLayer();
2156 }
2157
2158 bool RenderLayer::needsCompositedScrolling() const
2159 {
2160     return m_needsCompositedScrolling;
2161 }
2162
2163 void RenderLayer::updateNeedsCompositedScrolling()
2164 {
2165     bool oldNeedsCompositedScrolling = m_needsCompositedScrolling;
2166
2167     if (!renderer().view().frameView().containsScrollableArea(this))
2168         m_needsCompositedScrolling = false;
2169     else {
2170         bool forceUseCompositedScrolling = acceleratedCompositingForOverflowScrollEnabled()
2171             && canBeStackingContainer()
2172             && !hasOutOfFlowPositionedDescendant();
2173
2174 #if !PLATFORM(IOS) && ENABLE(ACCELERATED_OVERFLOW_SCROLLING)
2175         m_needsCompositedScrolling = forceUseCompositedScrolling || renderer().style().useTouchOverflowScrolling();
2176 #else
2177         // On iOS we don't want to opt into accelerated composited scrolling, which creates scroll bar
2178         // layers in WebCore, because we use UIKit to composite our scroll bars.
2179         m_needsCompositedScrolling = forceUseCompositedScrolling;
2180 #endif
2181         // We gather a boolean value for use with Google UMA histograms to
2182         // quantify the actual effects of a set of patches attempting to
2183         // relax composited scrolling requirements, thereby increasing the
2184         // number of composited overflow divs.
2185         if (acceleratedCompositingForOverflowScrollEnabled())
2186             HistogramSupport::histogramEnumeration("Renderer.NeedsCompositedScrolling", m_needsCompositedScrolling, 2);
2187     }
2188
2189     if (oldNeedsCompositedScrolling != m_needsCompositedScrolling) {
2190         updateSelfPaintingLayer();
2191         if (isStackingContainer())
2192             dirtyZOrderLists();
2193         else
2194             clearZOrderLists();
2195
2196         dirtyStackingContainerZOrderLists();
2197
2198         compositor().setShouldReevaluateCompositingAfterLayout();
2199         compositor().setCompositingLayersNeedRebuild();
2200     }
2201 }
2202
2203 static inline int adjustedScrollDelta(int beginningDelta) {
2204     // This implemention matches Firefox's.
2205     // http://mxr.mozilla.org/firefox/source/toolkit/content/widgets/browser.xml#856.
2206     const int speedReducer = 12;
2207
2208     int adjustedDelta = beginningDelta / speedReducer;
2209     if (adjustedDelta > 1)
2210         adjustedDelta = static_cast<int>(adjustedDelta * sqrt(static_cast<double>(adjustedDelta))) - 1;
2211     else if (adjustedDelta < -1)
2212         adjustedDelta = static_cast<int>(adjustedDelta * sqrt(static_cast<double>(-adjustedDelta))) + 1;
2213
2214     return adjustedDelta;
2215 }
2216
2217 static inline IntSize adjustedScrollDelta(const IntSize& delta)
2218 {
2219     return IntSize(adjustedScrollDelta(delta.width()), adjustedScrollDelta(delta.height()));
2220 }
2221
2222 void RenderLayer::panScrollFromPoint(const IntPoint& sourcePoint)
2223 {
2224     IntPoint lastKnownMousePosition = renderer().frame().eventHandler().lastKnownMousePosition();
2225     
2226     // We need to check if the last known mouse position is out of the window. When the mouse is out of the window, the position is incoherent
2227     static IntPoint previousMousePosition;
2228     if (lastKnownMousePosition.x() < 0 || lastKnownMousePosition.y() < 0)
2229         lastKnownMousePosition = previousMousePosition;
2230     else
2231         previousMousePosition = lastKnownMousePosition;
2232
2233     IntSize delta = lastKnownMousePosition - sourcePoint;
2234
2235     if (abs(delta.width()) <= ScrollView::noPanScrollRadius) // at the center we let the space for the icon
2236         delta.setWidth(0);
2237     if (abs(delta.height()) <= ScrollView::noPanScrollRadius)
2238         delta.setHeight(0);
2239
2240     scrollByRecursively(adjustedScrollDelta(delta), ScrollOffsetClamped);
2241 }
2242
2243 void RenderLayer::scrollByRecursively(const IntSize& delta, ScrollOffsetClamping clamp, ScrollableArea** scrolledArea)
2244 {
2245     if (delta.isZero())
2246         return;
2247
2248     bool restrictedByLineClamp = false;
2249     if (renderer().parent())
2250         restrictedByLineClamp = !renderer().parent()->style().lineClamp().isNone();
2251
2252     if (renderer().hasOverflowClip() && !restrictedByLineClamp) {
2253         IntSize newScrollOffset = scrollOffset() + delta;
2254         scrollToOffset(newScrollOffset, clamp);
2255         if (scrolledArea)
2256             *scrolledArea = this;
2257
2258         // If this layer can't do the scroll we ask the next layer up that can scroll to try
2259         IntSize remainingScrollOffset = newScrollOffset - scrollOffset();
2260         if (!remainingScrollOffset.isZero() && renderer().parent()) {
2261             if (RenderLayer* scrollableLayer = enclosingScrollableLayer())
2262                 scrollableLayer->scrollByRecursively(remainingScrollOffset, clamp, scrolledArea);
2263
2264             renderer().frame().eventHandler().updateAutoscrollRenderer();
2265         }
2266     } else {
2267         // If we are here, we were called on a renderer that can be programmatically scrolled, but doesn't
2268         // have an overflow clip. Which means that it is a document node that can be scrolled.
2269         renderer().view().frameView().scrollBy(delta);
2270         if (scrolledArea)
2271             *scrolledArea = &renderer().view().frameView();
2272
2273         // FIXME: If we didn't scroll the whole way, do we want to try looking at the frames ownerElement? 
2274         // https://bugs.webkit.org/show_bug.cgi?id=28237
2275     }
2276 }
2277
2278 IntSize RenderLayer::clampScrollOffset(const IntSize& scrollOffset) const
2279 {
2280     RenderBox* box = renderBox();
2281     ASSERT(box);
2282
2283     int maxX = scrollWidth() - box->pixelSnappedClientWidth();
2284     int maxY = scrollHeight() - box->pixelSnappedClientHeight();
2285
2286     int x = std::max(std::min(scrollOffset.width(), maxX), 0);
2287     int y = std::max(std::min(scrollOffset.height(), maxY), 0);
2288     return IntSize(x, y);
2289 }
2290
2291 void RenderLayer::scrollToOffset(const IntSize& scrollOffset, ScrollOffsetClamping clamp)
2292 {
2293     IntSize newScrollOffset = clamp == ScrollOffsetClamped ? clampScrollOffset(scrollOffset) : scrollOffset;
2294     if (newScrollOffset != this->scrollOffset())
2295         scrollToOffsetWithoutAnimation(IntPoint(newScrollOffset));
2296 }
2297
2298 void RenderLayer::scrollTo(int x, int y)
2299 {
2300     RenderBox* box = renderBox();
2301     if (!box)
2302         return;
2303
2304     if (box->style().overflowX() != OMARQUEE) {
2305         // Ensure that the dimensions will be computed if they need to be (for overflow:hidden blocks).
2306         if (m_scrollDimensionsDirty)
2307             computeScrollDimensions();
2308 #if PLATFORM(IOS)
2309         if (adjustForIOSCaretWhenScrolling()) {
2310             int maxX = scrollWidth() - box->clientWidth();
2311             if (x > maxX - caretWidth) {
2312                 x += caretWidth;
2313                 if (x <= caretWidth)
2314                     x = 0;
2315             } else if (x < m_scrollOffset.width() - caretWidth)
2316                 x -= caretWidth;
2317         }
2318 #endif
2319     }
2320     
2321     // FIXME: Eventually, we will want to perform a blit.  For now never
2322     // blit, since the check for blitting is going to be very
2323     // complicated (since it will involve testing whether our layer
2324     // is either occluded by another layer or clipped by an enclosing
2325     // layer or contains fixed backgrounds, etc.).
2326     IntSize newScrollOffset = IntSize(x - scrollOrigin().x(), y - scrollOrigin().y());
2327     if (m_scrollOffset == newScrollOffset) {
2328 #if PLATFORM(IOS)
2329         if (m_requiresScrollBoundsOriginUpdate)
2330             updateCompositingLayersAfterScroll();
2331 #endif
2332         return;
2333     }
2334     
2335     IntPoint oldPosition = IntPoint(m_scrollOffset);
2336     m_scrollOffset = newScrollOffset;
2337
2338     InspectorInstrumentation::willScrollLayer(&renderer().frame());
2339
2340     RenderView& view = renderer().view();
2341
2342     // Update the positions of our child layers (if needed as only fixed layers should be impacted by a scroll).
2343     // We don't update compositing layers, because we need to do a deep update from the compositing ancestor.
2344     bool inLayout = view.frameView().isInLayout();
2345     if (!inLayout) {
2346         // If we're in the middle of layout, we'll just update layers once layout has finished.
2347         updateLayerPositionsAfterOverflowScroll();
2348         // Update regions, scrolling may change the clip of a particular region.
2349 #if ENABLE(DASHBOARD_SUPPORT)
2350         view.frameView().updateAnnotatedRegions();
2351 #endif
2352         view.frameView().updateWidgetPositions();
2353
2354         if (!m_updatingMarqueePosition) {
2355             // Avoid updating compositing layers if, higher on the stack, we're already updating layer
2356             // positions. Updating layer positions requires a full walk of up-to-date RenderLayers, and
2357             // in this case we're still updating their positions; we'll update compositing layers later
2358             // when that completes.
2359             updateCompositingLayersAfterScroll();
2360         }
2361
2362 #if PLATFORM(IOS) && ENABLE(TOUCH_EVENTS)
2363         renderer().document().dirtyTouchEventRects();
2364 #endif
2365     }
2366
2367     Frame& frame = renderer().frame();
2368     RenderLayerModelObject* repaintContainer = renderer().containerForRepaint();
2369     // The caret rect needs to be invalidated after scrolling
2370     frame.selection().setCaretRectNeedsUpdate();
2371
2372     FloatQuad quadForFakeMouseMoveEvent = FloatQuad(m_repaintRect);
2373     if (repaintContainer)
2374         quadForFakeMouseMoveEvent = repaintContainer->localToAbsoluteQuad(quadForFakeMouseMoveEvent);
2375     frame.eventHandler().dispatchFakeMouseMoveEventSoonInQuad(quadForFakeMouseMoveEvent);
2376
2377     bool requiresRepaint = true;
2378     if (compositor().inCompositingMode() && usesCompositedScrolling())
2379         requiresRepaint = false;
2380
2381     // Just schedule a full repaint of our object.
2382     if (requiresRepaint)
2383         renderer().repaintUsingContainer(repaintContainer, m_repaintRect);
2384
2385     // Schedule the scroll and scroll-related DOM events.
2386     if (Element* element = renderer().element()) {
2387         element->document().eventQueue().enqueueOrDispatchScrollEvent(*element);
2388         element->document().sendWillRevealEdgeEventsIfNeeded(oldPosition, IntPoint(newScrollOffset), visibleContentRect(), contentsSize(), element);
2389     }
2390
2391     InspectorInstrumentation::didScrollLayer(&frame);
2392     if (scrollsOverflow())
2393         frame.loader().client().didChangeScrollOffset();
2394 }
2395
2396 static inline bool frameElementAndViewPermitScroll(HTMLFrameElementBase* frameElementBase, FrameView* frameView) 
2397 {
2398     // If scrollbars aren't explicitly forbidden, permit scrolling.
2399     if (frameElementBase && frameElementBase->scrollingMode() != ScrollbarAlwaysOff)
2400         return true;
2401
2402     // If scrollbars are forbidden, user initiated scrolls should obviously be ignored.
2403     if (frameView->wasScrolledByUser())
2404         return false;
2405
2406     // Forbid autoscrolls when scrollbars are off, but permits other programmatic scrolls,
2407     // like navigation to an anchor.
2408     return !frameView->frame().eventHandler().autoscrollInProgress();
2409 }
2410
2411 void RenderLayer::scrollRectToVisible(const LayoutRect& rect, const ScrollAlignment& alignX, const ScrollAlignment& alignY)
2412 {
2413     RenderLayer* parentLayer = 0;
2414     LayoutRect newRect = rect;
2415
2416     // We may end up propagating a scroll event. It is important that we suspend events until 
2417     // the end of the function since they could delete the layer or the layer's renderer().
2418     FrameView& frameView = renderer().view().frameView();
2419
2420     bool restrictedByLineClamp = false;
2421     if (renderer().parent()) {
2422         parentLayer = renderer().parent()->enclosingLayer();
2423         restrictedByLineClamp = !renderer().parent()->style().lineClamp().isNone();
2424     }
2425
2426     if (renderer().hasOverflowClip() && !restrictedByLineClamp) {
2427         // Don't scroll to reveal an overflow layer that is restricted by the -webkit-line-clamp property.
2428         // This will prevent us from revealing text hidden by the slider in Safari RSS.
2429         RenderBox* box = renderBox();
2430         ASSERT(box);
2431         LayoutRect localExposeRect(box->absoluteToLocalQuad(FloatQuad(FloatRect(rect)), UseTransforms).boundingBox());
2432         LayoutRect layerBounds(0, 0, box->clientWidth(), box->clientHeight());
2433         LayoutRect r = getRectToExpose(layerBounds, layerBounds, localExposeRect, alignX, alignY);
2434
2435         IntSize clampedScrollOffset = clampScrollOffset(scrollOffset() + toIntSize(roundedIntRect(r).location()));
2436         if (clampedScrollOffset != scrollOffset()) {
2437             IntSize oldScrollOffset = scrollOffset();
2438             scrollToOffset(clampedScrollOffset);
2439             IntSize scrollOffsetDifference = scrollOffset() - oldScrollOffset;
2440             localExposeRect.move(-scrollOffsetDifference);
2441             newRect = LayoutRect(box->localToAbsoluteQuad(FloatQuad(FloatRect(localExposeRect)), UseTransforms).boundingBox());
2442         }
2443     } else if (!parentLayer && renderer().isBox() && renderBox()->canBeProgramaticallyScrolled()) {
2444         Element* ownerElement = renderer().document().ownerElement();
2445
2446         if (ownerElement && ownerElement->renderer()) {
2447             HTMLFrameElementBase* frameElementBase = 0;
2448
2449             if (ownerElement->hasTagName(frameTag) || ownerElement->hasTagName(iframeTag))
2450                 frameElementBase = toHTMLFrameElementBase(ownerElement);
2451
2452             if (frameElementAndViewPermitScroll(frameElementBase, &frameView)) {
2453                 LayoutRect viewRect = frameView.visibleContentRect(LegacyIOSDocumentVisibleRect);
2454                 LayoutRect exposeRect = getRectToExpose(viewRect, viewRect, rect, alignX, alignY);
2455
2456                 int xOffset = roundToInt(exposeRect.x());
2457                 int yOffset = roundToInt(exposeRect.y());
2458                 // Adjust offsets if they're outside of the allowable range.
2459                 xOffset = std::max(0, std::min(frameView.contentsWidth(), xOffset));
2460                 yOffset = std::max(0, std::min(frameView.contentsHeight(), yOffset));
2461
2462                 frameView.setScrollPosition(IntPoint(xOffset, yOffset));
2463                 if (frameView.safeToPropagateScrollToParent()) {
2464                     parentLayer = ownerElement->renderer()->enclosingLayer();
2465                     // FIXME: This doesn't correctly convert the rect to
2466                     // absolute coordinates in the parent.
2467                     newRect.setX(rect.x() - frameView.scrollX() + frameView.x());
2468                     newRect.setY(rect.y() - frameView.scrollY() + frameView.y());
2469                 } else
2470                     parentLayer = 0;
2471             }
2472         } else {
2473 #if !PLATFORM(IOS)
2474             LayoutRect viewRect = frameView.visibleContentRect();
2475             LayoutRect visibleRectRelativeToDocument = viewRect;
2476             IntSize scrollOffsetRelativeToDocument = frameView.scrollOffsetRelativeToDocument();
2477             visibleRectRelativeToDocument.setLocation(IntPoint(scrollOffsetRelativeToDocument.width(), scrollOffsetRelativeToDocument.height()));
2478 #else
2479             LayoutRect viewRect = frameView.unobscuredContentRect();
2480             LayoutRect visibleRectRelativeToDocument = viewRect;
2481 #endif
2482
2483             LayoutRect r = getRectToExpose(viewRect, visibleRectRelativeToDocument, rect, alignX, alignY);
2484                 
2485             frameView.setScrollPosition(roundedIntPoint(r.location()));
2486
2487             // This is the outermost view of a web page, so after scrolling this view we
2488             // scroll its container by calling Page::scrollRectIntoView.
2489             // This only has an effect on the Mac platform in applications
2490             // that put web views into scrolling containers, such as Mac OS X Mail.
2491             // The canAutoscroll function in EventHandler also knows about this.
2492             if (Page* page = frameView.frame().page())
2493                 page->chrome().scrollRectIntoView(pixelSnappedIntRect(rect));
2494         }
2495     }
2496     
2497     if (renderer().frame().eventHandler().autoscrollInProgress())
2498         parentLayer = enclosingScrollableLayer();
2499
2500     if (parentLayer)
2501         parentLayer->scrollRectToVisible(newRect, alignX, alignY);
2502 }
2503
2504 void RenderLayer::updateCompositingLayersAfterScroll()
2505 {
2506     if (compositor().inCompositingMode()) {
2507         // Our stacking container is guaranteed to contain all of our descendants that may need
2508         // repositioning, so update compositing layers from there.
2509         if (RenderLayer* compositingAncestor = stackingContainer()->enclosingCompositingLayer()) {
2510             if (usesCompositedScrolling() && !hasOutOfFlowPositionedDescendant())
2511                 compositor().updateCompositingLayers(CompositingUpdateOnCompositedScroll, compositingAncestor);
2512             else
2513                 compositor().updateCompositingLayers(CompositingUpdateOnScroll, compositingAncestor);
2514         }
2515     }
2516 }
2517
2518 LayoutRect RenderLayer::getRectToExpose(const LayoutRect &visibleRect, const LayoutRect &visibleRectRelativeToDocument, const LayoutRect &exposeRect, const ScrollAlignment& alignX, const ScrollAlignment& alignY)
2519 {
2520     // Determine the appropriate X behavior.
2521     ScrollBehavior scrollX;
2522     LayoutRect exposeRectX(exposeRect.x(), visibleRect.y(), exposeRect.width(), visibleRect.height());
2523     LayoutUnit intersectWidth = intersection(visibleRect, exposeRectX).width();
2524     if (intersectWidth == exposeRect.width() || intersectWidth >= MIN_INTERSECT_FOR_REVEAL)
2525         // If the rectangle is fully visible, use the specified visible behavior.
2526         // If the rectangle is partially visible, but over a certain threshold,
2527         // then treat it as fully visible to avoid unnecessary horizontal scrolling
2528         scrollX = ScrollAlignment::getVisibleBehavior(alignX);
2529     else if (intersectWidth == visibleRect.width()) {
2530         // If the rect is bigger than the visible area, don't bother trying to center. Other alignments will work.
2531         scrollX = ScrollAlignment::getVisibleBehavior(alignX);
2532         if (scrollX == alignCenter)
2533             scrollX = noScroll;
2534     } else if (intersectWidth > 0)
2535         // If the rectangle is partially visible, but not above the minimum threshold, use the specified partial behavior
2536         scrollX = ScrollAlignment::getPartialBehavior(alignX);
2537     else
2538         scrollX = ScrollAlignment::getHiddenBehavior(alignX);
2539     // If we're trying to align to the closest edge, and the exposeRect is further right
2540     // than the visibleRect, and not bigger than the visible area, then align with the right.
2541     if (scrollX == alignToClosestEdge && exposeRect.maxX() > visibleRect.maxX() && exposeRect.width() < visibleRect.width())
2542         scrollX = alignRight;
2543
2544     // Given the X behavior, compute the X coordinate.
2545     LayoutUnit x;
2546     if (scrollX == noScroll) 
2547         x = visibleRect.x();
2548     else if (scrollX == alignRight)
2549         x = exposeRect.maxX() - visibleRect.width();
2550     else if (scrollX == alignCenter)
2551         x = exposeRect.x() + (exposeRect.width() - visibleRect.width()) / 2;
2552     else
2553         x = exposeRect.x();
2554
2555     // Determine the appropriate Y behavior.
2556     ScrollBehavior scrollY;
2557     LayoutRect exposeRectY(visibleRect.x(), exposeRect.y(), visibleRect.width(), exposeRect.height());
2558     LayoutUnit intersectHeight = intersection(visibleRectRelativeToDocument, exposeRectY).height();
2559     if (intersectHeight == exposeRect.height())
2560         // If the rectangle is fully visible, use the specified visible behavior.
2561         scrollY = ScrollAlignment::getVisibleBehavior(alignY);
2562     else if (intersectHeight == visibleRect.height()) {
2563         // If the rect is bigger than the visible area, don't bother trying to center. Other alignments will work.
2564         scrollY = ScrollAlignment::getVisibleBehavior(alignY);
2565         if (scrollY == alignCenter)
2566             scrollY = noScroll;
2567     } else if (intersectHeight > 0)
2568         // If the rectangle is partially visible, use the specified partial behavior
2569         scrollY = ScrollAlignment::getPartialBehavior(alignY);
2570     else
2571         scrollY = ScrollAlignment::getHiddenBehavior(alignY);
2572     // If we're trying to align to the closest edge, and the exposeRect is further down
2573     // than the visibleRect, and not bigger than the visible area, then align with the bottom.
2574     if (scrollY == alignToClosestEdge && exposeRect.maxY() > visibleRect.maxY() && exposeRect.height() < visibleRect.height())
2575         scrollY = alignBottom;
2576
2577     // Given the Y behavior, compute the Y coordinate.
2578     LayoutUnit y;
2579     if (scrollY == noScroll) 
2580         y = visibleRect.y();
2581     else if (scrollY == alignBottom)
2582         y = exposeRect.maxY() - visibleRect.height();
2583     else if (scrollY == alignCenter)
2584         y = exposeRect.y() + (exposeRect.height() - visibleRect.height()) / 2;
2585     else
2586         y = exposeRect.y();
2587
2588     return LayoutRect(LayoutPoint(x, y), visibleRect.size());
2589 }
2590
2591 void RenderLayer::autoscroll(const IntPoint& position)
2592 {
2593     IntPoint currentDocumentPosition = renderer().view().frameView().windowToContents(position);
2594     scrollRectToVisible(LayoutRect(currentDocumentPosition, LayoutSize(1, 1)), ScrollAlignment::alignToEdgeIfNeeded, ScrollAlignment::alignToEdgeIfNeeded);
2595 }
2596
2597 bool RenderLayer::canResize() const
2598 {
2599     // We need a special case for <iframe> because they never have
2600     // hasOverflowClip(). However, they do "implicitly" clip their contents, so
2601     // we want to allow resizing them also.
2602     return (renderer().hasOverflowClip() || renderer().isRenderIFrame()) && renderer().style().resize() != RESIZE_NONE;
2603 }
2604
2605 void RenderLayer::resize(const PlatformMouseEvent& evt, const LayoutSize& oldOffset)
2606 {
2607     // FIXME: This should be possible on generated content but is not right now.
2608     if (!inResizeMode() || !canResize() || !renderer().element())
2609         return;
2610
2611     // FIXME: The only case where renderer->element()->renderer() != renderer is with continuations. Do they matter here?
2612     // If they do it would still be better to deal with them explicitly.
2613     Element* element = renderer().element();
2614     RenderBox* renderer = toRenderBox(element->renderer());
2615
2616     Document& document = element->document();
2617     if (!document.frame()->eventHandler().mousePressed())
2618         return;
2619
2620     float zoomFactor = renderer->style().effectiveZoom();
2621
2622     LayoutSize newOffset = offsetFromResizeCorner(document.view()->windowToContents(evt.position()));
2623     newOffset.setWidth(newOffset.width() / zoomFactor);
2624     newOffset.setHeight(newOffset.height() / zoomFactor);
2625     
2626     LayoutSize currentSize = LayoutSize(renderer->width() / zoomFactor, renderer->height() / zoomFactor);
2627     LayoutSize minimumSize = element->minimumSizeForResizing().shrunkTo(currentSize);
2628     element->setMinimumSizeForResizing(minimumSize);
2629     
2630     LayoutSize adjustedOldOffset = LayoutSize(oldOffset.width() / zoomFactor, oldOffset.height() / zoomFactor);
2631     if (renderer->style().shouldPlaceBlockDirectionScrollbarOnLogicalLeft()) {
2632         newOffset.setWidth(-newOffset.width());
2633         adjustedOldOffset.setWidth(-adjustedOldOffset.width());
2634     }
2635     
2636     LayoutSize difference = (currentSize + newOffset - adjustedOldOffset).expandedTo(minimumSize) - currentSize;
2637
2638     StyledElement* styledElement = toStyledElement(element);
2639     bool isBoxSizingBorder = renderer->style().boxSizing() == BORDER_BOX;
2640
2641     EResize resize = renderer->style().resize();
2642     if (resize != RESIZE_VERTICAL && difference.width()) {
2643         if (element->isFormControlElement()) {
2644             // Make implicit margins from the theme explicit (see <http://bugs.webkit.org/show_bug.cgi?id=9547>).
2645             styledElement->setInlineStyleProperty(CSSPropertyMarginLeft, renderer->marginLeft() / zoomFactor, CSSPrimitiveValue::CSS_PX);
2646             styledElement->setInlineStyleProperty(CSSPropertyMarginRight, renderer->marginRight() / zoomFactor, CSSPrimitiveValue::CSS_PX);
2647         }
2648         LayoutUnit baseWidth = renderer->width() - (isBoxSizingBorder ? LayoutUnit() : renderer->horizontalBorderAndPaddingExtent());
2649         baseWidth = baseWidth / zoomFactor;
2650         styledElement->setInlineStyleProperty(CSSPropertyWidth, roundToInt(baseWidth + difference.width()), CSSPrimitiveValue::CSS_PX);
2651     }
2652
2653     if (resize != RESIZE_HORIZONTAL && difference.height()) {
2654         if (element->isFormControlElement()) {
2655             // Make implicit margins from the theme explicit (see <http://bugs.webkit.org/show_bug.cgi?id=9547>).
2656             styledElement->setInlineStyleProperty(CSSPropertyMarginTop, renderer->marginTop() / zoomFactor, CSSPrimitiveValue::CSS_PX);
2657             styledElement->setInlineStyleProperty(CSSPropertyMarginBottom, renderer->marginBottom() / zoomFactor, CSSPrimitiveValue::CSS_PX);
2658         }
2659         LayoutUnit baseHeight = renderer->height() - (isBoxSizingBorder ? LayoutUnit() : renderer->verticalBorderAndPaddingExtent());
2660         baseHeight = baseHeight / zoomFactor;
2661         styledElement->setInlineStyleProperty(CSSPropertyHeight, roundToInt(baseHeight + difference.height()), CSSPrimitiveValue::CSS_PX);
2662     }
2663
2664     document.updateLayout();
2665
2666     // FIXME (Radar 4118564): We should also autoscroll the window as necessary to keep the point under the cursor in view.
2667 }
2668
2669 int RenderLayer::scrollSize(ScrollbarOrientation orientation) const
2670 {
2671     Scrollbar* scrollbar = ((orientation == HorizontalScrollbar) ? m_hBar : m_vBar).get();
2672     return scrollbar ? (scrollbar->totalSize() - scrollbar->visibleSize()) : 0;
2673 }
2674
2675 void RenderLayer::setScrollOffset(const IntPoint& offset)
2676 {
2677     scrollTo(offset.x(), offset.y());
2678 }
2679
2680 int RenderLayer::scrollPosition(Scrollbar* scrollbar) const
2681 {
2682     if (scrollbar->orientation() == HorizontalScrollbar)
2683         return scrollXOffset();
2684     if (scrollbar->orientation() == VerticalScrollbar)
2685         return scrollYOffset();
2686     return 0;
2687 }
2688
2689 IntPoint RenderLayer::scrollPosition() const
2690 {
2691     return IntPoint(m_scrollOffset);
2692 }
2693
2694 IntPoint RenderLayer::minimumScrollPosition() const
2695 {
2696     return -scrollOrigin();
2697 }
2698
2699 IntPoint RenderLayer::maximumScrollPosition() const
2700 {
2701     // FIXME: m_scrollSize may not be up-to-date if m_scrollDimensionsDirty is true.
2702     return -scrollOrigin() + roundedIntSize(m_scrollSize) - visibleContentRectIncludingScrollbars(ContentsVisibleRect).size();
2703 }
2704
2705 IntRect RenderLayer::visibleContentRectInternal(VisibleContentRectIncludesScrollbars scrollbarInclusion, VisibleContentRectBehavior) const
2706 {
2707     int verticalScrollbarWidth = 0;
2708     int horizontalScrollbarHeight = 0;
2709     if (showsOverflowControls() && scrollbarInclusion == IncludeScrollbars) {
2710         verticalScrollbarWidth = (verticalScrollbar() && !verticalScrollbar()->isOverlayScrollbar()) ? verticalScrollbar()->width() : 0;
2711         horizontalScrollbarHeight = (horizontalScrollbar() && !horizontalScrollbar()->isOverlayScrollbar()) ? horizontalScrollbar()->height() : 0;
2712     }
2713     
2714     return IntRect(IntPoint(scrollXOffset(), scrollYOffset()),
2715                    IntSize(std::max(0, m_layerSize.width() - verticalScrollbarWidth),
2716                            std::max(0, m_layerSize.height() - horizontalScrollbarHeight)));
2717 }
2718
2719 IntSize RenderLayer::overhangAmount() const
2720 {
2721     return IntSize();
2722 }
2723
2724 bool RenderLayer::isActive() const
2725 {
2726     Page* page = renderer().frame().page();
2727     return page && page->focusController().isActive();
2728 }
2729
2730 static int cornerStart(const RenderLayer* layer, int minX, int maxX, int thickness)
2731 {
2732     if (layer->renderer().style().shouldPlaceBlockDirectionScrollbarOnLogicalLeft())
2733         return minX + layer->renderer().style().borderLeftWidth();
2734     return maxX - thickness - layer->renderer().style().borderRightWidth();
2735 }
2736
2737 static LayoutRect cornerRect(const RenderLayer* layer, const LayoutRect& bounds)
2738 {
2739     int horizontalThickness;
2740     int verticalThickness;
2741     if (!layer->verticalScrollbar() && !layer->horizontalScrollbar()) {
2742         // FIXME: This isn't right.  We need to know the thickness of custom scrollbars
2743         // even when they don't exist in order to set the resizer square size properly.
2744         horizontalThickness = ScrollbarTheme::theme()->scrollbarThickness();
2745         verticalThickness = horizontalThickness;
2746     } else if (layer->verticalScrollbar() && !layer->horizontalScrollbar()) {
2747         horizontalThickness = layer->verticalScrollbar()->width();
2748         verticalThickness = horizontalThickness;
2749     } else if (layer->horizontalScrollbar() && !layer->verticalScrollbar()) {
2750         verticalThickness = layer->horizontalScrollbar()->height();
2751         horizontalThickness = verticalThickness;
2752     } else {
2753         horizontalThickness = layer->verticalScrollbar()->width();
2754         verticalThickness = layer->horizontalScrollbar()->height();
2755     }
2756     return LayoutRect(cornerStart(layer, bounds.x(), bounds.maxX(), horizontalThickness),
2757         bounds.maxY() - verticalThickness - layer->renderer().style().borderBottomWidth(),
2758         horizontalThickness, verticalThickness);
2759 }
2760
2761 IntRect RenderLayer::scrollCornerRect() const
2762 {
2763     // We have a scrollbar corner when a scrollbar is visible and not filling the entire length of the box.
2764     // This happens when:
2765     // (a) A resizer is present and at least one scrollbar is present
2766     // (b) Both scrollbars are present.
2767     bool hasHorizontalBar = horizontalScrollbar();
2768     bool hasVerticalBar = verticalScrollbar();
2769     bool hasResizer = renderer().style().resize() != RESIZE_NONE;
2770     if ((hasHorizontalBar && hasVerticalBar) || (hasResizer && (hasHorizontalBar || hasVerticalBar)))
2771         return pixelSnappedIntRect(cornerRect(this, renderBox()->borderBoxRect()));
2772     return IntRect();
2773 }
2774
2775 static LayoutRect resizerCornerRect(const RenderLayer* layer, const LayoutRect& bounds)
2776 {
2777     ASSERT(layer->renderer().isBox());
2778     if (layer->renderer().style().resize() == RESIZE_NONE)
2779         return LayoutRect();
2780     return cornerRect(layer, bounds);
2781 }
2782
2783 LayoutRect RenderLayer::scrollCornerAndResizerRect() const
2784 {
2785     RenderBox* box = renderBox();
2786     if (!box)
2787         return LayoutRect();
2788     LayoutRect scrollCornerAndResizer = scrollCornerRect();
2789     if (scrollCornerAndResizer.isEmpty())
2790         scrollCornerAndResizer = resizerCornerRect(this, box->borderBoxRect());
2791     return scrollCornerAndResizer;
2792 }
2793
2794 bool RenderLayer::isScrollCornerVisible() const
2795 {
2796     ASSERT(renderer().isBox());
2797     return !scrollCornerRect().isEmpty();
2798 }
2799
2800 IntRect RenderLayer::convertFromScrollbarToContainingView(const Scrollbar* scrollbar, const IntRect& scrollbarRect) const
2801 {
2802     IntRect rect = scrollbarRect;
2803     rect.move(scrollbarOffset(scrollbar));
2804
2805     return renderer().view().frameView().convertFromRenderer(&renderer(), rect);
2806 }
2807
2808 IntRect RenderLayer::convertFromContainingViewToScrollbar(const Scrollbar* scrollbar, const IntRect& parentRect) const
2809 {
2810     IntRect rect = renderer().view().frameView().convertToRenderer(&renderer(), parentRect);
2811     rect.move(-scrollbarOffset(scrollbar));
2812     return rect;
2813 }
2814
2815 IntPoint RenderLayer::convertFromScrollbarToContainingView(const Scrollbar* scrollbar, const IntPoint& scrollbarPoint) const
2816 {
2817     IntPoint point = scrollbarPoint;
2818     point.move(scrollbarOffset(scrollbar));
2819     return renderer().view().frameView().convertFromRenderer(&renderer(), point);
2820 }
2821
2822 IntPoint RenderLayer::convertFromContainingViewToScrollbar(const Scrollbar* scrollbar, const IntPoint& parentPoint) const
2823 {
2824     IntPoint point = renderer().view().frameView().convertToRenderer(&renderer(), parentPoint);
2825     point.move(-scrollbarOffset(scrollbar));
2826     return point;
2827 }
2828
2829 IntSize RenderLayer::contentsSize() const
2830 {
2831     return IntSize(scrollWidth(), scrollHeight());
2832 }
2833
2834 bool RenderLayer::shouldSuspendScrollAnimations() const
2835 {
2836     return renderer().view().frameView().shouldSuspendScrollAnimations();
2837 }
2838
2839 #if PLATFORM(IOS)
2840 void RenderLayer::didStartScroll()
2841 {
2842     if (Page* page = renderer().frame().page())
2843         page->chrome().client().didStartOverflowScroll();
2844 }
2845
2846 void RenderLayer::didEndScroll()
2847 {
2848     if (Page* page = renderer().frame().page())
2849         page->chrome().client().didEndOverflowScroll();
2850 }
2851     
2852 void RenderLayer::didUpdateScroll()
2853 {
2854     // Send this notification when we scroll, since this is how we keep selection updated.
2855     if (Page* page = renderer().frame().page())
2856         page->chrome().client().didLayout(ChromeClient::Scroll);
2857 }
2858 #endif
2859
2860 IntPoint RenderLayer::lastKnownMousePosition() const
2861 {
2862     return renderer().frame().eventHandler().lastKnownMousePosition();
2863 }
2864
2865 bool RenderLayer::isHandlingWheelEvent() const
2866 {
2867     return renderer().frame().eventHandler().isHandlingWheelEvent();
2868 }
2869
2870 IntRect RenderLayer::rectForHorizontalScrollbar(const IntRect& borderBoxRect) const
2871 {
2872     if (!m_hBar)
2873         return IntRect();
2874
2875     const RenderBox* box = renderBox();
2876     const IntRect& scrollCorner = scrollCornerRect();
2877
2878     return IntRect(horizontalScrollbarStart(borderBoxRect.x()),
2879         borderBoxRect.maxY() - box->borderBottom() - m_hBar->height(),
2880         borderBoxRect.width() - (box->borderLeft() + box->borderRight()) - scrollCorner.width(),
2881         m_hBar->height());
2882 }
2883
2884 IntRect RenderLayer::rectForVerticalScrollbar(const IntRect& borderBoxRect) const
2885 {
2886     if (!m_vBar)
2887         return IntRect();
2888
2889     const RenderBox* box = renderBox();
2890     const IntRect& scrollCorner = scrollCornerRect();
2891
2892     return IntRect(verticalScrollbarStart(borderBoxRect.x(), borderBoxRect.maxX()),
2893         borderBoxRect.y() + box->borderTop(),
2894         m_vBar->width(),
2895         borderBoxRect.height() - (box->borderTop() + box->borderBottom()) - scrollCorner.height());
2896 }
2897
2898 LayoutUnit RenderLayer::verticalScrollbarStart(int minX, int maxX) const
2899 {
2900     const RenderBox* box = renderBox();
2901     if (renderer().style().shouldPlaceBlockDirectionScrollbarOnLogicalLeft())
2902         return minX + box->borderLeft();
2903     return maxX - box->borderRight() - m_vBar->width();
2904 }
2905
2906 LayoutUnit RenderLayer::horizontalScrollbarStart(int minX) const
2907 {
2908     const RenderBox* box = renderBox();
2909     int x = minX + box->borderLeft();
2910     if (renderer().style().shouldPlaceBlockDirectionScrollbarOnLogicalLeft())
2911         x += m_vBar ? m_vBar->width() : roundToInt(resizerCornerRect(this, box->borderBoxRect()).width());
2912     return x;
2913 }
2914
2915 IntSize RenderLayer::scrollbarOffset(const Scrollbar* scrollbar) const
2916 {
2917     RenderBox* box = renderBox();
2918
2919     if (scrollbar == m_vBar.get())
2920         return IntSize(verticalScrollbarStart(0, box->width()), box->borderTop());
2921
2922     if (scrollbar == m_hBar.get())
2923         return IntSize(horizontalScrollbarStart(0), box->height() - box->borderBottom() - scrollbar->height());
2924     
2925     ASSERT_NOT_REACHED();
2926     return IntSize();
2927 }
2928
2929 void RenderLayer::invalidateScrollbarRect(Scrollbar* scrollbar, const IntRect& rect)
2930 {
2931     if (!showsOverflowControls())
2932         return;
2933
2934     if (scrollbar == m_vBar.get()) {
2935         if (GraphicsLayer* layer = layerForVerticalScrollbar()) {
2936             layer->setNeedsDisplayInRect(rect);
2937             return;
2938         }
2939     } else {
2940         if (GraphicsLayer* layer = layerForHorizontalScrollbar()) {
2941             layer->setNeedsDisplayInRect(rect);
2942             return;
2943         }
2944     }
2945
2946     IntRect scrollRect = rect;
2947     RenderBox* box = renderBox();
2948     ASSERT(box);
2949     // If we are not yet inserted into the tree, there is no need to repaint.
2950     if (!box->parent())
2951         return;
2952
2953     if (scrollbar == m_vBar.get())
2954         scrollRect.move(verticalScrollbarStart(0, box->width()), box->borderTop());
2955     else
2956         scrollRect.move(horizontalScrollbarStart(0), box->height() - box->borderBottom() - scrollbar->height());
2957     LayoutRect repaintRect = scrollRect;
2958     renderBox()->flipForWritingMode(repaintRect);
2959     renderer().repaintRectangle(repaintRect);
2960 }
2961
2962 void RenderLayer::invalidateScrollCornerRect(const IntRect& rect)
2963 {
2964     if (!showsOverflowControls())
2965         return;
2966
2967     if (GraphicsLayer* layer = layerForScrollCorner()) {
2968         layer->setNeedsDisplayInRect(rect);
2969         return;
2970     }
2971
2972     if (m_scrollCorner)
2973         m_scrollCorner->repaintRectangle(rect);
2974     if (m_resizer)
2975         m_resizer->repaintRectangle(rect);
2976 }
2977
2978 static inline RenderElement* rendererForScrollbar(RenderLayerModelObject& renderer)
2979 {
2980     if (Element* element = renderer.element()) {
2981         if (ShadowRoot* shadowRoot = element->containingShadowRoot()) {
2982             if (shadowRoot->type() == ShadowRoot::UserAgentShadowRoot)
2983                 return shadowRoot->hostElement()->renderer();
2984         }
2985     }
2986
2987     return &renderer;
2988 }
2989
2990 PassRefPtr<Scrollbar> RenderLayer::createScrollbar(ScrollbarOrientation orientation)
2991 {
2992     RefPtr<Scrollbar> widget;
2993     RenderElement* actualRenderer = rendererForScrollbar(renderer());
2994     bool hasCustomScrollbarStyle = actualRenderer->isBox() && actualRenderer->style().hasPseudoStyle(SCROLLBAR);
2995     if (hasCustomScrollbarStyle)
2996         widget = RenderScrollbar::createCustomScrollbar(this, orientation, actualRenderer->element());
2997     else {
2998         widget = Scrollbar::createNativeScrollbar(this, orientation, RegularScrollbar);
2999         didAddScrollbar(widget.get(), orientation);
3000     }
3001     renderer().view().frameView().addChild(widget.get());
3002     return widget.release();
3003 }
3004
3005 void RenderLayer::destroyScrollbar(ScrollbarOrientation orientation)
3006 {
3007     RefPtr<Scrollbar>& scrollbar = orientation == HorizontalScrollbar ? m_hBar : m_vBar;
3008     if (!scrollbar)
3009         return;
3010
3011     if (!scrollbar->isCustomScrollbar())
3012         willRemoveScrollbar(scrollbar.get(), orientation);
3013
3014     scrollbar->removeFromParent();
3015     scrollbar->disconnectFromScrollableArea();
3016     scrollbar = 0;
3017 }
3018
3019 bool RenderLayer::scrollsOverflow() const
3020 {
3021     if (!renderer().isBox())
3022         return false;
3023
3024     return toRenderBox(renderer()).scrollsOverflow();
3025 }
3026
3027 void RenderLayer::setHasHorizontalScrollbar(bool hasScrollbar)
3028 {
3029     if (hasScrollbar == hasHorizontalScrollbar())
3030         return;
3031
3032     if (hasScrollbar)
3033         m_hBar = createScrollbar(HorizontalScrollbar);
3034     else
3035         destroyScrollbar(HorizontalScrollbar);
3036
3037     // Destroying or creating one bar can cause our scrollbar corner to come and go.  We need to update the opposite scrollbar's style.
3038     if (m_hBar)
3039         m_hBar->styleChanged();
3040     if (m_vBar)
3041         m_vBar->styleChanged();
3042
3043     // Force an update since we know the scrollbars have changed things.
3044 #if ENABLE(DASHBOARD_SUPPORT)
3045     if (renderer().document().hasAnnotatedRegions())
3046         renderer().document().setAnnotatedRegionsDirty(true);
3047 #endif
3048 }
3049
3050 void RenderLayer::setHasVerticalScrollbar(bool hasScrollbar)
3051 {
3052     if (hasScrollbar == hasVerticalScrollbar())
3053         return;
3054
3055     if (hasScrollbar)
3056         m_vBar = createScrollbar(VerticalScrollbar);
3057     else
3058         destroyScrollbar(VerticalScrollbar);
3059
3060      // Destroying or creating one bar can cause our scrollbar corner to come and go.  We need to update the opposite scrollbar's style.
3061     if (m_hBar)
3062         m_hBar->styleChanged();
3063     if (m_vBar)
3064         m_vBar->styleChanged();
3065
3066     // Force an update since we know the scrollbars have changed things.
3067 #if ENABLE(DASHBOARD_SUPPORT)
3068     if (renderer().document().hasAnnotatedRegions())
3069         renderer().document().setAnnotatedRegionsDirty(true);
3070 #endif
3071 }
3072
3073 ScrollableArea* RenderLayer::enclosingScrollableArea() const
3074 {
3075     if (RenderLayer* scrollableLayer = enclosingScrollableLayer())
3076         return scrollableLayer;
3077
3078     // FIXME: We should return the frame view here (or possibly an ancestor frame view,
3079     // if the frame view isn't scrollable.
3080     return 0;
3081 }
3082
3083 int RenderLayer::verticalScrollbarWidth(OverlayScrollbarSizeRelevancy relevancy) const
3084 {
3085     if (!m_vBar
3086         || !showsOverflowControls()
3087         || (m_vBar->isOverlayScrollbar() && (relevancy == IgnoreOverlayScrollbarSize || !m_vBar->shouldParticipateInHitTesting())))
3088         return 0;
3089
3090     return m_vBar->width();
3091 }
3092
3093 int RenderLayer::horizontalScrollbarHeight(OverlayScrollbarSizeRelevancy relevancy) const
3094 {
3095     if (!m_hBar
3096         || !showsOverflowControls()
3097         || (m_hBar->isOverlayScrollbar() && (relevancy == IgnoreOverlayScrollbarSize || !m_hBar->shouldParticipateInHitTesting())))
3098         return 0;
3099
3100     return m_hBar->height();
3101 }
3102
3103 IntSize RenderLayer::offsetFromResizeCorner(const IntPoint& absolutePoint) const
3104 {
3105     // Currently the resize corner is either the bottom right corner or the bottom left corner.
3106     // FIXME: This assumes the location is 0, 0. Is this guaranteed to always be the case?
3107     IntSize elementSize = size();
3108     if (renderer().style().shouldPlaceBlockDirectionScrollbarOnLogicalLeft())
3109         elementSize.setWidth(0);
3110     IntPoint resizerPoint = IntPoint(elementSize);
3111     IntPoint localPoint = roundedIntPoint(absoluteToContents(absolutePoint));
3112     return localPoint - resizerPoint;
3113 }
3114
3115 bool RenderLayer::hasOverflowControls() const
3116 {
3117     return m_hBar || m_vBar || m_scrollCorner || renderer().style().resize() != RESIZE_NONE;
3118 }
3119
3120 void RenderLayer::positionOverflowControls(const IntSize& offsetFromRoot)
3121 {
3122     if (!m_hBar && !m_vBar && !canResize())
3123         return;
3124     
3125     RenderBox* box = renderBox();
3126     if (!box)
3127         return;
3128
3129     const IntRect borderBox = box->pixelSnappedBorderBoxRect();
3130     const IntRect& scrollCorner = scrollCornerRect();
3131     IntRect absBounds(borderBox.location() + offsetFromRoot, borderBox.size());
3132     if (m_vBar) {
3133         IntRect vBarRect = rectForVerticalScrollbar(borderBox);
3134         vBarRect.move(offsetFromRoot);
3135         m_vBar->setFrameRect(vBarRect);
3136     }
3137     
3138     if (m_hBar) {
3139         IntRect hBarRect = rectForHorizontalScrollbar(borderBox);
3140         hBarRect.move(offsetFromRoot);
3141         m_hBar->setFrameRect(hBarRect);
3142     }
3143     
3144     if (m_scrollCorner)
3145         m_scrollCorner->setFrameRect(scrollCorner);
3146     if (m_resizer)
3147         m_resizer->setFrameRect(resizerCornerRect(this, borderBox));
3148
3149     if (isComposited())
3150         backing()->positionOverflowControlsLayers();
3151 }
3152
3153 int RenderLayer::scrollWidth() const
3154 {
3155     ASSERT(renderBox());
3156     if (m_scrollDimensionsDirty)
3157         const_cast<RenderLayer*>(this)->computeScrollDimensions();
3158     return snapSizeToPixel(m_scrollSize.width(), renderBox()->clientLeft() + renderBox()->x());
3159 }
3160
3161 int RenderLayer::scrollHeight() const
3162 {
3163     ASSERT(renderBox());
3164     if (m_scrollDimensionsDirty)
3165         const_cast<RenderLayer*>(this)->computeScrollDimensions();
3166     return snapSizeToPixel(m_scrollSize.height(), renderBox()->clientTop() + renderBox()->y());
3167 }
3168
3169 LayoutUnit RenderLayer::overflowTop() const
3170 {
3171     RenderBox* box = renderBox();
3172     LayoutRect overflowRect(box->layoutOverflowRect());
3173     box->flipForWritingMode(overflowRect);
3174     return overflowRect.y();
3175 }
3176
3177 LayoutUnit RenderLayer::overflowBottom() const
3178 {
3179     RenderBox* box = renderBox();
3180     LayoutRect overflowRect(box->layoutOverflowRect());
3181     box->flipForWritingMode(overflowRect);
3182     return overflowRect.maxY();
3183 }
3184
3185 LayoutUnit RenderLayer::overflowLeft() const
3186 {
3187     RenderBox* box = renderBox();
3188     LayoutRect overflowRect(box->layoutOverflowRect());
3189     box->flipForWritingMode(overflowRect);
3190     return overflowRect.x();
3191 }
3192
3193 LayoutUnit RenderLayer::overflowRight() const
3194 {
3195     RenderBox* box = renderBox();
3196     LayoutRect overflowRect(box->layoutOverflowRect());
3197     box->flipForWritingMode(overflowRect);
3198     return overflowRect.maxX();
3199 }
3200
3201 void RenderLayer::computeScrollDimensions()
3202 {
3203     RenderBox* box = renderBox();
3204     ASSERT(box);
3205
3206     m_scrollDimensionsDirty = false;
3207
3208     m_scrollSize.setWidth(overflowRight() - overflowLeft());
3209     m_scrollSize.setHeight(overflowBottom() - overflowTop());
3210
3211     int scrollableLeftOverflow = overflowLeft() - box->borderLeft();
3212     int scrollableTopOverflow = overflowTop() - box->borderTop();
3213     setScrollOrigin(IntPoint(-scrollableLeftOverflow, -scrollableTopOverflow));
3214 }
3215
3216 bool RenderLayer::hasScrollableHorizontalOverflow() const
3217 {
3218     return hasHorizontalOverflow() && renderBox()->scrollsOverflowX();
3219 }
3220
3221 bool RenderLayer::hasScrollableVerticalOverflow() const
3222 {
3223     return hasVerticalOverflow() && renderBox()->scrollsOverflowY();
3224 }
3225
3226 bool RenderLayer::hasHorizontalOverflow() const
3227 {
3228     ASSERT(!m_scrollDimensionsDirty);
3229
3230     return scrollWidth() > renderBox()->pixelSnappedClientWidth();
3231 }
3232
3233 bool RenderLayer::hasVerticalOverflow() const
3234 {
3235     ASSERT(!m_scrollDimensionsDirty);
3236
3237     return scrollHeight() > renderBox()->pixelSnappedClientHeight();
3238 }
3239
3240 void RenderLayer::updateScrollbarsAfterLayout()
3241 {
3242     RenderBox* box = renderBox();
3243     ASSERT(box);
3244
3245     // List box parts handle the scrollbars by themselves so we have nothing to do.
3246     if (box->style().appearance() == ListboxPart)
3247         return;
3248
3249     bool hasHorizontalOverflow = this->hasHorizontalOverflow();
3250     bool hasVerticalOverflow = this->hasVerticalOverflow();
3251
3252     // overflow:scroll should just enable/disable.
3253     if (renderer().style().overflowX() == OSCROLL)
3254         m_hBar->setEnabled(hasHorizontalOverflow);
3255     if (renderer().style().overflowY() == OSCROLL)
3256         m_vBar->setEnabled(hasVerticalOverflow);
3257
3258     // overflow:auto may need to lay out again if scrollbars got added/removed.
3259     bool autoHorizontalScrollBarChanged = box->hasAutoHorizontalScrollbar() && (hasHorizontalScrollbar() != hasHorizontalOverflow);
3260     bool autoVerticalScrollBarChanged = box->hasAutoVerticalScrollbar() && (hasVerticalScrollbar() != hasVerticalOverflow);
3261
3262     if (autoHorizontalScrollBarChanged || autoVerticalScrollBarChanged) {
3263         if (box->hasAutoHorizontalScrollbar())
3264             setHasHorizontalScrollbar(hasHorizontalOverflow);
3265         if (box->hasAutoVerticalScrollbar())
3266             setHasVerticalScrollbar(hasVerticalOverflow);
3267
3268         updateSelfPaintingLayer();
3269
3270         // Force an update since we know the scrollbars have changed things.
3271 #if ENABLE(DASHBOARD_SUPPORT)
3272         if (renderer().document().hasAnnotatedRegions())
3273             renderer().document().setAnnotatedRegionsDirty(true);
3274 #endif
3275
3276         renderer().repaint();
3277
3278         if (renderer().style().overflowX() == OAUTO || renderer().style().overflowY() == OAUTO) {
3279             if (!m_inOverflowRelayout) {
3280                 // Our proprietary overflow: overlay value doesn't trigger a layout.
3281                 m_inOverflowRelayout = true;
3282                 renderer().setNeedsLayout(MarkOnlyThis);
3283                 if (renderer().isRenderBlock()) {
3284                     RenderBlock& block = toRenderBlock(renderer());
3285                     block.scrollbarsChanged(autoHorizontalScrollBarChanged, autoVerticalScrollBarChanged);
3286                     block.layoutBlock(true);
3287                 } else
3288                     renderer().layout();
3289                 m_inOverflowRelayout = false;
3290             }
3291         }
3292     }
3293
3294     // Set up the range (and page step/line step).
3295     if (m_hBar) {
3296         int clientWidth = box->pixelSnappedClientWidth();
3297         int pageStep = std::max(std::max<int>(clientWidth * Scrollbar::minFractionToStepWhenPaging(), clientWidth - Scrollbar::maxOverlapBetweenPages()), 1);
3298         m_hBar->setSteps(Scrollbar::pixelsPerLineStep(), pageStep);
3299         m_hBar->setProportion(clientWidth, m_scrollSize.width());
3300     }
3301     if (m_vBar) {
3302         int clientHeight = box->pixelSnappedClientHeight();
3303         int pageStep = std::max(std::max<int>(clientHeight * Scrollbar::minFractionToStepWhenPaging(), clientHeight - Scrollbar::maxOverlapBetweenPages()), 1);
3304         m_vBar->setSteps(Scrollbar::pixelsPerLineStep(), pageStep);
3305         m_vBar->setProportion(clientHeight, m_scrollSize.height());
3306     }
3307
3308     updateScrollableAreaSet(hasScrollableHorizontalOverflow() || hasScrollableVerticalOverflow());
3309 }
3310
3311 void RenderLayer::updateScrollInfoAfterLayout()
3312 {
3313     RenderBox* box = renderBox();
3314     if (!box)
3315         return;
3316
3317     m_scrollDimensionsDirty = true;
3318     IntSize originalScrollOffset = scrollOffset();
3319
3320     computeScrollDimensions();
3321
3322     if (box->style().overflowX() != OMARQUEE) {
3323         // Layout may cause us to be at an invalid scroll position. In this case we need
3324         // to pull our scroll offsets back to the max (or push them up to the min).
3325         IntSize clampedScrollOffset = clampScrollOffset(scrollOffset());
3326 #if PLATFORM(IOS)
3327         // FIXME: This looks wrong. The caret adjust mode should only be enabled on editing related entry points.
3328         // This code was added to fix an issue where the text insertion point would always be drawn on the right edge
3329         // of a text field whose content overflowed its bounds. See <rdar://problem/15579797> for more details.
3330         setAdjustForIOSCaretWhenScrolling(true);
3331 #endif
3332         if (clampedScrollOffset != scrollOffset())
3333             scrollToOffset(clampedScrollOffset);
3334
3335 #if PLATFORM(IOS)
3336         setAdjustForIOSCaretWhenScrolling(false);
3337 #endif
3338     }
3339
3340     updateScrollbarsAfterLayout();
3341
3342     if (originalScrollOffset != scrollOffset())
3343         scrollToOffsetWithoutAnimation(IntPoint(scrollOffset()));
3344
3345     // Composited scrolling may need to be enabled or disabled if the amount of overflow changed.
3346     if (compositor().updateLayerCompositingState(*this))
3347         compositor().setCompositingLayersNeedRebuild();
3348 }
3349
3350 bool RenderLayer::overflowControlsIntersectRect(const IntRect& localRect) const
3351 {
3352     const IntRect borderBox = renderBox()->pixelSnappedBorderBoxRect();
3353
3354     if (rectForHorizontalScrollbar(borderBox).intersects(localRect))
3355         return true;
3356
3357     if (rectForVerticalScrollbar(borderBox).intersects(localRect))
3358         return true;
3359
3360     if (scrollCornerRect().intersects(localRect))
3361         return true;
3362     
3363     if (resizerCornerRect(this, borderBox).intersects(localRect))
3364         return true;
3365
3366     return false;
3367 }
3368
3369 bool RenderLayer::showsOverflowControls() const
3370 {
3371 #if PLATFORM(IOS)
3372     // Don't render (custom) scrollbars if we have accelerated scrolling.
3373     if (hasAcceleratedTouchScrolling())
3374         return false;
3375 #endif
3376
3377     return true;
3378 }
3379
3380 void RenderLayer::paintOverflowControls(GraphicsContext* context, const IntPoint& paintOffset, const IntRect& damageRect, bool paintingOverlayControls)
3381 {
3382     // Don't do anything if we have no overflow.
3383     if (!renderer().hasOverflowClip())
3384         return;
3385
3386     if (!showsOverflowControls())
3387         return;
3388
3389     // Overlay scrollbars paint in a second pass through the layer tree so that they will paint
3390     // on top of everything else. If this is the normal painting pass, paintingOverlayControls
3391     // will be false, and we should just tell the root layer that there are overlay scrollbars
3392     // that need to be painted. That will cause the second pass through the layer tree to run,
3393     // and we'll paint the scrollbars then. In the meantime, cache tx and ty so that the 
3394     // second pass doesn't need to re-enter the RenderTree to get it right.
3395     if (hasOverlayScrollbars() && !paintingOverlayControls) {
3396         m_cachedOverlayScrollbarOffset = paintOffset;
3397
3398         // It's not necessary to do the second pass if the scrollbars paint into layers.
3399         if ((m_hBar && layerForHorizontalScrollbar()) || (m_vBar && layerForVerticalScrollbar()))
3400             return;
3401         IntRect localDamgeRect = damageRect;
3402         localDamgeRect.moveBy(-paintOffset);
3403         if (!overflowControlsIntersectRect(localDamgeRect))
3404             return;
3405
3406         RenderLayer* paintingRoot = enclosingCompositingLayer();