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