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