Convert BitmapTextBatch from STArray to AutoSTMalloc

src/gpu/GrAtlasTextContext.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "GrAtlasTextContext.h"
 
 #include "GrAtlas.h"
 #include "GrBatch.h"
@@ skipping 764 matching lines @@
     subRun->fGlyphEndIndex++;
     subRun->fVertexEndIndex += vertexStride * kVerticesPerGlyph;
 }
 
 class BitmapTextBatch : public GrBatch {
 public:
     typedef GrAtlasTextContext::BitmapTextBlob Blob;
     typedef Blob::Run Run;
     typedef Run::SubRunInfo TextInfo;
     struct Geometry {
-        Geometry() {}
-        Geometry(const Geometry& geometry)
-            : fBlob(SkRef(geometry.fBlob.get()))
-            , fRun(geometry.fRun)
-            , fSubRun(geometry.fSubRun)
-            , fColor(geometry.fColor)
-            , fTransX(geometry.fTransX)
-            , fTransY(geometry.fTransY) {}
-        SkAutoTUnref<Blob> fBlob;
+        Blob* fBlob;
         int fRun;
         int fSubRun;
         GrColor fColor;
         SkScalar fTransX;
         SkScalar fTransY;
     };
 
-    static GrBatch* Create(const Geometry& geometry, GrMaskFormat maskFormat,
-                           int glyphCount, GrBatchFontCache* fontCache) {
-        return SkNEW_ARGS(BitmapTextBatch, (geometry, maskFormat, glyphCount, fontCache));
+    static BitmapTextBatch* Create(GrMaskFormat maskFormat, int glyphCount,
+                                   GrBatchFontCache* fontCache) {
+        return SkNEW_ARGS(BitmapTextBatch, (maskFormat, glyphCount, fontCache));
     }
 
     const char* name() const override { return "BitmapTextBatch"; }
 
     void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
         if (kARGB_GrMaskFormat == fMaskFormat) {
             out->setUnknownFourComponents();
         } else {
             out->setKnownFourComponents(fBatch.fColor);
         }
@@ skipping 55 matching lines @@
                                             fMaskFormat,
                                             opaqueVertexColors,
                                             localMatrix));
 
         size_t vertexStride = gp->getVertexStride();
         SkASSERT(vertexStride == get_vertex_stride(fMaskFormat));
 
         this->initDraw(batchTarget, gp, pipeline);
 
         int glyphCount = this->numGlyphs();
-        int instanceCount = fGeoData.count();
+        int instanceCount = fInstanceCount;
         const GrVertexBuffer* vertexBuffer;
         int firstVertex;
 
         void* vertices = batchTarget->vertexPool()->makeSpace(vertexStride,
                                                               glyphCount * kVerticesPerGlyph,
                                                               &vertexBuffer,
                                                               &firstVertex);
         if (!vertices) {
             SkDebugf("Could not allocate vertices\n");
             return;
@@ skipping 121 matching lines @@
             // now copy all vertices
             size_t byteCount = info.fVertexEndIndex - info.fVertexStartIndex;
             memcpy(currVertex, blob->fVertices + info.fVertexStartIndex, byteCount);
 
             currVertex += byteCount;
         }
 
         this->flush(batchTarget, &drawInfo, instancesToFlush, maxInstancesPerDraw);
     }
 
-    SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
+    // The minimum number of Geometry we will try to allocate.
+    static const int kMinAllocated = 32;
+
+    // Total number of Geometry this Batch owns
+    int instanceCount() const { return fInstanceCount; }
+    SkAutoSTMalloc<kMinAllocated, Geometry>* geoData() { return &fGeoData; }
+
+    // to avoid even the initial copy of the struct, we have a getter for the first item which
+    // is used to seed the batch with its initial geometry.  After seeding, the client should call
+    // init() so the Batch can initialize itself
+    Geometry& geometry() { return fGeoData[0]; }
+    void init() {
+        fBatch.fColor = fGeoData[0].fColor;
+        fBatch.fViewMatrix = fGeoData[0].fBlob->fViewMatrix;
+    }
 
 private:
