Clean up some remaining obsolete coordinate-space naming.

third_party/WebKit/Source/core/frame/FrameView.cpp

 /*
  * Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
  *                     1999 Lars Knoll <knoll@kde.org>
  *                     1999 Antti Koivisto <koivisto@kde.org>
  *                     2000 Dirk Mueller <mueller@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *           (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
@@ skipping 2688 matching lines @@
 IntPoint FrameView::convertToLayoutObject(const LayoutObject& layoutObject, const IntPoint& framePoint) const
 {
     IntPoint point = framePoint;
 
     // Convert from FrameView coords into page ("absolute") coordinates.
     point += IntSize(scrollX(), scrollY());
 
     return roundedIntPoint(layoutObject.absoluteToLocal(point, UseTransforms));
 }
 
-IntRect FrameView::convertToContainingView(const IntRect& localRect) const
+IntRect FrameView::convertToContainingWidget(const IntRect& localRect) const
 {
     if (const FrameView* parentView = toFrameView(parent())) {
         // Get our layoutObject in the parent view
         LayoutPart* layoutObject = m_frame->ownerLayoutObject();
         if (!layoutObject)
             return localRect;
 
         IntRect rect(localRect);
         // Add borders and padding??
         rect.move(layoutObject->borderLeft() + layoutObject->paddingLeft(),
             layoutObject->borderTop() + layoutObject->paddingTop());
         return parentView->convertFromLayoutObject(*layoutObject, rect);
     }
 
     return localRect;
 }
 
-IntRect FrameView::convertFromContainingView(const IntRect& parentRect) const
+IntRect FrameView::convertFromContainingWidget(const IntRect& parentRect) const
 {
     if (const FrameView* parentView = toFrameView(parent())) {
         // Get our layoutObject in the parent view
         LayoutPart* layoutObject = m_frame->ownerLayoutObject();
         if (!layoutObject)
             return parentRect;
 
         IntRect rect = parentView->convertToLayoutObject(*layoutObject, parentRect);
         // Subtract borders and padding
         rect.move(-layoutObject->borderLeft() - layoutObject->paddingLeft(),
             -layoutObject->borderTop() - layoutObject->paddingTop());
         return rect;
     }
 
     return parentRect;
 }
 
-IntPoint FrameView::convertToContainingView(const IntPoint& localPoint) const
+IntPoint FrameView::convertToContainingWidget(const IntPoint& localPoint) const
 {
     if (const FrameView* parentView = toFrameView(parent())) {
         // Get our layoutObject in the parent view
         LayoutPart* layoutObject = m_frame->ownerLayoutObject();
         if (!layoutObject)
             return localPoint;
 
         IntPoint point(localPoint);
 
         // Add borders and padding
         point.move(layoutObject->borderLeft() + layoutObject->paddingLeft(),
             layoutObject->borderTop() + layoutObject->paddingTop());
         return parentView->convertFromLayoutObject(*layoutObject, point);
     }
 
     return localPoint;
 }
 
-IntPoint FrameView::convertFromContainingView(const IntPoint& parentPoint) const
+IntPoint FrameView::convertFromContainingWidget(const IntPoint& parentPoint) const
 {
     if (const FrameView* parentView = toFrameView(parent())) {
         // Get our layoutObject in the parent view
         LayoutPart* layoutObject = m_frame->ownerLayoutObject();
         if (!layoutObject)
             return parentPoint;
 
         IntPoint point = parentView->convertToLayoutObject(*layoutObject, parentPoint);
         // Subtract borders and padding
         point.move(-layoutObject->borderLeft() - layoutObject->paddingLeft(),
@@ skipping 454 matching lines @@
     }
 }
 
 IntRect FrameView::adjustScrollbarRectForResizer(const IntRect& rect, Scrollbar* scrollbar)
 {
     // Get our window resizer rect and see if we overlap. Adjust to avoid the overlap
     // if necessary.
     IntRect adjustedRect(rect);
     bool overlapsResizer = false;
     if (!rect.isEmpty() && !windowResizerRect().isEmpty()) {
-        IntRect resizerRect = convertFromContainingWindow(windowResizerRect());
+        IntRect resizerRect = convertFromRootFrame(windowResizerRect());
         if (rect.intersects(resizerRect)) {
             if (scrollbar->orientation() == HorizontalScrollbar) {
                 int overlap = rect.maxX() - resizerRect.x();
                 if (overlap > 0 && resizerRect.maxX() >= rect.maxX()) {
                     adjustedRect.setWidth(rect.width() - overlap);
                     overlapsResizer = true;
                 }
             } else {
                 int overlap = rect.maxY() - resizerRect.y();
                 if (overlap > 0 && resizerRect.maxY() >= rect.maxY()) {
@@ skipping 110 matching lines @@
     DoublePoint adjustedScrollPosition = clampScrollPosition(DoublePoint(offset));
 
     if (adjustedScrollPosition != scrollPositionDouble() || scrollOriginChanged()) {
         ScrollableArea::setScrollPosition(adjustedScrollPosition, ProgrammaticScroll);
         resetScrollOriginChanged();
     }
 }
 
 IntRect FrameView::rectToCopyOnScroll() const
 {
-    IntRect scrollViewRect = convertToContainingWindow(IntRect((shouldPlaceVerticalScrollbarOnLeft() && verticalScrollbar()) ? verticalScrollbar()->width() : 0, 0, visibleWidth(), visibleHeight()));
+    IntRect scrollViewRect = convertToRootFrame(IntRect((shouldPlaceVerticalScrollbarOnLeft() && verticalScrollbar()) ? verticalScrollbar()->width() : 0, 0, visibleWidth(), visibleHeight()));
     if (hasOverlayScrollbars()) {
         int verticalScrollbarWidth = (verticalScrollbar() && !hasLayerForVerticalScrollbar()) ? verticalScrollbar()->width() : 0;
         int horizontalScrollbarHeight = (horizontalScrollbar() && !hasLayerForHorizontalScrollbar()) ? horizontalScrollbar()->height() : 0;
 
         scrollViewRect.setWidth(scrollViewRect.width() - verticalScrollbarWidth);
         scrollViewRect.setHeight(scrollViewRect.height() - horizontalScrollbarHeight);
     }
     return scrollViewRect;
 }
 
@@ skipping 46 matching lines @@
     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 framePoint = convertFromContainingWindow(rootFramePoint);
+    IntPoint framePoint = convertFromRootFrame(rootFramePoint);
     return frameToContents(framePoint);
 }
 
 IntRect FrameView::rootFrameToContents(const IntRect& rootFrameRect) const
 {
     return IntRect(rootFrameToContents(rootFrameRect.location()), rootFrameRect.size());
 }
 
 IntPoint FrameView::contentsToRootFrame(const IntPoint& contentsPoint) const
 {
     IntPoint framePoint = contentsToFrame(contentsPoint);
-    return convertToContainingWindow(framePoint);
+    return convertToRootFrame(framePoint);
 }
 
 IntRect FrameView::contentsToRootFrame(const IntRect& contentsRect) const
 {
     IntRect rectInFrame = contentsToFrame(contentsRect);
-    return convertToContainingWindow(rectInFrame);
+    return convertToRootFrame(rectInFrame);
 }
 
-FloatPoint FrameView::rootFrameToContents(const FloatPoint& windowPoint) const
+FloatPoint FrameView::rootFrameToContents(const FloatPoint& pointInRootFrame) const
 {
-    FloatPoint framePoint = convertFromContainingWindow(windowPoint);
+    FloatPoint framePoint = convertFromRootFrame(pointInRootFrame);
     return frameToContents(framePoint);
 }
 
 IntRect FrameView::viewportToContents(const IntRect& rectInViewport) const
 {
     IntRect rectInRootFrame = m_frame->host()->visualViewport().viewportToRootFrame(rectInViewport);
-    IntRect frameRect = convertFromContainingWindow(rectInRootFrame);
+    IntRect frameRect = convertFromRootFrame(rectInRootFrame);
     return frameToContents(frameRect);
 }
 
 IntPoint FrameView::viewportToContents(const IntPoint& pointInViewport) const
 {
     IntPoint pointInRootFrame = m_frame->host()->visualViewport().viewportToRootFrame(pointInViewport);
-    IntPoint pointInFrame = convertFromContainingWindow(pointInRootFrame);
+    IntPoint pointInFrame = convertFromRootFrame(pointInRootFrame);
     return frameToContents(pointInFrame);
 }
 
 IntRect FrameView::contentsToViewport(const IntRect& rectInContents) const
 {
     IntRect rectInFrame = contentsToFrame(rectInContents);
-    IntRect rectInRootFrame = convertToContainingWindow(rectInFrame);
+    IntRect rectInRootFrame = convertToRootFrame(rectInFrame);
     return m_frame->host()->visualViewport().rootFrameToViewport(rectInRootFrame);
 }
 
 IntPoint FrameView::contentsToViewport(const IntPoint& pointInContents) const
 {
     IntPoint pointInFrame = contentsToFrame(pointInContents);
-    IntPoint pointInRootFrame = convertToContainingWindow(pointInFrame);
+    IntPoint pointInRootFrame = convertToRootFrame(pointInFrame);
     return m_frame->host()->visualViewport().rootFrameToViewport(pointInRootFrame);
 }
 
 IntRect FrameView::contentsToScreen(const IntRect& rect) const
 {
     HostWindow* window = hostWindow();
     if (!window)
         return IntRect();
     return window->viewportToScreen(contentsToViewport(rect));
 }
 
 IntRect FrameView::soonToBeRemovedContentsToUnscaledViewport(const IntRect& rectInContents) const
 {
     IntRect rectInFrame = contentsToFrame(rectInContents);
-    IntRect rectInRootFrame = convertToContainingWindow(rectInFrame);
+    IntRect rectInRootFrame = convertToRootFrame(rectInFrame);
     return enclosingIntRect(m_frame->host()->visualViewport().mainViewToViewportCSSPixels(rectInRootFrame));
 }
 
 IntPoint FrameView::soonToBeRemovedUnscaledViewportToContents(const IntPoint& pointInViewport) const
 {
     IntPoint pointInRootFrame = flooredIntPoint(m_frame->host()->visualViewport().viewportCSSPixelsToRootFrame(pointInViewport));
-    IntPoint pointInThisFrame = convertFromContainingWindow(pointInRootFrame);
+    IntPoint pointInThisFrame = convertFromRootFrame(pointInRootFrame);
     return frameToContents(pointInThisFrame);
 }
 
 bool FrameView::containsScrollbarsAvoidingResizer() const
 {
     return !m_scrollbarsAvoidingResizer;
 }
 
 void FrameView::adjustScrollbarsAvoidingResizerCount(int overlapDelta)
 {
     int oldCount = m_scrollbarsAvoidingResizer;
     m_scrollbarsAvoidingResizer += overlapDelta;
     if (parent()) {
         toFrameView(parent())->adjustScrollbarsAvoidingResizerCount(overlapDelta);
     } else if (!scrollbarsSuppressed()) {
         // If we went from n to 0 or from 0 to n and we're the outermost view,
         // we need to invalidate the windowResizerRect(), since it will now need to paint
         // differently.
         if ((oldCount > 0 && m_scrollbarsAvoidingResizer == 0)
             || (oldCount == 0 && m_scrollbarsAvoidingResizer > 0))
             invalidateRect(windowResizerRect());
     }
 }
 
 Scrollbar* FrameView::scrollbarAtRootFramePoint(const IntPoint& pointInRootFrame)
 {
-    IntPoint pointInFrame = convertFromContainingWindow(pointInRootFrame);
+    IntPoint pointInFrame = convertFromRootFrame(pointInRootFrame);
     return scrollbarAtFramePoint(pointInFrame);
 }
 
 Scrollbar* FrameView::scrollbarAtFramePoint(const IntPoint& pointInFrame)
 {
     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(pointInFrame))
         return m_verticalScrollbar.get();
     return nullptr;
@@ skipping 126 matching lines @@
     FramePainter(*this).paint(context, globalPaintFlags, cullRect);
 }
 
 void FrameView::paintContents(GraphicsContext* context, const GlobalPaintFlags globalPaintFlags, const IntRect& damageRect) const
 {
     if (shouldThrottleRendering())
         return;
     FramePainter(*this).paintContents(context, globalPaintFlags, damageRect);
 }
 
-bool FrameView::isPointInScrollbarCorner(const IntPoint& windowPoint)
+bool FrameView::isPointInScrollbarCorner(const IntPoint& pointInRootFrame)
 {
     if (!scrollbarCornerPresent())
         return false;
 
-    IntPoint framePoint = convertFromContainingWindow(windowPoint);
+    IntPoint framePoint = convertFromRootFrame(pointInRootFrame);
 
     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 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 framePoint.x() > verticalScrollbarXMin && framePoint.x() < verticalScrollbarXMax && framePoint.y() > verticalScrollbarYMin;
 }
 
 bool FrameView::scrollbarCornerPresent() const
 {
     return (m_horizontalScrollbar && width() - m_horizontalScrollbar->width() > 0)
         || (m_verticalScrollbar && height() - m_verticalScrollbar->height() > 0);
 }
 
-IntRect FrameView::convertFromScrollbarToContainingView(const Scrollbar* scrollbar, const IntRect& localRect) const
+IntRect FrameView::convertFromScrollbarToContainingWidget(const Scrollbar* scrollbar, const IntRect& localRect) const
 {
     // Scrollbars won't be transformed within us
     IntRect newRect = localRect;
     newRect.moveBy(scrollbar->location());
     return newRect;
 }
 
-IntRect FrameView::convertFromContainingViewToScrollbar(const Scrollbar* scrollbar, const IntRect& parentRect) const
+IntRect FrameView::convertFromContainingWidgetToScrollbar(const Scrollbar* scrollbar, const IntRect& parentRect) const
 {
     IntRect newRect = parentRect;
     // Scrollbars won't be transformed within us
     newRect.moveBy(-scrollbar->location());
     return newRect;
 }
 
 // FIXME: test these on windows
-IntPoint FrameView::convertFromScrollbarToContainingView(const Scrollbar* scrollbar, const IntPoint& localPoint) const
+IntPoint FrameView::convertFromScrollbarToContainingWidget(const Scrollbar* scrollbar, const IntPoint& localPoint) const
 {
     // Scrollbars won't be transformed within us
     IntPoint newPoint = localPoint;
     newPoint.moveBy(scrollbar->location());
     return newPoint;
 }
 
-IntPoint FrameView::convertFromContainingViewToScrollbar(const Scrollbar* scrollbar, const IntPoint& parentPoint) const
+IntPoint FrameView::convertFromContainingWidgetToScrollbar(const Scrollbar* scrollbar, const IntPoint& parentPoint) const
 {
     IntPoint newPoint = parentPoint;
     // Scrollbars won't be transformed within us
     newPoint.moveBy(-scrollbar->location());
     return newPoint;
 }
 
 void FrameView::setParentVisible(bool visible)
 {
     if (isParentVisible() == visible)
@@ skipping 237 matching lines @@
     return m_hiddenForThrottling && m_crossOriginForThrottling;
 }
 
 LayoutBox& FrameView::boxForScrollControlPaintInvalidation() const
 {
     ASSERT(layoutView());
     return *layoutView();
 }
 
 } // namespace blink