Removed FrameView's windowToContents and contentsToWindow methods.

Source/core/frame/PinchViewport.cpp

Index: Source/core/frame/PinchViewport.cpp
diff --git a/Source/core/frame/PinchViewport.cpp b/Source/core/frame/PinchViewport.cpp
index 7e406ba1cb79539d04e7fa5f6be1b319d79f9196..a1e615cdfbd123ce7ea94721ebf75fc2e96906e8 100644
--- a/Source/core/frame/PinchViewport.cpp
+++ b/Source/core/frame/PinchViewport.cpp
@@ -592,6 +592,62 @@ void PinchViewport::clampToBoundaries()
     setLocation(m_offset);
 }
 
+FloatRect PinchViewport::viewportToRootFrame(const FloatRect& rectInViewport) const
+{
+    FloatRect rectInRootFrame = rectInViewport;
+    rectInRootFrame.scale(1 / scale());
+    rectInRootFrame.moveBy(location());
+    return rectInRootFrame;
+}
+
+IntRect PinchViewport::viewportToRootFrame(const IntRect& rectInViewport) const
+{
+    // FIXME: How to snap to pixels?

[Rick Byers, 2015/03/05 17:56:20]

The only right answer here is probably to update all callers to expect float
return values, right?  How hard would that be?  If it's not too hard, it would
be nice to avoid introducing new int-based APIs for something that's inherently
float.  At least then you could easily apply different truncation policies at
the call site depending on the scenario (making it clear callers need to
consider how to correctly handle fractional values).

[bokan, 2015/03/06 21:54:37]

I'm of the opposite viewpoint. I think we should centralize all the pixel
snapping to these kinds of methods. From what I've seen, having call sites
decide how to pixel snap usually leads to arbitrary flooring/ceiling with subtle
bugs. I'm not an expert in snapping to discrete pixel values, so maybe this is
impractical, but I think having the decision applied consistently, or at least
based on semantics (changing the vocabulary from floats and ints will force
callers to think about it, when a dev sees float but wants int they know how to
get an int) is valuable. In any case, can we agree to fix this in a follow up?

[Rick Byers, 2015/03/07 15:44:08]

Interesting.  You should have a chat with eae@ - he's the expert.  My
understanding, especially for rects, is that there's no one right answer (which
is why our generic APIs often have terms like 'floored', 'enclosing', etc. so
clients can pick the right one for their scenario).  Regardless I think we
should be continuing to move to replacing ints with floats / layoutunits as
appropriate - there are still a lot of examples of using ints for things that
really aren't integers.

But yes, absolutely leaving a FIXME and covering this in a follow-up CL is fine.

+    return enclosingIntRect(viewportToRootFrame(FloatRect(rectInViewport)));
+}
+
+FloatRect PinchViewport::rootFrameToViewport(const FloatRect& rectInRootFrame) const
+{
+    FloatRect rectInViewport = rectInRootFrame;
+    rectInViewport.moveBy(-location());
+    rectInViewport.scale(scale());
+    return rectInViewport;
+}
+
+IntRect PinchViewport::rootFrameToViewport(const IntRect& rectInRootFrame) const
+{
+    // FIXME: How to snap to pixels?
+    return enclosingIntRect(rootFrameToViewport(FloatRect(rectInRootFrame)));
+}
+
+FloatPoint PinchViewport::viewportToRootFrame(const FloatPoint& pointInViewport) const
+{
+    FloatPoint pointInRootFrame = pointInViewport;
+    pointInRootFrame.scale(1 / scale(), 1 / scale());
+    pointInRootFrame.moveBy(location());
+    return pointInRootFrame;
+}
+
+FloatPoint PinchViewport::rootFrameToViewport(const FloatPoint& pointInRootFrame) const
+{
+    FloatPoint pointInViewport = pointInRootFrame;
+    pointInViewport.moveBy(-location());
+    pointInViewport.scale(scale(), scale());
+    return pointInViewport;
+}
+
+IntPoint PinchViewport::viewportToRootFrame(const IntPoint& pointInViewport) const
+{
+    // FIXME: How to snap to pixels?
+    return flooredIntPoint(FloatPoint(viewportToRootFrame(FloatPoint(pointInViewport))));
+}
+
+IntPoint PinchViewport::rootFrameToViewport(const IntPoint& pointInRootFrame) const
+{
+    // FIXME: How to snap to pixels?
+    return flooredIntPoint(FloatPoint(rootFrameToViewport(FloatPoint(pointInRootFrame))));
+}
+
 String PinchViewport::debugName(const GraphicsLayer* graphicsLayer)
 {
     String name;