Switch to one single bitmap text blob cache allocation

src/gpu/GrBitmapTextContext.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "GrBitmapTextContext.h"
 
 #include "GrAtlas.h"
 #include "GrBatch.h"
@@ skipping 83 matching lines @@
 }
 
 bool GrBitmapTextContextB::MustRegenerateBlob(const BitmapTextBlob& blob, const SkPaint& paint,
                                              const SkMatrix& viewMatrix, SkScalar x, SkScalar y) {
     // We always regenerate blobs with patheffects or mask filters we could cache these
     // TODO find some way to cache the maskfilter / patheffects on the textblob
     return !blob.fViewMatrix.cheapEqualTo(viewMatrix) || blob.fX != x || blob.fY != y ||
             paint.getMaskFilter() || paint.getPathEffect() || paint.getStyle() != blob.fStyle;
 }
 
+
+inline SkGlyphCache* GrBitmapTextContextB::setupCache(BitmapTextBlob::Run* run,
+                                                      const SkPaint& skPaint,
+                                                      const SkMatrix& viewMatrix) {
+    skPaint.getScalerContextDescriptor(&run->fDescriptor, &fDeviceProperties, &viewMatrix, false);
+    run->fTypeface.reset(SkSafeRef(skPaint.getTypeface()));
+    return SkGlyphCache::DetachCache(run->fTypeface, run->fDescriptor.getDesc());
+}
+
+inline void GrBitmapTextContextB::BlobGlyphCount(int* glyphCount, int* runCount,
+                                                 const SkTextBlob* blob) {
+    SkTextBlob::RunIterator itCounter(blob);
+    for (; !itCounter.done(); itCounter.next(), (*runCount)++) {
+        *glyphCount += itCounter.glyphCount();
+    }
+}
+
+GrBitmapTextContextB::BitmapTextBlob* GrBitmapTextContextB::CreateBlob(int glyphCount,
+                                                                       int runCount) {
+    // We allocate size for the BitmapTextBlob itself, plus size for the vertices array,
+    // and size for the glyphIds array.
+    SK_COMPILE_ASSERT(kGrayTextVASize >= kColorTextVASize && kGrayTextVASize >= kLCDTextVASize,
+                      vertex_attribute_changed);
+    size_t verticesCount = glyphCount * kVerticesPerGlyph * kGrayTextVASize;
+    size_t length = sizeof(BitmapTextBlob) +
+                    verticesCount +
+                    glyphCount * sizeof(GrGlyph::PackedID) +
+                    sizeof(BitmapTextBlob::Run) * runCount;
+
+    BitmapTextBlob* cacheBlob = SkNEW_PLACEMENT(sk_malloc_throw(length), BitmapTextBlob);
+
+    // setup offsets for vertices / glyphs
+    cacheBlob->fVertices = sizeof(BitmapTextBlob) + reinterpret_cast<unsigned char*>(cacheBlob);
+    cacheBlob->fGlyphIDs =
+            reinterpret_cast<GrGlyph::PackedID*>(cacheBlob->fVertices + verticesCount);
+    cacheBlob->fRuns = reinterpret_cast<BitmapTextBlob::Run*>(cacheBlob->fGlyphIDs + glyphCount);
+
+    // Initialize runs
+    for (int i = 0; i < runCount; i++) {
+        SkNEW_PLACEMENT(&cacheBlob->fRuns[i], BitmapTextBlob::Run);
+    }
+    cacheBlob->fRunCount = runCount;
+    return cacheBlob;
+}
+
 void GrBitmapTextContextB::drawTextBlob(GrRenderTarget* rt, const GrClip& clip,
                                         const SkPaint& skPaint, const SkMatrix& viewMatrix,
                                         const SkTextBlob* blob, SkScalar x, SkScalar y,
                                         SkDrawFilter* drawFilter, const SkIRect& clipBounds) {
     BitmapTextBlob* cacheBlob;
     BitmapTextBlob** foundBlob = fCache.find(blob->uniqueID());
-
     SkIRect clipRect;
     clip.getConservativeBounds(rt->width(), rt->height(), &clipRect);
 
     if (foundBlob) {
         cacheBlob = *foundBlob;
         if (MustRegenerateBlob(*cacheBlob, skPaint, viewMatrix, x, y)) {
-            // We can get away with reusing the blob if there are no outstanding refs on it.
-            // However, we still have to reset all of the runs.
-            if (!cacheBlob->unique()) {
-                cacheBlob->unref();
-                cacheBlob = SkNEW(BitmapTextBlob);
-                fCache.set(blob->uniqueID(), cacheBlob);
-            }
+            // We have to remake the blob because changes may invalidate our masks.
+            // TODO we could probably get away reuse most of the time if the pointer is unique,
+            // but we'd have to clear the subrun information
+            cacheBlob->unref();
+            int glyphCount = 0;
+            int runCount = 0;
+            BlobGlyphCount(&glyphCount, &runCount, blob);
+            cacheBlob = CreateBlob(glyphCount, runCount);
+            fCache.set(blob->uniqueID(), cacheBlob);
             this->regenerateTextBlob(cacheBlob, skPaint, viewMatrix, blob, x, y, drawFilter,
                                      clipRect);
         }
     } else {
-        cacheBlob = SkNEW(BitmapTextBlob);
+        int glyphCount = 0;
+        int runCount = 0;
+        BlobGlyphCount(&glyphCount, &runCount, blob);
+        cacheBlob = CreateBlob(glyphCount, runCount);
         fCache.set(blob->uniqueID(), cacheBlob);
         this->regenerateTextBlob(cacheBlob, skPaint, viewMatrix, blob, x, y, drawFilter, clipRect);
     }
 
     // Though for the time being runs in the textblob can override the paint, they only touch font
     // info.
     GrPaint grPaint;
     SkPaint2GrPaintShader(fContext, rt, skPaint, viewMatrix, true, &grPaint);
 
     this->flush(fContext->getTextTarget(), cacheBlob, rt, grPaint, clip, viewMatrix,
                 fSkPaint.getAlpha());
 }
 
 void GrBitmapTextContextB::regenerateTextBlob(BitmapTextBlob* cacheBlob,
                                               const SkPaint& skPaint, const SkMatrix& viewMatrix,
                                               const SkTextBlob* blob, SkScalar x, SkScalar y,
                                               SkDrawFilter* drawFilter, const SkIRect& clipRect) {
     cacheBlob->fViewMatrix = viewMatrix;
     cacheBlob->fX = x;
     cacheBlob->fY = y;
     cacheBlob->fStyle = skPaint.getStyle();
-    cacheBlob->fRuns.reset(blob->fRunCount);
 
     // Regenerate textblob
     SkPaint runPaint = skPaint;
     SkTextBlob::RunIterator it(blob);
     for (int run = 0; !it.done(); it.next(), run++) {
-        size_t textLen = it.glyphCount() * sizeof(uint16_t);
+        int glyphCount = it.glyphCount();
+        size_t textLen = glyphCount * sizeof(uint16_t);
         const SkPoint& offset = it.offset();
         // applyFontToPaint() always overwrites the exact same attributes,
         // so it is safe to not re-seed the paint for this reason.
         it.applyFontToPaint(&runPaint);
 
         if (drawFilter && !drawFilter->filter(&runPaint, SkDrawFilter::kText_Type)) {
             // A false return from filter() means we should abort the current draw.
             runPaint = skPaint;
             continue;
         }
 
         runPaint.setFlags(fGpuDevice->filterTextFlags(runPaint));
 
+        SkGlyphCache* cache = this->setupCache(&cacheBlob->fRuns[run], runPaint, viewMatrix);
+
+        // setup vertex / glyphIndex for the new run
+        if (run > 0) {
+            PerSubRunInfo& newRun = cacheBlob->fRuns[run].fSubRunInfo.back();
+            PerSubRunInfo& lastRun = cacheBlob->fRuns[run - 1].fSubRunInfo.back();
+
+            newRun.fVertexStartIndex = lastRun.fVertexEndIndex;
+            newRun.fVertexEndIndex = lastRun.fVertexEndIndex;
+
+            newRun.fGlyphStartIndex = lastRun.fGlyphEndIndex;
+            newRun.fGlyphEndIndex = lastRun.fGlyphEndIndex;
+        }
+
         switch (it.positioning()) {
             case SkTextBlob::kDefault_Positioning:
-                this->internalDrawText(cacheBlob, run, runPaint, viewMatrix,
+                this->internalDrawText(cacheBlob, run, cache, runPaint, viewMatrix,
                                        (const char *)it.glyphs(), textLen,
                                        x + offset.x(), y + offset.y(), clipRect);
                 break;
             case SkTextBlob::kHorizontal_Positioning:
-                this->internalDrawPosText(cacheBlob, run, runPaint, viewMatrix,
+                this->internalDrawPosText(cacheBlob, run, cache, runPaint, viewMatrix,
                                           (const char*)it.glyphs(), textLen, it.pos(), 1,
                                           SkPoint::Make(x, y + offset.y()), clipRect);
                 break;
             case SkTextBlob::kFull_Positioning:
-                this->internalDrawPosText(cacheBlob, run, runPaint, viewMatrix,
+                this->internalDrawPosText(cacheBlob, run, cache, runPaint, viewMatrix,
                                           (const char*)it.glyphs(), textLen, it.pos(), 2,
                                           SkPoint::Make(x, y), clipRect);
                 break;
         }
 
         if (drawFilter) {
             // A draw filter may change the paint arbitrarily, so we must re-seed in this case.
             runPaint = skPaint;
         }
+
+        SkGlyphCache::AttachCache(cache);
     }
 }
 
 void GrBitmapTextContextB::onDrawText(GrRenderTarget* rt, const GrClip& clip,
                                      const GrPaint& paint, const SkPaint& skPaint,
                                      const SkMatrix& viewMatrix,
                                      const char text[], size_t byteLength,
                                      SkScalar x, SkScalar y, const SkIRect& regionClipBounds) {
-    SkAutoTUnref<BitmapTextBlob> blob(SkNEW(BitmapTextBlob));
+    int glyphCount = skPaint.countText(text, byteLength);
+    SkAutoTUnref<BitmapTextBlob> blob(CreateBlob(glyphCount, 1));
     blob->fViewMatrix = viewMatrix;
     blob->fX = x;
     blob->fY = y;
     blob->fStyle = skPaint.getStyle();
-    blob->fRuns.push_back();
 
     SkIRect clipRect;
     clip.getConservativeBounds(rt->width(), rt->height(), &clipRect);
-    this->internalDrawText(blob, 0, skPaint, viewMatrix, text, byteLength, x, y, clipRect);
+
+    // setup cache
+    SkGlyphCache* cache = this->setupCache(&blob->fRuns[0], skPaint, viewMatrix);
+    this->internalDrawText(blob, 0, cache, skPaint, viewMatrix, text, byteLength, x, y, clipRect);
+    SkGlyphCache::AttachCache(cache);
+
     this->flush(fContext->getTextTarget(), blob, rt, paint, clip, viewMatrix, skPaint.getAlpha());
 }
 
 void GrBitmapTextContextB::internalDrawText(BitmapTextBlob* blob, int runIndex,
-                                            const SkPaint& skPaint,
+                                            SkGlyphCache* cache, const SkPaint& skPaint,
                                            const SkMatrix& viewMatrix,
                                            const char text[], size_t byteLength,
                                            SkScalar x, SkScalar y, const SkIRect& clipRect) {
     SkASSERT(byteLength == 0 || text != NULL);
 
     // nothing to draw
     if (text == NULL || byteLength == 0) {
         return;
     }
 
     fCurrStrike = NULL;
     SkDrawCacheProc glyphCacheProc = skPaint.getDrawCacheProc();
 
     // Get GrFontScaler from cache
-    BitmapTextBlob::Run& run = blob->fRuns[runIndex];
-    run.fDescriptor.reset(skPaint.getScalerContextDescriptor(&fDeviceProperties, &viewMatrix,
-                                                              false));
-    run.fTypeface.reset(SkSafeRef(skPaint.getTypeface()));
-    const SkDescriptor* desc = reinterpret_cast<const SkDescriptor*>(run.fDescriptor->data());
-    SkGlyphCache* cache = SkGlyphCache::DetachCache(run.fTypeface, desc);
     GrFontScaler* fontScaler = GetGrFontScaler(cache);
 
     // transform our starting point
     {
         SkPoint loc;
         viewMatrix.mapXY(x, y, &loc);
         x = loc.fX;
         y = loc.fY;
     }
 
@@ skipping 51 matching lines @@
                                             GrGlyph::kCoverage_MaskStyle),
                               Sk48Dot16FloorToInt(fx),
                               Sk48Dot16FloorToInt(fy),
                               fontScaler,
                               clipRect);
         }
 
         fx += glyph.fAdvanceX;
         fy += glyph.fAdvanceY;
     }
