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