Replace factory generation of TextContexts with persistent objects.

src/gpu/GrBitmapTextContext.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 "GrBitmapTextContext.h"
 #include "GrAtlas.h"
 #include "GrDrawTarget.h"
@@ skipping 11 matching lines @@
 #include "SkDraw.h"
 #include "SkGlyphCache.h"
 #include "SkGpuDevice.h"
 #include "SkGr.h"
 
 static const int kGlyphCoordsAttributeIndex = 1;
 
 SK_CONF_DECLARE(bool, c_DumpFontCache, "gpu.dumpFontCache", false,
                 "Dump the contents of the font cache before every purge.");
 
-bool GrBitmapTextContext::CanDraw(const SkPaint& paint, const SkMatrix& ctm) {
-    return !SkDraw::ShouldDrawTextAsPaths(paint, ctm);
-}
-
 GrBitmapTextContext::GrBitmapTextContext(GrContext* context,
-                                         const GrPaint& grPaint,
-                                         const SkPaint& skPaint,
                                          const SkDeviceProperties& properties)
-                                       : GrTextContext(context, grPaint, skPaint, properties) {
+                                       : GrTextContext(context, properties) {
     fStrike = NULL;
 
     fCurrTexture = NULL;
     fCurrVertex = 0;
 
     fVertices = NULL;
     fMaxVertices = 0;
 }
 
 GrBitmapTextContext::~GrBitmapTextContext() {
     this->flushGlyphs();
 }
 
+bool GrBitmapTextContext::canDraw(const SkPaint& paint) {
+    return !SkDraw::ShouldDrawTextAsPaths(paint, fContext->getMatrix());
+}
+
 static inline GrColor skcolor_to_grcolor_nopremultiply(SkColor c) {
     unsigned r = SkColorGetR(c);
     unsigned g = SkColorGetG(c);
     unsigned b = SkColorGetB(c);
     return GrColorPackRGBA(r, g, b, 0xff);
 }
 
 void GrBitmapTextContext::flushGlyphs() {
     if (NULL == fDrawTarget) {
         return;
@@ skipping 46 matching lines @@
                                           4, 6);
 
         fDrawTarget->resetVertexSource();
         fVertices = NULL;
         fMaxVertices = 0;
         fCurrVertex = 0;
         SkSafeSetNull(fCurrTexture);
     }
 }
 
-void GrBitmapTextContext::drawText(const char text[], size_t byteLength,
+inline void GrBitmapTextContext::init(const GrPaint& paint, const SkPaint& skPaint) {
+    GrTextContext::init(paint, skPaint);
+
+    fStrike = NULL;
+
+    fCurrTexture = NULL;
+    fCurrVertex = 0;
+
+    fVertices = NULL;
+    fMaxVertices = 0;
+}
+
+inline void GrBitmapTextContext::finish() {
+    flushGlyphs();
+
+    GrTextContext::finish();
+}
+
+void GrBitmapTextContext::drawText(const GrPaint& paint, const SkPaint& skPaint, 
+                                   const char text[], size_t byteLength,
                                    SkScalar x, SkScalar y) {
     SkASSERT(byteLength == 0 || text != NULL);
 
     // nothing to draw
     if (text == NULL || byteLength == 0 /*|| fRC->isEmpty()*/) {
         return;
     }
 
+    this->init(paint, skPaint);
+
     SkDrawCacheProc glyphCacheProc = fSkPaint.getDrawCacheProc();
 
     SkAutoGlyphCache    autoCache(fSkPaint, &fDeviceProperties, &fContext->getMatrix());
     SkGlyphCache*       cache = autoCache.getCache();
     GrFontScaler*       fontScaler = GetGrFontScaler(cache);
 
     // transform our starting point
     {
         SkPoint loc;
         fContext->getMatrix().mapXY(x, y, &loc);
@@ skipping 55 matching lines @@
                                           glyph.getSubXFixed(),
                                           glyph.getSubYFixed()),
                                   SkFixedFloorToFixed(fx),
                                   SkFixedFloorToFixed(fy),
                                   fontScaler);
         }
 
         fx += glyph.fAdvanceX;
         fy += glyph.fAdvanceY;
     }
+
+    this->finish();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Copied from SkDraw
 
 // last parameter is interpreted as SkFixed [x, y]
 // return the fixed position, which may be rounded or not by the caller
 //   e.g. subpixel doesn't round
 typedef void (*AlignProc)(const SkPoint&, const SkGlyph&, SkIPoint*);
 
@@ skipping 74 matching lines @@
             return (mtype & SkMatrix::kScale_Mask) ?
                         MapOnlyScaleXProc : MapOnlyTransXProc;
         }
     } else {
         return MapXYProc;
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-void GrBitmapTextContext::drawPosText(const char text[], size_t byteLength,
+void GrBitmapTextContext::drawPosText(const GrPaint& paint, const SkPaint& skPaint, 
+                                      const char text[], size_t byteLength,
                                       const SkScalar pos[], SkScalar constY,
                                       int scalarsPerPosition) {
     SkASSERT(byteLength == 0 || text != NULL);
     SkASSERT(1 == scalarsPerPosition || 2 == scalarsPerPosition);
 
     // nothing to draw
     if (text == NULL || byteLength == 0/* || fRC->isEmpty()*/) {
         return;
     }
 
+    this->init(paint, skPaint);
+
     SkDrawCacheProc glyphCacheProc = fSkPaint.getDrawCacheProc();
 
     SkAutoGlyphCache    autoCache(fSkPaint, &fDeviceProperties, &fContext->getMatrix());
     SkGlyphCache*       cache = autoCache.getCache();
     GrFontScaler*       fontScaler = GetGrFontScaler(cache);
 
     // store original matrix before we reset, so we can use it to transform positions
     SkMatrix ctm = fContext->getMatrix();
     GrContext::AutoMatrix  autoMatrix;
     autoMatrix.setIdentity(fContext, &fPaint);
@@ skipping 113 matching lines @@
                                                         glyph.getSubXFixed(),
                                                         glyph.getSubYFixed()),
                                           SkFixedFloorToFixed(fx),
                                           SkFixedFloorToFixed(fy),
                                           fontScaler);
                 }
                 pos += scalarsPerPosition;
             }
         }
     }
+
+    this->finish();
 }
 
 namespace {
 
 // position + texture coord
 extern const GrVertexAttrib gTextVertexAttribs[] = {
     {kVec2f_GrVertexAttribType, 0,               kPosition_GrVertexAttribBinding},
     {kVec2f_GrVertexAttribType, sizeof(GrPoint), kEffect_GrVertexAttribBinding}
 };
 
@@ skipping 143 matching lines @@
                                         SkFixedToFloat(vx + width),
                                         SkFixedToFloat(vy + height),
                                         2 * sizeof(SkPoint));
     fVertices[2*fCurrVertex+1].setRectFan(SkFixedToFloat(texture->normalizeFixedX(tx)),
                                           SkFixedToFloat(texture->normalizeFixedY(ty)),
                                           SkFixedToFloat(texture->normalizeFixedX(tx + width)),
                                           SkFixedToFloat(texture->normalizeFixedY(ty + height)),
                                           2 * sizeof(SkPoint));
     fCurrVertex += 4;
 }