drawVertices bug on gpu side

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 1594 matching lines @@
 
 void SkGpuDevice::drawVertices(const SkDraw& draw, SkCanvas::VertexMode vmode,
                               int vertexCount, const SkPoint vertices[],
                               const SkPoint texs[], const SkColor colors[],
                               SkXfermode* xmode,
                               const uint16_t indices[], int indexCount,
                               const SkPaint& paint) {
     CHECK_SHOULD_DRAW(draw, false);
 
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::drawVertices", fContext);
+    
+    const uint16_t* outIndices;
+    SkAutoTDeleteArray<uint16_t> outAlloc(NULL);
+    GrPrimitiveType primType;
+    GrPaint grPaint;
+    
     // If both textures and vertex-colors are NULL, strokes hairlines with the paint's color.
     if ((NULL == texs || NULL == paint.getShader()) && NULL == colors) {
+        
         texs = NULL;
+        
         SkPaint copy(paint);
         copy.setStyle(SkPaint::kStroke_Style);
         copy.setStrokeWidth(0);
+        
+        // we ignore the shader if texs is null.
+        SkPaint2GrPaintNoShader(this->context(), copy, SkColor2GrColor(copy.getColor()),
+                                NULL == colors, &grPaint);
 
+        primType = kLines_GrPrimitiveType;
+        int triangleCount = 0;
+        switch (vmode) {
+            case SkCanvas::kTriangles_VertexMode:
+                triangleCount = indexCount / 3;
+                break;
+            case SkCanvas::kTriangleStrip_VertexMode:
+            case SkCanvas::kTriangleFan_VertexMode:
+                triangleCount = indexCount - 2;
+                break;
+        }
+        
         VertState       state(vertexCount, indices, indexCount);
         VertState::Proc vertProc = state.chooseProc(vmode);
-
-        SkPoint* pts = new SkPoint[vertexCount * 6];
+        
+        //number of indices for lines per triangle with kLines
+        indexCount = triangleCount * 6;
+        
+        outAlloc.reset(SkNEW_ARRAY(uint16_t, indexCount));
+        outIndices = outAlloc.get();
+        uint16_t* auxIndices = outAlloc.get();
         int i = 0;
         while (vertProc(&state)) {
-            pts[i] = vertices[state.f0];
-            pts[i + 1] = vertices[state.f1];
-            pts[i + 2] = vertices[state.f1];
-            pts[i + 3] = vertices[state.f2];
-            pts[i + 4] = vertices[state.f2];
-            pts[i + 5] = vertices[state.f0];
+            auxIndices[i]     = state.f0;
+            auxIndices[i + 1] = state.f1;
+            auxIndices[i + 2] = state.f1;
+            auxIndices[i + 3] = state.f2;
+            auxIndices[i + 4] = state.f2;
+            auxIndices[i + 5] = state.f0;
             i += 6;
         }
-        draw.drawPoints(SkCanvas::kLines_PointMode, i, pts, copy, true);
-        return;
-    }
-
-    GrPaint grPaint;
-    // we ignore the shader if texs is null.
-    if (NULL == texs) {
-        SkPaint2GrPaintNoShader(this->context(), paint, SkColor2GrColor(paint.getColor()),
-                                NULL == colors, &grPaint);
     } else {
-        SkPaint2GrPaintShader(this->context(), paint, NULL == colors, &grPaint);
+        outIndices = indices;
+        primType = gVertexMode2PrimitiveType[vmode];
+        
+        if (NULL == texs || NULL == paint.getShader()) {
+            SkPaint2GrPaintNoShader(this->context(), paint, SkColor2GrColor(paint.getColor()),
+                                    NULL == colors, &grPaint);
+        } else {
+            SkPaint2GrPaintShader(this->context(), paint, NULL == colors, &grPaint);
+        }
     }
 
 #if 0
     if (NULL != xmode && NULL != texs && NULL != colors) {
         if (!SkXfermode::IsMode(xmode, SkXfermode::kModulate_Mode)) {
             SkDebugf("Unsupported vertex-color/texture xfer mode.\n");
             return;
         }
     }
 #endif
 
     SkAutoSTMalloc<128, GrColor> convertedColors(0);
     if (NULL != colors) {
         // need to convert byte order and from non-PM to PM
         convertedColors.reset(vertexCount);
         SkColor color;
         for (int i = 0; i < vertexCount; ++i) {
             color = colors[i];
             if (paint.getAlpha() != 255) {
                 color = SkColorSetA(color, SkMulDiv255Round(SkColorGetA(color), paint.getAlpha()));
             }
             convertedColors[i] = SkColor2GrColor(color);
         }
         colors = convertedColors.get();
     }
     fContext->drawVertices(grPaint,
-                           gVertexMode2PrimitiveType[vmode],
+                           primType,
                            vertexCount,
                            vertices,
                            texs,
                            colors,
-                           indices,
+                           outIndices,
                            indexCount);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkGpuDevice::drawText(const SkDraw& draw, const void* text,
                           size_t byteLength, SkScalar x, SkScalar y,
                           const SkPaint& paint) {
     CHECK_SHOULD_DRAW(draw, false);
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::drawText", fContext);
@@ skipping 342 matching lines @@
     playback.draw(canvas, NULL);
 
     // unlock the layers
     for (int i = 0; i < gpuData->numSaveLayers(); ++i) {
         GrCachedLayer* layer = fContext->getLayerCache()->findLayer(picture, i);
         fContext->getLayerCache()->unlock(layer);
     }
 
     return true;
 }