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