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