-
-    SkGlyphCache::AttachCache(cache);
 }
 
 void GrBitmapTextContextB::onDrawPosText(GrRenderTarget* rt, const GrClip& clip,
                                         const GrPaint& paint, const SkPaint& skPaint,
                                         const SkMatrix& viewMatrix,
                                         const char text[], size_t byteLength,
                                         const SkScalar pos[], int scalarsPerPosition,
                                         const SkPoint& offset, const SkIRect& regionClipBounds) {
-    SkAutoTUnref<BitmapTextBlob> blob(SkNEW(BitmapTextBlob));
+    int glyphCount = skPaint.countText(text, byteLength);
+    SkAutoTUnref<BitmapTextBlob> blob(CreateBlob(glyphCount, 1));
     blob->fStyle = skPaint.getStyle();
-    blob->fRuns.push_back();
     blob->fViewMatrix = viewMatrix;
 
     SkIRect clipRect;
     clip.getConservativeBounds(rt->width(), rt->height(), &clipRect);
-    this->internalDrawPosText(blob, 0, skPaint, viewMatrix, text, byteLength, pos,
+
+    // setup cache
+    SkGlyphCache* cache = this->setupCache(&blob->fRuns[0], skPaint, viewMatrix);
+    this->internalDrawPosText(blob, 0, cache, skPaint, viewMatrix, text, byteLength, pos,
                               scalarsPerPosition, offset, clipRect);
+    SkGlyphCache::AttachCache(cache);
+
     this->flush(fContext->getTextTarget(), blob, rt, paint, clip, viewMatrix, fSkPaint.getAlpha());
 }
 
 void GrBitmapTextContextB::internalDrawPosText(BitmapTextBlob* blob, int runIndex,
-                                               const SkPaint& skPaint,
+                                               SkGlyphCache* cache, const SkPaint& skPaint,
                                               const SkMatrix& viewMatrix,
                                               const char text[], size_t byteLength,
                                               const SkScalar pos[], int scalarsPerPosition,
                                               const SkPoint& offset, const SkIRect& clipRect) {
     SkASSERT(byteLength == 0 || text != NULL);
     SkASSERT(1 == scalarsPerPosition || 2 == scalarsPerPosition);
 
     // nothing to draw
     if (text == NULL || byteLength == 0) {
         return;
     }
 
     fCurrStrike = NULL;
     SkDrawCacheProc glyphCacheProc = skPaint.getDrawCacheProc();
 
     // Get GrFontScaler from cache
-    BitmapTextBlob::Run& run = blob->fRuns[runIndex];
-    run.fDescriptor.reset(skPaint.getScalerContextDescriptor(&fDeviceProperties, &viewMatrix,
-                                                              false));
-    run.fTypeface.reset(SkSafeRef(skPaint.getTypeface()));
-    const SkDescriptor* desc = reinterpret_cast<const SkDescriptor*>(run.fDescriptor->data());
-    SkGlyphCache* cache = SkGlyphCache::DetachCache(run.fTypeface, desc);
     GrFontScaler* fontScaler = GetGrFontScaler(cache);
 
     const char*        stop = text + byteLength;
     SkTextAlignProc    alignProc(skPaint.getTextAlign());
     SkTextMapStateProc tmsProc(viewMatrix, offset, scalarsPerPosition);
     SkScalar halfSampleX = 0, halfSampleY = 0;
 
     if (cache->isSubpixel()) {
         // maybe we should skip the rounding if linearText is set
         SkAxisAlignment baseline = SkComputeAxisAlignmentForHText(viewMatrix);
@@ skipping 118 matching lines @@
                                                     GrGlyph::kCoverage_MaskStyle),
                                       Sk48Dot16FloorToInt(fx),
                                       Sk48Dot16FloorToInt(fy),
                                       fontScaler,
                                       clipRect);
                 }
                 pos += scalarsPerPosition;
             }
         }
     }
