A change to cleanup some organization around df text

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 273 matching lines @@
 
         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();
+            SkGlyphCache* cache = this->setupCache(&cacheBlob->fRuns[run], dfPaint, nullptr, true);
 
-            SkTDArray<char> fallbackTxt;
-            SkTDArray<SkScalar> fallbackPos;
-            SkPoint dfOffset;
-            int scalarsPerPosition = 2;
             switch (it.positioning()) {
                 case SkTextBlob::kDefault_Positioning: {
-                    this->internalDrawDFText(cacheBlob, run, dfPaint, color, viewMatrix,
+                    this->internalDrawDFText(cacheBlob, run, cache, dfPaint, color, viewMatrix,
                                              (const char *)it.glyphs(), textLen,
-                                             x + offset.x(), y + offset.y(), textRatio,
-                                             &fallbackTxt, &fallbackPos, &dfOffset, runPaint);
+                                             x + offset.x(), y + offset.y(), textRatio, runPaint);
                     break;
                 }
                 case SkTextBlob::kHorizontal_Positioning: {
-                    scalarsPerPosition = 1;
-                    dfOffset = SkPoint::Make(x, y + offset.y());
-                    this->internalDrawDFPosText(cacheBlob, run, dfPaint, color, viewMatrix,
+                    SkPoint dfOffset = SkPoint::Make(x, y + offset.y());
+                    this->internalDrawDFPosText(cacheBlob, run, cache, dfPaint, color, viewMatrix,
                                                 (const char*)it.glyphs(), textLen, it.pos(),
-                                                scalarsPerPosition, dfOffset, textRatio,
-                                                &fallbackTxt, &fallbackPos);
+                                                1, dfOffset, textRatio,
+                                                runPaint);
                     break;
                 }
                 case SkTextBlob::kFull_Positioning: {
-                    dfOffset = SkPoint::Make(x, y);
-                    this->internalDrawDFPosText(cacheBlob, run, dfPaint, color, viewMatrix,
+                    SkPoint dfOffset = SkPoint::Make(x, y);
+                    this->internalDrawDFPosText(cacheBlob, run, cache, dfPaint, color, viewMatrix,
                                                 (const char*)it.glyphs(), textLen, it.pos(),
-                                                scalarsPerPosition, dfOffset, textRatio,
-                                                &fallbackTxt, &fallbackPos);
+                                                2, dfOffset, textRatio, runPaint);
                     break;
                 }
             }
-            if (fallbackTxt.count()) {
-                this->fallbackDrawPosText(cacheBlob, run, clip, color, runPaint, viewMatrix,
-                                          fallbackTxt, fallbackPos, scalarsPerPosition, dfOffset);
-            }
+            SkGlyphCache::AttachCache(cache);
         } else if (SkDraw::ShouldDrawTextAsPaths(runPaint, viewMatrix)) {
             cacheBlob->fRuns[run].fDrawAsPaths = true;
         } else {
             cacheBlob->setHasBitmap();
             SkGlyphCache* cache = this->setupCache(&cacheBlob->fRuns[run], runPaint, &viewMatrix,
                                                    false);
             switch (it.positioning()) {
                 case SkTextBlob::kDefault_Positioning:
                     GrTextUtils::DrawBmpText(cacheBlob, run, fContext->getBatchFontCache(),
                                              cache, runPaint, color, viewMatrix,
@@ skipping 72 matching lines @@
     blob->fMinMaxScale = SkMinScalar(dfMaskScaleCeil / scaledTextSize, blob->fMinMaxScale);
 
     skPaint->setLCDRenderText(false);
     skPaint->setAutohinted(false);
     skPaint->setHinting(SkPaint::kNormal_Hinting);
     skPaint->setSubpixelText(true);
 }
 
 inline void GrAtlasTextContext::fallbackDrawPosText(GrAtlasTextBlob* blob,
                                                     int runIndex,
-                                                    const GrClip& clip,
                                                     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];
@@ skipping 21 matching lines @@
     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 GrClip& clip,
-                                       const GrPaint& paint, const SkPaint& skPaint,
+GrAtlasTextContext::createDrawTextBlob(const GrPaint& paint, const SkPaint& skPaint,
                                        const SkMatrix& viewMatrix,
                                        const char text[], size_t byteLength,
-                                       SkScalar x, SkScalar y, const SkIRect& regionClipBounds) {
+                                       SkScalar x, SkScalar y) {
     int glyphCount = skPaint.countText(text, byteLength);
 
     GrAtlasTextBlob* blob;
     if (this->canDrawAsDistanceFields(skPaint, viewMatrix)) {
         SkPaint dfPaint;
         SkScalar textRatio;
         blob = this->setupDFBlob(glyphCount, skPaint, viewMatrix, &dfPaint, &textRatio);
+        SkGlyphCache* cache = this->setupCache(&blob->fRuns[0], dfPaint, nullptr, true);
 
-        SkTDArray<char> fallbackTxt;
-        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);
-        }
+        this->internalDrawDFText(blob, 0, cache, dfPaint, paint.getColor(), viewMatrix, text,
+                                 byteLength, x, y, textRatio, skPaint);
+        SkGlyphCache::AttachCache(cache);
     } else {
         blob = fCache->createBlob(glyphCount, 1, GrAtlasTextBlob::kGrayTextVASize);
         blob->fViewMatrix = viewMatrix;
 
         SkGlyphCache* cache = this->setupCache(&blob->fRuns[0], skPaint, &viewMatrix, false);
         GrTextUtils::DrawBmpText(blob, 0, fContext->getBatchFontCache(), cache, skPaint,
                                  paint.getColor(), viewMatrix, text, byteLength, x, y);
         SkGlyphCache::AttachCache(cache);
     }
     return blob;
 }
 
 inline GrAtlasTextBlob*
