Update WebLocalFrameImpl and RotationViewportAnchor for root layer scrolling.

Source/web/RotationViewportAnchor.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 "config.h"
 #include "web/RotationViewportAnchor.h"
 
 #include "core/dom/ContainerNode.h"
 #include "core/dom/Node.h"
 #include "core/frame/FrameView.h"
@@ skipping 83 matching lines @@
 
 RotationViewportAnchor::~RotationViewportAnchor()
 {
     restoreToAnchor();
 }
 
 void RotationViewportAnchor::setAnchor()
 {
     // FIXME: Scroll offsets are now fractional (DoublePoint and FloatPoint for the FrameView and PinchViewport
     //        respectively. This path should be rewritten without pixel snapping.
-    IntRect outerViewRect = m_rootFrameView->visibleContentRect();
+    IntRect outerViewRect = m_rootFrameView->layoutViewportScrollableArea()->visibleContentRect();
     IntRect innerViewRect = enclosedIntRect(m_rootFrameView->scrollableArea()->visibleContentRectDouble());
 
     m_oldPageScaleFactor = m_pinchViewport->scale();
     m_oldMinimumPageScaleFactor = m_pageScaleConstraintsSet.finalConstraints().minimumScale;
 
     // Save the absolute location in case we won't find the anchor node, we'll fall back to that.
     m_pinchViewportInDocument = FloatPoint(m_rootFrameView->scrollableArea()->visibleContentRectDouble().location());
 
     m_anchorNode.clear();
     m_anchorNodeBounds = LayoutRect();
@@ skipping 38 matching lines @@
     newPageScaleFactor = m_pageScaleConstraintsSet.finalConstraints().clampToConstraints(newPageScaleFactor);
 
     FloatSize pinchViewportSize = m_pinchViewport->size();
     pinchViewportSize.scale(1 / newPageScaleFactor);
 
     IntPoint mainFrameOrigin;
     FloatPoint pinchViewportOrigin;
 
     computeOrigins(pinchViewportSize, mainFrameOrigin, pinchViewportOrigin);
 
-    m_rootFrameView->setScrollPosition(mainFrameOrigin, ProgrammaticScroll);
+    m_rootFrameView->layoutViewportScrollableArea()->setScrollPosition(mainFrameOrigin, ProgrammaticScroll);
 
     // Set scale before location, since location can be clamped on setting scale.
     m_pinchViewport->setScale(newPageScaleFactor);
     m_pinchViewport->setLocation(pinchViewportOrigin);
 }
 
 void RotationViewportAnchor::computeOrigins(const FloatSize& innerSize, IntPoint& mainFrameOffset, FloatPoint& pinchViewportOffset) const
 {
-    IntSize outerSize = m_rootFrameView->visibleContentRect().size();
+    IntSize outerSize = m_rootFrameView->layoutViewportScrollableArea()->visibleContentRect().size();
 
     // Compute the viewport origins in CSS pixels relative to the document.
     FloatSize absPinchViewportOffset = m_normalizedPinchViewportOffset;
     absPinchViewportOffset.scale(outerSize.width(), outerSize.height());
 
     FloatPoint innerOrigin = getInnerOrigin(innerSize);
     FloatPoint outerOrigin = innerOrigin - absPinchViewportOffset;
 
     IntRect outerRect = IntRect(flooredIntPoint(outerOrigin), outerSize);
     FloatRect innerRect = FloatRect(innerOrigin, innerSize);
 
     moveToEncloseRect(outerRect, innerRect);
 
-    outerRect.setLocation(m_rootFrameView->clampScrollPosition(outerRect.location()));
+    outerRect.setLocation(m_rootFrameView->layoutViewportScrollableArea()->clampScrollPosition(outerRect.location()));
 
     moveIntoRect(innerRect, outerRect);
 
     mainFrameOffset = outerRect.location();
     pinchViewportOffset = FloatPoint(innerRect.location() - outerRect.location());
 }
 
 FloatPoint RotationViewportAnchor::getInnerOrigin(const FloatSize& innerSize) const
 {
     if (!m_anchorNode || !m_anchorNode->inDocument())
         return m_pinchViewportInDocument;
 
     const LayoutRect currentNodeBounds = m_anchorNode->boundingBox();
     if (m_anchorNodeBounds == currentNodeBounds)
         return m_pinchViewportInDocument;
 
     // Compute the new anchor point relative to the node position
     FloatSize anchorOffsetFromNode(currentNodeBounds.size());
     anchorOffsetFromNode.scale(m_anchorInNodeCoords.width(), m_anchorInNodeCoords.height());
     FloatPoint anchorPoint = FloatPoint(currentNodeBounds.location()) + anchorOffsetFromNode;
 
     // Compute the new origin point relative to the new anchor point
     FloatSize anchorOffsetFromOrigin = innerSize;
     anchorOffsetFromOrigin.scale(m_anchorInInnerViewCoords.width(), m_anchorInInnerViewCoords.height());
     return anchorPoint - anchorOffsetFromOrigin;
 }
 
 } // namespace blink