A small text cleanup

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 "GrBlurUtils.h"
 #include "GrDrawContext.h"
@@ skipping 37 matching lines @@
 #endif
 
 SkDEBUGCODE(static const int kExpectedDistanceAdjustTableSize = 8;)
 };
 
 GrAtlasTextContext::GrAtlasTextContext(GrContext* context, const SkSurfaceProps& surfaceProps)
     : INHERITED(context, surfaceProps)
     , fDistanceAdjustTable(new DistanceAdjustTable) {
     // We overallocate vertices in our textblobs based on the assumption that A8 has the greatest
     // vertexStride
-    static_assert(GrAtlasTextBatch::kGrayTextVASize >= GrAtlasTextBatch::kColorTextVASize &&
-                  GrAtlasTextBatch::kGrayTextVASize >= GrAtlasTextBatch::kLCDTextVASize,
+    static_assert(GrAtlasTextBlob::kGrayTextVASize >= GrAtlasTextBlob::kColorTextVASize &&
+                  GrAtlasTextBlob::kGrayTextVASize >= GrAtlasTextBlob::kLCDTextVASize,
                   "vertex_attribute_changed");
     fCurrStrike = nullptr;
     fCache = context->getTextBlobCache();
 }
 
 void GrAtlasTextContext::DistanceAdjustTable::buildDistanceAdjustTable() {
 
     // This is used for an approximation of the mask gamma hack, used by raster and bitmap
     // text. The mask gamma hack is based off of guessing what the blend color is going to
     // be, and adjusting the mask so that when run through the linear blend will
@@ skipping 272 matching lines @@
     }
 
     if (cacheBlob) {
         if (MustRegenerateBlob(&transX, &transY, *cacheBlob, skPaint, grPaint.getColor(), blurRec,
                                viewMatrix, x, y)) {
             // 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
             fCache->remove(cacheBlob);
             cacheBlob.reset(SkRef(fCache->createCachedBlob(blob, key, blurRec, skPaint,
-                                                           GrAtlasTextBatch::kGrayTextVASize)));
+                                                           GrAtlasTextBlob::kGrayTextVASize)));
             this->regenerateTextBlob(cacheBlob, skPaint, grPaint.getColor(), viewMatrix,
                                      blob, x, y, drawFilter, clip);
         } else {
             // If we can reuse the blob, then make sure we update the blob's viewmatrix, and x/y
             // offsets.  Note, we offset the vertex bounds right before flushing
             cacheBlob->fViewMatrix = viewMatrix;
             cacheBlob->fX = x;
             cacheBlob->fY = y;
             fCache->makeMRU(cacheBlob);
 #ifdef CACHE_SANITY_CHECK
             {
                 int glyphCount = 0;
                 int runCount = 0;
                 GrTextBlobCache::BlobGlyphCount(&glyphCount, &runCount, blob);
                 SkAutoTUnref<GrAtlasTextBlob> sanityBlob(fCache->createBlob(glyphCount, runCount,
                                                                             kGrayTextVASize));
                 GrTextBlobCache::SetupCacheBlobKey(sanityBlob, key, blurRec, skPaint);
                 this->regenerateTextBlob(sanityBlob, skPaint, grPaint.getColor(), viewMatrix,
                                          blob, x, y, drawFilter, clip);
                 GrAtlasTextBlob::AssertEqual(*sanityBlob, *cacheBlob);
             }
 
 #endif
         }
     } else {
         if (canCache) {
             cacheBlob.reset(SkRef(fCache->createCachedBlob(blob, key, blurRec, skPaint,
-                                                           GrAtlasTextBatch::kGrayTextVASize)));
+                                                           GrAtlasTextBlob::kGrayTextVASize)));
         } else {
-            cacheBlob.reset(fCache->createBlob(blob, GrAtlasTextBatch::kGrayTextVASize));
+            cacheBlob.reset(fCache->createBlob(blob, GrAtlasTextBlob::kGrayTextVASize));
         }
         this->regenerateTextBlob(cacheBlob, skPaint, grPaint.getColor(), viewMatrix,
                                  blob, x, y, drawFilter, clip);
     }
 
     this->flush(blob, cacheBlob, dc, skPaint, grPaint, drawFilter,
                 clip, viewMatrix, clipBounds, x, y, transX, transY);
 }
 
 inline bool GrAtlasTextContext::canDrawAsDistanceFields(const SkPaint& skPaint,
@@ skipping 224 matching lines @@
     this->internalDrawBMPPosText(blob, runIndex, cache, skPaint, color, viewMatrix,
                                  fallbackTxt.begin(), fallbackTxt.count(),
                                  fallbackPos.begin(), scalarsPerPosition, offset);
     SkGlyphCache::AttachCache(cache);
 }
 
 inline GrAtlasTextBlob*
 GrAtlasTextContext::setupDFBlob(int glyphCount, const SkPaint& origPaint,
                                 const SkMatrix& viewMatrix, SkPaint* dfPaint,
                                 SkScalar* textRatio) {
-    GrAtlasTextBlob* blob = fCache->createBlob(glyphCount, 1, GrAtlasTextBatch::kGrayTextVASize);
+    GrAtlasTextBlob* blob = fCache->createBlob(glyphCount, 1, GrAtlasTextBlob::kGrayTextVASize);
 
     *dfPaint = origPaint;
     this->initDistanceFieldPaint(blob, dfPaint, textRatio, viewMatrix);
     blob->fViewMatrix = viewMatrix;
     Run& run = blob->fRuns[0];
     PerSubRunInfo& subRun = run.fSubRunInfo.back();
     subRun.setUseLCDText(origPaint.isLCDRenderText());
     subRun.setDrawAsDistanceFields();
 
     return blob;
@@ skipping 17 matching lines @@
         SkTDArray<SkScalar> fallbackPos;
         SkPoint offset;
         this->internalDrawDFText(blob, 0, dfPaint, paint.getColor(), viewMatrix, text,
                                  byteLength, x, y, textRatio, &fallbackTxt, &fallbackPos,
                                  &offset, skPaint);
         if (fallbackTxt.count()) {
             this->fallbackDrawPosText(blob, 0, clip, paint.getColor(), skPaint, viewMatrix,
                                       fallbackTxt, fallbackPos, 2, offset);
         }
     } else {
-        blob = fCache->createBlob(glyphCount, 1, GrAtlasTextBatch::kGrayTextVASize);
+        blob = fCache->createBlob(glyphCount, 1, GrAtlasTextBlob::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);
         SkGlyphCache::AttachCache(cache);
     }
     return blob;
 }
 
