Change drawText() to generate positions and send to drawPosText()

src/gpu/GrTextContext.cpp

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrTextContext.h"
 #include "GrContext.h"
 
@@ skipping 26 matching lines @@
     fDrawTarget = fContext->getTextTarget();
 
     fPaint = grPaint;
     fSkPaint = skPaint;
 }
 
 bool GrTextContext::drawText(const GrPaint& paint, const SkPaint& skPaint,
                              const char text[], size_t byteLength,
                              SkScalar x, SkScalar y) {
 
-    GrTextContext* textContext = this;
-    do {
-        if (textContext->canDraw(skPaint)) {
-            textContext->onDrawText(paint, skPaint, text, byteLength, x, y);
-            return true;
-        }
-        textContext = textContext->fFallbackTextContext;
-    } while (textContext);
+    SkASSERT(byteLength == 0 || text != NULL);
 
-    return false;
+    // nothing to draw
+    if (text == NULL || byteLength == 0) {
+        return true;
+    }
+
+    SkDrawCacheProc          glyphCacheProc = skPaint.getDrawCacheProc();
+    SkAutoGlyphCache         autoCache(skPaint, &fDeviceProperties, NULL);
+    SkGlyphCache*            cache = autoCache.getCache();
+
+    SkTArray<SkScalar> positions;
+
+    const char* textPtr = text;
+    SkFixed stopX = 0;
+    SkFixed stopY = 0;
+    SkFixed origin;
+    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;
+        default: SkFAIL("Invalid paint origin"); return false;
+    }
+
+    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(cache, &textPtr, 0, 0);
+
+        SkFixed width = glyph.fAdvanceX + autokern.adjust(glyph);
+        positions.push_back(SkFixedToScalar(stopX + SkFixedMul_portable(origin, width)));
+
+        SkFixed height = glyph.fAdvanceY;
+        positions.push_back(SkFixedToScalar(stopY + SkFixedMul_portable(origin, height)));
+
+        stopX += width;
+        stopY += height;
+    }
+    SkASSERT(textPtr == stop);
+
+    // now adjust starting point depending on alignment
+    SkScalar alignX = SkFixedToScalar(stopX);
+    SkScalar alignY = SkFixedToScalar(stopY);
+    if (skPaint.getTextAlign() == SkPaint::kCenter_Align) {
+        alignX = SkScalarHalf(alignX);
+        alignY = SkScalarHalf(alignY);
+    } else if (skPaint.getTextAlign() == SkPaint::kLeft_Align) {
+        alignX = 0;
+        alignY = 0;
+    }
+    x -= alignX;
+    y -= alignY;
+    SkPoint offset = SkPoint::Make(x, y);
+
+    return this->drawPosText(paint, skPaint, text, byteLength, positions.begin(), 2, offset);
 }
 
 bool GrTextContext::drawPosText(const GrPaint& paint, const SkPaint& skPaint,
                                 const char text[], size_t byteLength,
                                 const SkScalar pos[], int scalarsPerPosition,
                                 const SkPoint& offset) {
 
     GrTextContext* textContext = this;
     do {
         if (textContext->canDraw(skPaint)) {
@@ skipping 41 matching lines @@
     if (cache->getAuxProcData(GlyphCacheAuxProc, &auxData)) {
         scaler = (GrFontScaler*)auxData;
     }
     if (NULL == scaler) {
         scaler = SkNEW_ARGS(GrFontScaler, (cache));
         cache->setAuxProc(GlyphCacheAuxProc, scaler);
     }
 
     return scaler;
 }