-GrAtlasTextContext::createDrawPosTextBlob(const GrClip& clip,
-                                          const GrPaint& paint, const SkPaint& skPaint,
+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, const SkIRect& regionClipBounds) {
+                                          const SkPoint& offset) {
     int glyphCount = skPaint.countText(text, byteLength);
 
     GrAtlasTextBlob* blob;
     if (this->canDrawAsDistanceFields(skPaint, viewMatrix)) {
         SkPaint dfPaint;
         SkScalar textRatio;
         blob = this->setupDFBlob(glyphCount, skPaint, viewMatrix, &dfPaint, &textRatio);
+        SkGlyphCache* cache = this->setupCache(&blob->fRuns[0], dfPaint, nullptr, true);
 
-        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);
-        }
+        this->internalDrawDFPosText(blob, 0, cache, dfPaint, paint.getColor(), viewMatrix, text,
+                                    byteLength, pos, scalarsPerPosition, offset, textRatio,
+                                    skPaint);
+        SkGlyphCache::AttachCache(cache);
     } else {
         blob = fCache->createBlob(glyphCount, 1, GrAtlasTextBlob::kGrayTextVASize);
         blob->fViewMatrix = viewMatrix;
         SkGlyphCache* cache = this->setupCache(&blob->fRuns[0], skPaint, &viewMatrix, false);
         GrTextUtils::DrawBmpPosText(blob, 0, fContext->getBatchFontCache(), cache, skPaint,
                                     paint.getColor(), viewMatrix, text,
                                     byteLength, pos, scalarsPerPosition, offset);
         SkGlyphCache::AttachCache(cache);
     }
     return blob;
 }
 
 void GrAtlasTextContext::onDrawText(GrDrawContext* dc,
                                     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<GrAtlasTextBlob> blob(
-        this->createDrawTextBlob(clip, paint, skPaint, viewMatrix,
-                                 text, byteLength, x, y, regionClipBounds));
+        this->createDrawTextBlob(paint, skPaint, viewMatrix, text, byteLength, x, y));
     blob->flushThrowaway(fContext, dc, fSurfaceProps, fDistanceAdjustTable, skPaint, paint,
                          clip, regionClipBounds);
 }
 
 void GrAtlasTextContext::onDrawPosText(GrDrawContext* dc,
                                        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<GrAtlasTextBlob> blob(
-        this->createDrawPosTextBlob(clip, paint, skPaint, viewMatrix,
+        this->createDrawPosTextBlob(paint, skPaint, viewMatrix,
                                     text, byteLength,
                                     pos, scalarsPerPosition,
-                                    offset, regionClipBounds));
+                                    offset));
 
     blob->flushThrowaway(fContext, dc, fSurfaceProps, fDistanceAdjustTable, skPaint, paint, clip,
                          regionClipBounds);
 }
 
 void GrAtlasTextContext::internalDrawDFText(GrAtlasTextBlob* blob, int runIndex,
+                                            SkGlyphCache* cache,
                                             const SkPaint& skPaint, GrColor color,
                                             const SkMatrix& viewMatrix,
                                             const char text[], size_t byteLength,
                                             SkScalar x, SkScalar y,
                                             SkScalar textRatio,
-                                            SkTDArray<char>* fallbackTxt,
-                                            SkTDArray<SkScalar>* fallbackPos,
-                                            SkPoint* offset,
                                             const SkPaint& origPaint) {
     SkASSERT(byteLength == 0 || text != nullptr);
 
     // nothing to draw
     if (text == nullptr || byteLength == 0) {
         return;
     }
 
     SkDrawCacheProc glyphCacheProc = origPaint.getDrawCacheProc();
     SkAutoDescriptor desc;
@@ skipping 38 matching lines @@
     SkScalar alignY = SkFixedToScalar(stopY);
     if (origPaint.getTextAlign() == SkPaint::kCenter_Align) {
         alignX = SkScalarHalf(alignX);
         alignY = SkScalarHalf(alignY);
     } else if (origPaint.getTextAlign() == SkPaint::kLeft_Align) {
         alignX = 0;
         alignY = 0;
     }
     x -= alignX;
     y -= alignY;
-    *offset = SkPoint::Make(x, y);
+    SkPoint offset = SkPoint::Make(x, y);
 
-    this->internalDrawDFPosText(blob, runIndex, skPaint, color, viewMatrix, text, byteLength,
-                                positions.begin(), 2, *offset, textRatio, fallbackTxt,
-                                fallbackPos);
+    this->internalDrawDFPosText(blob, runIndex, cache, skPaint, color, viewMatrix, text, byteLength,
+                                positions.begin(), 2, offset, textRatio, origPaint);
 }
 
 void GrAtlasTextContext::internalDrawDFPosText(GrAtlasTextBlob* blob, int runIndex,
-                                               const SkPaint& skPaint, GrColor color,
+                                               SkGlyphCache* cache,
+                                               const SkPaint& skPaint,
+                                               GrColor color,
                                                const SkMatrix& viewMatrix,
                                                const char text[], size_t byteLength,
                                                const SkScalar pos[], int scalarsPerPosition,
                                                const SkPoint& offset,
                                                SkScalar textRatio,
-                                               SkTDArray<char>* fallbackTxt,
-                                               SkTDArray<SkScalar>* fallbackPos) {
+                                               const SkPaint& origPaint) {
 
     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;
+
     fCurrStrike = nullptr;
 
     SkDrawCacheProc glyphCacheProc = skPaint.getDrawCacheProc();
-    SkGlyphCache* cache = this->setupCache(&blob->fRuns[runIndex], skPaint, nullptr, true);
     GrFontScaler* fontScaler = GetGrFontScaler(cache);
 
     const char* stop = text + byteLength;
 
     if (SkPaint::kLeft_Align == skPaint.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];
+                    fallbackTxt.append(SkToInt(text-lastText), lastText);
+                    *fallbackPos.append() = pos[0];
                     if (2 == scalarsPerPosition) {
-                        *fallbackPos->append() = pos[1];
+                        *fallbackPos.append() = pos[1];
                     }
                 }
             }
             pos += scalarsPerPosition;
         }
     } else {
         SkScalar alignMul = SkPaint::kCenter_Align == skPaint.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);
 
                 SkScalar advanceX = SkFixedToScalar(glyph.fAdvanceX) * alignMul * textRatio;
                 SkScalar advanceY = SkFixedToScalar(glyph.fAdvanceY) * alignMul * textRatio;
 
                 if (!this->dfAppendGlyph(blob,
                                          runIndex,
                                          glyph,
                                          x - advanceX, y - advanceY, color,
                                          fontScaler,
                                          textRatio,
                                          viewMatrix)) {
                     // couldn't append, send to fallback
-                    fallbackTxt->append(SkToInt(text-lastText), lastText);
-                    *fallbackPos->append() = pos[0];
+                    fallbackTxt.append(SkToInt(text-lastText), lastText);
+                    *fallbackPos.append() = pos[0];
                     if (2 == scalarsPerPosition) {
-                        *fallbackPos->append() = pos[1];
+                        *fallbackPos.append() = pos[1];
                     }
                 }
             }
             pos += scalarsPerPosition;
         }
     }
 