-    SkGlyphCache::AttachCache(cache);
 }
 
 static size_t get_vertex_stride(GrMaskFormat maskFormat) {
     switch (maskFormat) {
         case kA8_GrMaskFormat:
             return kGrayTextVASize;
         case kARGB_GrMaskFormat:
             return kColorTextVASize;
         default:
             return kLCDTextVASize;
@@ skipping 32 matching lines @@
                 // flag the glyph as being dead?
                 SkDELETE(path);
                 return;
             }
             glyph->fPath = path;
         }
         SkASSERT(glyph->fPath);
         blob->fBigGlyphs.push_back(BitmapTextBlob::BigGlyph(*glyph->fPath, vx, vy));
         return;
     }
+
+    Run& run = blob->fRuns[runIndex];
+
     GrMaskFormat format = glyph->fMaskFormat;
+
+    PerSubRunInfo* subRun = &run.fSubRunInfo.back();
+    if (run.fInitialized && subRun->fMaskFormat != format) {
+        PerSubRunInfo* newSubRun = &run.fSubRunInfo.push_back();
+        newSubRun->fGlyphStartIndex = subRun->fGlyphEndIndex;
+        newSubRun->fGlyphEndIndex = subRun->fGlyphEndIndex;
+
+        newSubRun->fVertexStartIndex = subRun->fVertexEndIndex;
+        newSubRun->fVertexEndIndex = subRun->fVertexEndIndex;
+
+        subRun = newSubRun;
+    }
+
+    run.fInitialized = true;
+    subRun->fMaskFormat = format;
+    blob->fGlyphIDs[subRun->fGlyphEndIndex] = packed;
+
     size_t vertexStride = get_vertex_stride(format);
 
