Removed FrameView's windowToContents and contentsToWindow methods.

Source/core/frame/PinchViewport.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 574 matching lines @@
     clampedOffset = clampedOffset.shrunkTo(FloatPoint(maximumScrollPositionDouble()));
     clampedOffset = clampedOffset.expandedTo(FloatPoint(minimumScrollPositionDouble()));
     return clampedOffset;
 }
 
 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;
     if (graphicsLayer == m_innerViewportContainerLayer.get()) {
         name = "Inner Viewport Container Layer";
     } else if (graphicsLayer == m_overscrollElasticityLayer.get()) {
         name =  "Overscroll Elasticity Layer";
     } else if (graphicsLayer == m_pageScaleLayer.get()) {
         name =  "Page Scale Layer";
     } else if (graphicsLayer == m_innerViewportScrollLayer.get()) {
         name =  "Inner Viewport Scroll Layer";
     } else if (graphicsLayer == m_overlayScrollbarHorizontal.get()) {
         name =  "Overlay Scrollbar Horizontal Layer";
     } else if (graphicsLayer == m_overlayScrollbarVertical.get()) {
         name =  "Overlay Scrollbar Vertical Layer";
     } else if (graphicsLayer == m_rootTransformLayer) {
         name =  "Root Transform Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace blink