Remove some dead code around touch events and zooming.

sky/engine/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 79 matching lines @@
         if (element->isMouseFocusable())
             return true;
     }
     if (RenderStyle* renderStyle = node->renderStyle()) {
         if (renderStyle->affectedByActive() || renderStyle->affectedByHover())
             return true;
     }
     return false;
 }
 
-bool nodeIsZoomTarget(Node* node)
-{
-    if (node->isTextNode() || node->isShadowRoot())
-        return false;
-
-    ASSERT(node->renderer());
-    return node->renderer()->isBox();
-}
-
 static inline void appendQuadsToSubtargetList(Vector<FloatQuad>& quads, Node* node, SubtargetGeometryList& subtargets)
 {
     Vector<FloatQuad>::const_iterator it = quads.begin();
     const Vector<FloatQuad>::const_iterator end = quads.end();
     for (; it != end; ++it)
         subtargets.append(SubtargetGeometry(node, *it));
 }
 
 static inline void appendBasicSubtargetsForNode(Node* node, SubtargetGeometryList& subtargets)
 {
     // Node guaranteed to have renderer due to check in node filter.
     ASSERT(node->renderer());
 
     Vector<FloatQuad> quads;
     node->renderer()->absoluteQuads(quads);
 
     appendQuadsToSubtargetList(quads, node, subtargets);
 }
 
-static inline void appendZoomableSubtargets(Node* node, SubtargetGeometryList& subtargets)
-{
-    RenderBox* renderer = toRenderBox(node->renderer());
-    ASSERT(renderer);
-
-    Vector<FloatQuad> quads;
-    FloatRect borderBoxRect = renderer->borderBoxRect();
-    FloatRect contentBoxRect = renderer->contentBoxRect();
-    quads.append(renderer->localToAbsoluteQuad(borderBoxRect));
-    if (borderBoxRect != contentBoxRect)
-        quads.append(renderer->localToAbsoluteQuad(contentBoxRect));
-    // FIXME: For RenderBlocks, add column boxes and content boxes cleared for floats.
-
-    Vector<FloatQuad>::const_iterator it = quads.begin();
-    const Vector<FloatQuad>::const_iterator end = quads.end();
-    for (; it != end; ++it)
-        subtargets.append(SubtargetGeometry(node, *it));
-}
-
-static inline Node* parentShadowHostOrOwner(const Node* node)
-{
-    if (Node* ancestor = node->parentOrShadowHostNode())
-        return ancestor;
-    return 0;
-}
-
 // Compiles a list of subtargets of all the relevant target nodes.
 void compileSubtargetList(const Vector<RefPtr<Node> >& intersectedNodes, SubtargetGeometryList& subtargets, NodeFilter nodeFilter, AppendSubtargetsForNode appendSubtargetsForNode)
 {
     // Find candidates responding to tap gesture events in O(n) time.
     HashMap<RawPtr<Node>, RawPtr<Node> > responderMap;
     HashSet<RawPtr<Node> > ancestorsToRespondersSet;
     Vector<RawPtr<Node> > candidates;
     HashSet<RawPtr<Node> > editableAncestors;
 
     // A node matching the NodeFilter is called a responder. Candidate nodes must either be a
     // responder or have an ancestor that is a responder.
     // This iteration tests all ancestors at most once by caching earlier results.
     for (unsigned i = 0; i < intersectedNodes.size(); ++i) {
         Node* node = intersectedNodes[i].get();
         Vector<RawPtr<Node> > visitedNodes;
         Node* respondingNode = 0;
         for (Node* visitedNode = node; visitedNode; visitedNode = visitedNode->parentOrShadowHostNode()) {
             // Check if we already have a result for a common ancestor from another candidate.
             respondingNode = responderMap.get(visitedNode);
             if (respondingNode)
                 break;
             visitedNodes.append(visitedNode);
             // Check if the node filter applies, which would mean we have found a responding node.
             if (nodeFilter(visitedNode)) {
                 respondingNode = visitedNode;
                 // Continue the iteration to collect the ancestors of the responder, which we will need later.
-                for (visitedNode = parentShadowHostOrOwner(visitedNode); visitedNode; visitedNode = parentShadowHostOrOwner(visitedNode)) {
+                for (visitedNode = visitedNode->parentOrShadowHostNode(); visitedNode; visitedNode = visitedNode->parentOrShadowHostNode()) {
                     HashSet<RawPtr<Node> >::AddResult addResult = ancestorsToRespondersSet.add(visitedNode);
                     if (!addResult.isNewEntry)
                         break;
                 }
                 break;
             }
         }
         // Insert the detected responder for all the visited nodes.
         for (unsigned j = 0; j < visitedNodes.size(); j++)
             responderMap.add(visitedNodes[j], respondingNode);
@@ skipping 28 matching lines @@
                 editableAncestors.add(replacement);
                 parent = parent->parentOrShadowHostNode();
             }
             candidate = replacement;
         }
         if (candidate)
             appendSubtargetsForNode(candidate, subtargets);
     }
 }
 
-// Compiles a list of zoomable subtargets.
-void compileZoomableSubtargets(const Vector<RefPtr<Node> >& intersectedNodes, SubtargetGeometryList& subtargets)
-{
-    for (unsigned i = 0; i < intersectedNodes.size(); ++i) {
-        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);
-
-    // 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();
 
@@ skipping 126 matching lines @@
 } // namespace TouchAdjustment
 
 bool findBestClickableCandidate(Node*& targetNode, IntPoint& targetPoint, const IntPoint& touchHotspot, const IntRect& touchArea, const Vector<RefPtr<Node> >& nodes)
 {
     IntRect targetArea;
     TouchAdjustment::SubtargetGeometryList subtargets;
     TouchAdjustment::compileSubtargetList(nodes, subtargets, TouchAdjustment::nodeRespondsToTapGesture, TouchAdjustment::appendBasicSubtargetsForNode);
     return TouchAdjustment::findNodeWithLowestDistanceMetric(targetNode, targetPoint, targetArea, touchHotspot, touchArea, subtargets, TouchAdjustment::hybridDistanceFunction);
 }
 
-bool findBestZoomableArea(Node*& targetNode, IntRect& targetArea, const IntPoint& touchHotspot, const IntRect& touchArea, const Vector<RefPtr<Node> >& nodes)
-{
-    IntPoint targetPoint;
-    TouchAdjustment::SubtargetGeometryList subtargets;
-    TouchAdjustment::compileZoomableSubtargets(nodes, subtargets);
-    return TouchAdjustment::findNodeWithLowestDistanceMetric(targetNode, targetPoint, targetArea, touchHotspot, touchArea, subtargets, TouchAdjustment::zoomableIntersectionQuotient);
-}
-
 } // namespace blink