-    BitmapTextBlob::Run& run = blob->fRuns[runIndex];
-    int glyphIdx = run.fInfos[format].fGlyphIDs.count();
-    *run.fInfos[format].fGlyphIDs.append() = packed;
-    run.fInfos[format].fVertices.append(static_cast<int>(vertexStride * kVerticesPerGlyph));
-
     SkRect r;
     r.fLeft = SkIntToScalar(x);
     r.fTop = SkIntToScalar(y);
     r.fRight = r.fLeft + SkIntToScalar(width);
     r.fBottom = r.fTop + SkIntToScalar(height);
 
     run.fVertexBounds.joinNonEmptyArg(r);
     GrColor color = fPaint.getColor();
     run.fColor = color;
 
-    intptr_t vertex = reinterpret_cast<intptr_t>(run.fInfos[format].fVertices.begin());
-    vertex += vertexStride * glyphIdx * kVerticesPerGlyph;
+    intptr_t vertex = reinterpret_cast<intptr_t>(blob->fVertices + subRun->fVertexEndIndex);
 
     // V0
     SkPoint* position = reinterpret_cast<SkPoint*>(vertex);
     position->set(r.fLeft, r.fTop);
     if (kA8_GrMaskFormat == format) {
         SkColor* colorPtr = reinterpret_cast<SkColor*>(vertex + sizeof(SkPoint));
         *colorPtr = color;
     }
     vertex += vertexStride;
 
