Fix placement of overlay scrollbars on high DPI with box shadow.

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 790 matching lines @@
 
     IntPoint graphicsLayerParentLocation;
     computeGraphicsLayerParentLocation(compositingContainer, ancestorCompositingBounds, graphicsLayerParentLocation);
 
     // Might update graphicsLayerParentLocation.
     updateAncestorClippingLayerGeometry(compositingContainer, snappedOffsetFromCompositedAncestor, graphicsLayerParentLocation);
 
     FloatSize contentsSize(relativeCompositingBounds.size());
 
     updateMainGraphicsLayerGeometry(relativeCompositingBounds, localCompositingBounds, graphicsLayerParentLocation);
-    updateOverflowControlsHostLayerGeometry(compositingStackingContext, compositingContainer);
+    updateOverflowControlsHostLayerGeometry(compositingStackingContext, compositingContainer, graphicsLayerParentLocation);
     updateContentsOffsetInCompositingLayer(snappedOffsetFromCompositedAncestor, graphicsLayerParentLocation);
     updateSquashingLayerGeometry(graphicsLayerParentLocation, compositingContainer, 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 83 matching lines @@
     m_ancestorClippingLayer->setPosition(FloatPoint(parentClipRect.location() - graphicsLayerParentLocation));
     m_ancestorClippingLayer->setSize(FloatSize(parentClipRect.size()));
 
     // backgroundRect is relative to compositingContainer, so subtract snappedOffsetFromCompositedAncestor.X/snappedOffsetFromCompositedAncestor.Y to get back to local coords.
     m_ancestorClippingLayer->setOffsetFromLayoutObject(parentClipRect.location() - snappedOffsetFromCompositedAncestor);
 
     // 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)
+void CompositedLayerMapping::updateOverflowControlsHostLayerGeometry(const PaintLayer* compositingStackingContext, const PaintLayer* compositingContainer, IntPoint graphicsLayerParentLocation)
 {
     if (!m_overflowControlsHostLayer)
         return;
 
+    // To position and clip the scrollbars correctly, m_overflowControlsHostLayer should match our
+    // border box rect, which is at the origin of our LayoutObject. Its position is computed in
+    // various ways depending on who its parent GraphicsLayer is going to be.
     LayoutPoint hostLayerPosition;
 
     if (needsToReparentOverflowControls()) {
+        CompositedLayerMapping* stackingCLM = compositingStackingContext->compositedLayerMapping();
+        DCHECK(stackingCLM);
+
+        // Either m_overflowControlsHostLayer or m_overflowControlsAncestorClippingLayer (if it
+        // exists) will be a child of the main GraphicsLayer of the compositing stacking context.
+        IntSize stackingOffsetFromLayoutObject = stackingCLM->mainGraphicsLayer()->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;
+            FloatPoint position;
+            if (compositingStackingContext == compositingContainer) {
+                position = m_ancestorClippingLayer->position();
+            } else {
+                // graphicsLayerParentLocation is the location of m_ancestorClippingLayer
+                // relative to compositingContainer (including any offset from
+                // compositingContainer's m_childContainmentLayer).
+                LayoutPoint offset = LayoutPoint(graphicsLayerParentLocation);
                 compositingContainer->convertToLayerCoords(compositingStackingContext, offset);
-                FloatSize offsetFromStackingContainer = toFloatSize(FloatPoint(offset));
-                position += offsetFromStackingContainer;
+                position = FloatPoint(offset) - FloatSize(stackingOffsetFromLayoutObject);
             }
 
             m_overflowControlsAncestorClippingLayer->setPosition(position);
+            hostLayerPosition.move(-m_ancestorClippingLayer->offsetFromLayoutObject());
         } 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()->mapLocalToAncestor(compositingStackingContext->layoutObject(), transformState, ApplyContainerFlip);
             transformState.flatten();
             hostLayerPosition = LayoutPoint(transformState.lastPlanarPoint());
             if (PaintLayerScrollableArea* scrollableArea = compositingStackingContext->getScrollableArea())
                 hostLayerPosition.move(LayoutSize(scrollableArea->adjustedScrollOffset()));
+            hostLayerPosition.move(-stackingOffsetFromLayoutObject);
         }
+    } else {
+        hostLayerPosition.move(-m_graphicsLayer->offsetFromLayoutObject());
     }
 
-    // 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)
@@ skipping 1786 matching lines @@
     } else if (graphicsLayer == m_scrollingContentsLayer.get()) {
         name = "Scrolling Contents Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace blink