Clean up some lint complaints and fix center_of_mass()

src/gpu/batches/GrAAConvexPathRenderer.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 "GrAAConvexPathRenderer.h"
 
@@ skipping 63 matching lines @@
         // from the origin.
         p0 = segments[0].endPt();
         SkPoint pi;
         SkPoint pj;
         // the first and last iteration of the below loop would compute
         // zeros since the starting / ending point is (0,0). So instead we start
         // at i=1 and make the last iteration i=count-2.
         pj = segments[1].endPt() - p0;
         for (int i = 1; i < count - 1; ++i) {
             pi = pj;
-            const SkPoint pj = segments[i + 1].endPt() - p0;
+            pj = segments[i + 1].endPt() - p0;
 
-            SkScalar t = SkScalarMul(pi.fX, pj.fY) - SkScalarMul(pj.fX, pi.fY);
+            SkScalar t = SkPoint::CrossProduct(pi, pj);
             area += t;
             center.fX += (pi.fX + pj.fX) * t;
             center.fY += (pi.fY + pj.fY) * t;
-
         }
     }
+
     // If the poly has no area then we instead return the average of
     // its points.
     if (SkScalarNearlyZero(area)) {
         SkPoint avg;
         avg.set(0, 0);
         for (int i = 0; i < count; ++i) {
             const SkPoint& pt = segments[i].endPt();
             avg.fX += pt.fX;
             avg.fY += pt.fY;
         }
         SkScalar denom = SK_Scalar1 / count;
         avg.scale(denom);
         *c = avg;
     } else {
         area *= 3;
         area = SkScalarInvert(area);
-        center.fX = SkScalarMul(center.fX, area);
-        center.fY = SkScalarMul(center.fY, area);
+        center.scale(area);
         // undo the translate of p0 to the origin.
         *c = center + p0;
     }
     SkASSERT(!SkScalarIsNaN(c->fX) && !SkScalarIsNaN(c->fY));
 }
 
 static void compute_vectors(SegmentArray* segments,
                             SkPoint* fanPt,
                             SkPathPriv::FirstDirection dir,
                             int* vCount,
@@ skipping 788 matching lines @@
             if (!idxs) {
                 SkDebugf("Could not allocate indices\n");
                 return;
             }
 
             SkSTArray<kPreallocDrawCnt, Draw, true> draws;
             create_vertices(segments, fanPt, &draws, verts, idxs);
 
             GrVertices vertices;
 
-            for (int i = 0; i < draws.count(); ++i) {
-                const Draw& draw = draws[i];
+            for (int j = 0; j < draws.count(); ++j) {
+                const Draw& draw = draws[j];
                 vertices.initIndexed(kTriangles_GrPrimitiveType, vertexBuffer, indexBuffer,
                                      firstVertex, firstIndex, draw.fVertexCnt, draw.fIndexCnt);
                 target->draw(vertices);
                 firstVertex += draw.fVertexCnt;
                 firstIndex += draw.fIndexCnt;
             }
         }
     }
 
     SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
@@ skipping 82 matching lines @@
 DRAW_BATCH_TEST_DEFINE(AAConvexPathBatch) {
     AAConvexPathBatch::Geometry geometry;
     geometry.fColor = GrRandomColor(random);
     geometry.fViewMatrix = GrTest::TestMatrixInvertible(random);
     geometry.fPath = GrTest::TestPathConvex(random);
 
     return AAConvexPathBatch::Create(geometry);
 }
 
 #endif