Make allocation count in TextBatch implicit

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 "GrBatch.h"
 #include "GrBatchFontCache.h"
@@ skipping 1445 matching lines @@
                 batch->fMaskType = kGrayscaleCoverageMask_MaskType;
                 break;
             case kA565_GrMaskFormat:
                 batch->fMaskType = kLCDCoverageMask_MaskType;
                 break;
             case kARGB_GrMaskFormat:
                 batch->fMaskType = kColorBitmapMask_MaskType;
                 break;
         }
         batch->fBatch.fNumGlyphs = glyphCount;
-        batch->fInstanceCount = 1;
-        batch->fAllocatedCount = kMinAllocated;
+        batch->fGeoCount = 1;
         batch->fFilteredColor = 0;
         batch->fFontCache = fontCache;
         batch->fUseBGR = false;
         return batch;
     }
 
     static TextBatch* CreateDistanceField(int glyphCount, GrBatchFontCache* fontCache,
                                           DistanceAdjustTable* distanceAdjustTable,
                                           SkColor filteredColor, bool isLCD,
                                           bool useBGR) {
         TextBatch* batch = SkNEW(TextBatch);
         batch->initClassID<TextBatch>();
         batch->fFontCache = fontCache;
         batch->fMaskType = isLCD ? kLCDDistanceField_MaskType : kGrayscaleDistanceField_MaskType;
         batch->fDistanceAdjustTable.reset(SkRef(distanceAdjustTable));
         batch->fFilteredColor = filteredColor;
         batch->fUseBGR = useBGR;
         batch->fBatch.fNumGlyphs = glyphCount;
-        batch->fInstanceCount = 1;
-        batch->fAllocatedCount = kMinAllocated;
+        batch->fGeoCount = 1;
         return batch;
     }
 
     const char* name() const override { return "TextBatch"; }
 
     void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
         if (kColorBitmapMask_MaskType == fMaskType) {
             out->setUnknownFourComponents();
         } else {
             out->setKnownFourComponents(fBatch.fColor);
@@ skipping 73 matching lines @@
         FlushInfo flushInfo;
         flushInfo.fGlyphsToFlush = 0;
         size_t vertexStride = gp->getVertexStride();
         SkASSERT(vertexStride == (usesDistanceFields ?
                                   get_vertex_stride_df(maskFormat, isLCD) :
                                   get_vertex_stride(maskFormat)));
 
         batchTarget->initDraw(gp, pipeline);
 
         int glyphCount = this->numGlyphs();
-        int instanceCount = fInstanceCount;
         const GrVertexBuffer* vertexBuffer;
 
         void* vertices = batchTarget->makeVertSpace(vertexStride,
                                                     glyphCount * kVerticesPerGlyph,
                                                     &vertexBuffer,
                                                     &flushInfo.fVertexOffset);
         flushInfo.fVertexBuffer.reset(SkRef(vertexBuffer));
         flushInfo.fIndexBuffer.reset(batchTarget->resourceProvider()->refQuadIndexBuffer());
         if (!vertices || !flushInfo.fVertexBuffer) {
             SkDebugf("Could not allocate vertices\n");
             return;
         }
 
         unsigned char* currVertex = reinterpret_cast<unsigned char*>(vertices);
 
         // We cache some values to avoid going to the glyphcache for the same fontScaler twice
         // in a row
         const SkDescriptor* desc = NULL;
         SkGlyphCache* cache = NULL;
         GrFontScaler* scaler = NULL;
         SkTypeface* typeface = NULL;
 
-        for (int i = 0; i < instanceCount; i++) {
+        for (int i = 0; i < fGeoCount; i++) {
             Geometry& args = fGeoData[i];
             Blob* blob = args.fBlob;
             Run& run = blob->fRuns[args.fRun];
             TextInfo& info = run.fSubRunInfo[args.fSubRun];
 
             uint64_t currentAtlasGen = fFontCache->atlasGeneration(maskFormat);
             bool regenerateTextureCoords = info.fAtlasGeneration != currentAtlasGen ||
                                            run.fStrike->isAbandoned();
             bool regenerateColors;
             if (usesDistanceFields) {
@@ skipping 139 matching lines @@
 
             currVertex += byteCount;
         }
         // Make sure to attach the last cache if applicable
         if (cache) {
             SkGlyphCache::AttachCache(cache);
         }
         this->flush(batchTarget, &flushInfo);
     }
 
-    // The minimum number of Geometry we will try to allocate.
-    static const int kMinAllocated = 4;
-
-    // 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() {
         const Geometry& geo = fGeoData[0];
         fBatch.fColor = geo.fColor;
         fBatch.fViewMatrix = geo.fBlob->fViewMatrix;
 
         // We don't yet position distance field text on the cpu, so we have to map the vertex bounds
         // into device space
         const Run& run = geo.fBlob->fRuns[geo.fRun];
         if (run.fSubRunInfo[geo.fSubRun].fDrawAsDistanceFields) {
             SkRect bounds = run.fVertexBounds;
             fBatch.fViewMatrix.mapRect(&bounds);
             this->setBounds(bounds);
         } else {
             this->setBounds(run.fVertexBounds);
         }
     }
 
 private:
     TextBatch() {} // initialized in factory functions.
 
     ~TextBatch() {
-        for (int i = 0; i < fInstanceCount; i++) {
+        for (int i = 0; i < fGeoCount; i++) {
             fGeoData[i].fBlob->unref();
         }
     }
 
     GrMaskFormat maskFormat() const {
         switch (fMaskType) {
             case kLCDCoverageMask_MaskType:
                 return kA565_GrMaskFormat;
             case kColorBitmapMask_MaskType:
                 return kARGB_GrMaskFormat;
@@ skipping 121 matching lines @@
                 return false;
             }
 
             // TODO see note above
             if (kLCDDistanceField_MaskType == fMaskType && this->color() != that->color()) {
             }
         }
 
         fBatch.fNumGlyphs += that->numGlyphs();
 
-        // 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);
+        // Reallocate space for geo data if necessary and then import that's geo data.
+        int newGeoCount = that->fGeoCount + fGeoCount;
+        // We assume (and here enforce) that the allocation size is the smallest power of two that
+        // is greater than or equal to the number of geometries (and at least
+        // kMinGeometryAllocated).
+        int newAllocSize = GrNextPow2(newGeoCount);
+        int currAllocSize = SkTMax<int>(kMinGeometryAllocated, GrNextPow2(fGeoCount));
+
+        if (newAllocSize > currAllocSize) {
+            fGeoData.realloc(newAllocSize);
         }
 
-        memcpy(&fGeoData[fInstanceCount], otherGeoData->get(),
-               otherInstanceCount * sizeof(Geometry));
-        int total = fInstanceCount + otherInstanceCount;
-        for (int i = fInstanceCount; i < total; i++) {
+        memcpy(&fGeoData[fGeoCount], that->fGeoData.get(), that->fGeoCount * sizeof(Geometry));
+        for (int i = fGeoCount; i < newGeoCount; ++i) {
             fGeoData[i].fBlob->ref();
         }
-        fInstanceCount = total;
+        fGeoCount = newGeoCount;
 
         this->joinBounds(that->bounds());
         return true;
     }
 
     // TODO just use class params
     // TODO trying to figure out why lcd is so whack
     GrGeometryProcessor* setupDfProcessor(const SkMatrix& viewMatrix, SkColor filteredColor,
                                           GrColor color, GrTexture* texture) {
         GrTextureParams params(SkShader::kClamp_TileMode, GrTextureParams::kBilerp_FilterMode);
@@ skipping 54 matching lines @@
     struct BatchTracker {
         GrColor fColor;
         SkMatrix fViewMatrix;
         bool fUsesLocalCoords;
         bool fColorIgnored;
         bool fCoverageIgnored;
         int fNumGlyphs;
     };
 
     BatchTracker fBatch;
-    SkAutoSTMalloc<kMinAllocated, Geometry> fGeoData;
-    int fInstanceCount;
-    int fAllocatedCount;
+    // The minimum number of Geometry we will try to allocate.
+    enum { kMinGeometryAllocated = 4 };
+    SkAutoSTMalloc<kMinGeometryAllocated, Geometry> fGeoData;
+    int fGeoCount;
 
     enum MaskType {
         kGrayscaleCoverageMask_MaskType,
         kLCDCoverageMask_MaskType,
         kColorBitmapMask_MaskType,
         kGrayscaleDistanceField_MaskType,
         kLCDDistanceField_MaskType,
     } fMaskType;
     bool fUseBGR; // fold this into the enum?
 
@@ skipping 237 matching lines @@
             gTextContext->createDrawTextBlob(rt, clip, grPaint, skPaint, viewMatrix, text,
                                              static_cast<size_t>(textLen), 0, 0, noClip));
 
     SkScalar transX = static_cast<SkScalar>(random->nextU());
     SkScalar transY = static_cast<SkScalar>(random->nextU());
     const GrAtlasTextBlob::Run::SubRunInfo& info = blob->fRuns[0].fSubRunInfo[0];
     return gTextContext->createBatch(blob, info, textLen, 0, 0, color, transX, transY, skPaint);
 }
 
 #endif