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