Source/WebCore/rendering/RenderLayer.cpp

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