@@ skipping 15 matching lines @@
         SkTDArray<char> fallbackTxt;
         SkTDArray<SkScalar> fallbackPos;
         this->internalDrawDFPosText(blob, 0, dfPaint, paint.getColor(), viewMatrix, text,
                                     byteLength, pos, scalarsPerPosition, offset,
                                     textRatio, &fallbackTxt, &fallbackPos);
         if (fallbackTxt.count()) {
             this->fallbackDrawPosText(blob, 0, clip, paint.getColor(), skPaint, viewMatrix,
                                       fallbackTxt, fallbackPos, scalarsPerPosition, offset);
         }
     } else {
-        blob = fCache->createBlob(glyphCount, 1, GrAtlasTextBatch::kGrayTextVASize);
+        blob = fCache->createBlob(glyphCount, 1, GrAtlasTextBlob::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);
         SkGlyphCache::AttachCache(cache);
     }
     return blob;
 }
 
 void GrAtlasTextContext::onDrawText(GrDrawContext* dc,
@@ skipping 248 matching lines @@
             pos += scalarsPerPosition;
         }
     }
 
     SkGlyphCache::AttachCache(cache);
 }
 
 void GrAtlasTextContext::bmpAppendGlyph(GrAtlasTextBlob* blob, int runIndex,
                                         const SkGlyph& skGlyph,
                                         int vx, int vy, GrColor color, GrFontScaler* scaler) {
-    Run& run = blob->fRuns[runIndex];
     if (!fCurrStrike) {
         fCurrStrike = fContext->getBatchFontCache()->getStrike(scaler);
     }
 
     GrGlyph::PackedID id = GrGlyph::Pack(skGlyph.getGlyphID(),
                                          skGlyph.getSubXFixed(),
                                          skGlyph.getSubYFixed(),
                                          GrGlyph::kCoverage_MaskStyle);
     GrGlyph* glyph = fCurrStrike->getGlyph(skGlyph, id, scaler);
     if (!glyph) {
         return;
     }
 
     int x = vx + glyph->fBounds.fLeft;
     int y = vy + glyph->fBounds.fTop;
 
     // keep them as ints until we've done the clip-test
     int width = glyph->fBounds.width();
     int height = glyph->fBounds.height();
 
     // If the glyph is too large we fall back to paths
     if (glyph->fTooLargeForAtlas) {
         this->appendGlyphPath(blob, glyph, scaler, skGlyph, SkIntToScalar(vx), SkIntToScalar(vy));
         return;
     }
 
-    GrMaskFormat format = glyph->fMaskFormat;
-
-    PerSubRunInfo* subRun = &run.fSubRunInfo.back();
-    if (run.fInitialized && subRun->maskFormat() != format) {
-        subRun = &run.push_back();
-        subRun->setStrike(fCurrStrike);
-    } else if (!run.fInitialized) {
-        subRun->setStrike(fCurrStrike);
-    }
-
-    run.fInitialized = true;
-
-    size_t vertexStride = GrAtlasTextBatch::GetVertexStride(format);
-
     SkRect r;
     r.fLeft = SkIntToScalar(x);
     r.fTop = SkIntToScalar(y);
     r.fRight = r.fLeft + SkIntToScalar(width);
     r.fBottom = r.fTop + SkIntToScalar(height);
-    subRun->setMaskFormat(format);
-    blob->appendGlyph(&run, subRun, r, color, vertexStride,
-                      kARGB_GrMaskFormat != format, glyph);
+
+    blob->appendGlyph(runIndex, r, color, fCurrStrike, glyph);
 }
 
 bool GrAtlasTextContext::dfAppendGlyph(GrAtlasTextBlob* blob, int runIndex,
                                        const SkGlyph& skGlyph,
                                        SkScalar sx, SkScalar sy, GrColor color,
                                        GrFontScaler* scaler,
                                        SkScalar textRatio, const SkMatrix& viewMatrix) {
-    Run& run = blob->fRuns[runIndex];
     if (!fCurrStrike) {
         fCurrStrike = fContext->getBatchFontCache()->getStrike(scaler);
     }
 
     GrGlyph::PackedID id = GrGlyph::Pack(skGlyph.getGlyphID(),
                                          skGlyph.getSubXFixed(),
                                          skGlyph.getSubYFixed(),
                                          GrGlyph::kDistance_MaskStyle);
     GrGlyph* glyph = fCurrStrike->getGlyph(skGlyph, id, scaler);
     if (!glyph) {
@@ skipping 19 matching lines @@
     sy += dy;
     SkRect glyphRect = SkRect::MakeXYWH(sx, sy, width, height);
 
     // TODO combine with the above
     // If the glyph is too large we fall back to paths
     if (glyph->fTooLargeForAtlas) {
         this->appendGlyphPath(blob, glyph, scaler, skGlyph, sx - dx, sy - dy, scale, true);
         return true;
     }
 
-    PerSubRunInfo* subRun = &run.fSubRunInfo.back();
-    if (!run.fInitialized) {
-        subRun->setStrike(fCurrStrike);
-    }
-    run.fInitialized = true;
-    SkASSERT(glyph->fMaskFormat == kA8_GrMaskFormat);
-    subRun->setMaskFormat(kA8_GrMaskFormat);
-
-    size_t vertexStride = GrAtlasTextBatch::GetVertexStride(kA8_GrMaskFormat);
-
-    blob->appendGlyph(&run, subRun, glyphRect, color, vertexStride, true, glyph);
+    blob->appendGlyph(runIndex, glyphRect, color, fCurrStrike, glyph);
     return true;
 }
 
 inline void GrAtlasTextContext::appendGlyphPath(GrAtlasTextBlob* blob, GrGlyph* glyph,
                                                 GrFontScaler* scaler, const SkGlyph& skGlyph,
                                                 SkScalar x, SkScalar y, SkScalar scale,
                                                 bool applyVM) {
     if (nullptr == glyph->fPath) {
         const SkPath* glyphPath = scaler->getGlyphPath(skGlyph);
         if (!glyphPath) {
@@ skipping 224 matching lines @@
             gTextContext->createDrawTextBlob(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