Even more win64 warning fixes

tests/PathTest.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 "SkCanvas.h"
 #include "SkPaint.h"
 #include "SkParse.h"
@@ skipping 769 matching lines @@
     SkRandom rand;
 
     for (size_t i = 0; i < SK_ARRAY_COUNT(pts); ++i) {
         pts[i].fX = rand.nextSScalar1();
         pts[i].fY = rand.nextSScalar1();
     }
 
     for (int doClose = 0; doClose <= 1; ++doClose) {
         for (size_t count = 1; count <= SK_ARRAY_COUNT(pts); ++count) {
             SkPath path;
-            path.addPoly(pts, count, SkToBool(doClose));
+            path.addPoly(pts, SkToInt(count), SkToBool(doClose));
             test_poly(reporter, path, pts, SkToBool(doClose));
         }
     }
 }
 
 static void test_strokerec(skiatest::Reporter* reporter) {
     SkStrokeRec rec(SkStrokeRec::kFill_InitStyle);
     REPORTER_ASSERT(reporter, rec.isFillStyle());
 
     rec.setHairlineStyle();
@@ skipping 898 matching lines @@
     SkPoint c3[] = {{0, 0}, {1, 0}, {1, 2}, {0, 2}, {0, 1}, {0, 0}}; // hit the start
 
     // like c2, but we double-back on ourselves
     SkPoint d1[] = {{0, 0}, {1, 0}, {1, 2}, {0, 2}, {0, 1}, {0, 2}};
     // like c2, but we overshoot the start point
     SkPoint d2[] = {{0, 0}, {1, 0}, {1, 2}, {0, 2}, {0, -1}};
     SkPoint d3[] = {{0, 0}, {1, 0}, {1, 2}, {0, 2}, {0, -1}, {0, 0}};
 
     struct IsRectTest {
         SkPoint *fPoints;
-        size_t fPointCount;
+        int fPointCount;
         bool fClose;
         bool fIsRect;
     } tests[] = {
         { r1, SK_ARRAY_COUNT(r1), true, true },
         { r2, SK_ARRAY_COUNT(r2), true, true },
         { r3, SK_ARRAY_COUNT(r3), true, true },
         { r4, SK_ARRAY_COUNT(r4), true, true },
         { r5, SK_ARRAY_COUNT(r5), true, true },
         { r6, SK_ARRAY_COUNT(r6), true, true },
         { r7, SK_ARRAY_COUNT(r7), true, true },
@@ skipping 162 matching lines @@
     SkPoint f6[] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}, {0, 2}}; // end overshoots
     SkPoint f7[] = {{0, 0}, {1, 0}, {1, 1}, {0, 2}}; // end overshoots
     SkPoint f8[] = {{0, 0}, {1, 0}, {1, 1}, {1, 0}}; // 'L'
 
     // failing, no close
     SkPoint c1[] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}}; // close doesn't match
     SkPoint c2[] = {{0, 0}, {1, 0}, {1, 2}, {0, 2}, {0, 1}}; // ditto
 
     struct IsNestedRectTest {
         SkPoint *fPoints;
-        size_t fPointCount;
+        int fPointCount;
         SkPath::Direction fDirection;
         bool fClose;
         bool fIsNestedRect; // nests with path.addRect(-1, -1, 2, 2);
     } tests[] = {
         { r1, SK_ARRAY_COUNT(r1), SkPath::kCW_Direction , true, true },
         { r2, SK_ARRAY_COUNT(r2), SkPath::kCW_Direction , true, true },
         { r3, SK_ARRAY_COUNT(r3), SkPath::kCW_Direction , true, true },
         { r4, SK_ARRAY_COUNT(r4), SkPath::kCW_Direction , true, true },
         { r5, SK_ARRAY_COUNT(r5), SkPath::kCCW_Direction, true, true },
         { r6, SK_ARRAY_COUNT(r6), SkPath::kCCW_Direction, true, true },
@@ skipping 1820 matching lines @@
     test_addEmptyPath(reporter, SkPath::kExtend_AddPathMode);
     test_addEmptyPath(reporter, SkPath::kAppend_AddPathMode);
     test_conicTo_special_case(reporter);
     test_get_point(reporter);
     test_contains(reporter);
     PathTest_Private::TestPathTo(reporter);
     PathRefTest_Private::TestPathRef(reporter);
     test_dump(reporter);
     test_path_crbugskia2820(reporter);
 }