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