Use viewportConstrainedVisibleContentRect() to get the scrolling offset

Source/core/rendering/RenderView.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple 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
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 226 matching lines @@
 {
     ASSERT_UNUSED(wasFixed, !wasFixed || *wasFixed == static_cast<bool>(mode & IsFixed));
 
     if (!paintInvalidationContainer && mode & UseTransforms && shouldUseTransformFromContainer(0)) {
         TransformationMatrix t;
         getTransformFromContainer(0, LayoutSize(), t);
         transformState.applyTransform(t);
     }
 
     if ((mode & IsFixed) && m_frameView) {
-        transformState.move(m_frameView->scrollOffsetForFixedPosition());
+        transformState.move(m_frameView->scrollOffsetForViewportConstrainedObjects());
         // IsFixed flag is only applicable within this RenderView.
         mode &= ~IsFixed;
     }
 
     if (paintInvalidationContainer == this)
         return;
 
     if (mode & TraverseDocumentBoundaries) {
         if (RenderObject* parentDocRenderer = frame()->ownerRenderer()) {
             transformState.move(-frame()->view()->scrollOffset());
             if (parentDocRenderer->isBox())
                 transformState.move(toRenderBox(parentDocRenderer)->contentBoxOffset());
             parentDocRenderer->mapLocalToContainer(paintInvalidationContainer, transformState, mode, wasFixed, paintInvalidationState);
             return;
         }
     }
 }
 
 const RenderObject* RenderView::pushMappingToContainer(const RenderLayerModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const
 {
     LayoutSize offsetForFixedPosition;
     LayoutSize offset;
     RenderObject* container = 0;
 
     if (m_frameView)
-        offsetForFixedPosition = LayoutSize(m_frameView->scrollOffsetForFixedPosition());
+        offsetForFixedPosition = LayoutSize(m_frameView->scrollOffsetForViewportConstrainedObjects());
 
     if (geometryMap.mapCoordinatesFlags() & TraverseDocumentBoundaries) {
         if (RenderPart* parentDocRenderer = frame()->ownerRenderer()) {
             offset = -LayoutSize(m_frameView->scrollOffset());
             offset += parentDocRenderer->contentBoxOffset();
             container = parentDocRenderer;
         }
     }
 
     // If a container was specified, and was not 0 or the RenderView, then we
     // should have found it by now unless we're traversing to a parent document.
     ASSERT_ARG(ancestorToStopAt, !ancestorToStopAt || ancestorToStopAt == this || container);
 
     if ((!ancestorToStopAt || container) && shouldUseTransformFromContainer(container)) {
         TransformationMatrix t;
         getTransformFromContainer(container, LayoutSize(), t);
         geometryMap.push(this, t, false, false, false, true, offsetForFixedPosition);
     } else {
         geometryMap.push(this, offset, false, false, false, false, offsetForFixedPosition);
     }
 
     return container;
 }
 
 void RenderView::mapAbsoluteToLocalPoint(MapCoordinatesFlags mode, TransformState& transformState) const
 {
     if (mode & IsFixed && m_frameView)
-        transformState.move(m_frameView->scrollOffsetForFixedPosition());
+        transformState.move(m_frameView->scrollOffsetForViewportConstrainedObjects());
 
     if (mode & UseTransforms && shouldUseTransformFromContainer(0)) {
         TransformationMatrix t;
         getTransformFromContainer(0, LayoutSize(), t);
         transformState.applyTransform(t);
     }
 }
 
 void RenderView::computeSelfHitTestRects(Vector<LayoutRect>& rects, const LayoutPoint&) const
 {
@@ skipping 101 matching lines @@
         obj->mapRectToPaintInvalidationBacking(paintInvalidationContainer, rect, 0);
     }
 }
 
 void RenderView::adjustViewportConstrainedOffset(LayoutRect& rect, ViewportConstrainedPosition viewportConstraint) const
 {
     if (viewportConstraint != IsFixedPosition)
         return;
 
     if (m_frameView) {
-        rect.move(m_frameView->scrollOffsetForFixedPosition());
+        rect.move(m_frameView->scrollOffsetForViewportConstrainedObjects());
 
         // FIXME: Paint invalidation should happen after scroll updates, so there should be no pending scroll delta.
         // However, we still have paint invalidation during layout, so we can't ASSERT for now. crbug.com/434950.
         // ASSERT(m_frameView->pendingScrollDelta().isZero());
         // If we have a pending scroll, invalidate the previous scroll position.
         if (!m_frameView->pendingScrollDelta().isZero())
             rect.move(-LayoutSize(m_frameView->pendingScrollDelta()));
     }
 }
 
@@ skipping 541 matching lines @@
     return viewWidth(IncludeScrollbars) / scale;
 }
 
 double RenderView::layoutViewportHeight() const
 {
     float scale = m_frameView ? m_frameView->frame().pageZoomFactor() : 1;
     return viewHeight(IncludeScrollbars) / scale;
 }
 
 } // namespace blink