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