fix size_t/int warnings in pictures

src/core/SkPictureRecord.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkPictureRecord_DEFINED
 #define SkPictureRecord_DEFINED
 
@@ skipping 82 matching lines @@
 
     void beginRecording();
     void endRecording();
 
     void internalOnly_EnableOpts(bool optsEnabled) {
         fOptsEnabled = optsEnabled;
     }
 
 private:
     void handleOptimization(int opt);
-    int recordRestoreOffsetPlaceholder(SkRegion::Op);
+    size_t recordRestoreOffsetPlaceholder(SkRegion::Op);
     void fillRestoreOffsetPlaceholdersForCurrentStackLevel(uint32_t restoreOffset);
 
 #ifndef SK_COLLAPSE_MATRIX_CLIP_STATE
     SkTDArray<int32_t> fRestoreOffsetStack;
     int fFirstSavedLayerIndex;
     enum {
         kNoSavedLayerIndex = -1
     };
 #endif
 
     SkTDArray<uint32_t> fCullOffsetStack;
 
     /*
      * Write the 'drawType' operation and chunk size to the skp. 'size'
      * can potentially be increased if the chunk size needs its own storage
      * location (i.e., it overflows 24 bits).
      * Returns the start offset of the chunk. This is the location at which
      * the opcode & size are stored.
      * TODO: since we are handing the size into here we could call reserve
      * and then return a pointer to the memory storage. This could decrease
      * allocation overhead but could lead to more wasted space (the tail
      * end of blocks could go unused). Possibly add a second addDraw that
      * operates in this manner.
      */
-    size_t addDraw(DrawType drawType, uint32_t* size) {
+    size_t addDraw(DrawType drawType, size_t* size) {
         size_t offset = fWriter.bytesWritten();
 
         this->predrawNotify();
 
     #ifdef SK_DEBUG_TRACE
         SkDebugf("add %s\n", DrawTypeToString(drawType));
     #endif
 
         SkASSERT(0 != *size);
         SkASSERT(((uint8_t) drawType) == drawType);
 
         if (0 != (*size & ~MASK_24) || *size == MASK_24) {
             fWriter.writeInt(PACK_8_24(drawType, MASK_24));
             *size += 1;
-            fWriter.writeInt(*size);
+            fWriter.writeInt(SkToU32(*size));
         } else {
-            fWriter.writeInt(PACK_8_24(drawType, *size));
+            fWriter.writeInt(PACK_8_24(drawType, SkToU32(*size)));
         }
 
         return offset;
     }
 
     void addInt(int value) {
         fWriter.writeInt(value);
     }
     void addScalar(SkScalar scalar) {
         fWriter.writeScalar(scalar);
@@ skipping 43 matching lines @@
 public:
     void validate(size_t initialOffset, uint32_t size) const;
 private:
     void validateBitmaps() const;
     void validateMatrices() const;
     void validatePaints() const;
     void validatePaths() const;
     void validateRegions() const;
 #else
 public:
-    void validate(size_t initialOffset, uint32_t size) const {
+    void validate(size_t initialOffset, size_t size) const {
         SkASSERT(fWriter.bytesWritten() == initialOffset + size);
     }
 #endif
 
 protected:
     virtual SkSurface* onNewSurface(const SkImageInfo&) SK_OVERRIDE;
     const void* onPeekPixels(SkImageInfo*, size_t*) SK_OVERRIDE {
         return NULL;
     }
 
@@ skipping 35 matching lines @@
                           const SkPaint& paint, const SkFlatData* flatPaintData);
 
     int addPathToHeap(const SkPath& path);  // does not write to ops stream
 
     // These entry points allow the writing of matrices, clips, saves &
     // restores to be deferred (e.g., if the MC state is being collapsed and
     // only written out as needed).
     void recordConcat(const SkMatrix& matrix);
     void recordTranslate(const SkMatrix& matrix);
     void recordScale(const SkMatrix& matrix);
-    int recordClipRect(const SkRect& rect, SkRegion::Op op, bool doAA);
-    int recordClipRRect(const SkRRect& rrect, SkRegion::Op op, bool doAA);
-    int recordClipPath(int pathID, SkRegion::Op op, bool doAA);
-    int recordClipRegion(const SkRegion& region, SkRegion::Op op);
+    size_t recordClipRect(const SkRect& rect, SkRegion::Op op, bool doAA);
+    size_t recordClipRRect(const SkRRect& rrect, SkRegion::Op op, bool doAA);
+    size_t recordClipPath(int pathID, SkRegion::Op op, bool doAA);
+    size_t recordClipRegion(const SkRegion& region, SkRegion::Op op);
     void recordSave(SaveFlags flags);
     void recordSaveLayer(const SkRect* bounds, const SkPaint* paint, SaveFlags flags);
     void recordRestore(bool fillInSkips = true);
 
     // These are set to NULL in our constructor, but may be changed by
     // subclasses, in which case they will be SkSafeUnref'd in our destructor.
     SkBBoxHierarchy* fBoundingHierarchy;
     SkPictureStateTree* fStateTree;
 
     // Allocated in the constructor and managed by this class.
@@ skipping 21 matching lines @@
     friend class SkPictureTester; // for unit testing
 
 #ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
     SkMatrixClipStateMgr fMCMgr;
 #endif
 
     typedef SkCanvas INHERITED;
 };
 
 #endif