Ganesh text rendering cleanup.

src/gpu/GrDistanceFieldTextContext.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrDistanceFieldTextContext.h"
 #include "GrAtlas.h"
 #include "GrBitmapTextContext.h"
 #include "GrDrawTarget.h"
 #include "GrDrawTargetCaps.h"
+#include "GrFontCache.h"
 #include "GrFontScaler.h"
 #include "GrGpu.h"
 #include "GrIndexBuffer.h"
 #include "GrStrokeInfo.h"
 #include "GrTexturePriv.h"
-#include "GrTextStrike.h"
-#include "GrTextStrike_impl.h"
 
 #include "SkAutoKern.h"
 #include "SkColorFilter.h"
 #include "SkDistanceFieldGen.h"
 #include "SkDraw.h"
 #include "SkGlyphCache.h"
 #include "SkGpuDevice.h"
 #include "SkPath.h"
 #include "SkRTConf.h"
 #include "SkStrokeRec.h"
@@ skipping 398 matching lines @@
                                                                                 params, flags));
 #endif
         }
         fEffectTextureUniqueID = textureUniqueID;
         fEffectColor = filteredColor;
         fEffectFlags = flags;
     }
     
 }
 
+inline bool GrDistanceFieldTextContext::uploadGlyph(GrGlyph* glyph, GrFontScaler* scaler) {
+    if (!fStrike->glyphTooLargeForAtlas(glyph)) {
+        if (fStrike->addGlyphToAtlas(glyph, scaler)) {
+            return true;
+        }
+        
+        // try to clear out an unused plot before we flush
+        if (fContext->getFontCache()->freeUnusedPlot(fStrike, glyph) &&
+            fStrike->addGlyphToAtlas(glyph, scaler)) {
+            return true;
+        }
+        
+        if (c_DumpFontCache) {
+#ifdef SK_DEVELOPER
+            fContext->getFontCache()->dump();
+#endif
+        }
+        
+        // before we purge the cache, we must flush any accumulated draws
+        this->flush();
+        fContext->flush();
+        
+        // we should have an unused plot now
+        if (fContext->getFontCache()->freeUnusedPlot(fStrike, glyph) &&
+            fStrike->addGlyphToAtlas(glyph, scaler)) {
+            return true;
+        }
+        
+        // we should never get here
+        SkASSERT(false);
+    }
+    
+    return false;
+}
+
+
 // Returns true if this method handled the glyph, false if needs to be passed to fallback
 //
 bool GrDistanceFieldTextContext::appendGlyph(GrGlyph::PackedID packed,
                                              SkScalar sx, SkScalar sy,
                                              GrFontScaler* scaler) {
     if (NULL == fDrawTarget) {
         return true;
     }
 
     if (NULL == fStrike) {
@@ skipping 29 matching lines @@
     const SkMatrix& ctm = fContext->getMatrix();
     (void) ctm.mapRect(&dstRect, glyphRect);
     if (fClipRect.quickReject(SkScalarTruncToInt(dstRect.left()),
                               SkScalarTruncToInt(dstRect.top()),
                               SkScalarTruncToInt(dstRect.right()),
                               SkScalarTruncToInt(dstRect.bottom()))) {
 //            SkCLZ(3);    // so we can set a break-point in the debugger
         return true;
     }
 
-    if (NULL == glyph->fPlot) {
-        if (!fStrike->glyphTooLargeForAtlas(glyph)) {
-            if (fStrike->addGlyphToAtlas(glyph, scaler)) {
-                goto HAS_ATLAS;
-            }
-
-            // try to clear out an unused plot before we flush
-            if (fContext->getFontCache()->freeUnusedPlot(fStrike, glyph) &&
-                fStrike->addGlyphToAtlas(glyph, scaler)) {
-                goto HAS_ATLAS;
-            }
-
-            if (c_DumpFontCache) {
-#ifdef SK_DEVELOPER
-                fContext->getFontCache()->dump();
-#endif
-            }
-
-            // before we purge the cache, we must flush any accumulated draws
-            this->flush();
-            fContext->flush();
-
-            // we should have an unused plot now
-            if (fContext->getFontCache()->freeUnusedPlot(fStrike, glyph) &&
-                fStrike->addGlyphToAtlas(glyph, scaler)) {
-                goto HAS_ATLAS;
-            }
-        }
-
+    if (NULL == glyph->fPlot && !uploadGlyph(glyph, scaler)) {
         if (NULL == glyph->fPath) {
             SkPath* path = SkNEW(SkPath);
             if (!scaler->getGlyphPath(glyph->glyphID(), path)) {
                 // flag the glyph as being dead?
                 delete path;
                 return true;
             }
             glyph->fPath = path;
         }
 
         // flush any accumulated draws before drawing this glyph as a path.
         this->flush();
 
         GrContext::AutoMatrix am;
         SkMatrix ctm;
         ctm.setScale(fTextRatio, fTextRatio);
         ctm.postTranslate(sx - dx, sy - dy);
         GrPaint tmpPaint(fPaint);
         am.setPreConcat(fContext, ctm, &tmpPaint);
         GrStrokeInfo strokeInfo(SkStrokeRec::kFill_InitStyle);
         fContext->drawPath(tmpPaint, *glyph->fPath, strokeInfo);
 
         // remove this glyph from the vertices we need to allocate
         fTotalVertexCount -= kVerticesPerGlyph;
         return true;
     }
 
-HAS_ATLAS:
     SkASSERT(glyph->fPlot);
     GrDrawTarget::DrawToken drawToken = fDrawTarget->getCurrentDrawToken();
     glyph->fPlot->setDrawToken(drawToken);
 
     GrTexture* texture = glyph->fPlot->texture();
     SkASSERT(texture);
 
     if (fCurrTexture != texture || fCurrVertex + kVerticesPerGlyph > fTotalVertexCount) {
         this->flush();
         fCurrTexture = texture;
@@ skipping 118 matching lines @@
     }
 }
 
 inline void GrDistanceFieldTextContext::finish() {
     this->flush();
     fTotalVertexCount = 0;
 
     GrTextContext::finish();
 }