fix (some) 64bit warnings -- size_t -> int

src/core/SkDraw.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkDraw.h"
 #include "SkBlitter.h"
 #include "SkBounder.h"
@@ skipping 133 matching lines @@
 
 typedef void (*BitmapXferProc)(void* pixels, size_t bytes, uint32_t data);
 
 static void D_Clear_BitmapXferProc(void* pixels, size_t bytes, uint32_t) {
     sk_bzero(pixels, bytes);
 }
 
 static void D_Dst_BitmapXferProc(void*, size_t, uint32_t data) {}
 
 static void D32_Src_BitmapXferProc(void* pixels, size_t bytes, uint32_t data) {
-    sk_memset32((uint32_t*)pixels, data, bytes >> 2);
+    sk_memset32((uint32_t*)pixels, data, SkToInt(bytes >> 2));
 }
 
 static void D16_Src_BitmapXferProc(void* pixels, size_t bytes, uint32_t data) {
-    sk_memset16((uint16_t*)pixels, data, bytes >> 1);
+    sk_memset16((uint16_t*)pixels, data, SkToInt(bytes >> 1));
 }
 
 static void DA8_Src_BitmapXferProc(void* pixels, size_t bytes, uint32_t data) {
     memset(pixels, data, bytes);
 }
 
 static BitmapXferProc ChooseBitmapXferProc(const SkBitmap& bitmap,
                                            const SkPaint& paint,
                                            uint32_t* data) {
     // todo: we can apply colorfilter up front if no shader, so we wouldn't
@@ skipping 377 matching lines @@
     return proc;
 }
 
 static bool bounder_points(SkBounder* bounder, SkCanvas::PointMode mode,
                            size_t count, const SkPoint pts[],
                            const SkPaint& paint, const SkMatrix& matrix) {
     SkIRect ibounds;
     SkRect bounds;
     SkScalar inset = paint.getStrokeWidth();
 
-    bounds.set(pts, count);
+    bounds.set(pts, SkToInt(count));
     bounds.inset(-inset, -inset);
     matrix.mapRect(&bounds);
 
     bounds.roundOut(&ibounds);
     return bounder->doIRect(ibounds);
 }
 
 // each of these costs 8-bytes of stack space, so don't make it too large
 // must be even for lines/polygon to work
 #define MAX_DEV_PTS     32
@@ skipping 36 matching lines @@
         SkAutoBlitterChoose blitter(*fBitmap, *fMatrix, paint);
 
         SkPoint             devPts[MAX_DEV_PTS];
         const SkMatrix*     matrix = fMatrix;
         SkBlitter*          bltr = blitter.get();
         PtProcRec::Proc     proc = rec.chooseProc(&bltr);
         // we have to back up subsequent passes if we're in polygon mode
         const size_t backup = (SkCanvas::kPolygon_PointMode == mode);
 
         do {
-            size_t n = count;
+            int n = SkToInt(count);
             if (n > MAX_DEV_PTS) {
                 n = MAX_DEV_PTS;
             }
             matrix->mapPoints(devPts, pts, n);
             proc(rec, devPts, n, bltr);
             pts += n - backup;
-            SkASSERT(count >= n);
+            SkASSERT(SkToInt(count) >= n);
             count -= n;
             if (count > 0) {
                 count += backup;
             }
         } while (count != 0);
     } else {
         switch (mode) {
             case SkCanvas::kPoints_PointMode: {
                 // temporarily mark the paint as filling.
                 SkPaint newPaint(paint);
@@ skipping 2189 matching lines @@
         mask->fImage = SkMask::AllocImage(size);
         memset(mask->fImage, 0, mask->computeImageSize());
     }
 
     if (SkMask::kJustComputeBounds_CreateMode != mode) {
         draw_into_mask(*mask, devPath, style);
     }
 
     return true;
 }