-    SkGlyphCache::AttachCache(cache);
+    if (fallbackTxt.count()) {

[jvanverth1, 2015/12/11 18:12:57]

+1. This makes a lot more sense than passing it out as a parameter.

+        this->fallbackDrawPosText(blob, runIndex, origPaint.getColor(), origPaint, viewMatrix,
+                                  fallbackTxt, fallbackPos, scalarsPerPosition, offset);
+    }
 }
 
 bool GrAtlasTextContext::dfAppendGlyph(GrAtlasTextBlob* blob, int runIndex,
                                        const SkGlyph& skGlyph,
                                        SkScalar sx, SkScalar sy, GrColor color,
                                        GrFontScaler* scaler,
                                        SkScalar textRatio, const SkMatrix& viewMatrix) {
     if (!fCurrStrike) {
         fCurrStrike = fContext->getBatchFontCache()->getStrike(scaler);
     }
@@ skipping 62 matching lines @@
     GrPaint grPaint;
     if (!SkPaintToGrPaint(context, skPaint, viewMatrix, &grPaint)) {
         SkFAIL("couldn't convert paint\n");
     }
 
     const char* text = "The quick brown fox jumps over the lazy dog.";
     int textLen = (int)strlen(text);
 
     // Setup clip
     GrClip clip;
-    SkIRect noClip = SkIRect::MakeLargest();
 
     // right now we don't handle textblobs, nor do we handle drawPosText.  Since we only
     // intend to test the batch with this unit test, that is okay.
     SkAutoTUnref<GrAtlasTextBlob> blob(
-            gTextContext->createDrawTextBlob(clip, grPaint, skPaint, viewMatrix, text,
-                                             static_cast<size_t>(textLen), 0, 0, noClip));
+            gTextContext->createDrawTextBlob(grPaint, skPaint, viewMatrix, text,
+                                             static_cast<size_t>(textLen), 0, 0));
 
     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