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

include/core/SkWriter32.h

 
 /*
  * Copyright 2008 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 SkWriter32_DEFINED
@@ skipping 26 matching lines @@
     // return the current offset (will always be a multiple of 4)
     size_t bytesWritten() const { return fCount * 4; }
 
     SK_ATTR_DEPRECATED("use bytesWritten")
     size_t size() const { return this->bytesWritten(); }
 
     void reset(void* external = NULL, size_t externalBytes = 0) {
         SkASSERT(SkIsAlign4((uintptr_t)external));
         SkASSERT(SkIsAlign4(externalBytes));
         fExternal = (uint32_t*)external;
-        fExternalLimit = externalBytes/4;
+        fExternalLimit = SkToInt(externalBytes/4);
         fCount = 0;
         fInternal.rewind();
     }
 
     // If all data written is contiguous, then this returns a pointer to it, otherwise NULL.
     // This will work if we've only written to the externally supplied block of storage, or if we've
     // only written to our internal dynamic storage, but will fail if we have written into both.
     const uint32_t* contiguousArray() const {
         if (this->externalCount()  == 0) {
             return fInternal.begin();
         } else if (fInternal.isEmpty()) {
             return fExternal;
         }
         return NULL;
     }
 
     // size MUST be multiple of 4
     uint32_t* reserve(size_t size) {
         SkASSERT(SkAlign4(size) == size);
-        const int count = size/4;
+        const int count = SkToInt(size/4);
 
         uint32_t* p;
         // Once we start writing to fInternal, we never write to fExternal again.
         // This simplifies tracking what data is where.
         if (fInternal.isEmpty() && this->externalCount() + count <= fExternalLimit) {
             p = fExternal + fCount;
         } else {
             p = fInternal.append(count);
         }
 
         fCount += count;
         return p;
     }
 
     // return the address of the 4byte int at the specified offset (which must
     // be a multiple of 4. This does not allocate any new space, so the returned
     // address is only valid for 1 int.
     uint32_t* peek32(size_t offset) {
         SkASSERT(SkAlign4(offset) == offset);
-        const int count = offset/4;
+        const int count = SkToInt(offset/4);
         SkASSERT(count < fCount);
 
         if (count < this->externalCount()) {
             return fExternal + count;
         }
         return &fInternal[count - this->externalCount()];
     }
 
     bool writeBool(bool value) {
         this->write32(value);
@@ skipping 115 matching lines @@
      */
     static size_t WriteStringSize(const char* str, size_t len = (size_t)-1);
 
     /**
      *  Move the cursor back to offset bytes from the beginning.
      *  This has the same restrictions as peek32: offset must be <= size() and
      *  offset must be a multiple of 4.
      */
     void rewindToOffset(size_t offset) {
         SkASSERT(SkAlign4(offset) == offset);
-        const int count = offset/4;
+        const int count = SkToInt(offset/4);
         if (count < this->externalCount()) {
             fInternal.setCount(0);
         } else {
             fInternal.setCount(count - this->externalCount());
         }
         fCount = count;
     }
 
     // copy into a single buffer (allocated by caller). Must be at least size()
     void flatten(void* dst) const {
@@ skipping 36 matching lines @@
 
 private:
     union {
         void*   fPtrAlignment;
         double  fDoubleAlignment;
         char    fStorage[SIZE];
     } fData;
 };
 
 #endif