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