Avoid drawing NVPR DIF text when text size is 0

src/gpu/gl/GrGLPathRendering.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "gl/GrGLPathRendering.h"
 #include "gl/GrGLUtil.h"
 #include "gl/GrGLGpu.h"
@@ skipping 31 matching lines @@
     GR_GL_TRANSPOSE_AFFINE_2D
 };
 
 GR_STATIC_ASSERT(0 == GrPathRendering::kNone_PathTransformType);
 GR_STATIC_ASSERT(1 == GrPathRendering::kTranslateX_PathTransformType);
 GR_STATIC_ASSERT(2 == GrPathRendering::kTranslateY_PathTransformType);
 GR_STATIC_ASSERT(3 == GrPathRendering::kTranslate_PathTransformType);
 GR_STATIC_ASSERT(4 == GrPathRendering::kAffine_PathTransformType);
 GR_STATIC_ASSERT(GrPathRendering::kAffine_PathTransformType == GrPathRendering::kLast_PathTransformType);
 
+#ifdef SK_DEBUG
+static const GrGLenum gXformType2ComponentCount[] = {
+    0,
+    1,
+    1,
+    2,
+    6
+};
+
+static void verify_floats(const float* floats, int count) {
+    for (int i = 0; i < count; ++i) {
+        SkASSERT(!SkScalarIsNaN(SkFloatToScalar(floats[i])));
+    }
+}
+#endif
+
 static GrGLenum gr_stencil_op_to_gl_path_rendering_fill_mode(GrStencilOp op) {
     switch (op) {
         default:
             SkFAIL("Unexpected path fill.");
             /* fallthrough */;
         case kIncClamp_StencilOp:
             return GR_GL_COUNT_UP;
         case kInvert_StencilOp:
             return GR_GL_INVERT;
     }
@@ skipping 86 matching lines @@
     } else {
         GL_CALL(StencilThenCoverFillPath(glPath->pathID(), fillMode, writeMask,
                                          GR_GL_BOUNDING_BOX));
     }
 }
 
 void GrGLPathRendering::onDrawPaths(const DrawPathArgs& args, const GrPathRange* pathRange,
                                     const void* indices, PathIndexType indexType,
                                     const float transformValues[], PathTransformType transformType,
                                     int count) {
+    SkDEBUGCODE(verify_floats(transformValues, gXformType2ComponentCount[transformType] * count));
+
     if (!this->gpu()->flushGLState(args)) {
         return;
     }
     this->flushPathStencilSettings(*args.fStencil);
     SkASSERT(!fHWPathStencilSettings.isTwoSided());
 
 
     const GrGLPathRange* glPathRange = static_cast<const GrGLPathRange*>(pathRange);
 
     GrGLenum fillMode =
@@ skipping 35 matching lines @@
         coefficients[3] = SkScalarToFloat(matrix[SkMatrix::kMSkewY]);
         coefficients[4] = SkScalarToFloat(matrix[SkMatrix::kMScaleY]);
         coefficients[5] = SkScalarToFloat(matrix[SkMatrix::kMTransY]);
     }
 
     if (components >= 3) {
         coefficients[6] = SkScalarToFloat(matrix[SkMatrix::kMPersp0]);
         coefficients[7] = SkScalarToFloat(matrix[SkMatrix::kMPersp1]);
         coefficients[8] = SkScalarToFloat(matrix[SkMatrix::kMPersp2]);
     }
+    SkDEBUGCODE(verify_floats(coefficients, components * 3));
 
     GL_CALL(ProgramPathFragmentInputGen(program, location, genMode, components, coefficients));
 }
 
 void GrGLPathRendering::setProjectionMatrix(const SkMatrix& matrix,
                                             const SkISize& renderTargetSize,
                                             GrSurfaceOrigin renderTargetOrigin) {
 
     SkASSERT(this->gpu()->glCaps().shaderCaps()->pathRenderingSupport());
 
     if (renderTargetOrigin == fHWProjectionMatrixState.fRenderTargetOrigin &&
         renderTargetSize == fHWProjectionMatrixState.fRenderTargetSize &&
         matrix.cheapEqualTo(fHWProjectionMatrixState.fViewMatrix)) {
         return;
     }
 
     fHWProjectionMatrixState.fViewMatrix = matrix;
     fHWProjectionMatrixState.fRenderTargetSize = renderTargetSize;
     fHWProjectionMatrixState.fRenderTargetOrigin = renderTargetOrigin;
 
     float glMatrix[4 * 4];
     fHWProjectionMatrixState.getRTAdjustedGLMatrix<4>(glMatrix);
+    SkDEBUGCODE(verify_floats(glMatrix, SK_ARRAY_COUNT(glMatrix)));
     GL_CALL(MatrixLoadf(GR_GL_PATH_PROJECTION, glMatrix));
 }
 
 GrGLuint GrGLPathRendering::genPaths(GrGLsizei range) {
     SkASSERT(range > 0);
     GrGLuint firstID;
     if (fPreallocatedPathCount >= range) {
         firstID = fFirstPreallocatedPathID;
         fPreallocatedPathCount -= range;
         fFirstPreallocatedPathID += range;
@@ skipping 60 matching lines @@
             funcMask != fHWPathStencilSettings.funcMask(kFront_Face)) {
             GL_CALL(PathStencilFunc(GrToGLStencilFunc(func), funcRef, funcMask));
         }
         fHWPathStencilSettings = stencilSettings;
     }
 }
 
 inline GrGLGpu* GrGLPathRendering::gpu() {
     return static_cast<GrGLGpu*>(fGpu);
 }