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