-    BitmapTextBatch(const Geometry& geometry, GrMaskFormat maskFormat,
+    BitmapTextBatch(GrMaskFormat maskFormat,
                     int glyphCount, GrBatchFontCache* fontCache)
             : fMaskFormat(maskFormat)
             , fPixelConfig(fontCache->getPixelConfig(maskFormat))
             , fFontCache(fontCache) {
         this->initClassID<BitmapTextBatch>();
-        fGeoData.push_back(geometry);
-        fBatch.fColor = geometry.fColor;
-        fBatch.fViewMatrix = geometry.fBlob->fViewMatrix;
         fBatch.fNumGlyphs = glyphCount;
+        fInstanceCount = 1;
+        fAllocatedCount = kMinAllocated;
+    }
+
+    ~BitmapTextBatch() {
+        for (int i = 0; i < fInstanceCount; i++) {
+            fGeoData[i].fBlob->unref();
+        }
     }
 
     void regenerateTextureCoords(GrGlyph* glyph, intptr_t vertex, size_t vertexStride) {
         int width = glyph->fBounds.width();
         int height = glyph->fBounds.height();
         int u0 = glyph->fAtlasLocation.fX;
         int v0 = glyph->fAtlasLocation.fY;
         int u1 = u0 + width;
         int v1 = v0 + height;
 
@@ skipping 82 matching lines @@
 
         if (this->fMaskFormat != kA8_GrMaskFormat && this->color() != that->color()) {
             return false;
         }
 
         if (this->usesLocalCoords() && !this->viewMatrix().cheapEqualTo(that->viewMatrix())) {
             return false;
         }
 
         fBatch.fNumGlyphs += that->numGlyphs();
-        fGeoData.push_back_n(that->geoData()->count(), that->geoData()->begin());
+
+        // copy that->geoData().  We do this manually for performance reasons
+        SkAutoSTMalloc<kMinAllocated, Geometry>* otherGeoData = that->geoData();
+        int otherInstanceCount = that->instanceCount();
+        int allocSize = otherInstanceCount + fInstanceCount;
+        if (allocSize > fAllocatedCount) {
+            while (allocSize > fAllocatedCount) {
+                fAllocatedCount = fAllocatedCount << 1;
+            }
+            fGeoData.realloc(fAllocatedCount);
+        }
+
+        memcpy(&fGeoData[fInstanceCount], otherGeoData->get(),
+               otherInstanceCount * sizeof(Geometry));
+        int total = fInstanceCount + otherInstanceCount;
+        for (int i = fInstanceCount; i < total; i++) {
+            fGeoData[i].fBlob->ref();
+        }
+        fInstanceCount = total;
         return true;
     }
 
     struct BatchTracker {
         GrColor fColor;
         SkMatrix fViewMatrix;
         bool fUsesLocalCoords;
         bool fColorIgnored;
         bool fCoverageIgnored;
         int fNumGlyphs;
     };
 
     BatchTracker fBatch;
-    SkSTArray<1, Geometry, true> fGeoData;
+    SkAutoSTMalloc<kMinAllocated, Geometry> fGeoData;
+    int fInstanceCount;
+    int fAllocatedCount;
     GrMaskFormat fMaskFormat;
     GrPixelConfig fPixelConfig;
     GrBatchFontCache* fFontCache;
 };
 
 void GrAtlasTextContext::flushRunAsPaths(const SkTextBlob::RunIterator& it, const SkPaint& skPaint,
                                          SkDrawFilter* drawFilter, const SkMatrix& viewMatrix,
                                          const SkIRect& clipBounds, SkScalar x, SkScalar y) {
     SkPaint runPaint = skPaint;
 
@@ skipping 33 matching lines @@
         int glyphCount = info.fGlyphEndIndex - info.fGlyphStartIndex;
         if (0 == glyphCount) {
             continue;
         }
 
         GrMaskFormat format = info.fMaskFormat;
         GrColor subRunColor = kARGB_GrMaskFormat == format ?
                               SkColorSetARGB(paintAlpha, paintAlpha, paintAlpha, paintAlpha) :
                               color;
 
-        BitmapTextBatch::Geometry geometry;
-        geometry.fBlob.reset(SkRef(cacheBlob));
+        SkAutoTUnref<BitmapTextBatch> batch(BitmapTextBatch::Create(format, glyphCount,
+                                                            fContext->getBatchFontCache()));
+        BitmapTextBatch::Geometry& geometry = batch->geometry();
+        geometry.fBlob = SkRef(cacheBlob);
         geometry.fRun = run;
         geometry.fSubRun = subRun;
         geometry.fColor = subRunColor;
         geometry.fTransX = transX;
         geometry.fTransY = transY;
-        SkAutoTUnref<GrBatch> batch(BitmapTextBatch::Create(geometry, format, glyphCount,
-                                                            fContext->getBatchFontCache()));
+        batch->init();
 
         target->drawBatch(pipelineBuilder, batch, &cacheBlob->fRuns[run].fVertexBounds);
     }
 }
 
 inline void GrAtlasTextContext::flushBigGlyphs(BitmapTextBlob* cacheBlob, GrRenderTarget* rt,
                                                const GrPaint& grPaint, const GrClip& clip,
                                                SkScalar transX, SkScalar transY) {
     for (int i = 0; i < cacheBlob->fBigGlyphs.count(); i++) {
         BitmapTextBlob::BigGlyph& bigGlyph = cacheBlob->fBigGlyphs[i];
@@ skipping 55 matching lines @@
 
     GrColor color = grPaint.getColor();
     uint8_t paintAlpha = skPaint.getAlpha();
     for (int run = 0; run < cacheBlob->fRunCount; run++) {
         this->flushRun(target, &pipelineBuilder, cacheBlob, run, color, paintAlpha, 0, 0);
     }
 
     // Now flush big glyphs
     this->flushBigGlyphs(cacheBlob, rt, grPaint, clip, 0, 0);
 }