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

third_party/WebKit/Source/core/layout/LayoutText.cpp

 /*
  * (C) 1999 Lars Knoll (knoll@kde.org)
  * (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)
  * Copyright (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *
  * 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
@@ skipping 315 matching lines @@
         textBox->nextTextBox()->start() > textBox->end() && text.length() &&
         !text.right(1).containsOnlyWhitespace())
       plainTextBuilder.append(spaceCharacter);
   }
   return plainTextBuilder.toString();
 }
 
 void LayoutText::absoluteRects(Vector<IntRect>& rects,
                                const LayoutPoint& accumulatedOffset) const {
   for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox()) {
-    rects.append(enclosingIntRect(LayoutRect(
+    rects.push_back(enclosingIntRect(LayoutRect(
         LayoutPoint(accumulatedOffset) + box->location(), box->size())));
   }
 }
 
 static FloatRect localQuadForTextBox(InlineTextBox* box,
                                      unsigned start,
                                      unsigned end,
                                      bool useSelectionHeight) {
   unsigned realEnd = std::min(box->end() + 1, end);
   LayoutRect r = box->localSelectionRect(start, realEnd);
@@ skipping 38 matching lines @@
       if (useSelectionHeight) {
         LayoutRect selectionRect = box->localSelectionRect(start, end);
         if (box->isHorizontal()) {
           r.setHeight(selectionRect.height().toFloat());
           r.setY(selectionRect.y().toFloat());
         } else {
           r.setWidth(selectionRect.width().toFloat());
           r.setX(selectionRect.x().toFloat());
         }
       }
-      rects.append(localToAbsoluteQuad(r).enclosingBoundingBox());
+      rects.push_back(localToAbsoluteQuad(r).enclosingBoundingBox());
     } else {
       // FIXME: This code is wrong. It's converting local to absolute twice.
       // http://webkit.org/b/65722
       FloatRect rect = localQuadForTextBox(box, start, end, useSelectionHeight);
       if (!rect.isZero())
-        rects.append(localToAbsoluteQuad(rect).enclosingBoundingBox());
+        rects.push_back(localToAbsoluteQuad(rect).enclosingBoundingBox());
     }
   }
 }
 
 static IntRect ellipsisRectForBox(InlineTextBox* box,
                                   unsigned startPos,
                                   unsigned endPos) {
   if (!box)
     return IntRect();
 
@@ skipping 30 matching lines @@
     IntRect ellipsisRect = (option == ClipToEllipsis)
                                ? ellipsisRectForBox(box, 0, textLength())
                                : IntRect();
     if (!ellipsisRect.isEmpty()) {
       if (style()->isHorizontalWritingMode())
         boundaries.setWidth(ellipsisRect.maxX() - boundaries.x());
       else
         boundaries.setHeight(ellipsisRect.maxY() - boundaries.y());
     }
     if (localOrAbsolute == AbsoluteQuads)
-      quads.append(localToAbsoluteQuad(boundaries, mode));
+      quads.push_back(localToAbsoluteQuad(boundaries, mode));
     else
-      quads.append(boundaries);
+      quads.push_back(boundaries);
   }
 }
 
 void LayoutText::absoluteQuads(Vector<FloatQuad>& quads,
                                MapCoordinatesFlags mode) const {
   this->quads(quads, NoClipping, AbsoluteQuads, mode);
 }
 
 void LayoutText::absoluteQuadsForRange(Vector<FloatQuad>& quads,
                                        unsigned start,
@@ skipping 27 matching lines @@
       if (useSelectionHeight) {
         LayoutRect selectionRect = box->localSelectionRect(start, end);
         if (box->isHorizontal()) {
           r.setHeight(selectionRect.height());
           r.setY(selectionRect.y());
         } else {
           r.setWidth(selectionRect.width());
           r.setX(selectionRect.x());
         }
       }
-      quads.append(localToAbsoluteQuad(FloatRect(r)));
+      quads.push_back(localToAbsoluteQuad(FloatRect(r)));
     } else {
       FloatRect rect = localQuadForTextBox(box, start, end, useSelectionHeight);
       if (!rect.isZero())
-        quads.append(localToAbsoluteQuad(rect));
+        quads.push_back(localToAbsoluteQuad(rect));
     }
   }
 }
 
 FloatRect LayoutText::localBoundingBoxRectForAccessibility() const {
   FloatRect result;
   Vector<FloatQuad> quads;
   this->quads(quads, LayoutText::ClipToEllipsis, LayoutText::LocalQuads);
   for (const FloatQuad& quad : quads)
     result.unite(quad.boundingBox());
@@ skipping 1476 matching lines @@
   LayoutRect rect = LayoutRect(
       IntRect(firstRunX(), firstRunY(), linesBox.width(), linesBox.height()));
   LayoutBlock* block = containingBlock();
   if (block && hasTextBoxes())
     block->adjustChildDebugRect(rect);
 
   return rect;
 }
 
 }  // namespace blink