Move distance field font code into SkGpuDevice

src/gpu/SkGpuDevice.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkGpuDevice.h"
 
 #include "effects/GrBicubicEffect.h"
@@ skipping 1731 matching lines @@
                                          procs->fFontScaler);
 }
 
 SkDrawProcs* SkGpuDevice::initDrawForText(GrTextContext* context) {
 
     // deferred allocation
     if (NULL == fDrawProcs) {
         fDrawProcs = SkNEW(GrSkDrawProcs);
         fDrawProcs->fD1GProc = SkGPU_Draw1Glyph;
         fDrawProcs->fContext = fContext;
-#if SK_DISTANCEFIELD_FONTS
-        fDrawProcs->fFlags = 0;
-#endif
     }
 
     // init our (and GL's) state
     fDrawProcs->fTextContext = context;
     fDrawProcs->fFontScaler = NULL;
     return fDrawProcs;
 }
 
 void SkGpuDevice::drawText(const SkDraw& draw, const void* text,
                           size_t byteLength, SkScalar x, SkScalar y,
                           const SkPaint& paint) {
     CHECK_SHOULD_DRAW(draw, false);
 
-    if (fContext->getMatrix().hasPerspective()) {
-        // this guy will just call our drawPath()
-        draw.drawText((const char*)text, byteLength, x, y, paint);
+    if (SkDraw::ShouldDrawTextAsPaths(paint, fContext->getMatrix())) {
+        draw.drawText_asPaths((const char*)text, byteLength, x, y, paint);
+#if SK_DISTANCEFIELD_FONTS
+    } else if (!paint.getRasterizer()) {
+        GrPaint grPaint;
+        if (!skPaint2GrPaintShader(this, paint, true, &grPaint)) {
+            return;
+        }
+
+        SkDEBUGCODE(this->validate();)
+
+        GrDistanceFieldTextContext context(fContext, grPaint, paint);
+
+        SkAutoGlyphCache    autoCache(context.getSkPaint(), &this->fLeakyProperties, NULL);
+        SkGlyphCache*       cache = autoCache.getCache();
+        GrFontScaler*       fontScaler = get_gr_font_scaler(cache);
+
+        context.drawText((const char *)text, byteLength, x, y, cache, fontScaler);
+#endif
     } else {
         SkDraw myDraw(draw);
 
         GrPaint grPaint;
         if (!skPaint2GrPaintShader(this, paint, true, &grPaint)) {
             return;
         }
-#if SK_DISTANCEFIELD_FONTS
-        if (paint.getRasterizer()) {
-#endif
-            GrBitmapTextContext context(fContext, grPaint, paint.getColor());
-            myDraw.fProcs = this->initDrawForText(&context);
-            this->INHERITED::drawText(myDraw, text, byteLength, x, y, paint);
-#if SK_DISTANCEFIELD_FONTS
-        } else {
-            GrDistanceFieldTextContext context(fContext, grPaint, paint.getColor(),
-                                               paint.getTextSize()/SkDrawProcs::kBaseDFFontSize);
-            myDraw.fProcs = this->initDrawForText(&context);
-            fDrawProcs->fFlags |= SkDrawProcs::kSkipBakedGlyphTransform_Flag;
-            fDrawProcs->fFlags |= SkDrawProcs::kUseScaledGlyphs_Flag;
-            this->INHERITED::drawText(myDraw, text, byteLength, x, y, paint);
-            fDrawProcs->fFlags = 0;
-       }
-#endif
+
+        GrBitmapTextContext context(fContext, grPaint, paint.getColor());
+        myDraw.fProcs = this->initDrawForText(&context);
+        this->INHERITED::drawText(myDraw, text, byteLength, x, y, paint);
     }
 }
 
 void SkGpuDevice::drawPosText(const SkDraw& draw, const void* text,
                              size_t byteLength, const SkScalar pos[],
                              SkScalar constY, int scalarsPerPos,
                              const SkPaint& paint) {
     CHECK_SHOULD_DRAW(draw, false);
 
-    if (fContext->getMatrix().hasPerspective()) {
+    if (SkDraw::ShouldDrawTextAsPaths(paint, fContext->getMatrix())) {
         // this guy will just call our drawPath()
-        draw.drawPosText((const char*)text, byteLength, pos, constY,
+        draw.drawPosText_asPaths((const char*)text, byteLength, pos, constY,
                          scalarsPerPos, paint);
+#if SK_DISTANCEFIELD_FONTS
+    } else if (!paint.getRasterizer()) {
+        GrPaint grPaint;
+        if (!skPaint2GrPaintShader(this, paint, true, &grPaint)) {
+            return;
+        }
+
+        SkDEBUGCODE(this->validate();)
+
+        GrDistanceFieldTextContext context(fContext, grPaint, paint);
+
+        SkAutoGlyphCache    autoCache(context.getSkPaint(), &this->fLeakyProperties, NULL);
+        SkGlyphCache*       cache = autoCache.getCache();
+        GrFontScaler*       fontScaler = get_gr_font_scaler(cache);
+        
+        context.drawPosText((const char *)text, byteLength, pos, constY, scalarsPerPos,
+                            cache, fontScaler);
+#endif
     } else {
         SkDraw myDraw(draw);
 
         GrPaint grPaint;
         if (!skPaint2GrPaintShader(this, paint, true, &grPaint)) {
             return;
         }
-#if SK_DISTANCEFIELD_FONTS
-        if (paint.getRasterizer()) {
-#endif
-            GrBitmapTextContext context(fContext, grPaint, paint.getColor());
-            myDraw.fProcs = this->initDrawForText(&context);
-            this->INHERITED::drawPosText(myDraw, text, byteLength, pos, constY,
-                                         scalarsPerPos, paint);
-#if SK_DISTANCEFIELD_FONTS
-        } else {
-            GrDistanceFieldTextContext context(fContext, grPaint, paint.getColor(),
-                                               paint.getTextSize()/SkDrawProcs::kBaseDFFontSize);
-            myDraw.fProcs = this->initDrawForText(&context);
-            fDrawProcs->fFlags |= SkDrawProcs::kSkipBakedGlyphTransform_Flag;
-            fDrawProcs->fFlags |= SkDrawProcs::kUseScaledGlyphs_Flag;
-            this->INHERITED::drawPosText(myDraw, text, byteLength, pos, constY,
-                                         scalarsPerPos, paint);
-            fDrawProcs->fFlags = 0;
-        }
-#endif
+        GrBitmapTextContext context(fContext, grPaint, paint.getColor());
+        myDraw.fProcs = this->initDrawForText(&context);
+        this->INHERITED::drawPosText(myDraw, text, byteLength, pos, constY,
+                                        scalarsPerPos, paint);
     }
 }
 
 void SkGpuDevice::drawTextOnPath(const SkDraw& draw, const void* text,
                                 size_t len, const SkPath& path,
                                 const SkMatrix* m, const SkPaint& paint) {
     CHECK_SHOULD_DRAW(draw, false);
 
     SkASSERT(draw.fDevice == this);
     draw.drawTextOnPath((const char*)text, len, path, m, paint);
@@ skipping 68 matching lines @@
                          GrTexture* texture,
                          bool needClear)
     : SkBitmapDevice(make_bitmap(context, texture->asRenderTarget())) {
 
     SkASSERT(texture && texture->asRenderTarget());
     // This constructor is called from onCreateCompatibleDevice. It has locked the RT in the texture
     // cache. We pass true for the third argument so that it will get unlocked.
     this->initFromRenderTarget(context, texture->asRenderTarget(), true);
     fNeedClear = needClear;
 }