Add vertex bounds check for distance field rendering.

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 "SkColorFilter.h"
@@ skipping 51 matching lines @@
 #else
     fEnableDFRendering = enable;
 #endif
     fStrike = NULL;
     fGammaTexture = NULL;
 
     fCurrVertex = 0;
     fEffectTextureUniqueID = SK_InvalidUniqueID;
     fEffectColor = GrColor_ILLEGAL;
     fEffectFlags = 0;
-                                                        
+
     fVertices = NULL;
+
+    fVertexBounds.setLargestInverted();
 }
 
 GrDistanceFieldTextContext::~GrDistanceFieldTextContext() {
     this->flushGlyphs();
     SkSafeSetNull(fGammaTexture);
 }
 
 bool GrDistanceFieldTextContext::canDraw(const SkPaint& paint) {
     if (!fEnableDFRendering && !paint.isDistanceFieldTextTEMP()) {
         return false;
@@ skipping 134 matching lines @@
             drawState->setBlendFunc(fPaint.getSrcBlendCoeff(), fPaint.getDstBlendCoeff());
             //drawState->setColor(fPaint.getColor());
             // We're using per-vertex color.
             SkASSERT(drawState->hasColorVertexAttribute());
             drawState->setColor(0xFFFFFFFF);
         }
         int nGlyphs = fCurrVertex / 4;
         fDrawTarget->setIndexSourceToBuffer(fContext->getQuadIndexBuffer());
         fDrawTarget->drawIndexedInstances(kTriangles_GrPrimitiveType,
                                           nGlyphs,
-                                          4, 6);
+                                          4, 6, &fVertexBounds);
         fCurrVertex = 0;
+        fVertexBounds.setLargestInverted();
     }
+
     fDrawTarget->resetVertexSource();
     fVertices = NULL;
 }
 
 void GrDistanceFieldTextContext::drawPackedGlyph(GrGlyph::PackedID packed,
                                                  SkFixed vx, SkFixed vy,
                                                  GrFontScaler* scaler) {
     GrGlyph* glyph = fStrike->getGlyph(packed, scaler);
     if (NULL == glyph || glyph->fBounds.isEmpty()) {
         return;
@@ skipping 81 matching lines @@
     SkScalar width = SkIntToScalar(glyph->fBounds.width() - 2*SK_DistanceFieldInset);
     SkScalar height = SkIntToScalar(glyph->fBounds.height() - 2*SK_DistanceFieldInset);
 
     SkScalar scale = fTextRatio;
     dx *= scale;
     dy *= scale;
     sx += dx;
     sy += dy;
     width *= scale;
     height *= scale;
-
+    
     SkFixed tx = SkIntToFixed(glyph->fAtlasLocation.fX + SK_DistanceFieldInset);
     SkFixed ty = SkIntToFixed(glyph->fAtlasLocation.fY + SK_DistanceFieldInset);
     SkFixed tw = SkIntToFixed(glyph->fBounds.width() - 2*SK_DistanceFieldInset);
     SkFixed th = SkIntToFixed(glyph->fBounds.height() - 2*SK_DistanceFieldInset);
 
+    SkRect r;
+    r.fLeft = SkFixedToFloat(sx);
+    r.fTop = SkFixedToFloat(sy);
+    r.fRight = SkFixedToFloat(sx + width);
+    r.fBottom = SkFixedToFloat(sy + height);
+
+    fVertexBounds.growToInclude(r);
+
     size_t vertSize = fUseLCDText ? (2 * sizeof(SkPoint))
                                   : (2 * sizeof(SkPoint) + sizeof(GrColor));
-    
+
     SkASSERT(vertSize == fDrawTarget->getDrawState().getVertexSize());
-    
+
     SkPoint* positions = reinterpret_cast<SkPoint*>(
         reinterpret_cast<intptr_t>(fVertices) + vertSize * fCurrVertex);
-    positions->setRectFan(sx, sy, sx + width, sy + height, vertSize);
-    
+    positions->setRectFan(r.fLeft, r.fTop, r.fRight, r.fBottom, vertSize);
+
     // The texture coords are last in both the with and without color vertex layouts.
     SkPoint* textureCoords = reinterpret_cast<SkPoint*>(
             reinterpret_cast<intptr_t>(positions) + vertSize  - sizeof(SkPoint));
     textureCoords->setRectFan(SkFixedToFloat(texture->normalizeFixedX(tx)),
                               SkFixedToFloat(texture->normalizeFixedY(ty)),
                               SkFixedToFloat(texture->normalizeFixedX(tx + tw)),
                               SkFixedToFloat(texture->normalizeFixedY(ty + th)),
                               vertSize);
     if (!fUseLCDText) {
         // color comes after position.
         GrColor* colors = reinterpret_cast<GrColor*>(positions + 1);
         for (int i = 0; i < 4; ++i) {
             *colors = fPaint.getColor();
             colors = reinterpret_cast<GrColor*>(reinterpret_cast<intptr_t>(colors) + vertSize);
         }
     }
-    
+
     fCurrVertex += 4;
 }
 
 inline void GrDistanceFieldTextContext::init(const GrPaint& paint, const SkPaint& skPaint) {
     GrTextContext::init(paint, skPaint);
 
     fStrike = NULL;
 
     fCurrVertex = 0;
 
@@ skipping 245 matching lines @@
                                       SkScalarToFixed(x) - (glyph.fAdvanceX >> alignShift),
                                       SkScalarToFixed(y) - (glyph.fAdvanceY >> alignShift),
                                       fontScaler);
             }
             pos += scalarsPerPosition;
         }
     }
 
     this->finish();
 }