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