Removed FrameView's windowToContents and contentsToWindow methods.

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 1708 matching lines @@
         RELEASE_ASSERT_NOT_REACHED();
     }
 
     IntRect paintRect = rectInContent;
     if (clipsPaintInvalidations())
         paintRect.intersect(visibleContentRect());
     if (paintRect.isEmpty())
         return;
 
     if (HostWindow* window = hostWindow())
-        window->invalidateRect(contentsToWindow(paintRect));
+        window->invalidateRect(contentsToRootFrame(paintRect));
 }
 
 void FrameView::contentsResized()
 {
     if (m_frame->isMainFrame() && m_frame->document()) {
         if (TextAutosizer* textAutosizer = m_frame->document()->textAutosizer())
             textAutosizer->updatePageInfoInAllFrames();
     }
 
     ScrollableArea::contentsResized();
@@ skipping 403 matching lines @@
         m_frame->document()->enqueueAnimationFrameEvent(event.release());
     }
 
 }
 
 IntRect FrameView::windowClipRect(IncludeScrollbarsInRect scrollbarInclusion) const
 {
     ASSERT(m_frame->view() == this);
 
     // Set our clip rect to be our contents.
-    IntRect clipRect = contentsToWindow(visibleContentRect(scrollbarInclusion));
+    IntRect clipRect = contentsToRootFrame(visibleContentRect(scrollbarInclusion));
     if (!m_frame->deprecatedLocalOwner())
         return clipRect;
 
     // Take our owner element and get its clip rect.
     // FIXME: Do we need to do this for remote frames?
     HTMLFrameOwnerElement* ownerElement = m_frame->deprecatedLocalOwner();
     FrameView* parentView = ownerElement->document().view();
     if (parentView)
         clipRect.intersect(parentView->windowClipRectForFrameOwner(ownerElement));
     return clipRect;
 }
 
 IntRect FrameView::windowClipRectForFrameOwner(const HTMLFrameOwnerElement* ownerElement) const
 {
     // The renderer can sometimes be null when style="display:none" interacts
     // with external content and plugins.
     if (!ownerElement->layoutObject())
         return windowClipRect();
 
     // If we have no layer, just return our window clip rect.
     const DeprecatedPaintLayer* enclosingLayer = ownerElement->layoutObject()->enclosingLayer();
     if (!enclosingLayer)
         return windowClipRect();
 
     // FIXME: childrenClipRect relies on compositingState, which is not necessarily up to date.
     // https://code.google.com/p/chromium/issues/detail?id=343769
     DisableCompositingQueryAsserts disabler;
 
     // Apply the clip from the layer.
-    IntRect clipRect = contentsToWindow(pixelSnappedIntRect(enclosingLayer->clipper().childrenClipRect()));
+    IntRect clipRect = contentsToRootFrame(pixelSnappedIntRect(enclosingLayer->clipper().childrenClipRect()));
     return intersection(clipRect, windowClipRect());
 }
 
 bool FrameView::shouldUseIntegerScrollOffset() const
 {
     if (m_frame->settings() && !m_frame->settings()->preferCompositingToLCDTextEnabled())
         return true;
     return false;
 }
 
@@ skipping 1424 matching lines @@
     IntPoint framePoint = contentsToFrame(contentsPoint);
     return convertToContainingWindow(framePoint);
 }
 
 IntRect FrameView::contentsToRootFrame(const IntRect& contentsRect) const
 {
     IntRect rectInFrame = contentsToFrame(contentsRect);
     return convertToContainingWindow(rectInFrame);
 }
 
-IntPoint FrameView::windowToContents(const IntPoint& windowPoint) const
-{
-    IntPoint framePoint = convertFromContainingWindow(windowPoint);
-    return frameToContents(framePoint);
-}
-
-FloatPoint FrameView::windowToContents(const FloatPoint& windowPoint) const
+FloatPoint FrameView::rootFrameToContents(const FloatPoint& windowPoint) const
 {
     FloatPoint framePoint = convertFromContainingWindow(windowPoint);
     return frameToContents(framePoint);
 }
 
-IntPoint FrameView::contentsToWindow(const IntPoint& contentsPoint) const
+IntRect FrameView::viewportToContents(const IntRect& rectInViewport) const
 {
-    IntPoint framePoint = contentsToFrame(contentsPoint);
-    return convertToContainingWindow(framePoint);
+    IntRect rectInRootFrame = page()->frameHost().pinchViewport().viewportToRootFrame(rectInViewport);
+    IntRect frameRect = convertFromContainingWindow(rectInRootFrame);
+    return frameToContents(frameRect);
 }
 
