Audited and renamed uses of methods and variables named RootView

Source/core/frame/FrameView.cpp

Index: Source/core/frame/FrameView.cpp
diff --git a/Source/core/frame/FrameView.cpp b/Source/core/frame/FrameView.cpp
index 8a39570e8b213508269616b772b35f1171af8afe..3d09c5ac02b4fc45929fe691d9392ecc48e1ba7b 100644
--- a/Source/core/frame/FrameView.cpp
+++ b/Source/core/frame/FrameView.cpp
@@ -1743,21 +1743,19 @@ HostWindow* FrameView::hostWindow() const
     return &page->chrome();
 }
 
-void FrameView::contentRectangleForPaintInvalidation(const IntRect& rect)
+void FrameView::contentRectangleForPaintInvalidation(const IntRect& rectInContent)
 {
     ASSERT(!m_frame->ownerRenderer());
 
     if (m_isTrackingPaintInvalidations) {
-        IntRect paintInvalidationRect = rect;
-        paintInvalidationRect.move(-scrollOffset());
-        m_trackedPaintInvalidationRects.append(paintInvalidationRect);
+        m_trackedPaintInvalidationRects.append(contentsToFrame(rectInContent));
         // FIXME: http://crbug.com/368518. Eventually, invalidateContentRectangleForPaint
         // is going away entirely once all layout tests are FCM. In the short
         // term, no code should be tracking non-composited FrameView paint invalidations.
         RELEASE_ASSERT_NOT_REACHED();
     }
 
-    IntRect paintRect = rect;
+    IntRect paintRect = rectInContent;
     if (clipsPaintInvalidations())
         paintRect.intersect(visibleContentRect());
     if (paintRect.isEmpty())
@@ -2757,17 +2755,17 @@ IntRect FrameView::convertFromRenderer(const LayoutObject& renderer, const IntRe
     return rect;
 }
 
-IntRect FrameView::convertToRenderer(const LayoutObject& renderer, const IntRect& viewRect) const
+IntRect FrameView::convertToRenderer(const LayoutObject& renderer, const IntRect& frameRect) const
 {
-    IntRect rect = viewRect;
+    IntRect rectInContent = frameToContents(frameRect);
 
     // Convert from FrameView coords into page ("absolute") coordinates.
-    rect.moveBy(scrollPosition());
+    rectInContent.moveBy(scrollPosition());
 
     // FIXME: we don't have a way to map an absolute rect down to a local quad, so just
     // move the rect for now.
-    rect.setLocation(roundedIntPoint(renderer.absoluteToLocal(rect.location(), UseTransforms)));
-    return rect;
+    rectInContent.setLocation(roundedIntPoint(renderer.absoluteToLocal(rectInContent.location(), UseTransforms)));
+    return rectInContent;
 }
 
 IntPoint FrameView::convertFromRenderer(const LayoutObject& renderer, const IntPoint& rendererPoint) const
@@ -2779,9 +2777,9 @@ IntPoint FrameView::convertFromRenderer(const LayoutObject& renderer, const IntP
     return point;
 }
 
-IntPoint FrameView::convertToRenderer(const LayoutObject& renderer, const IntPoint& viewPoint) const
+IntPoint FrameView::convertToRenderer(const LayoutObject& renderer, const IntPoint& framePoint) const
 {
-    IntPoint point = viewPoint;
+    IntPoint point = framePoint;
 
     // Convert from FrameView coords into page ("absolute") coordinates.
     point += IntSize(scrollX(), scrollY());
@@ -3626,62 +3624,82 @@ void FrameView::scrollContents(const IntSize& scrollDelta)
     frameRectsChanged();
 }
 
-IntPoint FrameView::rootViewToContents(const IntPoint& rootViewPoint) const
+IntPoint FrameView::contentsToFrame(const IntPoint& pointInContentSpace) const
+{
+    return pointInContentSpace - scrollOffset();
+}
+
+IntRect FrameView::contentsToFrame(const IntRect& rectInContentSpace) const
+{
+    return IntRect(contentsToFrame(rectInContentSpace.location()), rectInContentSpace.size());
+}
+
+FloatPoint FrameView::frameToContents(const FloatPoint& pointInFrame) const
+{
+    return pointInFrame + scrollOffset();
+}
+
+IntPoint FrameView::frameToContents(const IntPoint& pointInFrame) const
+{
+    return pointInFrame + scrollOffset();
+}
+
+IntRect FrameView::frameToContents(const IntRect& rectInFrame) const
+{
+    return IntRect(frameToContents(rectInFrame.location()), rectInFrame.size());
+}
+
+IntPoint FrameView::rootFrameToContents(const IntPoint& rootFramePoint) const
 {
-    IntPoint viewPoint = convertFromContainingWindow(rootViewPoint);
-    return viewPoint + scrollOffset();
+    IntPoint framePoint = convertFromContainingWindow(rootFramePoint);
+    return frameToContents(framePoint);
 }
 
-IntPoint FrameView::contentsToRootView(const IntPoint& contentsPoint) const
+IntRect FrameView::rootFrameToContents(const IntRect& rootFrameRect) const
 {
-    IntPoint viewPoint = contentsPoint - scrollOffset();
-    return convertToContainingWindow(viewPoint);
+    return IntRect(rootFrameToContents(rootFrameRect.location()), rootFrameRect.size());
 }
 
-IntRect FrameView::rootViewToContents(const IntRect& rootViewRect) const
+IntPoint FrameView::contentsToRootFrame(const IntPoint& contentsPoint) const
 {
-    IntRect viewRect = convertFromContainingWindow(rootViewRect);
-    viewRect.move(scrollOffset());
-    return viewRect;
+    IntPoint framePoint = contentsToFrame(contentsPoint);
+    return convertToContainingWindow(framePoint);
 }
 
-IntRect FrameView::contentsToRootView(const IntRect& contentsRect) const
+IntRect FrameView::contentsToRootFrame(const IntRect& contentsRect) const
 {
-    IntRect viewRect = contentsRect;
-    viewRect.move(-scrollOffset());
-    return convertToContainingWindow(viewRect);
+    IntRect rectInFrame = contentsToFrame(contentsRect);
+    return convertToContainingWindow(rectInFrame);
 }
 
 IntPoint FrameView::windowToContents(const IntPoint& windowPoint) const
 {
-    IntPoint viewPoint = convertFromContainingWindow(windowPoint);
-    return viewPoint + scrollOffset();
+    IntPoint framePoint = convertFromContainingWindow(windowPoint);
+    return frameToContents(framePoint);
 }
 
 FloatPoint FrameView::windowToContents(const FloatPoint& windowPoint) const
 {
-    FloatPoint viewPoint = convertFromContainingWindow(windowPoint);
-    return viewPoint + scrollOffset();
+    FloatPoint framePoint = convertFromContainingWindow(windowPoint);
+    return frameToContents(framePoint);
 }
 
 IntPoint FrameView::contentsToWindow(const IntPoint& contentsPoint) const
 {
-    IntPoint viewPoint = contentsPoint - scrollOffset();
-    return convertToContainingWindow(viewPoint);
+    IntPoint framePoint = contentsToFrame(contentsPoint);
+    return convertToContainingWindow(framePoint);
 }
 
 IntRect FrameView::windowToContents(const IntRect& windowRect) const
 {
-    IntRect viewRect = convertFromContainingWindow(windowRect);
-    viewRect.move(scrollOffset());
-    return viewRect;
+    IntRect rectInFrame = convertFromContainingWindow(windowRect);
+    return frameToContents(rectInFrame);
 }
 
 IntRect FrameView::contentsToWindow(const IntRect& contentsRect) const
 {
-    IntRect viewRect = contentsRect;
-    viewRect.move(-scrollOffset());
-    return convertToContainingWindow(viewRect);
+    IntRect rectInFrame = contentsToFrame(contentsRect);
+    return convertToContainingWindow(rectInFrame);
 }
 
 IntRect FrameView::contentsToScreen(const IntRect& rect) const
@@ -3689,7 +3707,7 @@ IntRect FrameView::contentsToScreen(const IntRect& rect) const
     HostWindow* window = hostWindow();
     if (!window)
         return IntRect();
-    return window->rootViewToScreen(contentsToRootView(rect));
+    return window->viewportToScreen(contentsToWindow(rect));
 }
 
 bool FrameView::containsScrollbarsAvoidingResizer() const
