Exclude border from overflow scroller in sticky constraints.

third_party/WebKit/Source/core/layout/LayoutBoxModelObject.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  *           (C) 2005, 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 786 matching lines @@
       containingBlock->isLayoutView()
           ? containingBlock->logicalWidth()
           : containingBlock->containingBlockLogicalWidthForContent();
   // Sticky positioned element ignore any override logical width on the
   // containing block, as they don't call containingBlockLogicalWidthForContent.
   // It's unclear whether this is totally fine.
   // Compute the container-relative area within which the sticky element is
   // allowed to move.
   LayoutUnit maxWidth = containingBlock->availableLogicalWidth();
 
-  // Map the containing block to the scroll ancestor without transforms.
+  // Map the containing block to the inner corner of the scroll ancestor without
+  // transforms.
   FloatRect scrollContainerRelativePaddingBoxRect(
       containingBlock->layoutOverflowRect());
+  FloatSize scrollContainerBorderOffset;
+  if (scrollAncestor) {
+    scrollContainerBorderOffset =
+        FloatSize(scrollAncestor->borderLeft(), scrollAncestor->borderTop());
+  }
   if (containingBlock != scrollAncestor) {
     FloatQuad localQuad(FloatRect(containingBlock->paddingBoxRect()));
     TransformState transformState(TransformState::ApplyTransformDirection,
                                   localQuad.boundingBox().center(), localQuad);
     containingBlock->mapLocalToAncestor(scrollAncestor, transformState,
                                         ApplyContainerFlip);
     transformState.flatten();
     scrollContainerRelativePaddingBoxRect =
         transformState.lastPlanarQuad().boundingBox();
 
     // The sticky position constraint rects should be independent of the current
     // scroll position, so after mapping we add in the scroll position to get
     // the container's position within the ancestor scroller's unscrolled layout
     // overflow.
     ScrollOffset scrollOffset(
         scrollAncestor
             ? toFloatSize(scrollAncestor->getScrollableArea()->scrollPosition())
             : FloatSize());
     scrollContainerRelativePaddingBoxRect.move(scrollOffset);
   }
+  // Remove top-left border offset from overflow scroller.
+  scrollContainerRelativePaddingBoxRect.move(-scrollContainerBorderOffset);
 
   LayoutRect scrollContainerRelativeContainingBlockRect(
       scrollContainerRelativePaddingBoxRect);
   // This is removing the padding of the containing block's overflow rect to get
   // the flow box rectangle and removing the margin of the sticky element to
   // ensure that space between the sticky element and its containing flow box.
   // It is an open issue whether the margin should collapse.
   // See https://www.w3.org/TR/css-position-3/#sticky-pos
   scrollContainerRelativeContainingBlockRect.contractEdges(
       minimumValueForLength(containingBlock->style()->paddingTop(),
@@ skipping 15 matching lines @@
   FloatRect stickyBoxRect =
       isLayoutInline() ? FloatRect(toLayoutInline(this)->linesBoundingBox())
                        : FloatRect(toLayoutBox(this)->frameRect());
   FloatRect flippedStickyBoxRect = stickyBoxRect;
   containingBlock->flipForWritingMode(flippedStickyBoxRect);
   FloatPoint stickyLocation =
       flippedStickyBoxRect.location() + skippedContainersOffset;
 
   // The scrollContainerRelativePaddingBoxRect's position is the padding box so
   // we need to remove the border when finding the position of the sticky box
-  // within the scroll ancestor if the container is not our scroll ancestor.
-  if (containingBlock != scrollAncestor) {
-    FloatSize containerBorderOffset(containingBlock->borderLeft(),
-                                    containingBlock->borderTop());
-    stickyLocation -= containerBorderOffset;
-  }
+  // within the scroll ancestor if the container is not our scroll ancestor. If
+  // the container is our scroll ancestor, we also need to remove the border
+  // box because we want the position from within the scroller border.
+  FloatSize containerBorderOffset(containingBlock->borderLeft(),
+                                  containingBlock->borderTop());
+  stickyLocation -= containerBorderOffset;
   constraints.setScrollContainerRelativeStickyBoxRect(
       FloatRect(scrollContainerRelativePaddingBoxRect.location() +
                     toFloatSize(stickyLocation),
                 flippedStickyBoxRect.size()));
 
   // We skip the right or top sticky offset if there is not enough space to
   // honor both the left/right or top/bottom offsets.
   LayoutUnit horizontalOffsets =
       minimumValueForLength(style()->right(),
                             LayoutUnit(constrainingSize.width())) +
@@ skipping 61 matching lines @@
 FloatRect LayoutBoxModelObject::computeStickyConstrainingRect() const {
   if (layer()->ancestorOverflowLayer()->isRootLayer())
     return view()->frameView()->visibleContentRect();
 
   LayoutBox* enclosingClippingBox =
       toLayoutBox(layer()->ancestorOverflowLayer()->layoutObject());
   FloatRect constrainingRect;
   constrainingRect =
       FloatRect(enclosingClippingBox->overflowClipRect(LayoutPoint(DoublePoint(
           enclosingClippingBox->getScrollableArea()->scrollPosition()))));
-  constrainingRect.move(enclosingClippingBox->paddingLeft(),
-                        enclosingClippingBox->paddingTop());
+  constrainingRect.move(
+      -enclosingClippingBox->borderLeft() + enclosingClippingBox->paddingLeft(),
+      -enclosingClippingBox->borderTop() + enclosingClippingBox->paddingTop());
   constrainingRect.contract(
       FloatSize(enclosingClippingBox->paddingLeft() +
                     enclosingClippingBox->paddingRight(),
                 enclosingClippingBox->paddingTop() +
                     enclosingClippingBox->paddingBottom()));
   return constrainingRect;
 }
 
 LayoutSize LayoutBoxModelObject::stickyPositionOffset() const {
   const PaintLayer* ancestorOverflowLayer = layer()->ancestorOverflowLayer();
@@ skipping 375 matching lines @@
   if (rootElementStyle->hasBackground())
     return false;
 
   if (node() != document().firstBodyElement())
     return false;
 
   return true;
 }
 
 }  // namespace blink