Removed FrameView's windowToContents and contentsToWindow methods.

Source/web/WebViewImpl.cpp

 /*
  * Copyright (C) 2011, 2012 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 512 matching lines @@
         ASSERT(!m_pagePopup);
     }
 
     m_lastMouseDownPoint = WebPoint(event.x, event.y);
 
     // Take capture on a mouse down on a plugin so we can send it mouse events.
     // If the hit node is a plugin but a scrollbar is over it don't start mouse
     // capture because it will interfere with the scrollbar receiving events.
     IntPoint point(event.x, event.y);
     if (event.button == WebMouseEvent::ButtonLeft && m_page->mainFrame()->isLocalFrame()) {
-        point = m_page->deprecatedLocalMainFrame()->view()->windowToContents(point);
+        point = m_page->deprecatedLocalMainFrame()->view()->rootFrameToContents(point);
         HitTestResult result(m_page->deprecatedLocalMainFrame()->eventHandler().hitTestResultAtPoint(point));
         result.setToShadowHostIfInClosedShadowRoot();
         Node* hitNode = result.innerNonSharedNode();
 
         if (!result.scrollbar() && hitNode && hitNode->renderer() && hitNode->renderer()->isEmbeddedObject()) {
             m_mouseCaptureNode = hitNode;
             TRACE_EVENT_ASYNC_BEGIN0("input", "capturing mouse", this);
         }
     }
 
@@ skipping 41 matching lines @@
 void WebViewImpl::mouseContextMenu(const WebMouseEvent& event)
 {
     if (!mainFrameImpl() || !mainFrameImpl()->frameView())
         return;
 
     m_page->contextMenuController().clearContextMenu();
 
     PlatformMouseEventBuilder pme(mainFrameImpl()->frameView(), event);
 
     // Find the right target frame. See issue 1186900.
-    HitTestResult result = hitTestResultForWindowPos(pme.position());
+    HitTestResult result = hitTestResultForRootFramePos(pme.position());
     Frame* targetFrame;
     if (result.innerNonSharedNode())
         targetFrame = result.innerNonSharedNode()->document().frame();
     else
         targetFrame = m_page->focusController().focusedOrMainFrame();
 
     if (!targetFrame->isLocalFrame())
         return;
 
     LocalFrame* targetLocalFrame = toLocalFrame(targetFrame);
@@ skipping 170 matching lines @@
         RefPtrWillBeRawPtr<PopupContainer> selectPopup = nullptr;
         selectPopup = m_selectPopup;
         hideSelectPopup();
         ASSERT(!m_selectPopup);
 
         // Don't trigger a disambiguation popup on sites designed for mobile devices.
         // Instead, assume that the page has been designed with big enough buttons and links.
         // Don't trigger a disambiguation popup when screencasting, since it's implemented outside of
         // compositor pipeline and is not being screencasted itself. This leads to bad user experience.
         if (event.data.tap.width > 0 && !shouldDisableDesktopWorkarounds() && !page()->inspectorController().screencastEnabled()) {
-            WebGestureEvent scaledEvent = event;
-            scaledEvent.x = event.x / pageScaleFactor();
-            scaledEvent.y = event.y / pageScaleFactor();
-            scaledEvent.data.tap.width = event.data.tap.width / pageScaleFactor();
-            scaledEvent.data.tap.height = event.data.tap.height / pageScaleFactor();
-            IntRect boundingBox(
-                scaledEvent.x - scaledEvent.data.tap.width / 2,
-                scaledEvent.y - scaledEvent.data.tap.height / 2,
-                scaledEvent.data.tap.width,
-                scaledEvent.data.tap.height);
+            IntRect boundingBox(page()->frameHost().pinchViewport().viewportToRootFrame(IntRect(
+                event.x - event.data.tap.width / 2,
+                event.y - event.data.tap.height / 2,
+                event.data.tap.width,
+                event.data.tap.height)));
 
-            WebSize pinchViewportOffset = pinchVirtualViewportEnabled() ?
-                flooredIntSize(page()->frameHost().pinchViewport().location()) : IntSize();
-
-            // Keep bounding box relative to the main frame.
-            boundingBox.move(pinchViewportOffset);
+            // FIXME: We shouldn't pass details of the PinchViewport offset to render_view_impl.
+            WebSize pinchViewportOffset = flooredIntSize(page()->frameHost().pinchViewport().location());
 
             Vector<IntRect> goodTargets;
             WillBeHeapVector<RawPtrWillBeMember<Node>> highlightNodes;
             findGoodTouchTargets(boundingBox, mainFrameImpl()->frame(), goodTargets, highlightNodes);
             // FIXME: replace touch adjustment code when numberOfGoodTargets == 1?
             // Single candidate case is currently handled by: https://bugs.webkit.org/show_bug.cgi?id=85101
             if (goodTargets.size() >= 2 && m_client
                 && m_client->didTapMultipleTargets(pinchViewportOffset, boundingBox, goodTargets)) {
 
                 enableTapHighlights(highlightNodes);
@@ skipping 307 matching lines @@
     // events.
     if (evt.isSystemKey())
         return false;
 
     if (!suppress && !handler.keyEvent(evt))
         return keyEventDefault(event);
 
     return true;
 }
 
-WebRect WebViewImpl::computeBlockBound(const WebPoint& webPoint, bool ignoreClipping)
+WebRect WebViewImpl::computeBlockBound(const WebPoint& pointInRootFrame, bool ignoreClipping)
 {
     if (!mainFrameImpl())
         return WebRect();
 
     // Use the point-based hit test to find the node.
-    IntPoint point = mainFrameImpl()->frameView()->windowToContents(IntPoint(webPoint.x, webPoint.y));
+    IntPoint point = mainFrameImpl()->frameView()->rootFrameToContents(IntPoint(pointInRootFrame.x, pointInRootFrame.y));
     HitTestRequest::HitTestRequestType hitType = HitTestRequest::ReadOnly | HitTestRequest::Active | (ignoreClipping ? HitTestRequest::IgnoreClipping : 0);
     HitTestResult result = mainFrameImpl()->frame()->eventHandler().hitTestResultAtPoint(point, hitType);
     result.setToShadowHostIfInClosedShadowRoot();
 
     Node* node = result.innerNonSharedNode();
     if (!node)
         return WebRect();
 
     // Find the block type node based on the hit node.
     // FIXME: This wants to walk composed tree with NodeRenderingTraversal::parent().
     while (node && (!node->renderer() || node->renderer()->isInline()))
         node = NodeRenderingTraversal::parent(*node);
 
-    // Return the bounding box in the window coordinate system.
+    // Return the bounding box in the root frame's coordinate space.
     if (node) {
-        IntRect rect = node->Node::pixelSnappedBoundingBox();
+        IntRect pointInRootFrame = node->Node::pixelSnappedBoundingBox();
         LocalFrame* frame = node->document().frame();
-        return frame->view()->contentsToWindow(rect);
+        return frame->view()->contentsToRootFrame(pointInRootFrame);
     }
     return WebRect();
 }
 
 WebRect WebViewImpl::widenRectWithinPageBounds(const WebRect& source, int targetMargin, int minimumMargin)
 {
     WebSize maxSize;
     if (mainFrame())
         maxSize = mainFrame()->contentsSize();
     IntSize scrollOffset;
@@ skipping 27 matching lines @@
 {
     // Pages should be as legible as on desktop when at dpi scale, so no
     // need to zoom in further when automatically determining zoom level
     // (after double tap, find in page, etc), though the user should still
     // be allowed to manually pinch zoom in further if they desire.
     if (page())
         return m_maximumLegibleScale * page()->settings().accessibilityFontScaleFactor();
     return m_maximumLegibleScale;
 }
 
-void WebViewImpl::computeScaleAndScrollForBlockRect(const WebPoint& hitPoint, const WebRect& blockRect, float padding, float defaultScaleWhenAlreadyLegible, float& scale, WebPoint& scroll)
+void WebViewImpl::computeScaleAndScrollForBlockRect(const WebPoint& hitPointInRootFrame, const WebRect& blockRectInRootFrame, float padding, float defaultScaleWhenAlreadyLegible, float& scale, WebPoint& scroll)
 {
     scale = pageScaleFactor();
     scroll.x = scroll.y = 0;
 
-    WebRect rect = blockRect;
+    WebRect rect = blockRectInRootFrame;
 
     if (!rect.isEmpty()) {
         float defaultMargin = doubleTapZoomContentDefaultMargin;
         float minimumMargin = doubleTapZoomContentMinimumMargin;
         // We want the margins to have the same physical size, which means we
         // need to express them in post-scale size. To do that we'd need to know
         // the scale we're scaling to, but that depends on the margins. Instead
         // we express them as a fraction of the target rectangle: this will be
         // correct if we end up fully zooming to it, and won't matter if we
         // don't.
@@ skipping 18 matching lines @@
     float screenWidth = m_size.width / scale;
     float screenHeight = m_size.height / scale;
 
     // Scroll to vertically align the block.
     if (rect.height < screenHeight) {
         // Vertically center short blocks.
         rect.y -= 0.5 * (screenHeight - rect.height);
     } else {
         // Ensure position we're zooming to (+ padding) isn't off the bottom of
         // the screen.
-        rect.y = std::max<float>(rect.y, hitPoint.y + padding - screenHeight);
+        rect.y = std::max<float>(rect.y, hitPointInRootFrame.y + padding - screenHeight);
     } // Otherwise top align the block.
 
     // Do the same thing for horizontal alignment.
     if (rect.width < screenWidth)
         rect.x -= 0.5 * (screenWidth - rect.width);
     else
-        rect.x = std::max<float>(rect.x, hitPoint.x + padding - screenWidth);
+        rect.x = std::max<float>(rect.x, hitPointInRootFrame.x + padding - screenWidth);
     scroll.x = rect.x;
     scroll.y = rect.y;
 
     scale = clampPageScaleFactorToLimits(scale);
-    scroll = mainFrameImpl()->frameView()->windowToContents(scroll);
+    scroll = mainFrameImpl()->frameView()->rootFrameToContents(scroll);
     scroll = clampOffsetAtScale(scroll, scale);
 }
 
 static Node* findCursorDefiningAncestor(Node* node, LocalFrame* frame)
 {
     // Go up the tree to find the node that defines a mouse cursor style
     while (node) {
         if (node->renderer()) {
             ECursor cursor = node->renderer()->style()->cursor();
             if (cursor != CURSOR_AUTO || frame->eventHandler().useHandCursor(node, node->isLink()))
@@ skipping 90 matching lines @@
         // Safari documentation for -webkit-tap-highlight-color says if the specified color has 0 alpha,
         // then tap highlighting is disabled.
         // http://developer.apple.com/library/safari/#documentation/appleapplications/reference/safaricssref/articles/standardcssproperties.html
         if (!highlightColor.alpha())
             continue;
 
         m_linkHighlights.append(LinkHighlight::create(node, this));
     }
 }
 
-void WebViewImpl::animateDoubleTapZoom(const IntPoint& point)
+void WebViewImpl::animateDoubleTapZoom(const IntPoint& pointInRootFrame)
 {
     if (!mainFrameImpl())
         return;
 
-    WebRect blockBounds = computeBlockBound(point, false);
+    WebRect blockBounds = computeBlockBound(pointInRootFrame, false);
     float scale;
     WebPoint scroll;
 
-    computeScaleAndScrollForBlockRect(point, blockBounds, touchPointPadding, minimumPageScaleFactor() * doubleTapZoomAlreadyLegibleRatio, scale, scroll);
+    computeScaleAndScrollForBlockRect(pointInRootFrame, blockBounds, touchPointPadding, minimumPageScaleFactor() * doubleTapZoomAlreadyLegibleRatio, scale, scroll);
 
     bool stillAtPreviousDoubleTapScale = (pageScaleFactor() == m_doubleTapZoomPageScaleFactor
         && m_doubleTapZoomPageScaleFactor != minimumPageScaleFactor())
         || m_doubleTapZoomPending;
 
     bool scaleUnchanged = fabs(pageScaleFactor() - scale) < minScaleDifference;
     bool shouldZoomOut = blockBounds.isEmpty() || scaleUnchanged || stillAtPreviousDoubleTapScale;
 
     bool isAnimating;
 
     if (shouldZoomOut) {
         scale = minimumPageScaleFactor();
-        isAnimating = startPageScaleAnimation(mainFrameImpl()->frameView()->windowToContents(point), true, scale, doubleTapZoomAnimationDurationInSeconds);
+        isAnimating = startPageScaleAnimation(mainFrameImpl()->frameView()->rootFrameToContents(pointInRootFrame), true, scale, doubleTapZoomAnimationDurationInSeconds);
     } else {
         isAnimating = startPageScaleAnimation(scroll, false, scale, doubleTapZoomAnimationDurationInSeconds);
     }
 
     if (isAnimating) {
         m_doubleTapZoomPageScaleFactor = scale;
         m_doubleTapZoomPending = true;
     }
 }
 
-void WebViewImpl::zoomToFindInPageRect(const WebRect& rect)
+void WebViewImpl::zoomToFindInPageRect(const WebRect& rectInRootFrame)
 {
     if (!mainFrameImpl())
         return;
 
-    WebRect blockBounds = computeBlockBound(WebPoint(rect.x + rect.width / 2, rect.y + rect.height / 2), true);
+    WebRect blockBounds = computeBlockBound(WebPoint(rectInRootFrame.x + rectInRootFrame.width / 2, rectInRootFrame.y + rectInRootFrame.height / 2), true);
 
     if (blockBounds.isEmpty()) {
         // Keep current scale (no need to scroll as x,y will normally already
         // be visible). FIXME: Revisit this if it isn't always true.
         return;
     }
 
     float scale;
     WebPoint scroll;
 
-    computeScaleAndScrollForBlockRect(WebPoint(rect.x, rect.y), blockBounds, nonUserInitiatedPointPadding, minimumPageScaleFactor(), scale, scroll);
+    computeScaleAndScrollForBlockRect(WebPoint(rectInRootFrame.x, rectInRootFrame.y), blockBounds, nonUserInitiatedPointPadding, minimumPageScaleFactor(), scale, scroll);
 
     startPageScaleAnimation(scroll, false, scale, findInPageAnimationDurationInSeconds);
 }
 
-bool WebViewImpl::zoomToMultipleTargetsRect(const WebRect& rect)
+bool WebViewImpl::zoomToMultipleTargetsRect(const WebRect& rectInRootFrame)
 {
     if (!mainFrameImpl())
         return false;
 
     float scale;
     WebPoint scroll;
 
-    computeScaleAndScrollForBlockRect(WebPoint(rect.x, rect.y), rect, nonUserInitiatedPointPadding, minimumPageScaleFactor(), scale, scroll);
+    computeScaleAndScrollForBlockRect(WebPoint(rectInRootFrame.x, rectInRootFrame.y), rectInRootFrame, nonUserInitiatedPointPadding, minimumPageScaleFactor(), scale, scroll);
 
     if (scale <= pageScaleFactor())
         return false;
 
     startPageScaleAnimation(scroll, false, scale, multipleTargetsZoomAnimationDurationInSeconds);
     return true;
 }
 
 void WebViewImpl::hasTouchEventHandlers(bool hasTouchHandlers)
 {
@@ skipping 1131 matching lines @@
         anchor = localFrame->editor().firstRectForRange(range.get());
 
         range = Range::create(selectedRange->endContainer()->document(),
             selectedRange->endContainer(),
             selectedRange->endOffset(),
             selectedRange->endContainer(),
             selectedRange->endOffset());
         focus = localFrame->editor().firstRectForRange(range.get());
     }
 
-    IntRect scaledAnchor(localFrame->view()->contentsToWindow(anchor));
-    IntRect scaledFocus(localFrame->view()->contentsToWindow(focus));
-
-    if (pinchVirtualViewportEnabled()) {
-        // FIXME(http://crbug.com/371902) - We shouldn't have to do this
-        // manually, the contentsToWindow methods above should be fixed to do
-        // this.
-        IntPoint pinchViewportOffset =
-            roundedIntPoint(page()->frameHost().pinchViewport().visibleRect().location());
-        scaledAnchor.moveBy(-pinchViewportOffset);
-        scaledFocus.moveBy(-pinchViewportOffset);
-    }
-
-    scaledAnchor.scale(pageScaleFactor());
-    scaledFocus.scale(pageScaleFactor());
-    anchor = scaledAnchor;
-    focus = scaledFocus;
+    anchor = localFrame->view()->contentsToViewport(anchor);
+    focus = localFrame->view()->contentsToViewport(focus);
 
     if (!selection.selection().isBaseFirst())
         std::swap(anchor, focus);
     return true;
 }
 
 InputMethodContext* WebViewImpl::inputMethodContext()
 {
     if (!m_imeAcceptEvents)
         return 0;
@@ skipping 305 matching lines @@
         return false;
 
     if (!m_webSettings->autoZoomFocusedNodeToLegibleScale()) {
         PinchViewport& pinchViewport = page()->frameHost().pinchViewport();
 
         // FIXME: The pixel snapping shouldn't be done ad-hoc. crbug.com/458579.
         IntRect viewportRectInRootFrame(
             ceiledIntPoint(pinchViewport.location()),
             expandedIntSize(pinchViewport.visibleSize()));
 
-        // FIXME: Use viewportToRootFrame when coordinate refactoring CL lands.
-        FloatRect targetRectInRootFrame(
-            rectInViewport.x,
-            rectInViewport.y,
-            rectInViewport.width,
-            rectInViewport.height);
-        targetRectInRootFrame.scale(1 / pinchViewport.scale());
-        targetRectInRootFrame.moveBy(viewportRectInRootFrame.location());
-
+        FloatRect targetRectInRootFrame = pinchViewport.viewportToRootFrame(rectInViewport);
         DoubleSize remainder = frame->view()->scrollElementToRect(element, IntRect(targetRectInRootFrame));
 
         // Scroll the remainder in the pinch viewport.
         page()->frameHost().pinchViewport().move(FloatPoint(remainder.width(), remainder.height()));
         return false;
     }
 
     float scale;
     IntPoint scroll;
     bool needAnimation;
     computeScaleAndScrollForFocusedNode(element, scale, scroll, needAnimation);
     if (needAnimation)
         return startPageScaleAnimation(scroll, false, scale, scrollAndScaleAnimationDurationInSeconds);
 
     return false;
 }
 
 void WebViewImpl::computeScaleAndScrollForFocusedNode(Node* focusedNode, float& newScale, IntPoint& newScroll, bool& needAnimation)
 {
     focusedNode->document().updateLayoutIgnorePendingStylesheets();
 
     // 'caret' is rect encompassing the blinking cursor.
-    IntRect textboxRect = focusedNode->document().view()->contentsToWindow(pixelSnappedIntRect(focusedNode->Node::boundingBox()));
+    IntRect textboxRectInRootFrame = focusedNode->document().view()->contentsToRootFrame(pixelSnappedIntRect(focusedNode->Node::boundingBox()));
     WebRect caret, unusedEnd;
     selectionBounds(caret, unusedEnd);
     IntRect unscaledCaret = caret;
     unscaledCaret.scale(1 / pageScaleFactor());
     caret = unscaledCaret;
 
     if (shouldDisableDesktopWorkarounds()) {
         newScale = pageScaleFactor();
     } else {
         // Pick a scale which is reasonably readable. This is the scale at which
         // the caret height will become minReadableCaretHeightForNode (adjusted
         // for dpi and font scale factor).
-        const int minReadableCaretHeightForNode = textboxRect.height() >= 2 * caret.height ? minReadableCaretHeightForTextArea : minReadableCaretHeight;
+        const int minReadableCaretHeightForNode = textboxRectInRootFrame.height() >= 2 * caret.height ? minReadableCaretHeightForTextArea : minReadableCaretHeight;
         newScale = clampPageScaleFactorToLimits(maximumLegiblePageScale() * minReadableCaretHeightForNode / caret.height);
         newScale = std::max(newScale, pageScaleFactor());
     }
     const float deltaScale = newScale / pageScaleFactor();
 
     needAnimation = false;
     // If we are at less than the target zoom level, zoom in.
     if (deltaScale > minScaleChangeToTriggerZoom)
         needAnimation = true;
     else
         newScale = pageScaleFactor();
 
     // Convert the rects to absolute space in the new scale.
-    IntRect textboxRectInDocumentCoordinates = textboxRect;
-    textboxRectInDocumentCoordinates.move(mainFrame()->scrollOffset());
+    IntRect textboxRectInDocumentCoordinates = mainFrameImpl()->frameView()->frameToContents(textboxRectInRootFrame);
     IntRect caretInDocumentCoordinates = caret;
     caretInDocumentCoordinates.move(mainFrame()->scrollOffset());
 
     int viewWidth = m_size.width / newScale;
     int viewHeight = m_size.height / newScale;
 
     // If the caret is offscreen, then animate.
     IntRect sizeRect(0, 0, viewWidth, viewHeight);
     sizeRect.scale(newScale / pageScaleFactor());
     if (!sizeRect.contains(caret))
         needAnimation = true;
 
     // If the box is partially offscreen and it's possible to bring it fully
     // onscreen, then animate.
-    if (sizeRect.contains(textboxRectInDocumentCoordinates.width(), textboxRectInDocumentCoordinates.height()) && !sizeRect.contains(textboxRect))
+    if (sizeRect.contains(textboxRectInDocumentCoordinates.width(), textboxRectInDocumentCoordinates.height()) && !sizeRect.contains(textboxRectInRootFrame))
         needAnimation = true;
 
     if (!needAnimation)
         return;
 
     if (textboxRectInDocumentCoordinates.width() <= viewWidth) {
         // Field is narrower than screen. Try to leave padding on left so field's
         // label is visible, but it's more important to ensure entire field is
         // onscreen.
         int idealLeftPadding = viewWidth * leftBoxRatio;
@@ skipping 516 matching lines @@
     m_pageScaleConstraintsSet.setNeedsReset(true);
 
     // Clobber saved scales and scroll offsets.
     if (FrameView* view = page()->deprecatedLocalMainFrame()->document()->view())
         view->cacheCurrentScrollPosition();
 }
 
 void WebViewImpl::performMediaPlayerAction(const WebMediaPlayerAction& action,
                                            const WebPoint& location)
 {
-    HitTestResult result = hitTestResultForWindowPos(location);
+    // FIXME: location is probably in viewport coordinates.
+    HitTestResult result = hitTestResultForRootFramePos(location);
     RefPtrWillBeRawPtr<Node> node = result.innerNonSharedNode();
     if (!isHTMLVideoElement(*node) && !isHTMLAudioElement(*node))
         return;
 
     RefPtrWillBeRawPtr<HTMLMediaElement> mediaElement = static_pointer_cast<HTMLMediaElement>(node);
     switch (action.type) {
     case WebMediaPlayerAction::Play:
         if (action.enable)
             mediaElement->play();
         else
             mediaElement->pause();
         break;
     case WebMediaPlayerAction::Mute:
         mediaElement->setMuted(action.enable);
         break;
     case WebMediaPlayerAction::Loop:
         mediaElement->setLoop(action.enable);
         break;
     case WebMediaPlayerAction::Controls:
         mediaElement->setBooleanAttribute(HTMLNames::controlsAttr, action.enable);
         break;
     default:
         ASSERT_NOT_REACHED();
     }
 }
 
 void WebViewImpl::performPluginAction(const WebPluginAction& action,
                                       const WebPoint& location)
 {
-    HitTestResult result = hitTestResultForWindowPos(location);
+    // FIXME: Location is probably in viewport coordinates
+    HitTestResult result = hitTestResultForRootFramePos(location);
     RefPtrWillBeRawPtr<Node> node = result.innerNonSharedNode();
     if (!isHTMLObjectElement(*node) && !isHTMLEmbedElement(*node))
         return;
 
     LayoutObject* object = node->renderer();
     if (object && object->isLayoutPart()) {
         Widget* widget = toLayoutPart(object)->widget();
         if (widget && widget->isPluginContainer()) {
             WebPluginContainerImpl* plugin = toWebPluginContainerImpl(widget);
             switch (action.type) {
             case WebPluginAction::Rotate90Clockwise:
                 plugin->plugin()->rotateView(WebPlugin::RotationType90Clockwise);
                 break;
             case WebPluginAction::Rotate90Counterclockwise:
                 plugin->plugin()->rotateView(WebPlugin::RotationType90Counterclockwise);
                 break;
             default:
                 ASSERT_NOT_REACHED();
             }
         }
     }
 }
 
 WebHitTestResult WebViewImpl::hitTestResultAt(const WebPoint& point)
 {
     return coreHitTestResultAt(point);
 }
 
-HitTestResult WebViewImpl::coreHitTestResultAt(const WebPoint& point)
+HitTestResult WebViewImpl::coreHitTestResultAt(const WebPoint& pointInViewport)
 {
-    FloatPoint scaledPoint(point.x, point.y);
-    scaledPoint.scale(1 / pageScaleFactor(), 1 / pageScaleFactor());
-    scaledPoint.moveBy(pinchViewportOffset());
-    return hitTestResultForWindowPos(flooredIntPoint(scaledPoint));
+    FrameView* view = mainFrameImpl()->frameView();
+    IntPoint pointInRootFrame = view->contentsToFrame(view->viewportToContents(pointInViewport));
+    return hitTestResultForRootFramePos(pointInRootFrame);
 }
 
 void WebViewImpl::copyImageAt(const WebPoint& point)
 {
     if (!m_page)
         return;
 
-    HitTestResult result = hitTestResultForWindowPos(point);
+    // FIXME: point is probably in viewport coordinates.
+    HitTestResult result = hitTestResultForRootFramePos(point);
     if (!isHTMLCanvasElement(result.innerNonSharedNode()) && result.absoluteImageURL().isEmpty()) {
         // There isn't actually an image at these coordinates.  Might be because
         // the window scrolled while the context menu was open or because the page
         // changed itself between when we thought there was an image here and when
         // we actually tried to retreive the image.
         //
         // FIXME: implement a cache of the most recent HitTestResult to avoid having
         //        to do two hit tests.
         return;
     }
 
     m_page->deprecatedLocalMainFrame()->editor().copyImage(result);
 }
 
 void WebViewImpl::saveImageAt(const WebPoint& point)
 {
     if (!m_client)
         return;
 
-    Node* node = hitTestResultForWindowPos(point).innerNonSharedNode();
+    // FIXME: point is probably in viewport coordinates.
+    Node* node = hitTestResultForRootFramePos(point).innerNonSharedNode();
     if (!node || !(isHTMLCanvasElement(*node) || isHTMLImageElement(*node)))
         return;
 
     String url = toElement(*node).imageSourceURL();
     if (!KURL(KURL(), url).protocolIsData())
         return;
 
     m_client->saveImageFromDataURL(url);
 }
 
@@ skipping 180 matching lines @@
         mainFrameImpl()->frame()->view()->enableAutoSizeMode(m_minAutoSize, m_maxAutoSize);
     else
         mainFrameImpl()->frame()->view()->disableAutoSizeMode();
 }
 
 unsigned long WebViewImpl::createUniqueIdentifierForRequest()
 {
     return createUniqueIdentifier();
 }
 
-void WebViewImpl::inspectElementAt(const WebPoint& point)
+void WebViewImpl::inspectElementAt(const WebPoint& pointInRootFrame)
 {
     if (!m_page)
         return;
 
-    if (point.x == -1 || point.y == -1) {
+    if (pointInRootFrame.x == -1 || pointInRootFrame.y == -1) {
         m_page->inspectorController().inspect(0);
     } else {
         HitTestRequest::HitTestRequestType hitType = HitTestRequest::Move | HitTestRequest::ReadOnly | HitTestRequest::AllowChildFrameContent;
         HitTestRequest request(hitType);
 
         WebMouseEvent dummyEvent;
         dummyEvent.type = WebInputEvent::MouseDown;
-        dummyEvent.x = point.x;
-        dummyEvent.y = point.y;
+        dummyEvent.x = pointInRootFrame.x;
+        dummyEvent.y = pointInRootFrame.y;
         IntPoint transformedPoint = PlatformMouseEventBuilder(m_page->deprecatedLocalMainFrame()->view(), dummyEvent).position();
-        HitTestResult result(m_page->deprecatedLocalMainFrame()->view()->windowToContents(transformedPoint));
+        HitTestResult result(m_page->deprecatedLocalMainFrame()->view()->rootFrameToContents(transformedPoint));
         m_page->deprecatedLocalMainFrame()->contentRenderer()->hitTest(request, result);
         Node* node = result.innerNode();
         if (!node && m_page->deprecatedLocalMainFrame()->document())
             node = m_page->deprecatedLocalMainFrame()->document()->documentElement();
         m_page->inspectorController().inspect(node);
     }
 }
 
 void WebViewImpl::setCompositorDeviceScaleFactorOverride(float deviceScaleFactor)
 {
@@ skipping 47 matching lines @@
     if (!page())
         return;
 
     page()->contextMenuController().clearContextMenu();
     m_contextMenuAllowed = true;
     if (LocalFrame* focusedFrame = toLocalFrame(page()->focusController().focusedOrMainFrame()))
         focusedFrame->eventHandler().sendContextMenuEventForKey();
     m_contextMenuAllowed = false;
 }
 
-void WebViewImpl::extractSmartClipData(WebRect rect, WebString& clipText, WebString& clipHtml, WebRect& clipRect)
+void WebViewImpl::extractSmartClipData(WebRect rectInViewport, WebString& clipText, WebString& clipHtml, WebRect& clipRectInViewport)
 {
     LocalFrame* localFrame = toLocalFrame(focusedCoreFrame());
     if (!localFrame)
         return;
-    SmartClipData clipData = SmartClip(localFrame).dataForRect(rect);
+    SmartClipData clipData = SmartClip(localFrame).dataForRect(rectInViewport);
     clipText = clipData.clipData();
-    clipRect = clipData.rect();
+    clipRectInViewport = clipData.rectInViewport();
 
     WebLocalFrameImpl* frame = mainFrameImpl();
     if (!frame)
         return;
-    WebPoint startPoint(rect.x, rect.y);
-    WebPoint endPoint(rect.x + rect.width, rect.y + rect.height);
-    VisiblePosition startVisiblePosition = frame->visiblePositionForWindowPoint(startPoint);
-    VisiblePosition endVisiblePosition = frame->visiblePositionForWindowPoint(endPoint);
+    WebPoint startPoint(rectInViewport.x, rectInViewport.y);
+    WebPoint endPoint(rectInViewport.x + rectInViewport.width, rectInViewport.y + rectInViewport.height);
+    VisiblePosition startVisiblePosition = frame->visiblePositionForViewportPoint(startPoint);
+    VisiblePosition endVisiblePosition = frame->visiblePositionForViewportPoint(endPoint);
 
     Position startPosition = startVisiblePosition.deepEquivalent();
     Position endPosition = endVisiblePosition.deepEquivalent();
 
     // document() will return null if -webkit-user-select is set to none.
     if (!startPosition.document() || !endPosition.document())
         return;
 
     RefPtrWillBeRawPtr<Range> range = Range::create(*startPosition.document(), startPosition, endPosition);
     if (!range)
@@ skipping 286 matching lines @@
     if (!frame || !frame->isLocalFrame())
         return 0;
 
     Document* document = toLocalFrame(frame)->document();
     if (!document)
         return 0;
 
     return document->focusedElement();
 }
 
-HitTestResult WebViewImpl::hitTestResultForWindowPos(const IntPoint& pos)
+HitTestResult WebViewImpl::hitTestResultForRootFramePos(const IntPoint& pos)
 {
     if (!m_page->mainFrame()->isLocalFrame())
         return HitTestResult();
-    IntPoint docPoint(m_page->deprecatedLocalMainFrame()->view()->windowToContents(pos));
+    IntPoint docPoint(m_page->deprecatedLocalMainFrame()->view()->rootFrameToContents(pos));
     HitTestResult result = m_page->deprecatedLocalMainFrame()->eventHandler().hitTestResultAtPoint(docPoint, HitTestRequest::ReadOnly | HitTestRequest::Active);
     result.setToShadowHostIfInClosedShadowRoot();
     return result;
 }
 
 WebHitTestResult WebViewImpl::hitTestResultForTap(const WebPoint& tapPointWindowPos, const WebSize& tapArea)
 {
     if (!m_page->mainFrame()->isLocalFrame())
         return HitTestResult();
 
@@ skipping 440 matching lines @@
     return mainFrameImpl()->frameView()->layoutSize().width() == m_size.width
         || (constraints.minimumScale == constraints.maximumScale && constraints.minimumScale != -1);
 }
 
 void WebViewImpl::forceNextWebGLContextCreationToFail()
 {
     WebGLRenderingContext::forceNextWebGLContextCreationToFail();
 }
 
 } // namespace blink