@@ -3733,15 +3751,15 @@ void FrameView::setScrollbarsSuppressed(bool suppressed, bool repaintOnUnsuppres
 
 Scrollbar* FrameView::scrollbarAtWindowPoint(const IntPoint& windowPoint)
 {
-    IntPoint viewPoint = convertFromContainingWindow(windowPoint);
-    return scrollbarAtViewPoint(viewPoint);
+    IntPoint pointInFrame = convertFromContainingWindow(windowPoint);
+    return scrollbarAtFramePoint(pointInFrame);
 }
 
-Scrollbar* FrameView::scrollbarAtViewPoint(const IntPoint& viewPoint)
+Scrollbar* FrameView::scrollbarAtFramePoint(const IntPoint& pointInFrame)
 {
-    if (m_horizontalScrollbar && m_horizontalScrollbar->shouldParticipateInHitTesting() && m_horizontalScrollbar->frameRect().contains(viewPoint))
+    if (m_horizontalScrollbar && m_horizontalScrollbar->shouldParticipateInHitTesting() && m_horizontalScrollbar->frameRect().contains(pointInFrame))
         return m_horizontalScrollbar.get();
-    if (m_verticalScrollbar && m_verticalScrollbar->shouldParticipateInHitTesting() && m_verticalScrollbar->frameRect().contains(viewPoint))
+    if (m_verticalScrollbar && m_verticalScrollbar->shouldParticipateInHitTesting() && m_verticalScrollbar->frameRect().contains(pointInFrame))
         return m_verticalScrollbar.get();
     return nullptr;
 }
@@ -3921,21 +3939,21 @@ bool FrameView::isPointInScrollbarCorner(const IntPoint& windowPoint)
     if (!scrollbarCornerPresent())
         return false;
 
-    IntPoint viewPoint = convertFromContainingWindow(windowPoint);
+    IntPoint framePoint = convertFromContainingWindow(windowPoint);
 
     if (m_horizontalScrollbar) {
         int horizontalScrollbarYMin = m_horizontalScrollbar->frameRect().y();
         int horizontalScrollbarYMax = m_horizontalScrollbar->frameRect().y() + m_horizontalScrollbar->frameRect().height();
         int horizontalScrollbarXMin = m_horizontalScrollbar->frameRect().x() + m_horizontalScrollbar->frameRect().width();
 
-        return viewPoint.y() > horizontalScrollbarYMin && viewPoint.y() < horizontalScrollbarYMax && viewPoint.x() > horizontalScrollbarXMin;
+        return framePoint.y() > horizontalScrollbarYMin && framePoint.y() < horizontalScrollbarYMax && framePoint.x() > horizontalScrollbarXMin;
     }
 
     int verticalScrollbarXMin = m_verticalScrollbar->frameRect().x();
     int verticalScrollbarXMax = m_verticalScrollbar->frameRect().x() + m_verticalScrollbar->frameRect().width();
     int verticalScrollbarYMin = m_verticalScrollbar->frameRect().y() + m_verticalScrollbar->frameRect().height();
 
-    return viewPoint.x() > verticalScrollbarXMin && viewPoint.x() < verticalScrollbarXMax && viewPoint.y() > verticalScrollbarYMin;
+    return framePoint.x() > verticalScrollbarXMin && framePoint.x() < verticalScrollbarXMax && framePoint.y() > verticalScrollbarYMin;
 }
 
 bool FrameView::scrollbarCornerPresent() const