Avoid drawing NVPR DIF text when text size is 0

src/gpu/gl/GrGLPath.cpp

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGLPath.h"
 #include "GrGLPathRendering.h"
@@ skipping 61 matching lines @@
         GR_GL_ROUND,
         GR_GL_SQUARE
     };
     return gSkCapsToGrGLCaps[cap];
     GR_STATIC_ASSERT(0 == SkPaint::kButt_Cap);
     GR_STATIC_ASSERT(1 == SkPaint::kRound_Cap);
     GR_STATIC_ASSERT(2 == SkPaint::kSquare_Cap);
     GR_STATIC_ASSERT(SK_ARRAY_COUNT(gSkCapsToGrGLCaps) == SkPaint::kCapCount);
 }
 
+#ifdef SK_DEBUG
+inline void verify_floats(const float* floats, int count) {
+    for (int i = 0; i < count; ++i) {
+        SkASSERT(!SkScalarIsNaN(SkFloatToScalar(floats[i])));
+    }
+}
+#endif
+
 inline void points_to_coords(const SkPoint points[], size_t first_point, size_t amount,
                              GrGLfloat coords[]) {
     for (size_t i = 0;  i < amount; ++i) {
         coords[i * 2] =  SkScalarToFloat(points[first_point + i].fX);
         coords[i * 2 + 1] = SkScalarToFloat(points[first_point + i].fY);
     }
 }
 
 template<bool checkForDegenerates>
 inline bool init_path_object_for_general_path(GrGLGpu* gpu, GrGLuint pathID,
@@ skipping 71 matching lines @@
                         // which produces a degenerate segment.
                         return false;
                     }
                 }
                 continue;
             default:
                 SkASSERT(false);  // Not reached.
                 continue;
         }
         SkDEBUGCODE(numCoords += num_coords(verb));
+        SkDEBUGCODE(verify_floats(coords, coordsForVerb));
         pathCoords.push_back_n(coordsForVerb, coords);
     }
     SkASSERT(verbCnt == pathCommands.count());
     SkASSERT(numCoords == pathCoords.count());
 
     GR_GL_CALL(gpu->glInterface(), PathCommands(pathID, pathCommands.count(), &pathCommands[0],
                                                 pathCoords.count(), GR_GL_FLOAT, &pathCoords[0]));
     return true;
 }
 
@@ skipping 42 matching lines @@
         skPath.getVerbs(&pathCommands[0], verbCnt);
 
         SkDEBUGCODE(int verbCoordCnt = 0);
         for (int i = 0; i < verbCnt; ++i) {
             SkPath::Verb v = static_cast<SkPath::Verb>(pathCommands[i]);
             pathCommands[i] = verb_to_gl_path_cmd(v);
             SkDEBUGCODE(verbCoordCnt += num_coords(v));
         }
         SkASSERT(verbCnt == pathCommands.count());
         SkASSERT(verbCoordCnt == pathCoords.count());
+        SkDEBUGCODE(verify_floats(&pathCoords[0], pathCoords.count()));
         GR_GL_CALL(gpu->glInterface(), PathCommands(pathID, pathCommands.count(), &pathCommands[0],
                                                     pathCoords.count(), GR_GL_FLOAT,
                                                     &pathCoords[0]));
         return;
     }
 #endif
     SkAssertResult(init_path_object_for_general_path<false>(gpu, pathID, skPath));
 }
 
 void GrGLPath::InitPathObjectStroke(GrGLGpu* gpu, GrGLuint pathID, const GrStrokeInfo& stroke) {
@@ skipping 85 matching lines @@
     }
 
     INHERITED::onRelease();
 }
 
 void GrGLPath::onAbandon() {
     fPathID = 0;
 
     INHERITED::onAbandon();
 }