Start cleaning up 64bit Win warnings

include/core/SkTemplates.h

 
 /*
  * 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.
  */
 
 
 #ifndef SkTemplates_DEFINED
@@ skipping 223 matching lines @@
 template <size_t N, typename T> class SkAutoSTArray : SkNoncopyable {
 public:
     /** Initialize with no objects */
     SkAutoSTArray() {
         fArray = NULL;
         fCount = 0;
     }
 
     /** Allocate count number of T elements
      */
-    SkAutoSTArray(size_t count) {
+    SkAutoSTArray(int count) {
         fArray = NULL;
         fCount = 0;
         this->reset(count);
     }
 
     ~SkAutoSTArray() {
         this->reset(0);
     }
 
     /** Destroys previous objects in the array and default constructs count number of objects */
-    void reset(size_t count) {
+    void reset(int count) {
         T* start = fArray;
         T* iter = start + fCount;
         while (iter > start) {
             (--iter)->~T();
         }
 
         if (fCount != count) {
             if (fCount > N) {
                 // 'fArray' was allocated last time so free it now
                 SkASSERT((T*) fStorage != fArray);
@@ skipping 13 matching lines @@
 
         iter = fArray;
         T* stop = fArray + count;
         while (iter < stop) {
             SkNEW_PLACEMENT(iter++, T);
         }
     }
 
     /** Return the number of T elements in the array
      */
-    size_t count() const { return fCount; }
+    int count() const { return fCount; }
 
     /** Return the array of T elements. Will be NULL if count == 0
      */
     T* get() const { return fArray; }
 
     /** Return the nth element in the array
      */
     T&  operator[](int index) const {
-        SkASSERT((unsigned)index < fCount);
+        SkASSERT(index < fCount);
         return fArray[index];
     }
 
 private:
-    size_t  fCount;
+    int     fCount;
     T*      fArray;
     // since we come right after fArray, fStorage should be properly aligned
     char    fStorage[N * sizeof(T)];
 };
 
 /** Manages an array of T elements, freeing the array in the destructor.
  *  Does NOT call any constructors/destructors on T (T must be POD).
  */
 template <typename T> class SkAutoTMalloc : SkNoncopyable {
 public:
@@ skipping 144 matching lines @@
     /**
      * Returns void* because this object does not initialize the
      * memory. Use placement new for types that require a cons.
      */
     void* get() { return fStorage.get(); }
 private:
     SkAlignedSStorage<sizeof(T)*N> fStorage;
 };
 
 #endif