Removed FrameView's windowToContents and contentsToWindow methods.

Source/core/page/TouchAdjustment.cpp

 /*
  * Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies)
  *
  * 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,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 314 matching lines @@
         Node* candidate = intersectedNodes[i].get();
         if (nodeIsZoomTarget(candidate))
             appendZoomableSubtargets(candidate, subtargets);
     }
 }
 
 // This returns quotient of the target area and its intersection with the touch area.
 // This will prioritize largest intersection and smallest area, while balancing the two against each other.
 float zoomableIntersectionQuotient(const IntPoint& touchHotspot, const IntRect& touchArea, const SubtargetGeometry& subtarget)
 {
-    IntRect rect = subtarget.boundingBox();
-
-    // Convert from frame coordinates to window coordinates.
-    rect = subtarget.node()->document().view()->contentsToWindow(rect);
+    IntRect rect = subtarget.node()->document().view()->contentsToRootFrame(subtarget.boundingBox());
 
     // Check the rectangle is meaningful zoom target. It should at least contain the hotspot.
     if (!rect.contains(touchHotspot))
         return std::numeric_limits<float>::infinity();
     IntRect intersection = rect;
     intersection.intersect(touchArea);
 
     // Return the quotient of the intersection.
     return rect.size().area() / (float)intersection.size().area();
 }
 
 // Uses a hybrid of distance to adjust and intersect ratio, normalizing each score between 0 and 1
 // and combining them. The distance to adjust works best for disambiguating clicks on targets such
 // as links, where the width may be significantly larger than the touch width. Using area of overlap
 // in such cases can lead to a bias towards shorter links. Conversely, percentage of overlap can
 // provide strong confidence in tapping on a small target, where the overlap is often quite high,
 // and works well for tightly packed controls.
 float hybridDistanceFunction(const IntPoint& touchHotspot, const IntRect& touchRect, const SubtargetGeometry& subtarget)
 {
-    IntRect rect = subtarget.boundingBox();
-
-    // Convert from frame coordinates to window coordinates.
-    rect = subtarget.node()->document().view()->contentsToWindow(rect);
+    IntRect rect = subtarget.node()->document().view()->contentsToRootFrame(subtarget.boundingBox());
 
     float radiusSquared = 0.25f * (touchRect.size().diagonalLengthSquared());
     float distanceToAdjustScore = rect.distanceSquaredToPoint(touchHotspot) / radiusSquared;
 
     int maxOverlapWidth = std::min(touchRect.width(), rect.width());
     int maxOverlapHeight = std::min(touchRect.height(), rect.height());
     float maxOverlapArea = std::max(maxOverlapWidth * maxOverlapHeight, 1);
     rect.intersect(touchRect);
     float intersectArea = rect.size().area();
     float intersectionScore = 1 - intersectArea / maxOverlapArea;
 
     float hybridScore = intersectionScore + distanceToAdjustScore;
 
     return hybridScore;
 }
 
-FloatPoint contentsToWindow(FrameView *view, FloatPoint pt)
+FloatPoint contentsToRootFrame(FrameView *view, FloatPoint pt)
 {
     int x = static_cast<int>(pt.x() + 0.5f);
     int y = static_cast<int>(pt.y() + 0.5f);
-    IntPoint adjusted = view->contentsToWindow(IntPoint(x, y));
+    IntPoint adjusted = view->contentsToRootFrame(IntPoint(x, y));
     return FloatPoint(adjusted.x(), adjusted.y());
 }
 
 // Adjusts 'point' to the nearest point inside rect, and leaves it unchanged if already inside.
 void adjustPointToRect(FloatPoint& point, const FloatRect& rect)
 {
     if (point.x() < rect.x())
         point.setX(rect.x());
     else if (point.x() > rect.maxX())
         point.setX(rect.maxX());
 
     if (point.y() < rect.y())
         point.setY(rect.y());
     else if (point.y() > rect.maxY())
         point.setY(rect.maxY());
 }
 
 bool snapTo(const SubtargetGeometry& geom, const IntPoint& touchPoint, const IntRect& touchArea, IntPoint& adjustedPoint)
 {
     FrameView* view = geom.node()->document().view();
     FloatQuad quad = geom.quad();
 
     if (quad.isRectilinear()) {
-        IntRect contentBounds = geom.boundingBox();
-        // Convert from frame coordinates to window coordinates.
-        IntRect bounds = view->contentsToWindow(contentBounds);
+        IntRect bounds = view->contentsToRootFrame(geom.boundingBox());
         if (bounds.contains(touchPoint)) {
             adjustedPoint = touchPoint;
             return true;
         }
         if (bounds.intersects(touchArea)) {
             bounds.intersect(touchArea);
             adjustedPoint = bounds.center();
             return true;
         }
         return false;
     }
 
     // The following code tries to adjust the point to place inside a both the touchArea and the non-rectilinear quad.
     // FIXME: This will return the point inside the touch area that is the closest to the quad center, but does not
     // guarantee that the point will be inside the quad. Corner-cases exist where the quad will intersect but this
     // will fail to adjust the point to somewhere in the intersection.
 
-    // Convert quad from content to window coordinates.
-    FloatPoint p1 = contentsToWindow(view, quad.p1());
-    FloatPoint p2 = contentsToWindow(view, quad.p2());
-    FloatPoint p3 = contentsToWindow(view, quad.p3());
-    FloatPoint p4 = contentsToWindow(view, quad.p4());
+    FloatPoint p1 = contentsToRootFrame(view, quad.p1());
+    FloatPoint p2 = contentsToRootFrame(view, quad.p2());
+    FloatPoint p3 = contentsToRootFrame(view, quad.p3());
+    FloatPoint p4 = contentsToRootFrame(view, quad.p4());
     quad = FloatQuad(p1, p2, p3, p4);
 
     if (quad.containsPoint(touchPoint)) {
         adjustedPoint = touchPoint;
         return true;
     }
 
     // Pull point towards the center of the element.
     FloatPoint center = quad.center();
 
@@ skipping 33 matching lines @@
                     targetArea = it->boundingBox();
                 }
             }
         }
     }
 
     // As for HitTestResult.innerNode, we skip over pseudo elements.
     if (targetNode && targetNode->isPseudoElement())
         targetNode = targetNode->parentOrShadowHostNode();
 
-    if (targetNode) {
-        targetArea = targetNode->document().view()->contentsToWindow(targetArea);
-    }
+    if (targetNode)
+        targetArea = targetNode->document().view()->contentsToRootFrame(targetArea);
+
     return (targetNode);
 }
 
 } // namespace TouchAdjustment
 
 bool findBestClickableCandidate(Node*& targetNode, IntPoint& targetPoint, const IntPoint& touchHotspot, const IntRect& touchArea, const WillBeHeapVector<RefPtrWillBeMember<Node>>& nodes)
 {
     IntRect targetArea;
     TouchAdjustment::SubtargetGeometryList subtargets;
     TouchAdjustment::compileSubtargetList(nodes, subtargets, TouchAdjustment::nodeRespondsToTapGesture, TouchAdjustment::appendBasicSubtargetsForNode);
@@ skipping 10 matching lines @@
 
 bool findBestZoomableArea(Node*& targetNode, IntRect& targetArea, const IntPoint& touchHotspot, const IntRect& touchArea, const WillBeHeapVector<RefPtrWillBeMember<Node>>& nodes)
 {
     IntPoint targetPoint;
     TouchAdjustment::SubtargetGeometryList subtargets;
     TouchAdjustment::compileZoomableSubtargets(nodes, subtargets);
     return TouchAdjustment::findNodeWithLowestDistanceMetric(targetNode, targetPoint, targetArea, touchHotspot, touchArea, subtargets, TouchAdjustment::zoomableIntersectionQuotient);
 }
 
 } // namespace blink