Migrate WTF::Vector::append() to ::push_back() [part 11 of N]

third_party/WebKit/Source/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 135 matching lines @@
   return false;
 }
 
 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));
+    subtargets.push_back(SubtargetGeometry(node, *it));
 }
 
 static inline void appendBasicSubtargetsForNode(
     Node* node,
     SubtargetGeometryList& subtargets) {
   // Node guaranteed to have layoutObject due to check in node filter.
   ASSERT(node->layoutObject());
 
   Vector<FloatQuad> quads;
   node->layoutObject()->absoluteQuads(quads);
@@ skipping 66 matching lines @@
 }
 
 static inline void appendZoomableSubtargets(Node* node,
                                             SubtargetGeometryList& subtargets) {
   LayoutBox* layoutObject = toLayoutBox(node->layoutObject());
   ASSERT(layoutObject);
 
   Vector<FloatQuad> quads;
   FloatRect borderBoxRect(layoutObject->borderBoxRect());
   FloatRect contentBoxRect(layoutObject->contentBoxRect());
-  quads.append(layoutObject->localToAbsoluteQuad(borderBoxRect));
+  quads.push_back(layoutObject->localToAbsoluteQuad(borderBoxRect));
   if (borderBoxRect != contentBoxRect)
-    quads.append(layoutObject->localToAbsoluteQuad(contentBoxRect));
+    quads.push_back(layoutObject->localToAbsoluteQuad(contentBoxRect));
   // FIXME: For LayoutBlocks, 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));
+    subtargets.push_back(SubtargetGeometry(node, *it));
 }
 
 static inline Node* parentShadowHostOrOwner(const Node* node) {
   if (Node* ancestor = node->parentOrShadowHostNode())
     return ancestor;
   if (node->isDocumentNode())
     return toDocument(node)->localOwner();
   return nullptr;
 }
 
@@ skipping 15 matching lines @@
     Node* node = intersectedNodes[i].get();
     HeapVector<Member<Node>> visitedNodes;
     Node* respondingNode = nullptr;
     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);
+      visitedNodes.push_back(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)) {
           HeapHashSet<Member<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);
 
     if (respondingNode)
-      candidates.append(node);
+      candidates.push_back(node);
   }
 
   // We compile the list of component absolute quads instead of using the
   // bounding rect to be able to perform better hit-testing on inline links on
   // line-breaks.
   for (unsigned i = 0; i < candidates.size(); i++) {
     Node* candidate = candidates[i];
     // Skip nodes who's responders are ancestors of other responders. This gives
     // preference to the inner-most event-handlers. So that a link is always
     // preferred even when contained in an element that monitors all
@@ skipping 241 matching lines @@
                           const HeapVector<Member<Node>>& nodes) {
   IntPoint targetPoint;
   TouchAdjustment::SubtargetGeometryList subtargets;
   TouchAdjustment::compileZoomableSubtargets(nodes, subtargets);
   return TouchAdjustment::findNodeWithLowestDistanceMetric(
       targetNode, targetPoint, targetArea, touchHotspot, touchArea, subtargets,
       TouchAdjustment::zoomableIntersectionQuotient);
 }
 
 }  // namespace blink