Move a bit more logic into GrAtlasTextBlob

src/gpu/text/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 "GrDrawContext.h"
 #include "GrDrawTarget.h"
@@ skipping 148 matching lines @@
     if (cacheBlob) {
         if (cacheBlob->mustRegenerate(&transX, &transY, 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,
                                                            GrAtlasTextBlob::kGrayTextVASize)));
             this->regenerateTextBlob(cacheBlob, skPaint, grPaint.getColor(), viewMatrix,
-                                     blob, x, y, drawFilter, clip);
+                                     blob, x, y, drawFilter);
         } else {
             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);
+                                         blob, x, y, drawFilter);
                 GrAtlasTextBlob::AssertEqual(*sanityBlob, *cacheBlob);
             }
 
 #endif
         }
     } else {
         if (canCache) {
             cacheBlob.reset(SkRef(fCache->createCachedBlob(blob, key, blurRec, skPaint,
                                                            GrAtlasTextBlob::kGrayTextVASize)));
         } else {
             cacheBlob.reset(fCache->createBlob(blob, GrAtlasTextBlob::kGrayTextVASize));
         }
         this->regenerateTextBlob(cacheBlob, skPaint, grPaint.getColor(), viewMatrix,
-                                 blob, x, y, drawFilter, clip);
+                                 blob, x, y, drawFilter);
     }
 
     cacheBlob->flushCached(fContext, dc, blob, fSurfaceProps, fDistanceAdjustTable, skPaint,
                            grPaint, drawFilter, clip, viewMatrix, clipBounds, x, y, transX, transY);
 }
 
 inline bool GrAtlasTextContext::canDrawAsDistanceFields(const SkPaint& skPaint,
                                                         const SkMatrix& viewMatrix) {
     // TODO: support perspective (need getMaxScale replacement)
     if (viewMatrix.hasPerspective()) {
@@ skipping 29 matching lines @@
         return false;
     }
 
     return true;
 }
 
 void GrAtlasTextContext::regenerateTextBlob(GrAtlasTextBlob* cacheBlob,
                                             const SkPaint& skPaint, GrColor color,
                                             const SkMatrix& viewMatrix,
                                             const SkTextBlob* blob, SkScalar x, SkScalar y,
-                                            SkDrawFilter* drawFilter,
-                                            const GrClip& clip) {
+                                            SkDrawFilter* drawFilter) {
     // The color here is the GrPaint color, and it is used to determine whether we
     // have to regenerate LCD text blobs.
     // We use this color vs the SkPaint color because it has the colorfilter applied.
     cacheBlob->fPaintColor = color;
     cacheBlob->fViewMatrix = viewMatrix;
     cacheBlob->fX = x;
     cacheBlob->fY = y;
 
     // Regenerate textblob
     SkPaint runPaint = skPaint;
@@ skipping 10 matching lines @@
             // A false return from filter() means we should abort the current draw.
             runPaint = skPaint;
             continue;
         }
 
         runPaint.setFlags(FilterTextFlags(fSurfaceProps, runPaint));
 
         cacheBlob->push_back_run(run);
 
         if (this->canDrawAsDistanceFields(runPaint, viewMatrix)) {
-            cacheBlob->setHasDistanceField();
-            SkPaint dfPaint = runPaint;
-            SkScalar textRatio;
-            this->initDistanceFieldPaint(cacheBlob, &dfPaint, &textRatio, viewMatrix);
-            Run& runIdx = cacheBlob->fRuns[run];
-            PerSubRunInfo& subRun = runIdx.fSubRunInfo.back();
-            subRun.setUseLCDText(runPaint.isLCDRenderText());
-            subRun.setDrawAsDistanceFields();
-
             switch (it.positioning()) {
                 case SkTextBlob::kDefault_Positioning: {
-                    this->internalDrawDFText(cacheBlob, run, dfPaint, color, viewMatrix,
+                    this->internalDrawDFText(cacheBlob, run, runPaint, color, viewMatrix,
                                              (const char *)it.glyphs(), textLen,
-                                             x + offset.x(), y + offset.y(), textRatio, runPaint);
+                                             x + offset.x(), y + offset.y());
                     break;
                 }
                 case SkTextBlob::kHorizontal_Positioning: {
                     SkPoint dfOffset = SkPoint::Make(x, y + offset.y());
-                    this->internalDrawDFPosText(cacheBlob, run, dfPaint, color, viewMatrix,
+                    this->internalDrawDFPosText(cacheBlob, run, runPaint, color, viewMatrix,
                                                 (const char*)it.glyphs(), textLen, it.pos(),
-                                                1, dfOffset, textRatio,
-                                                runPaint);
+                                                1, dfOffset);
                     break;
                 }
                 case SkTextBlob::kFull_Positioning: {
                     SkPoint dfOffset = SkPoint::Make(x, y);
-                    this->internalDrawDFPosText(cacheBlob, run, dfPaint, color, viewMatrix,
+                    this->internalDrawDFPosText(cacheBlob, run, runPaint, color, viewMatrix,
                                                 (const char*)it.glyphs(), textLen, it.pos(),
-                                                2, dfOffset, textRatio, runPaint);
+                                                2, dfOffset);
                     break;
                 }
             }
         } else if (SkDraw::ShouldDrawTextAsPaths(runPaint, viewMatrix)) {
             cacheBlob->fRuns[run].fDrawAsPaths = true;
         } else {
-            cacheBlob->setHasBitmap();
             switch (it.positioning()) {
                 case SkTextBlob::kDefault_Positioning:
                     GrTextUtils::DrawBmpText(cacheBlob, run, fContext->getBatchFontCache(),
                                              fSurfaceProps, runPaint, color, viewMatrix,
                                              (const char *)it.glyphs(), textLen,
                                              x + offset.x(), y + offset.y());
                     break;
                 case SkTextBlob::kHorizontal_Positioning:
                     GrTextUtils::DrawBmpPosText(cacheBlob, run, fContext->getBatchFontCache(),
                                                 fSurfaceProps, runPaint, color, viewMatrix,
@@ skipping 73 matching lines @@
 inline void GrAtlasTextContext::fallbackDrawPosText(GrAtlasTextBlob* blob,
                                                     int runIndex,
                                                     GrColor color,
                                                     const SkPaint& skPaint,
                                                     const SkMatrix& viewMatrix,
                                                     const SkTDArray<char>& fallbackTxt,
                                                     const SkTDArray<SkScalar>& fallbackPos,
                                                     int scalarsPerPosition,
                                                     const SkPoint& offset) {
     SkASSERT(fallbackTxt.count());
-    blob->setHasBitmap();
     Run& run = blob->fRuns[runIndex];
     // Push back a new subrun to fill and set the override descriptor
     run.push_back();
     run.fOverrideDescriptor.reset(new SkAutoDescriptor);
     GrTextUtils::DrawBmpPosText(blob, runIndex, fContext->getBatchFontCache(), fSurfaceProps,
                                 skPaint, color, viewMatrix, fallbackTxt.begin(), fallbackTxt.count(),
                                 fallbackPos.begin(), scalarsPerPosition, offset);
 }
 
 inline GrAtlasTextBlob*
-GrAtlasTextContext::setupDFBlob(int glyphCount, const SkPaint& origPaint,
-                                const SkMatrix& viewMatrix, SkPaint* dfPaint,
-                                SkScalar* textRatio) {
-    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;
-}
-
-inline GrAtlasTextBlob*
 GrAtlasTextContext::createDrawTextBlob(const GrPaint& paint, const SkPaint& skPaint,
                                        const SkMatrix& viewMatrix,
                                        const char text[], size_t byteLength,
                                        SkScalar x, SkScalar y) {
     int glyphCount = skPaint.countText(text, byteLength);
 
-    GrAtlasTextBlob* blob;
+    GrAtlasTextBlob* blob = fCache->createBlob(glyphCount, 1, GrAtlasTextBlob::kGrayTextVASize);
+    blob->fViewMatrix = viewMatrix;
+
     if (this->canDrawAsDistanceFields(skPaint, viewMatrix)) {
-        SkPaint dfPaint;
-        SkScalar textRatio;
-        blob = this->setupDFBlob(glyphCount, skPaint, viewMatrix, &dfPaint, &textRatio);
-
-        this->internalDrawDFText(blob, 0, dfPaint, paint.getColor(), viewMatrix, text,
-                                 byteLength, x, y, textRatio, skPaint);
+        this->internalDrawDFText(blob, 0, skPaint, paint.getColor(), viewMatrix, text,
+                                 byteLength, x, y);
     } else {
-        blob = fCache->createBlob(glyphCount, 1, GrAtlasTextBlob::kGrayTextVASize);
-        blob->fViewMatrix = viewMatrix;
-
         GrTextUtils::DrawBmpText(blob, 0, fContext->getBatchFontCache(), fSurfaceProps, skPaint,
                                  paint.getColor(), viewMatrix, text, byteLength, x, y);
     }
     return blob;
 }
 
 inline GrAtlasTextBlob*
 GrAtlasTextContext::createDrawPosTextBlob(const GrPaint& paint, const SkPaint& skPaint,
                                           const SkMatrix& viewMatrix,
                                           const char text[], size_t byteLength,
                                           const SkScalar pos[], int scalarsPerPosition,
                                           const SkPoint& offset) {
     int glyphCount = skPaint.countText(text, byteLength);
 
-    GrAtlasTextBlob* blob;
+    GrAtlasTextBlob* blob = fCache->createBlob(glyphCount, 1, GrAtlasTextBlob::kGrayTextVASize);
+    blob->fViewMatrix = viewMatrix;
+
     if (this->canDrawAsDistanceFields(skPaint, viewMatrix)) {
-        SkPaint dfPaint;
-        SkScalar textRatio;
-        blob = this->setupDFBlob(glyphCount, skPaint, viewMatrix, &dfPaint, &textRatio);
-
-        this->internalDrawDFPosText(blob, 0, dfPaint, paint.getColor(), viewMatrix, text,
-                                    byteLength, pos, scalarsPerPosition, offset, textRatio,
-                                    skPaint);
+        this->internalDrawDFPosText(blob, 0, skPaint, paint.getColor(), viewMatrix, text,
+                                    byteLength, pos, scalarsPerPosition, offset);
     } else {
-        blob = fCache->createBlob(glyphCount, 1, GrAtlasTextBlob::kGrayTextVASize);
-        blob->fViewMatrix = viewMatrix;
         GrTextUtils::DrawBmpPosText(blob, 0, fContext->getBatchFontCache(), fSurfaceProps, skPaint,
                                     paint.getColor(), viewMatrix, text,
                                     byteLength, pos, scalarsPerPosition, offset);
     }
     return blob;
 }
 
 void GrAtlasTextContext::onDrawText(GrDrawContext* dc,
                                     const GrClip& clip,
                                     const GrPaint& paint, const SkPaint& skPaint,
@@ skipping 20 matching lines @@
                                     offset));
 
     blob->flushThrowaway(fContext, dc, fSurfaceProps, fDistanceAdjustTable, skPaint, paint, clip,
                          regionClipBounds);
 }
 
 void GrAtlasTextContext::internalDrawDFText(GrAtlasTextBlob* blob, int runIndex,
                                             const SkPaint& skPaint, GrColor color,
                                             const SkMatrix& viewMatrix,
                                             const char text[], size_t byteLength,
-                                            SkScalar x, SkScalar y,
-                                            SkScalar textRatio,
-                                            const SkPaint& origPaint) {
+                                            SkScalar x, SkScalar y) {
     SkASSERT(byteLength == 0 || text != nullptr);
 
     // nothing to draw
     if (text == nullptr || byteLength == 0) {
         return;
     }
 
-    SkDrawCacheProc glyphCacheProc = origPaint.getDrawCacheProc();
+    SkDrawCacheProc glyphCacheProc = skPaint.getDrawCacheProc();
     SkAutoDescriptor desc;
-    origPaint.getScalerContextDescriptor(&desc, fSurfaceProps, nullptr, true);
-    SkGlyphCache* origPaintCache = SkGlyphCache::DetachCache(origPaint.getTypeface(),
+    skPaint.getScalerContextDescriptor(&desc, fSurfaceProps, nullptr, true);
+    SkGlyphCache* origPaintCache = SkGlyphCache::DetachCache(skPaint.getTypeface(),
                                                              desc.getDesc());
 
     SkTArray<SkScalar> positions;
 
     const char* textPtr = text;
     SkFixed stopX = 0;
     SkFixed stopY = 0;
     SkFixed origin = 0;
-    switch (origPaint.getTextAlign()) {
+    switch (skPaint.getTextAlign()) {
         case SkPaint::kRight_Align: origin = SK_Fixed1; break;
         case SkPaint::kCenter_Align: origin = SK_FixedHalf; break;
         case SkPaint::kLeft_Align: origin = 0; break;
     }
 
     SkAutoKern autokern;
     const char* stop = text + byteLength;
     while (textPtr < stop) {
         // don't need x, y here, since all subpixel variants will have the
         // same advance
         const SkGlyph& glyph = glyphCacheProc(origPaintCache, &textPtr, 0, 0);
 
         SkFixed width = glyph.fAdvanceX + autokern.adjust(glyph);
         positions.push_back(SkFixedToScalar(stopX + SkFixedMul(origin, width)));
 
         SkFixed height = glyph.fAdvanceY;
         positions.push_back(SkFixedToScalar(stopY + SkFixedMul(origin, height)));
 
         stopX += width;
         stopY += height;
     }
     SkASSERT(textPtr == stop);
 
     SkGlyphCache::AttachCache(origPaintCache);
 
     // now adjust starting point depending on alignment
     SkScalar alignX = SkFixedToScalar(stopX);
     SkScalar alignY = SkFixedToScalar(stopY);
-    if (origPaint.getTextAlign() == SkPaint::kCenter_Align) {
+    if (skPaint.getTextAlign() == SkPaint::kCenter_Align) {
         alignX = SkScalarHalf(alignX);
         alignY = SkScalarHalf(alignY);
-    } else if (origPaint.getTextAlign() == SkPaint::kLeft_Align) {
+    } else if (skPaint.getTextAlign() == SkPaint::kLeft_Align) {
         alignX = 0;
         alignY = 0;
     }
     x -= alignX;
     y -= alignY;
     SkPoint offset = SkPoint::Make(x, y);
 
     this->internalDrawDFPosText(blob, runIndex, skPaint, color, viewMatrix, text, byteLength,
-                                positions.begin(), 2, offset, textRatio, origPaint);
+                                positions.begin(), 2, offset);
 }
 
 void GrAtlasTextContext::internalDrawDFPosText(GrAtlasTextBlob* blob, int runIndex,
-                                               const SkPaint& skPaint,
+                                               const SkPaint& origPaint,
                                                GrColor color,
                                                const SkMatrix& viewMatrix,
                                                const char text[], size_t byteLength,
                                                const SkScalar pos[], int scalarsPerPosition,
-                                               const SkPoint& offset,
-                                               SkScalar textRatio,
-                                               const SkPaint& origPaint) {
+                                               const SkPoint& offset) {
 
     SkASSERT(byteLength == 0 || text != nullptr);
     SkASSERT(1 == scalarsPerPosition || 2 == scalarsPerPosition);
 
     // nothing to draw
     if (text == nullptr || byteLength == 0) {
         return;
     }
 
     SkTDArray<char> fallbackTxt;
     SkTDArray<SkScalar> fallbackPos;
 
+    // Setup distance field paint and text ratio
+    SkScalar textRatio;
+    SkPaint dfPaint(origPaint);
+    this->initDistanceFieldPaint(blob, &dfPaint, &textRatio, viewMatrix);
+    blob->setHasDistanceField();
+    blob->setSubRunHasDistanceFields(runIndex, origPaint.isLCDRenderText());
+
     fCurrStrike = nullptr;
 
-    SkGlyphCache* cache = blob->setupCache(runIndex, fSurfaceProps, skPaint, nullptr, true);
-    SkDrawCacheProc glyphCacheProc = skPaint.getDrawCacheProc();
+    SkGlyphCache* cache = blob->setupCache(runIndex, fSurfaceProps, dfPaint, nullptr, true);
+    SkDrawCacheProc glyphCacheProc = dfPaint.getDrawCacheProc();
     GrFontScaler* fontScaler = GetGrFontScaler(cache);
 
     const char* stop = text + byteLength;
 
-    if (SkPaint::kLeft_Align == skPaint.getTextAlign()) {
+    if (SkPaint::kLeft_Align == dfPaint.getTextAlign()) {
         while (text < stop) {
             const char* lastText = text;
             // the last 2 parameters are ignored
             const SkGlyph& glyph = glyphCacheProc(cache, &text, 0, 0);
 
             if (glyph.fWidth) {
                 SkScalar x = offset.x() + pos[0];
                 SkScalar y = offset.y() + (2 == scalarsPerPosition ? pos[1] : 0);
 
                 if (!this->dfAppendGlyph(blob,
                                          runIndex,
                                          glyph,
                                          x, y, color, fontScaler,
                                          textRatio, viewMatrix)) {
                     // couldn't append, send to fallback
                     fallbackTxt.append(SkToInt(text-lastText), lastText);
                     *fallbackPos.append() = pos[0];
                     if (2 == scalarsPerPosition) {
                         *fallbackPos.append() = pos[1];
                     }
                 }
             }
             pos += scalarsPerPosition;
         }
     } else {
-        SkScalar alignMul = SkPaint::kCenter_Align == skPaint.getTextAlign() ? SK_ScalarHalf
+        SkScalar alignMul = SkPaint::kCenter_Align == dfPaint.getTextAlign() ? SK_ScalarHalf
                                                                              : SK_Scalar1;
         while (text < stop) {
             const char* lastText = text;
             // the last 2 parameters are ignored
             const SkGlyph& glyph = glyphCacheProc(cache, &text, 0, 0);
 
             if (glyph.fWidth) {
                 SkScalar x = offset.x() + pos[0];
                 SkScalar y = offset.y() + (2 == scalarsPerPosition ? pos[1] : 0);
 
@@ skipping 115 matching lines @@
 
     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 blob->createBatch(info, textLen, 0, 0, color, transX, transY, skPaint,
                              gSurfaceProps, gTextContext->dfAdjustTable(),
                              context->getBatchFontCache());
 }
 
 #endif