Let text contexts fall back directly to paths

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"
@@ skipping 24 matching lines @@
 static const int kSmallDFFontSize = 32;
 static const int kSmallDFFontLimit = 32;
 static const int kMediumDFFontSize = 72;
 static const int kMediumDFFontLimit = 72;
 static const int kLargeDFFontSize = 162;
 
 static const int kVerticesPerGlyph = 4;
 static const int kIndicesPerGlyph = 6;
 
 GrDistanceFieldTextContext::GrDistanceFieldTextContext(GrContext* context,
+                                                       SkGpuDevice* gpuDevice,
                                                        const SkDeviceProperties& properties,
                                                        bool enable)
-                                                    : GrTextContext(context, properties) {
+    : GrTextContext(context, gpuDevice, properties) {
 #if SK_FORCE_DISTANCE_FIELD_TEXT
     fEnableDFRendering = true;
 #else
     fEnableDFRendering = enable;
 #endif
     fStrike = NULL;
     fGammaTexture = NULL;
 
     fEffectTextureUniqueID = SK_InvalidUniqueID;
     fEffectColor = GrColor_ILLEGAL;
     fEffectFlags = kInvalid_DistanceFieldEffectFlag;
 
     fVertices = NULL;
     fCurrVertex = 0;
     fAllocVertexCount = 0;
     fTotalVertexCount = 0;
     fCurrTexture = NULL;
 
     fVertexBounds.setLargestInverted();
 }
 
 GrDistanceFieldTextContext* GrDistanceFieldTextContext::Create(GrContext* context,
+                                                               SkGpuDevice* gpuDevice,
                                                                const SkDeviceProperties& props,
                                                                bool enable) {
     GrDistanceFieldTextContext* textContext = SkNEW_ARGS(GrDistanceFieldTextContext, 
-                                                         (context, props, enable));
-    textContext->fFallbackTextContext = GrBitmapTextContext::Create(context, props);
+                                                         (context, gpuDevice, props, enable));
+    textContext->fFallbackTextContext = GrBitmapTextContext::Create(context, gpuDevice, props);
 
     return textContext;
 }
 
 GrDistanceFieldTextContext::~GrDistanceFieldTextContext() {
     SkSafeSetNull(fGammaTexture);
 }
 
 bool GrDistanceFieldTextContext::canDraw(const SkPaint& paint, const SkMatrix& viewMatrix) {
     // TODO: support perspective (need getMaxScale replacement)
@@ skipping 22 matching lines @@
 
     // TODO: add some stroking support
     if (paint.getStyle() != SkPaint::kFill_Style) {
         return false;
     }
 
     return true;
 }
 
 inline void GrDistanceFieldTextContext::init(GrRenderTarget* rt, const GrClip& clip,
-                                             const GrPaint& paint, const SkPaint& skPaint) {
-    GrTextContext::init(rt, clip, paint, skPaint);
+                                             const GrPaint& paint, const SkPaint& skPaint,
+                                             const SkIRect& regionClipBounds) {
+    GrTextContext::init(rt, clip, paint, skPaint, regionClipBounds);
 
     fStrike = NULL;
 
     const SkMatrix& ctm = fViewMatrix;
 
     // getMaxScale doesn't support perspective, so neither do we at the moment
     SkASSERT(!ctm.hasPerspective());
     SkScalar maxScale = ctm.getMaxScale();
     SkScalar textSize = fSkPaint.getTextSize();
     SkScalar scaledTextSize = textSize;
@@ skipping 76 matching lines @@
         (*gammaTexture)->writePixels(0, 0, width, height,
                                      (*gammaTexture)->config(), data.get(), 0,
                                      GrContext::kDontFlush_PixelOpsFlag);
     }
 }
 
 void GrDistanceFieldTextContext::onDrawText(GrRenderTarget* rt, const GrClip& clip,
                                             const GrPaint& paint,
                                             const SkPaint& skPaint, const SkMatrix& viewMatrix,
                                             const char text[], size_t byteLength,
-                                            SkScalar x, SkScalar y) {
+                                            SkScalar x, SkScalar y,
+                                            const SkIRect& regionClipBounds) {
     SkASSERT(byteLength == 0 || text != NULL);
 
     // nothing to draw
     if (text == NULL || byteLength == 0) {
         return;
     }
 
     fViewMatrix = viewMatrix;
     SkDrawCacheProc          glyphCacheProc = skPaint.getDrawCacheProc();
     SkAutoGlyphCache         autoCache(skPaint, &fDeviceProperties, NULL);
@@ skipping 37 matching lines @@
         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);
 
-    this->drawPosText(rt, clip, paint, skPaint, viewMatrix, text, byteLength, positions.begin(), 2,
-                      offset);
+    this->onDrawPosText(rt, clip, paint, skPaint, viewMatrix, text, byteLength, positions.begin(),
+                        2, offset, regionClipBounds);
 }
 
 void GrDistanceFieldTextContext::onDrawPosText(GrRenderTarget* rt, const GrClip& clip,
                                                const GrPaint& paint,
                                                const SkPaint& skPaint, const SkMatrix& viewMatrix,
                                                const char text[], size_t byteLength,
                                                const SkScalar pos[], int scalarsPerPosition,
-                                               const SkPoint& offset) {
+                                               const SkPoint& offset,
+                                               const SkIRect& regionClipBounds) {
 
     SkASSERT(byteLength == 0 || text != NULL);
     SkASSERT(1 == scalarsPerPosition || 2 == scalarsPerPosition);
 
     // nothing to draw
     if (text == NULL || byteLength == 0 /* no raster clip? || fRC->isEmpty()*/) {
         return;
     }
 
     fViewMatrix = viewMatrix;
-    this->init(rt, clip, paint, skPaint);
+    this->init(rt, clip, paint, skPaint, regionClipBounds);
 
     SkDrawCacheProc glyphCacheProc = fSkPaint.getDrawCacheProc();
 
     SkAutoGlyphCacheNoGamma    autoCache(fSkPaint, &fDeviceProperties, NULL);
     SkGlyphCache*              cache = autoCache.getCache();
     GrFontScaler*              fontScaler = GetGrFontScaler(cache);
 
     setup_gamma_texture(fContext, cache, fDeviceProperties, &fGammaTexture);
 
     int numGlyphs = fSkPaint.textToGlyphs(text, byteLength, NULL);
@@ skipping 56 matching lines @@
                     }
                 }
             }
             pos += scalarsPerPosition;
         }
     }
 
     this->finish();
     
     if (fallbackTxt.count() > 0) {
-        fFallbackTextContext->drawPosText(rt, clip, paint, skPaint, viewMatrix, fallbackTxt.begin(),
-                                          fallbackTxt.count(), fallbackPos.begin(),
-                                          scalarsPerPosition, offset);
+        fFallbackTextContext->drawPosText(rt, clip, paint, skPaint, viewMatrix,
+                                          fallbackTxt.begin(), fallbackTxt.count(),
+                                          fallbackPos.begin(), scalarsPerPosition, offset,
+                                          regionClipBounds);
     }
 }
 
 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);
 }
 
@@ skipping 337 matching lines @@
     }
 }
 
 inline void GrDistanceFieldTextContext::finish() {
     this->flush();
     fTotalVertexCount = 0;
 
     GrTextContext::finish();
 }