Only anchor along the block layout axis.

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

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/layout/ScrollAnchor.h"
 
 #include "core/frame/FrameView.h"
 #include "core/frame/UseCounter.h"
 #include "core/layout/LayoutBlockFlow.h"
 #include "core/layout/api/LayoutBoxItem.h"
@@ skipping 39 matching lines @@
     LayoutBox* box = scroller->layoutBox();
     DCHECK(box);
     return box;
 }
 
 static LayoutBoxItem scrollerLayoutBoxItem(const ScrollableArea* scroller)
 {
     return LayoutBoxItem(scrollerLayoutBox(scroller));
 }
 
-static Corner cornerFromCandidateRect(const LayoutObject* layoutObject)
+static Corner cornerToAnchor(const ScrollableArea* scroller)
 {
-    ASSERT(layoutObject);
-    if (layoutObject->style()->isFlippedBlocksWritingMode()
-        || !layoutObject->style()->isLeftToRightDirection())
+    const ComputedStyle* style = scrollerLayoutBox(scroller)->style();
+    if (style->isFlippedBlocksWritingMode() || !style->isLeftToRightDirection())
         return Corner::TopRight;
     return Corner::TopLeft;
 }
 
 static LayoutPoint cornerPointOfRect(LayoutRect rect, Corner whichCorner)
 {
     switch (whichCorner) {
     case Corner::TopLeft: return rect.minXMinYCorner();
     case Corner::TopRight: return rect.maxXMinYCorner();
     }
@@ skipping 78 matching lines @@
     if (candidate->style()->overflowAnchor() == AnchorNone)
         return ExamineResult(Skip);
 
     LayoutRect candidateRect = relativeBounds(candidate, m_scroller);
     LayoutRect visibleRect = scrollerLayoutBoxItem(m_scroller).overflowClipRect(LayoutPoint());
 
     bool occupiesSpace = candidateRect.width() > 0 && candidateRect.height() > 0;
     if (occupiesSpace && visibleRect.intersects(candidateRect)) {
         return ExamineResult(
             visibleRect.contains(candidateRect) ? Return : Constrain,
-            cornerFromCandidateRect(candidate));
+            cornerToAnchor(m_scroller));
     } else {
         return ExamineResult(Skip);
     }
 }
 
 void ScrollAnchor::findAnchor()
 {
     TRACE_EVENT0("blink", "ScrollAnchor::findAnchor");
     SCOPED_BLINK_UMA_HISTOGRAM_TIMER("Layout.ScrollAnchor.TimeToFindAnchor");
 
@@ skipping 37 matching lines @@
         current = current->parent();
     }
 }
 
 void ScrollAnchor::save()
 {
     if (m_saved)
         return;
     m_saved = true;
     DCHECK(m_scroller);
-    if (m_scroller->scrollPosition() == IntPoint::zero()) {
+
+    ScrollbarOrientation blockLayoutAxis =
+        scrollerLayoutBox(m_scroller)->isHorizontalWritingMode() ? VerticalScrollbar : HorizontalScrollbar;
+    if (m_scroller->scrollPosition(blockLayoutAxis) == 0) {
         clear();
         return;
     }
 
     if (!m_anchorObject) {
         findAnchor();
         if (!m_anchorObject)
             return;
 
         m_anchorObject->setIsScrollAnchorObject();
         m_savedRelativeOffset = computeRelativeOffset(
             m_anchorObject, m_scroller, m_corner);
     }
 
     // Note that we must compute this during save() since the scroller's
     // descendants have finished layout (and had the bit cleared) by the
     // time restore() is called.
     m_scrollAnchorDisablingStyleChanged = computeScrollAnchorDisablingStyleChanged();
 }
 
 IntSize ScrollAnchor::computeAdjustment() const
 {
     // The anchor node can report fractional positions, but it is DIP-snapped when
     // painting (crbug.com/610805), so we must round the offsets to determine the
     // visual delta. If we scroll by the delta in LayoutUnits, the snapping of the
     // anchor node may round differently from the snapping of the scroll position.
     // (For example, anchor moving from 2.4px -> 2.6px is really 2px -> 3px, so we
     // should scroll by 1px instead of 0.2px.) This is true regardless of whether
     // the ScrollableArea actually uses fractional scroll positions.
-    return roundedIntSize(computeRelativeOffset(m_anchorObject, m_scroller, m_corner)) -
+    IntSize delta = roundedIntSize(computeRelativeOffset(m_anchorObject, m_scroller, m_corner)) -
         roundedIntSize(m_savedRelativeOffset);
+
+    // Only adjust on the block layout axis.
+    if (scrollerLayoutBox(m_scroller)->isHorizontalWritingMode())
+        delta.setWidth(0);
+    else
+        delta.setHeight(0);
+    return delta;
 }
 
 void ScrollAnchor::restore()
 {
     if (!m_saved)
         return;
     m_saved = false;
     DCHECK(m_scroller);
     if (!m_anchorObject)
         return;
@@ skipping 37 matching lines @@
     return m_anchorObject == layoutObject;
 }
 
 void ScrollAnchor::notifyRemoved(LayoutObject* layoutObject)
 {
     if (m_anchorObject == layoutObject)
         clear();
 }
 
 } // namespace blink