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