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