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