Removed FrameView's windowToContents and contentsToWindow methods.

Source/core/frame/SmartClip.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 25 matching lines @@
 #include "core/dom/NodeTraversal.h"
 #include "core/frame/LocalDOMWindow.h"
 #include "core/frame/FrameView.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/layout/LayoutObject.h"
 #include "core/page/Page.h"
 #include "wtf/text/StringBuilder.h"
 
 namespace blink {
 
-static IntRect applyScaleWithoutCollapsingToZero(const IntRect& rect, float scale)
+static IntRect convertToContentCoordinatesWithoutCollapsingToZero(const IntRect& rectInViewport, const FrameView* view)
 {
-    IntRect result = rect;
-    result.scale(scale);
-    if (rect.width() > 0 && !result.width())
-        result.setWidth(1);
-    if (rect.height() > 0 && !result.height())
-        result.setHeight(1);
-    return result;
+    IntRect rectInContents = view->viewportToContents(rectInViewport);
+    if (rectInViewport.width() > 0 && !rectInContents.width())
+        rectInContents.setWidth(1);
+    if (rectInViewport.height() > 0 && !rectInContents.height())
+        rectInContents.setHeight(1);
+    return rectInContents;
 }
 
 static Node* nodeInsideFrame(Node* node)
 {
     if (node->isFrameOwnerElement())
         return toHTMLFrameOwnerElement(node)->contentDocument();
     return nullptr;
 }
 
-IntRect SmartClipData::rect() const
+IntRect SmartClipData::rectInViewport() const
 {
-    return m_rect;
+    return m_rectInViewport;
 }
 
 const String& SmartClipData::clipData() const
 {
     return m_string;
 }
 
 SmartClip::SmartClip(PassRefPtrWillBeRawPtr<LocalFrame> frame)
     : m_frame(frame)
 {
 }
 
-SmartClipData SmartClip::dataForRect(const IntRect& cropRect)
+SmartClipData SmartClip::dataForRect(const IntRect& cropRectInViewport)
 {
-    IntRect resizedCropRect = applyScaleWithoutCollapsingToZero(cropRect, 1 / pageScaleFactor());
-
-    Node* bestNode = findBestOverlappingNode(m_frame->document(), resizedCropRect);
+    Node* bestNode = findBestOverlappingNode(m_frame->document(), cropRectInViewport);
     if (!bestNode)
         return SmartClipData();
 
     if (Node* nodeFromFrame = nodeInsideFrame(bestNode)) {
         // FIXME: This code only hit-tests a single iframe. It seems like we ought support nested frames.
-        if (Node* bestNodeInFrame = findBestOverlappingNode(nodeFromFrame, resizedCropRect))
+        if (Node* bestNodeInFrame = findBestOverlappingNode(nodeFromFrame, cropRectInViewport))
             bestNode = bestNodeInFrame;
     }
 
     WillBeHeapVector<RawPtrWillBeMember<Node>> hitNodes;
-    collectOverlappingChildNodes(bestNode, resizedCropRect, hitNodes);
+    collectOverlappingChildNodes(bestNode, cropRectInViewport, hitNodes);
 
     if (hitNodes.isEmpty() || hitNodes.size() == bestNode->countChildren()) {
         hitNodes.clear();
         hitNodes.append(bestNode);
     }
 
     // Unite won't work with the empty rect, so we initialize to the first rect.
     IntRect unitedRects = hitNodes[0]->pixelSnappedBoundingBox();
     StringBuilder collectedText;
     for (size_t i = 0; i < hitNodes.size(); ++i) {
         collectedText.append(extractTextFromNode(hitNodes[i]));
         unitedRects.unite(hitNodes[i]->pixelSnappedBoundingBox());
     }
 
-    return SmartClipData(bestNode, convertRectToWindow(unitedRects), collectedText.toString());
+    return SmartClipData(bestNode, m_frame->document()->view()->contentsToViewport(unitedRects), collectedText.toString());
 }
 
 float SmartClip::pageScaleFactor()
 {
     return m_frame->page()->pageScaleFactor();
 }
 
 // This function is a bit of a mystery. If you understand what it does, please
 // consider adding a more descriptive name.
 Node* SmartClip::minNodeContainsNodes(Node* minNode, Node* newNode)
@@ skipping 32 matching lines @@
             if (nodeRect.contains(newNodeRect)) {
                 return node;
             }
         }
         node = node->parentNode();
     }
 
     return nullptr;
 }
 
-Node* SmartClip::findBestOverlappingNode(Node* rootNode, const IntRect& cropRect)
+Node* SmartClip::findBestOverlappingNode(Node* rootNode, const IntRect& cropRectInViewport)
 {
     if (!rootNode)
         return nullptr;
 
-    IntRect resizedCropRect = rootNode->document().view()->windowToContents(cropRect);
+    IntRect resizedCropRect = convertToContentCoordinatesWithoutCollapsingToZero(cropRectInViewport, rootNode->document().view());
 
     Node* node = rootNode;
     Node* minNode = nullptr;
 
     while (node) {
         IntRect nodeRect = node->pixelSnappedBoundingBox();
 
         if (node->isElementNode() && equalIgnoringCase(toElement(node)->fastGetAttribute(HTMLNames::aria_hiddenAttr), "true")) {
             node = NodeTraversal::nextSkippingChildren(*node, rootNode);
             continue;
@@ skipping 33 matching lines @@
     // image out of a CSS background, you're probably going to specify a height
     // or a width. On the other hand, if we've got a legit background image,
     // it's very likely the height or the width will be set to auto.
     LayoutObject* renderer = node->layoutObject();
     if (renderer && (renderer->style()->logicalHeight().isAuto() || renderer->style()->logicalWidth().isAuto()))
         return true;
 
     return false;
 }
 
-void SmartClip::collectOverlappingChildNodes(Node* parentNode, const IntRect& cropRect, WillBeHeapVector<RawPtrWillBeMember<Node>>& hitNodes)
+void SmartClip::collectOverlappingChildNodes(Node* parentNode, const IntRect& cropRectInViewport, WillBeHeapVector<RawPtrWillBeMember<Node>>& hitNodes)
 {
     if (!parentNode)
         return;
-    IntRect resizedCropRect = parentNode->document().view()->windowToContents(cropRect);
+    IntRect resizedCropRect = convertToContentCoordinatesWithoutCollapsingToZero(cropRectInViewport, parentNode->document().view());
     for (Node* child = parentNode->firstChild(); child; child = child->nextSibling()) {
         IntRect childRect = child->pixelSnappedBoundingBox();
         if (resizedCropRect.intersects(childRect))
             hitNodes.append(child);
     }
 }
 
-IntRect SmartClip::convertRectToWindow(const IntRect& nodeRect)
-{
-    IntRect result = m_frame->document()->view()->contentsToWindow(nodeRect);
-    result.scale(pageScaleFactor());
-    return result;
-}
-
 String SmartClip::extractTextFromNode(Node* node)
 {
     // Science has proven that no text nodes are ever positioned at y == -99999.
     int prevYPos = -99999;
 
     StringBuilder result;
     for (Node& currentNode : NodeTraversal::inclusiveDescendantsOf(*node)) {
         const LayoutStyle* style = currentNode.computedStyle();
         if (style && style->userSelect() == SELECT_NONE)
             continue;
@@ skipping 18 matching lines @@
 
                 result.append(nodeValue);
             }
         }
     }
 
     return result.toString();
 }
 
 } // namespace blink