fix size_t/int warnings in pictures

src/core/SkPicturePlayback.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 <new>
 #include "SkBBoxHierarchy.h"
 #include "SkPicturePlayback.h"
 #include "SkPictureRecord.h"
@@ skipping 294 matching lines @@
     return false;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkStream.h"
 
 static void write_tag_size(SkWriteBuffer& buffer, uint32_t tag, size_t size) {
     buffer.writeUInt(tag);
-    buffer.writeUInt(size);
+    buffer.writeUInt(SkToU32(size));
 }
 
 static void write_tag_size(SkWStream* stream, uint32_t tag,  size_t size) {
     stream->write32(tag);
     stream->write32(SkToU32(size));
 }
 
 static size_t compute_chunk_size(SkFlattenable::Factory* array, int count) {
     size_t size = 4;  // for 'count'
 
@@ skipping 151 matching lines @@
     for (size_t i = 0; i < SK_ARRAY_COUNT(gSD); ++i) {
         if (pictInfoFlags & gSD[i].fSrc) {
             rbMask |= gSD[i].fDst;
         }
     }
     return rbMask;
 }
 
 bool SkPicturePlayback::parseStreamTag(SkStream* stream,
                                        uint32_t tag,
-                                       size_t size,
+                                       uint32_t size,
                                        SkPicture::InstallPixelRefProc proc) {
     /*
      *  By the time we encounter BUFFER_SIZE_TAG, we need to have already seen
      *  its dependents: FACTORY_TAG and TYPEFACE_TAG. These two are not required
      *  but if they are present, they need to have been seen before the buffer.
      *
      *  We assert that if/when we see either of these, that we have not yet seen
      *  the buffer tag, because if we have, then its too-late to deal with the
      *  factories or typefaces.
      */
@@ skipping 27 matching lines @@
                 const size_t len = stream->readPackedUInt();
                 str.resize(len);
                 if (stream->read(str.writable_str(), len) != len) {
                     return false;
                 }
                 fFactoryPlayback->base()[i] = SkFlattenable::NameToFactory(str.c_str());
             }
         } break;
         case SK_PICT_TYPEFACE_TAG: {
             SkASSERT(!haveBuffer);
-            fTFPlayback.setCount(size);
-            for (size_t i = 0; i < size; i++) {
+            const int count = SkToInt(size);
+            fTFPlayback.setCount(count);
+            for (int i = 0; i < count; i++) {
                 SkAutoTUnref<SkTypeface> tf(SkTypeface::Deserialize(stream));
                 if (!tf.get()) {    // failed to deserialize
                     // fTFPlayback asserts it never has a null, so we plop in
                     // the default here.
                     tf.reset(SkTypeface::RefDefault());
                 }
                 fTFPlayback.set(i, tf);
             }
         } break;
         case SK_PICT_PICTURE_TAG: {
@@ skipping 40 matching lines @@
                     return false;
                 }
             }
             SkDEBUGCODE(haveBuffer = true;)
         } break;
     }
     return true;    // success
 }
 
 bool SkPicturePlayback::parseBufferTag(SkReadBuffer& buffer,
-                                       uint32_t tag, size_t size) {
+                                       uint32_t tag, uint32_t size) {
     switch (tag) {
         case SK_PICT_BITMAP_BUFFER_TAG: {
+            const int count = SkToInt(size);
             fBitmaps = SkTRefArray<SkBitmap>::Create(size);
-            for (size_t i = 0; i < size; ++i) {
+            for (int i = 0; i < count; ++i) {
                 SkBitmap* bm = &fBitmaps->writableAt(i);
                 buffer.readBitmap(bm);
                 bm->setImmutable();
             }
         } break;
         case SK_PICT_PAINT_BUFFER_TAG: {
+            const int count = SkToInt(size);
             fPaints = SkTRefArray<SkPaint>::Create(size);
-            for (size_t i = 0; i < size; ++i) {
+            for (int i = 0; i < count; ++i) {
                 buffer.readPaint(&fPaints->writableAt(i));
             }
         } break;
         case SK_PICT_PATH_BUFFER_TAG:
             if (size > 0) {
                 fPathHeap.reset(SkNEW_ARGS(SkPathHeap, (buffer)));
             }
             break;
         case SK_PICT_READER_TAG: {
             SkAutoMalloc storage(size);
@@ skipping 1159 matching lines @@
     for (index = 0; index < fPictureCount; index++)
         bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
             "picture%p, ", fPictureRefs[index]);
     if (fPictureCount > 0)
         SkDebugf("%s0};\n", pBuffer);
 
     const_cast<SkPicturePlayback*>(this)->dumpStream();
 }
 
 #endif