Small change to allow DistanceField and BMP text to coexist in a blob

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 527 matching lines @@
         *textRatio = textSize / kLargeDFFontSize;
         skPaint->setTextSize(SkIntToScalar(kLargeDFFontSize));
     }
 
     skPaint->setLCDRenderText(false);
     skPaint->setAutohinted(false);
     skPaint->setHinting(SkPaint::kNormal_Hinting);
     skPaint->setSubpixelText(true);
 }
 
-inline void GrAtlasTextContext::fallbackDrawPosText(GrRenderTarget* rt, const GrClip& clip,
+inline void GrAtlasTextContext::fallbackDrawPosText(BitmapTextBlob* blob,
+                                                    GrRenderTarget* rt, const GrClip& clip,
                                                     const GrPaint& paint,
                                                     const SkPaint& skPaint,
                                                     const SkMatrix& viewMatrix,
                                                     const SkTDArray<char>& fallbackTxt,
                                                     const SkTDArray<SkScalar>& fallbackPos,
                                                     int scalarsPerPosition,
                                                     const SkPoint& offset,
                                                     const SkIRect& clipRect) {
     size_t glyphCount = fallbackTxt.count();
     SkASSERT(glyphCount);
-    // TODO currently we have to create a whole new blob for fallback text.  This is because
-    // they have a different descriptor and we currently only have one descriptor per run.
-    // We should fix this and allow an override descriptor on each subrun
-    SkAutoTUnref<BitmapTextBlob> blob(fCache->createBlob(glyphCount, 1, kGrayTextVASize));
-    blob->fViewMatrix = viewMatrix;
-
-    SkGlyphCache* cache = this->setupCache(&blob->fRuns[0], skPaint, &viewMatrix, false);
+    Run& run = blob->fRuns[0];
+    PerSubRunInfo& subRun = run.fSubRunInfo.push_back();
+    subRun.fOverrideDescriptor.reset(SkNEW(SkAutoDescriptor));
+    skPaint.getScalerContextDescriptor(subRun.fOverrideDescriptor,
+                                       &fDeviceProperties, &viewMatrix, false);
+    SkGlyphCache* cache = SkGlyphCache::DetachCache(run.fTypeface,
+                                                    subRun.fOverrideDescriptor->getDesc());
     this->internalDrawBMPPosText(blob, 0, cache, skPaint, paint.getColor(), viewMatrix,
                                  fallbackTxt.begin(), fallbackTxt.count(),
                                  fallbackPos.begin(), scalarsPerPosition, offset, clipRect);
     SkGlyphCache::AttachCache(cache);
-    this->flush(fContext->getTextTarget(), blob, rt, skPaint, paint, clip);
 }
 
 inline GrAtlasTextContext::BitmapTextBlob*
 GrAtlasTextContext::setupDFBlob(size_t glyphCount, const SkPaint& origPaint,
                                 const SkMatrix& viewMatrix, SkGlyphCache** cache,
                                 SkPaint* dfPaint, SkScalar* textRatio) {
     BitmapTextBlob* blob = fCache->createBlob(glyphCount, 1, kGrayTextVASize);
 
     *dfPaint = origPaint;
     this->initDistanceFieldPaint(dfPaint, textRatio, viewMatrix);
@@ skipping 22 matching lines @@
         SkAutoTUnref<BitmapTextBlob> blob(this->setupDFBlob(glyphCount, skPaint, viewMatrix, &cache,
                                                             &dfPaint, &textRatio));
 
         SkTDArray<char> fallbackTxt;
         SkTDArray<SkScalar> fallbackPos;
         SkPoint offset;
         this->internalDrawDFText(blob, 0, cache, dfPaint, paint.getColor(), viewMatrix, text,
                                  byteLength, x, y, clipRect, textRatio, &fallbackTxt, &fallbackPos,
                                  &offset, skPaint);
         SkGlyphCache::AttachCache(cache);
-        this->flush(fContext->getTextTarget(), blob, rt, dfPaint, paint, clip);
         if (fallbackTxt.count()) {
-            this->fallbackDrawPosText(rt, clip, paint, skPaint, viewMatrix, fallbackTxt,
+            this->fallbackDrawPosText(blob, rt, clip, paint, skPaint, viewMatrix, fallbackTxt,
                                       fallbackPos, 2, offset, clipRect);
         }
+        this->flush(fContext->getTextTarget(), blob, rt, skPaint, paint, clip);
     } else {
         SkAutoTUnref<BitmapTextBlob> blob(fCache->createBlob(glyphCount, 1, kGrayTextVASize));
         blob->fViewMatrix = viewMatrix;
 
         SkGlyphCache* cache = this->setupCache(&blob->fRuns[0], skPaint, &viewMatrix, false);
         this->internalDrawBMPText(blob, 0, cache, skPaint, paint.getColor(), viewMatrix, text,
                                   byteLength, x, y, clipRect);
         SkGlyphCache::AttachCache(cache);
         this->flush(fContext->getTextTarget(), blob, rt, skPaint, paint, clip);
     }
@@ skipping 16 matching lines @@
         SkGlyphCache* cache;
         SkAutoTUnref<BitmapTextBlob> blob(this->setupDFBlob(glyphCount, skPaint, viewMatrix, &cache,
                                                             &dfPaint, &textRatio));
 
         SkTDArray<char> fallbackTxt;
         SkTDArray<SkScalar> fallbackPos;
         this->internalDrawDFPosText(blob, 0, cache, dfPaint, paint.getColor(), viewMatrix, text,
                                     byteLength, pos, scalarsPerPosition, offset, clipRect,
                                     textRatio, &fallbackTxt, &fallbackPos);
         SkGlyphCache::AttachCache(cache);
-        this->flush(fContext->getTextTarget(), blob, rt, dfPaint, paint, clip);
         if (fallbackTxt.count()) {
-            this->fallbackDrawPosText(rt, clip, paint, skPaint, viewMatrix, fallbackTxt,
+            this->fallbackDrawPosText(blob, rt, clip, paint, skPaint, viewMatrix, fallbackTxt,
                                       fallbackPos, scalarsPerPosition, offset, clipRect);
         }
+        this->flush(fContext->getTextTarget(), blob, rt, skPaint, paint, clip);
     } else {
         SkAutoTUnref<BitmapTextBlob> blob(fCache->createBlob(glyphCount, 1, kGrayTextVASize));
         blob->fViewMatrix = viewMatrix;
         SkGlyphCache* cache = this->setupCache(&blob->fRuns[0], skPaint, &viewMatrix, false);
         this->internalDrawBMPPosText(blob, 0, cache, skPaint, paint.getColor(), viewMatrix, text,
                                      byteLength, pos, scalarsPerPosition, offset, clipRect);
         SkGlyphCache::AttachCache(cache);
         this->flush(fContext->getTextTarget(), blob, rt, skPaint, paint, clip);
     }
 }
@@ skipping 458 matching lines @@
         this->appendGlyphPath(blob, glyph, scaler, 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;
+        subRun = &run.fSubRunInfo.push_back();
     }
 
     run.fInitialized = true;
 
     size_t vertexStride = get_vertex_stride(format);
 
     SkRect r;
     r.fLeft = SkIntToScalar(x);
     r.fTop = SkIntToScalar(y);
     r.fRight = r.fLeft + SkIntToScalar(width);
@@ skipping 312 matching lines @@
             // should be pretty rare, so we just always regenerate in those cases
             if (regenerateTextureCoords || regenerateColors || regeneratePositions) {
                 // 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) {
                     info.fBulkUseToken.reset();
-                    desc = run.fDescriptor.getDesc();
+                    desc = info.fOverrideDescriptor ? info.fOverrideDescriptor->getDesc() :
+                                                      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 = blob->fGlyphIDs[glyphIdx + info.fGlyphStartIndex];
 
                     if (regenerateTextureCoords) {
                         // Upload the glyph only if needed
                         GrGlyph* glyph = strike->getGlyph(glyphID, scaler);
@@ skipping 518 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);
 }