-IntRect FrameView::windowToContents(const IntRect& windowRect) const
+IntPoint FrameView::viewportToContents(const IntPoint& pointInViewport) const
 {
-    IntRect rectInFrame = convertFromContainingWindow(windowRect);
-    return frameToContents(rectInFrame);
+    IntPoint pointInRootFrame = page()->frameHost().pinchViewport().viewportToRootFrame(pointInViewport);
+    IntPoint pointInFrame = convertFromContainingWindow(pointInRootFrame);
+    return frameToContents(pointInFrame);
 }
 
-IntRect FrameView::contentsToWindow(const IntRect& contentsRect) const
+IntRect FrameView::contentsToViewport(const IntRect& rectInContents) const
 {
-    IntRect rectInFrame = contentsToFrame(contentsRect);
-    return convertToContainingWindow(rectInFrame);
+    IntRect rectInFrame = contentsToFrame(rectInContents);
+    IntRect rectInRootFrame = convertToContainingWindow(rectInFrame);
+    return page()->frameHost().pinchViewport().rootFrameToViewport(rectInRootFrame);
+}
+
+IntPoint FrameView::contentsToViewport(const IntPoint& pointInContents) const
+{
+    IntPoint pointInFrame = contentsToFrame(pointInContents);
+    IntPoint pointInRootFrame = convertToContainingWindow(pointInFrame);
+    return page()->frameHost().pinchViewport().rootFrameToViewport(pointInRootFrame);
 }
 
 IntRect FrameView::contentsToScreen(const IntRect& rect) const
 {
     HostWindow* window = hostWindow();
     if (!window)
         return IntRect();
-    return window->viewportToScreen(contentsToWindow(rect));
+    return window->viewportToScreen(contentsToViewport(rect));
+}
+
+IntRect FrameView::soonToBeRemovedContentsToUnscaledViewport(const IntRect& rectInContents) const
+{
+    IntRect rectInFrame = contentsToFrame(rectInContents);
+    IntRect rectInRootFrame = convertToContainingWindow(rectInFrame);
+    return enclosingIntRect(page()->frameHost().pinchViewport().mainViewToViewportCSSPixels(rectInRootFrame));
+}
+
+IntPoint FrameView::soonToBeRemovedUnscaledViewportToContents(const IntPoint& pointInViewport) const
+{
+    IntPoint pointInRootFrame = flooredIntPoint(page()->frameHost().pinchViewport().viewportCSSPixelsToRootFrame(pointInViewport));
+    IntPoint pointInThisFrame = convertFromContainingWindow(pointInRootFrame);
+    return frameToContents(pointInThisFrame);
 }
 
 bool FrameView::containsScrollbarsAvoidingResizer() const
 {
     return !m_scrollbarsAvoidingResizer;
 }
 
 void FrameView::adjustScrollbarsAvoidingResizerCount(int overlapDelta)
 {
     int oldCount = m_scrollbarsAvoidingResizer;
@@ skipping 21 matching lines @@
         if (m_horizontalScrollbar)
             m_horizontalScrollbar->invalidate();
         if (m_verticalScrollbar)
             m_verticalScrollbar->invalidate();
 
         // Invalidate the scroll corner too on unsuppress.
         invalidateRect(scrollCornerRect());
     }
 }
 
-Scrollbar* FrameView::scrollbarAtWindowPoint(const IntPoint& windowPoint)
+Scrollbar* FrameView::scrollbarAtRootFramePoint(const IntPoint& pointInRootFrame)
 {
-    IntPoint pointInFrame = convertFromContainingWindow(windowPoint);
+    IntPoint pointInFrame = convertFromContainingWindow(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 92 matching lines @@
 void FrameView::invalidateScrollCornerRect(const IntRect& rect)
 {
     invalidateRect(rect);
 }
 
 void FrameView::paintPanScrollIcon(GraphicsContext* context)
 {
     DEFINE_STATIC_REF(Image, panScrollIcon, (Image::loadPlatformResource("panIcon")));
     IntPoint iconGCPoint = m_panScrollIconPoint;
     if (parent())
-        iconGCPoint = toFrameView(parent())->windowToContents(iconGCPoint);
+        iconGCPoint = toFrameView(parent())->rootFrameToContents(iconGCPoint);
     context->drawImage(panScrollIcon, iconGCPoint);
 }
 
 void FrameView::paint(GraphicsContext* context, const IntRect& rect)
 {
     FramePainter(*this).paint(context, rect);
 }
 
 void FrameView::paintContents(GraphicsContext* context, const IntRect& damageRect)
 {
@@ skipping 200 matching lines @@
 {
     Settings* settings = frame().settings();
     if (!settings || !settings->rootLayerScrolls())
         return this;
 
     LayoutView* layoutView = this->layoutView();
     return layoutView ? layoutView->scrollableArea() : nullptr;
 }
 
 } // namespace blink