Add factory class for generating various flavors of GrTextContext.

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 182 matching lines @@
 }
 
 void SkGpuDevice::initFromRenderTarget(GrContext* context,
                                        GrRenderTarget* renderTarget,
                                        bool cached) {
     fDrawProcs = NULL;
 
     fContext = context;
     fContext->ref();
 
+#if SK_DISTANCEFIELD_FONTS
+    fTextContextFactory = new GrTTextContextFactory<GrDistanceFieldTextContext>();
+#else
+    fTextContextFactory = new GrTTextContextFactory<GrBitmapTextContext>();
+#endif
+
     fRenderTarget = NULL;
     fNeedClear = false;
 
     SkASSERT(NULL != renderTarget);
     fRenderTarget = renderTarget;
     fRenderTarget->ref();
 
     // Hold onto to the texture in the pixel ref (if there is one) because the texture holds a ref
     // on the RT but not vice-versa.
     // TODO: Remove this trickery once we figure out how to make SkGrPixelRef do this without
@@ skipping 15 matching lines @@
                          int width,
                          int height,
                          int sampleCount)
     : SkBitmapDevice(make_bitmap(config, width, height, false /*isOpaque*/))
 {
     fDrawProcs = NULL;
 
     fContext = context;
     fContext->ref();
 
+#if SK_DISTANCEFIELD_FONTS
+    fTextContextFactory = new GrTTextContextFactory<GrDistanceFieldTextContext>();
+#else
+    fTextContextFactory = new GrTTextContextFactory<GrBitmapTextContext>();
+#endif
+
     fRenderTarget = NULL;
     fNeedClear = false;
 
     if (config != SkBitmap::kRGB_565_Config) {
         config = SkBitmap::kARGB_8888_Config;
     }
 
     GrTextureDesc desc;
     desc.fFlags = kRenderTarget_GrTextureFlagBit;
     desc.fWidth = width;
@@ skipping 24 matching lines @@
         GrPrintf("--- failed to create gpu-offscreen [%d %d]\n",
                  width, height);
         SkASSERT(false);
     }
 }
 
 SkGpuDevice::~SkGpuDevice() {
     if (fDrawProcs) {
         delete fDrawProcs;
     }
+    
+    if (fTextContextFactory) {
+        delete fTextContextFactory;
+    }
 
     // The GrContext takes a ref on the target. We don't want to cause the render
     // target to be unnecessarily kept alive.
     if (fContext->getRenderTarget() == fRenderTarget) {
         fContext->setRenderTarget(NULL);
     }
 
     if (fContext->getClip() == &fClipData) {
         fContext->setClip(NULL);
     }
@@ skipping 1521 matching lines @@
         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);
+        GrDistanceFieldTextContext* context = 
+                (GrDistanceFieldTextContext*) fTextContextFactory->Create(fContext, grPaint, paint);
 
-        SkAutoGlyphCache    autoCache(context.getSkPaint(), &this->fLeakyProperties, NULL);
+        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);
+        context->drawText((const char *)text, byteLength, x, y, cache, fontScaler);
+        fTextContextFactory->Destroy(context);
 #endif
     } else {
         SkDraw myDraw(draw);
 
         GrPaint grPaint;
         if (!skPaint2GrPaintShader(this, paint, true, &grPaint)) {
             return;
         }
 
-        GrBitmapTextContext context(fContext, grPaint, paint.getColor());
-        myDraw.fProcs = this->initDrawForText(&context);
+        GrTextContext* context = fTextContextFactory->Create(fContext, grPaint, paint);
+        myDraw.fProcs = this->initDrawForText(context);
         this->INHERITED::drawText(myDraw, text, byteLength, x, y, paint);
+        fTextContextFactory->Destroy(context);
     }
 }
 
 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 (SkDraw::ShouldDrawTextAsPaths(paint, fContext->getMatrix())) {
         // this guy will just call our drawPath()
         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);
+        GrDistanceFieldTextContext* context = 
+                (GrDistanceFieldTextContext*) fTextContextFactory->Create(fContext, grPaint, paint);

[bsalomon, 2014/01/21 20:46:17]

Does phase 2 remove the need for this downcast?

[jvanverth1, 2014/01/21 21:10:56]

Yes. The current shared interface is for working with SkDraw. The new one will
be closer to GrDistanceFieldContext, so this cast won't be necessary.

 
-        SkAutoGlyphCache    autoCache(context.getSkPaint(), &this->fLeakyProperties, NULL);
+        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,
+        context->drawPosText((const char *)text, byteLength, pos, constY, scalarsPerPos,
                             cache, fontScaler);
+        fTextContextFactory->Destroy(context);
 #endif
     } else {
         SkDraw myDraw(draw);
 
         GrPaint grPaint;
         if (!skPaint2GrPaintShader(this, paint, true, &grPaint)) {
             return;
         }
-        GrBitmapTextContext context(fContext, grPaint, paint.getColor());
-        myDraw.fProcs = this->initDrawForText(&context);
+
+        GrTextContext* context = fTextContextFactory->Create(fContext, grPaint, paint);
+        myDraw.fProcs = this->initDrawForText(context);
         this->INHERITED::drawPosText(myDraw, text, byteLength, pos, constY,
                                         scalarsPerPos, paint);
+        fTextContextFactory->Destroy(context);
     }
 }
 
 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;
 }