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