Rename SkTArray::reserve to reserve_back.

The semantics of `vector::reserve` and `SkTArray::reserve` were not the
same. SkTArray::reserve takes a delta over the current array size,
whereas vector takes a total array size. This could lead to subtle
errors with over- or under-reservation, hurting performance.

This CL renames `SkTArray::reserve` to `SkTArray::reserve_back` to give
the SkTArray behavior a distinct (hopefully easily understandable) name,
leaving its functionality as-is.

Change-Id: Icbd3114bb317fd5f307f393c02ae6fb6f83764e9
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/326956
Commit-Queue: John Stiles <johnstiles@google.com>
Reviewed-by: Mike Klein <mtklein@google.com>

Author: johnstiles-google

bench/CreateBackendTextureBench.cpp

@@ -28,7 +28,7 @@ class CreateBackendTextureBench : public Benchmark {
     void onDraw(int loops, SkCanvas* canvas) override {
         auto context = canvas->recordingContext()->asDirectContext();
 
-        fBackendTextures.reserve(loops);
+        fBackendTextures.reserve_back(loops);
 
         static const int kSize = 16;
         for (int i = 0; i < loops; ++i) {

bench/SKPBench.cpp

@@ -57,7 +57,7 @@ void SKPBench::onPerCanvasPreDraw(SkCanvas* canvas) {
     int xTiles = SkScalarCeilToInt(bounds.width()  / SkIntToScalar(tileW));
     int yTiles = SkScalarCeilToInt(bounds.height() / SkIntToScalar(tileH));
 
-    fSurfaces.reserve(xTiles * yTiles);
+    fSurfaces.reserve_back(xTiles * yTiles);
     fTileRects.setReserve(xTiles * yTiles);
 
     SkImageInfo ii = canvas->imageInfo().makeWH(tileW, tileH);

include/private/SkTArray.h

@@ -162,9 +162,9 @@ template <typename T, bool MEM_MOVE = false> class SkTArray {
     /**
      * Ensures there is enough reserved space for n additional elements. The is guaranteed at least
      * until the array size grows above n and subsequently shrinks below n, any version of reset()
-     * is called, or reserve() is called again.
+     * is called, or reserve_back() is called again.
      */
-    void reserve(int n) {
+    void reserve_back(int n) {
         SkASSERT(n >= 0);
         if (n > 0) {
             this->checkRealloc(n);

modules/skparagraph/src/ParagraphImpl.cpp

@@ -308,7 +308,7 @@ void ParagraphImpl::buildClusterTable() {
             fCodeUnitProperties[run.textRange().start] |= CodeUnitFlags::kSoftLineBreakBefore;
             fCodeUnitProperties[run.textRange().end] |= CodeUnitFlags::kSoftLineBreakBefore;
         } else {
-            fClusters.reserve(fClusters.size() + run.size());
+            fClusters.reserve_back(fClusters.size() + run.size());
             // Walk through the glyph in the direction of input text
             run.iterateThroughClustersInTextOrder([runIndex, this](size_t glyphStart,
                                                                    size_t glyphEnd,

samplecode/SampleImageFilterDAG.cpp

@@ -70,7 +70,7 @@ struct FilterNode {
         this->computeInputBounds();
         this->computeOutputBounds();
         if (fFilter) {
-            fInputNodes.reserve(fFilter->countInputs());
+            fInputNodes.reserve_back(fFilter->countInputs());
             for (int i = 0; i < fFilter->countInputs(); ++i) {
                 fInputNodes.emplace_back(fFilter->getInput(i), mapping, content, depth + 1);
             }

src/core/SkPictureData.cpp

@@ -327,7 +327,7 @@ bool SkPictureData::parseStreamTag(SkStream* stream,
         } break;
         case SK_PICT_PICTURE_TAG: {
             SkASSERT(fPictures.empty());
-            fPictures.reserve(SkToInt(size));
+            fPictures.reserve_back(SkToInt(size));
 
             for (uint32_t i = 0; i < size; i++) {
                 auto pic = SkPicture::MakeFromStream(stream, &procs, topLevelTFPlayback);

src/core/SkTTopoSort.h

@@ -86,7 +86,7 @@ bool SkTTopoSort(SkTArray<sk_sp<T>>* graph) {
     SkTTopoSort_CheckAllUnmarked<T, Traits>(*graph);
 #endif
 
-    result.reserve(graph->count());
+    result.reserve_back(graph->count());
 
     for (int i = 0; i < graph->count(); ++i) {
         if (Traits::WasOutput((*graph)[i].get())) {

src/gpu/ccpr/GrCCStrokeGeometry.cpp

@@ -572,12 +572,12 @@ void GrCCStrokeGeometry::recordCapsIfAny() {
 
     // Reserve the space first, since push_back() takes the point by reference and might
     // invalidate the reference if the array grows.
-    fPoints.reserve(fPoints.count() + 1);
+    fPoints.reserve_back(fPoints.count() + 1);
     fPoints.push_back(fPoints[fCurrContourFirstPtIdx]);
 
     // Reserve the space first, since push_back() takes the normal by reference and might
     // invalidate the reference if the array grows. (Although in this case we should be fine
     // since there is a negate operator.)
-    fNormals.reserve(fNormals.count() + 1);
+    fNormals.reserve_back(fNormals.count() + 1);
     fNormals.push_back(-fNormals[fCurrContourFirstNormalIdx]);
 }

src/gpu/ccpr/GrCoverageCountingPathRenderer.cpp

@@ -246,7 +246,7 @@ void GrCoverageCountingPathRenderer::preFlush(
 
     // Move the per-opsTask paths that are about to be flushed from fPendingPaths to fFlushingPaths,
     // and count them up so we can preallocate buffers.
-    fFlushingPaths.reserve(numOpsTaskIDs);
+    fFlushingPaths.reserve_back(numOpsTaskIDs);
     for (int i = 0; i < numOpsTaskIDs; ++i) {
         auto iter = fPendingPaths.find(opsTaskIDs[i]);
         if (fPendingPaths.end() == iter) {

src/gpu/gradients/GrGradientShader.cpp

@@ -185,7 +185,7 @@ static std::unique_ptr<GrFragmentProcessor> make_gradient(const SkGradientShader
     if (shader.fOrigPos) {
         positions = shader.fOrigPos;
     } else {
-        implicitPos.reserve(shader.fColorCount);
+        implicitPos.reserve_back(shader.fColorCount);
         SkScalar posScale = SK_Scalar1 / (shader.fColorCount - 1);
         for (int i = 0 ; i < shader.fColorCount; i++) {
             implicitPos.push_back(SkIntToScalar(i) * posScale);