Clip scrollbars to box bounds when they don't fit.

third_party/WebKit/Source/core/layout/compositing/CompositedLayerMapping.cpp

 /*
  * Copyright (C) 2009, 2010, 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 531 matching lines @@
     } else if (layoutObject->isVideo()) {
         HTMLMediaElement* mediaElement = toHTMLMediaElement(layoutObject->node());
         m_graphicsLayer->setContentsToPlatformLayer(mediaElement->platformLayer());
     } else if (isAcceleratedCanvas(layoutObject)) {
         HTMLCanvasElement* canvas = toHTMLCanvasElement(layoutObject->node());
         if (CanvasRenderingContext* context = canvas->renderingContext())
             m_graphicsLayer->setContentsToPlatformLayer(context->platformLayer());
         layerConfigChanged = true;
     }
     if (layoutObject->isLayoutPart()) {
-        if (PaintLayerCompositor::parentFrameContentLayers(toLayoutPart(layoutObject)))
+        if (PaintLayerCompositor::attachFrameContentLayersToIframeLayer(toLayoutPart(layoutObject)))
             layerConfigChanged = true;
     }
 
     // Changes to either the internal hierarchy or the mask layer have an impact
     // on painting phases, so we need to update when either are updated.
     if (layerConfigChanged || maskLayerChanged)
         updatePaintingPhases();
 
     return layerConfigChanged;
 }
@@ skipping 140 matching lines @@
     IntRect relativeCompositingBounds;
     LayoutPoint offsetFromCompositedAncestor;
     IntPoint snappedOffsetFromCompositedAncestor;
     computeBoundsOfOwningLayer(compositingContainer, localCompositingBounds, relativeCompositingBounds, offsetFromCompositedAncestor, snappedOffsetFromCompositedAncestor);
 
     IntPoint graphicsLayerParentLocation;
     computeGraphicsLayerParentLocation(compositingContainer, ancestorCompositingBounds, graphicsLayerParentLocation);
 
     // Might update graphicsLayerParentLocation.
     updateAncestorClippingLayerGeometry(compositingContainer, snappedOffsetFromCompositedAncestor, graphicsLayerParentLocation);
-    updateOverflowControlsHostLayerGeometry(compositingStackingContext, compositingContainer);
 
     FloatSize contentsSize(relativeCompositingBounds.size());
 
     updateMainGraphicsLayerGeometry(relativeCompositingBounds, localCompositingBounds, graphicsLayerParentLocation);
+    updateOverflowControlsHostLayerGeometry(compositingStackingContext, compositingContainer);
     updateContentsOffsetInCompositingLayer(snappedOffsetFromCompositedAncestor, graphicsLayerParentLocation);
     updateSquashingLayerGeometry(offsetFromCompositedAncestor, graphicsLayerParentLocation, m_owningLayer, m_squashedLayers, m_squashingLayer.get(), &m_squashingLayerOffsetFromTransformedAncestor, layersNeedingPaintInvalidation);
 
     // If we have a layer that clips children, position it.
     IntRect clippingBox;
     if (m_childContainmentLayer)
         clippingBox = clipBox(toLayoutBox(layoutObject()));
 
     updateChildTransformLayerGeometry();
     updateChildContainmentLayerGeometry(clippingBox, localCompositingBounds);
@@ skipping 94 matching lines @@
 
     // The primary layer is then parented in, and positioned relative to this clipping layer.
     graphicsLayerParentLocation = parentClipRect.location();
 }
 
 void CompositedLayerMapping::updateOverflowControlsHostLayerGeometry(const PaintLayer* compositingStackingContext, const PaintLayer* compositingContainer)
 {
     if (!m_overflowControlsHostLayer)
         return;
 
+    LayoutPoint hostLayerPosition;
+
     if (needsToReparentOverflowControls()) {
-        if (m_overflowControlsClippingLayer) {
-            m_overflowControlsClippingLayer->setSize(m_ancestorClippingLayer->size());
-            m_overflowControlsClippingLayer->setOffsetFromLayoutObject(m_ancestorClippingLayer->offsetFromLayoutObject());
-            m_overflowControlsClippingLayer->setMasksToBounds(true);
-            m_overflowControlsHostLayer->setPosition(IntPoint(-m_overflowControlsClippingLayer->offsetFromLayoutObject()));
+        if (m_overflowControlsAncestorClippingLayer) {
+            m_overflowControlsAncestorClippingLayer->setSize(m_ancestorClippingLayer->size());
+            m_overflowControlsAncestorClippingLayer->setOffsetFromLayoutObject(m_ancestorClippingLayer->offsetFromLayoutObject());
+            m_overflowControlsAncestorClippingLayer->setMasksToBounds(true);
+            hostLayerPosition = toLayoutPoint(LayoutSize(-m_overflowControlsAncestorClippingLayer->offsetFromLayoutObject()));
 
             FloatPoint position = m_ancestorClippingLayer->position();
             if (compositingStackingContext != compositingContainer) {
                 LayoutPoint offset;
                 compositingContainer->convertToLayerCoords(compositingStackingContext, offset);
                 FloatSize offsetFromStackingContainer = toFloatSize(FloatPoint(offset));
                 position += offsetFromStackingContainer;
             }
 
-            m_overflowControlsClippingLayer->setPosition(position);
+            m_overflowControlsAncestorClippingLayer->setPosition(position);
         } else {
             // The controls are in the same 2D space as the compositing container, so we can map them into the space of the container.
             TransformState transformState(TransformState::ApplyTransformDirection, FloatPoint());
             m_owningLayer.layoutObject()->mapLocalToContainer(compositingStackingContext->layoutObject(), transformState, ApplyContainerFlip);
             transformState.flatten();
-            LayoutPoint offsetFromStackingContainer = LayoutPoint(transformState.lastPlanarPoint());
+            hostLayerPosition = LayoutPoint(transformState.lastPlanarPoint());
             if (PaintLayerScrollableArea* scrollableArea = compositingStackingContext->scrollableArea())
-                offsetFromStackingContainer.move(LayoutSize(scrollableArea->adjustedScrollOffset()));
-            m_overflowControlsHostLayer->setPosition(FloatPoint(offsetFromStackingContainer));
+                hostLayerPosition.move(LayoutSize(scrollableArea->adjustedScrollOffset()));
         }
-    } else {
-        m_overflowControlsHostLayer->setPosition(FloatPoint());
     }
+
+    // To clip correctly, m_overflowControlsHostLayer should match the border box rect, which is at
+    // the origin of the LayoutObject. The parent is m_graphicsLayer, so we must adjust the position
+    // by the distance from m_graphicsLayer to the LayoutObject.
+
+    IntSize offsetFromLayoutObject = m_graphicsLayer->offsetFromLayoutObject() - roundedIntSize(m_owningLayer.subpixelAccumulation());
+    hostLayerPosition.move(-offsetFromLayoutObject);
+    m_overflowControlsHostLayer->setPosition(FloatPoint(hostLayerPosition));
+
+    const IntRect borderBox = toLayoutBox(m_owningLayer.layoutObject())->pixelSnappedBorderBoxRect();
+    m_overflowControlsHostLayer->setSize(FloatSize(borderBox.size()));
+    m_overflowControlsHostLayer->setMasksToBounds(true);
 }
 
 void CompositedLayerMapping::updateChildContainmentLayerGeometry(const IntRect& clippingBox, const IntRect& localCompositingBounds)
 {
     if (!m_childContainmentLayer)
         return;
 
     FloatPoint clipPositionInLayoutObjectSpace(clippingBox.location() - localCompositingBounds.location() + roundedIntSize(m_owningLayer.subpixelAccumulation()));
 
     // If there are layers between the the child containment layer and
@@ skipping 226 matching lines @@
     };
 
     updateBottomLayer(m_childTransformLayer.get());
     updateBottomLayer(m_childContainmentLayer.get());
     updateBottomLayer(m_scrollingLayer.get());
 
     // Now constructing the subtree for the overflow controls.
     bottomLayer = m_graphicsLayer.get();
     if (m_isMainFrameLayoutViewLayer)
         bottomLayer = layoutObject()->frame()->page()->frameHost().visualViewport().containerLayer();
-    updateBottomLayer(m_overflowControlsClippingLayer.get());
+    updateBottomLayer(m_overflowControlsAncestorClippingLayer.get());
     updateBottomLayer(m_overflowControlsHostLayer.get());
     if (m_layerForHorizontalScrollbar)
         m_overflowControlsHostLayer->addChild(m_layerForHorizontalScrollbar.get());
     if (m_layerForVerticalScrollbar)
         m_overflowControlsHostLayer->addChild(m_layerForVerticalScrollbar.get());
     if (m_layerForScrollCorner)
         m_overflowControlsHostLayer->addChild(m_layerForScrollCorner.get());
 
     // The squashing containment layer, if it exists, becomes a no-op parent.
     if (m_squashingLayer) {
@@ skipping 220 matching lines @@
     needsHorizontalScrollbarLayer &= !invisible;
     needsVerticalScrollbarLayer &= !invisible;
     needsScrollCornerLayer &= !invisible;
 
     bool horizontalScrollbarLayerChanged = toggleScrollbarLayerIfNeeded(m_layerForHorizontalScrollbar, needsHorizontalScrollbarLayer, CompositingReasonLayerForHorizontalScrollbar);
     bool verticalScrollbarLayerChanged = toggleScrollbarLayerIfNeeded(m_layerForVerticalScrollbar, needsVerticalScrollbarLayer, CompositingReasonLayerForVerticalScrollbar);
     bool scrollCornerLayerChanged = toggleScrollbarLayerIfNeeded(m_layerForScrollCorner, needsScrollCornerLayer, CompositingReasonLayerForScrollCorner);
 
     bool needsOverflowControlsHostLayer = needsHorizontalScrollbarLayer || needsVerticalScrollbarLayer || needsScrollCornerLayer;
     toggleScrollbarLayerIfNeeded(m_overflowControlsHostLayer, needsOverflowControlsHostLayer, CompositingReasonLayerForOverflowControlsHost);
-    bool needsOverflowClipLayer = needsOverflowControlsHostLayer && needsAncestorClip;
-    toggleScrollbarLayerIfNeeded(m_overflowControlsClippingLayer, needsOverflowClipLayer, CompositingReasonLayerForOverflowControlsHost);
+    bool needsOverflowAncestorClipLayer = needsOverflowControlsHostLayer && needsAncestorClip;
+    toggleScrollbarLayerIfNeeded(m_overflowControlsAncestorClippingLayer, needsOverflowAncestorClipLayer, CompositingReasonLayerForOverflowControlsHost);
 
     if (ScrollingCoordinator* scrollingCoordinator = scrollingCoordinatorFromLayer(m_owningLayer)) {
         if (horizontalScrollbarLayerChanged)
             scrollingCoordinator->scrollableAreaScrollbarLayerDidChange(m_owningLayer.scrollableArea(), HorizontalScrollbar);
         if (verticalScrollbarLayerChanged)
             scrollingCoordinator->scrollableAreaScrollbarLayerDidChange(m_owningLayer.scrollableArea(), VerticalScrollbar);
     }
 
     return horizontalScrollbarLayerChanged || verticalScrollbarLayerChanged || scrollCornerLayerChanged;
 }
 
 void CompositedLayerMapping::positionOverflowControlsLayers()
 {
-    IntSize offsetFromLayoutObject = m_graphicsLayer->offsetFromLayoutObject() - roundedIntSize(m_owningLayer.subpixelAccumulation());
     if (GraphicsLayer* layer = layerForHorizontalScrollbar()) {
         Scrollbar* hBar = m_owningLayer.scrollableArea()->horizontalScrollbar();
         if (hBar) {
-            layer->setPosition(hBar->frameRect().location() - offsetFromLayoutObject);
+            layer->setPosition(hBar->frameRect().location());
             layer->setSize(FloatSize(hBar->frameRect().size()));
             if (layer->hasContentsLayer())
                 layer->setContentsRect(IntRect(IntPoint(), hBar->frameRect().size()));
         }
         layer->setDrawsContent(hBar && !layer->hasContentsLayer());
     }
 
     if (GraphicsLayer* layer = layerForVerticalScrollbar()) {
         Scrollbar* vBar = m_owningLayer.scrollableArea()->verticalScrollbar();
         if (vBar) {
-            layer->setPosition(vBar->frameRect().location() - offsetFromLayoutObject);
+            layer->setPosition(vBar->frameRect().location());
             layer->setSize(FloatSize(vBar->frameRect().size()));
             if (layer->hasContentsLayer())
                 layer->setContentsRect(IntRect(IntPoint(), vBar->frameRect().size()));
         }
         layer->setDrawsContent(vBar && !layer->hasContentsLayer());
     }
 
     if (GraphicsLayer* layer = layerForScrollCorner()) {
         const IntRect& scrollCornerAndResizer = m_owningLayer.scrollableArea()->scrollCornerAndResizerRect();
-        layer->setPosition(FloatPoint(scrollCornerAndResizer.location() - offsetFromLayoutObject));
+        layer->setPosition(FloatPoint(scrollCornerAndResizer.location()));
         layer->setSize(FloatSize(scrollCornerAndResizer.size()));
         layer->setDrawsContent(!scrollCornerAndResizer.isEmpty());
     }
 }
 
 enum ApplyToGraphicsLayersModeFlags {
     ApplyToLayersAffectedByPreserve3D = (1 << 0),
     ApplyToSquashingLayer = (1 << 1),
     ApplyToScrollbarLayers = (1 << 2),
     ApplyToBackgroundLayer = (1 << 3),
@@ skipping 554 matching lines @@
 
 bool CompositedLayerMapping::needsToReparentOverflowControls() const
 {
     return m_owningLayer.scrollableArea()
         && m_owningLayer.scrollableArea()->hasOverlayScrollbars()
         && m_owningLayer.scrollableArea()->topmostScrollChild();
 }
 
 GraphicsLayer* CompositedLayerMapping::detachLayerForOverflowControls(const PaintLayer& enclosingLayer)
 {
-    GraphicsLayer* host = m_overflowControlsClippingLayer.get();
+    GraphicsLayer* host = m_overflowControlsAncestorClippingLayer.get();
     if (!host)
         host = m_overflowControlsHostLayer.get();
     host->removeFromParent();
     return host;
 }
 
 GraphicsLayer* CompositedLayerMapping::parentForSublayers() const
 {
     if (m_scrollingBlockSelectionLayer)
         return m_scrollingBlockSelectionLayer.get();
 
     if (m_scrollingContentsLayer)
         return m_scrollingContentsLayer.get();
 
     if (m_childContainmentLayer)
         return m_childContainmentLayer.get();
 
     if (m_childTransformLayer)
         return m_childTransformLayer.get();
 
     return m_graphicsLayer.get();
 }
 
+void CompositedLayerMapping::setSublayers(const GraphicsLayerVector& sublayers)
+{
+    GraphicsLayer* overflowControlsContainer = m_overflowControlsAncestorClippingLayer
+        ? m_overflowControlsAncestorClippingLayer.get()
+        : m_overflowControlsHostLayer.get();
+    GraphicsLayer* parent = parentForSublayers();
+    bool needsOverflowControlsReattached = overflowControlsContainer && overflowControlsContainer->parent() == parent;
+
+    parent->setChildren(sublayers);
+
+    // If we have scrollbars, but are not using composited scrolling, then parentForSublayers may return m_graphicsLayer.
+    // In that case, the above call to setChildren has clobbered the overflow controls host layer, so we need to reattach it.
+    if (needsOverflowControlsReattached)
+        parent->addChild(overflowControlsContainer);
+}
+
 GraphicsLayer* CompositedLayerMapping::childForSuperlayers() const
 {
     if (m_squashingContainmentLayer)
         return m_squashingContainmentLayer.get();
 
     if (m_ancestorClippingLayer)
         return m_ancestorClippingLayer.get();
 
     return m_graphicsLayer.get();
 }
@@ skipping 501 matching lines @@
     } else if (graphicsLayer == m_childClippingMaskLayer.get()) {
         name = "Child Clipping Mask Layer";
     } else if (graphicsLayer == m_layerForHorizontalScrollbar.get()) {
         name = "Horizontal Scrollbar Layer";
     } else if (graphicsLayer == m_layerForVerticalScrollbar.get()) {
         name = "Vertical Scrollbar Layer";
     } else if (graphicsLayer == m_layerForScrollCorner.get()) {
         name = "Scroll Corner Layer";
     } else if (graphicsLayer == m_overflowControlsHostLayer.get()) {
         name = "Overflow Controls Host Layer";
-    } else if (graphicsLayer == m_overflowControlsClippingLayer.get()) {
-        name = "Overflow Controls ClipLayer Layer";
+    } else if (graphicsLayer == m_overflowControlsAncestorClippingLayer.get()) {
+        name = "Overflow Controls Ancestor Clipping Layer";
     } else if (graphicsLayer == m_scrollingLayer.get()) {
         name = "Scrolling Layer";
     } else if (graphicsLayer == m_scrollingContentsLayer.get()) {
         name = "Scrolling Contents Layer";
     } else if (graphicsLayer == m_scrollingBlockSelectionLayer.get()) {
         name = "Scrolling Block Selection Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace blink