@@ skipping 15 matching lines @@
     }
     vertex += vertexStride;
 
     // V3
     position = reinterpret_cast<SkPoint*>(vertex);
     position->set(r.fRight, r.fTop);
     if (kA8_GrMaskFormat == format) {
         SkColor* colorPtr = reinterpret_cast<SkColor*>(vertex + sizeof(SkPoint));
         *colorPtr = color;
     }
+
+    subRun->fGlyphEndIndex++;
+    subRun->fVertexEndIndex += vertexStride * kVerticesPerGlyph;
 }
 
 class BitmapTextBatch : public GrBatch {
 public:
     typedef GrBitmapTextContextB::BitmapTextBlob Blob;
     typedef Blob::Run Run;
-    typedef Run::PerFormatInfo TextInfo;
+    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) {}
         SkAutoTUnref<Blob> fBlob;
         int fRun;
+        int fSubRun;
         GrColor fColor;
     };
 
     static GrBatch* Create(const Geometry& geometry, GrColor color, GrMaskFormat maskFormat,
-                           GrBatchFontCache* fontCache) {
-        return SkNEW_ARGS(BitmapTextBatch, (geometry, color, maskFormat, fontCache));
+                           int glyphCount, GrBatchFontCache* fontCache) {
+        return SkNEW_ARGS(BitmapTextBatch, (geometry, color, 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 82 matching lines @@
         drawInfo.setIndicesPerInstance(kIndicesPerGlyph);
         drawInfo.adjustStartVertex(firstVertex);
         drawInfo.setVertexBuffer(vertexBuffer);
         drawInfo.setIndexBuffer(quadIndexBuffer);
 
         int instancesToFlush = 0;
         for (int i = 0; i < instanceCount; i++) {
             Geometry& args = fGeoData[i];
             Blob* blob = args.fBlob;
             Run& run = blob->fRuns[args.fRun];
-            TextInfo& info = run.fInfos[fMaskFormat];
+            TextInfo& info = run.fSubRunInfo[args.fSubRun];
 
             uint64_t currentAtlasGen = fFontCache->atlasGeneration(fMaskFormat);
             bool regenerateTextureCoords = info.fAtlasGeneration != currentAtlasGen;
             bool regenerateColors = kA8_GrMaskFormat == fMaskFormat && run.fColor != args.fColor;
-            int glyphCount = info.fGlyphIDs.count();
+            int glyphCount = info.fGlyphEndIndex - info.fGlyphStartIndex;
 
             // We regenerate both texture coords and colors in the blob itself, and update the
             // atlas generation.  If we don't end up purging any unused plots, we can avoid
             // regenerating the coords.  We could take a finer grained approach to updating texture
             // coords but its not clear if the extra bookkeeping would offset any gains.
             // To avoid looping over the glyphs twice, we do one loop and conditionally update color
             // or coords as needed.  One final note, if we have to break a run for an atlas eviction
             // then we can't really trust the atlas has all of the correct data.  Atlas evictions
             // should be pretty rare, so we just always regenerate in those cases
             if (regenerateTextureCoords || regenerateColors) {
                 // first regenerate texture coordinates / colors if need be
                 const SkDescriptor* desc = NULL;
                 SkGlyphCache* cache = NULL;
                 GrFontScaler* scaler = NULL;
                 GrBatchTextStrike* strike = NULL;
                 bool brokenRun = false;
                 if (regenerateTextureCoords) {
-                    desc = reinterpret_cast<const SkDescriptor*>(run.fDescriptor->data());
+                    desc = run.fDescriptor.getDesc();
                     cache = SkGlyphCache::DetachCache(run.fTypeface, desc);
                     scaler = GrTextContext::GetGrFontScaler(cache);
                     strike = fFontCache->getStrike(scaler);
                 }
                 for (int glyphIdx = 0; glyphIdx < glyphCount; glyphIdx++) {
-                    GrGlyph::PackedID glyphID = info.fGlyphIDs[glyphIdx];
+                    GrGlyph::PackedID glyphID = blob->fGlyphIDs[glyphIdx + info.fGlyphStartIndex];
 
                     if (regenerateTextureCoords) {
                         // Upload the glyph only if needed
                         GrGlyph* glyph = strike->getGlyph(glyphID, scaler);
                         SkASSERT(glyph);
 
                         if (!fFontCache->hasGlyph(glyph) &&
                             !strike->addGlyphToAtlas(batchTarget, glyph, scaler)) {
                             this->flush(batchTarget, &drawInfo, instancesToFlush,
                                         maxInstancesPerDraw);
                             this->initDraw(batchTarget, gp, pipeline);
                             instancesToFlush = 0;
                             brokenRun = glyphIdx > 0;
 
                             SkDEBUGCODE(bool success =) strike->addGlyphToAtlas(batchTarget, glyph,
                                                                                 scaler);
                             SkASSERT(success);
                         }
 
                         fFontCache->setGlyphRefToken(glyph, batchTarget->currentToken());
 
                         // Texture coords are the last vertex attribute so we get a pointer to the
                         // first one and then map with stride in regenerateTextureCoords
-                        intptr_t vertex = reinterpret_cast<intptr_t>(info.fVertices.begin());
+                        intptr_t vertex = reinterpret_cast<intptr_t>(blob->fVertices);
+                        vertex += info.fVertexStartIndex;
                         vertex += vertexStride * glyphIdx * kVerticesPerGlyph;
                         vertex += vertexStride - sizeof(SkIPoint16);
 
                         this->regenerateTextureCoords(glyph, vertex, vertexStride);
                     }
 
                     if (regenerateColors) {
-                        intptr_t vertex = reinterpret_cast<intptr_t>(info.fVertices.begin());
+                        intptr_t vertex = reinterpret_cast<intptr_t>(blob->fVertices);
+                        vertex += info.fVertexStartIndex;
                         vertex += vertexStride * glyphIdx * kVerticesPerGlyph + sizeof(SkPoint);
                         this->regenerateColors(vertex, vertexStride, args.fColor);
                     }
 
                     instancesToFlush++;
                 }
 
                 if (regenerateTextureCoords) {
                     SkGlyphCache::AttachCache(cache);
                     info.fAtlasGeneration = brokenRun ? GrBatchAtlas::kInvalidAtlasGeneration :
                                                         fFontCache->atlasGeneration(fMaskFormat);
                 }
             } else {
                 instancesToFlush += glyphCount;
             }
 
             // now copy all vertices
-            int byteCount = info.fVertices.count();
-            memcpy(currVertex, info.fVertices.begin(), byteCount);
+            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; }
 
 private:
     BitmapTextBatch(const Geometry& geometry, GrColor color, GrMaskFormat maskFormat,
-                    GrBatchFontCache* fontCache)
+                    int glyphCount, GrBatchFontCache* fontCache)
             : fMaskFormat(maskFormat)
             , fPixelConfig(fontCache->getPixelConfig(maskFormat))
             , fFontCache(fontCache) {
         this->initClassID<BitmapTextBatch>();
         fGeoData.push_back(geometry);
         fBatch.fColor = color;
         fBatch.fViewMatrix = geometry.fBlob->fViewMatrix;
-        int numGlyphs = geometry.fBlob->fRuns[geometry.fRun].fInfos[maskFormat].fGlyphIDs.count();
-        fBatch.fNumGlyphs = numGlyphs;
+        fBatch.fNumGlyphs = glyphCount;
     }
 
     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 92 matching lines @@
         int fNumGlyphs;
     };
 
     BatchTracker fBatch;
     SkSTArray<1, Geometry, true> fGeoData;
     GrMaskFormat fMaskFormat;
     GrPixelConfig fPixelConfig;
     GrBatchFontCache* fFontCache;
 };
 
