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