Fix for segfault on destruction of BitmapTextBlob

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 642 matching lines @@
                                                     const SkPaint& skPaint,
                                                     const SkMatrix& viewMatrix,
                                                     const SkTDArray<char>& fallbackTxt,
                                                     const SkTDArray<SkScalar>& fallbackPos,
                                                     int scalarsPerPosition,
                                                     const SkPoint& offset,
                                                     const SkIRect& clipRect) {
     SkASSERT(fallbackTxt.count());
     blob->setHasBitmap();
     Run& run = blob->fRuns[runIndex];
-    PerSubRunInfo& subRun = run.fSubRunInfo.push_back();
-    subRun.fOverrideDescriptor.reset(SkNEW(SkAutoDescriptor));
-    skPaint.getScalerContextDescriptor(subRun.fOverrideDescriptor,
+    // Push back a new subrun to fill and set the override descriptor
+    run.push_back();
+    run.fOverrideDescriptor.reset(SkNEW(SkAutoDescriptor));
+    skPaint.getScalerContextDescriptor(run.fOverrideDescriptor,
                                        &fDeviceProperties, &viewMatrix, false);
     SkGlyphCache* cache = SkGlyphCache::DetachCache(run.fTypeface,
-                                                    subRun.fOverrideDescriptor->getDesc());
+                                                    run.fOverrideDescriptor->getDesc());
     this->internalDrawBMPPosText(blob, runIndex, cache, skPaint, paint.getColor(), viewMatrix,
                                  fallbackTxt.begin(), fallbackTxt.count(),
                                  fallbackPos.begin(), scalarsPerPosition, offset, clipRect);
     SkGlyphCache::AttachCache(cache);
 }
 
 inline GrAtlasTextContext::BitmapTextBlob*
 GrAtlasTextContext::setupDFBlob(int glyphCount, const SkPaint& origPaint,
                                 const SkMatrix& viewMatrix, SkGlyphCache** cache,
                                 SkPaint* dfPaint, SkScalar* textRatio) {
@@ skipping 916 matching lines @@
                 // new strike, we instead keep our ref to the old strike and use the packed ids from
                 // it.  These ids will still be valid as long as we hold the ref.  When we are done
                 // updating our cache of the GrGlyph*s, we drop our ref on the old strike
                 bool regenerateGlyphs = false;
                 GrBatchTextStrike* strike = NULL;
                 if (regenerateTextureCoords) {
                     info.fBulkUseToken.reset();
 
                     // We can reuse if we have a valid strike and our descriptors / typeface are the
                     // same
-                    const SkDescriptor* newDesc = info.fOverrideDescriptor ?
-                                                  info.fOverrideDescriptor->getDesc() :
+                    const SkDescriptor* newDesc = run.fOverrideDescriptor ?
+                                                  run.fOverrideDescriptor->getDesc() :
                                                   run.fDescriptor.getDesc();
                     if (!cache || !SkTypeface::Equal(typeface, run.fTypeface) ||
                                   !(desc->equals(*newDesc))) {
                         if (cache) {
                             SkGlyphCache::AttachCache(cache);
                         }
                         desc = newDesc;
                         cache = SkGlyphCache::DetachCache(run.fTypeface, desc);
                         scaler = GrTextContext::GetGrFontScaler(cache);
                         strike = run.fStrike;
@@ skipping 547 matching lines @@
     pipelineBuilder.setFromPaint(grPaint, rt, clip);
 
     GrColor color = grPaint.getColor();
     for (int run = 0; run < cacheBlob->fRunCount; run++) {
         this->flushRun(target, &pipelineBuilder, cacheBlob, run, color, 0, 0, skPaint);
     }
 
     // Now flush big glyphs
     this->flushBigGlyphs(cacheBlob, rt, grPaint, clip, 0, 0);
 }