-void GrBitmapTextContextB::flushSubRun(GrDrawTarget* target, BitmapTextBlob* blob, int i,
-                                       GrPipelineBuilder* pipelineBuilder, GrMaskFormat format,
-                                       GrColor color, int paintAlpha) {
-    if (0 == blob->fRuns[i].fInfos[format].fGlyphIDs.count()) {
-        return;
-    }
-
-    if (kARGB_GrMaskFormat == format) {
-        color = SkColorSetARGB(paintAlpha, paintAlpha, paintAlpha, paintAlpha);
-    }
-
-    BitmapTextBatch::Geometry geometry;
-    geometry.fBlob.reset(SkRef(blob));
-    geometry.fRun = i;
-    geometry.fColor = color;
-    SkAutoTUnref<GrBatch> batch(BitmapTextBatch::Create(geometry, color, format,
-                                                        fContext->getBatchFontCache()));
-
-    target->drawBatch(pipelineBuilder, batch, &blob->fRuns[i].fVertexBounds);
-}
-
 void GrBitmapTextContextB::flush(GrDrawTarget* target, BitmapTextBlob* blob, GrRenderTarget* rt,
                                  const GrPaint& paint, const GrClip& clip,
                                  const SkMatrix& viewMatrix, int paintAlpha) {
     GrPipelineBuilder pipelineBuilder;
     pipelineBuilder.setFromPaint(paint, rt, clip);
 
     GrColor color = paint.getColor();
-    for (int i = 0; i < blob->fRuns.count(); i++) {
-        this->flushSubRun(target, blob, i, &pipelineBuilder, kA8_GrMaskFormat, color, paintAlpha);
-        this->flushSubRun(target, blob, i, &pipelineBuilder, kA565_GrMaskFormat, color, paintAlpha);
-        this->flushSubRun(target, blob, i, &pipelineBuilder, kARGB_GrMaskFormat, color, paintAlpha);
+    for (uint32_t run = 0; run < blob->fRunCount; run++) {
+        for (int subRun = 0; subRun < blob->fRuns[run].fSubRunInfo.count(); subRun++) {
+            PerSubRunInfo& info = blob->fRuns[run].fSubRunInfo[subRun];
+            int glyphCount = info.fGlyphEndIndex - info.fGlyphStartIndex;
+            if (0 == glyphCount) {
+                continue;
+            }
+
+            GrMaskFormat format = info.fMaskFormat;
+            if (kARGB_GrMaskFormat == format) {
+                color = SkColorSetARGB(paintAlpha, paintAlpha, paintAlpha, paintAlpha);
+            }
+
+            BitmapTextBatch::Geometry geometry;
+            geometry.fBlob.reset(SkRef(blob));
+            geometry.fRun = run;
+            geometry.fSubRun = subRun;
+            geometry.fColor = color;
+            SkAutoTUnref<GrBatch> batch(BitmapTextBatch::Create(geometry, color, format, glyphCount,
+                                                                fContext->getBatchFontCache()));
+
+            target->drawBatch(&pipelineBuilder, batch, &blob->fRuns[run].fVertexBounds);
+        }
     }
 
     // Now flush big glyphs
     for (int i = 0; i < blob->fBigGlyphs.count(); i++) {
         BitmapTextBlob::BigGlyph& bigGlyph = blob->fBigGlyphs[i];
         SkMatrix translate;
         translate.setTranslate(SkIntToScalar(bigGlyph.fVx), SkIntToScalar(bigGlyph.fVy));
         SkPath tmpPath(bigGlyph.fPath);
         tmpPath.transform(translate);
         GrStrokeInfo strokeInfo(SkStrokeRec::kFill_InitStyle);
@@ skipping 576 matching lines @@
         SkSafeSetNull(fCurrTexture);
     }
 }
 
 inline void GrBitmapTextContext::finish() {
     this->flush();
     fTotalVertexCount = 0;
 
     GrTextContext::finish();
 }