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