fix int/size_t warnings in pipe

src/pipe/SkGPipeWrite.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 "SkAnnotation.h"
 #include "SkBitmapDevice.h"
@@ skipping 41 matching lines @@
     SkDEBUGFAIL("never gets here");
     return NULL;
 }
 
 static size_t writeTypeface(SkWriter32* writer, SkTypeface* typeface) {
     SkASSERT(typeface);
     SkDynamicMemoryWStream stream;
     typeface->serialize(&stream);
     size_t size = stream.getOffset();
     if (writer) {
-        writer->write32(size);
+        writer->write32(SkToU32(size));
         SkAutoDataUnref data(stream.copyToData());
         writer->writePad(data->data(), size);
     }
     return 4 + SkAlign4(size);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class FlattenableHeap : public SkFlatController {
 public:
@@ skipping 299 matching lines @@
         }
     }
 }
 
 bool SkGPipeCanvas::shuttleBitmap(const SkBitmap& bm, int32_t slot) {
     SkASSERT(shouldFlattenBitmaps(fFlags));
     SkWriteBuffer buffer;
     buffer.setNamedFactoryRecorder(fFactorySet);
     buffer.writeBitmap(bm);
     this->flattenFactoryNames();
-    uint32_t size = buffer.bytesWritten();
+    size_t size = buffer.bytesWritten();
     if (this->needOpBytes(size)) {
         this->writeOp(kDef_Bitmap_DrawOp, 0, slot);
         void* dst = static_cast<void*>(fWriter.reserve(size));
         buffer.writeToMemory(dst);
         return true;
     }
     return false;
 }
 
 // return 0 for NULL (or unflattenable obj), or index-base-1
@@ skipping 78 matching lines @@
 bool SkGPipeCanvas::needOpBytes(size_t needed) {
     if (fDone) {
         return false;
     }
 
     needed += 4;  // size of DrawOp atom
     if (fWriter.bytesWritten() + needed > fBlockSize) {
         // Before we wipe out any data that has already been written, read it
         // out.
         this->doNotify();
-        size_t blockSize = SkMax32(MIN_BLOCK_SIZE, needed);
+        size_t blockSize = SkTMax<size_t>(MIN_BLOCK_SIZE, needed);
         void* block = fController->requestBlock(blockSize, &fBlockSize);
         if (NULL == block) {
             // Do not notify the readers, which would call this function again.
             this->finish(false);
             return false;
         }
         SkASSERT(SkIsAlign4(fBlockSize));
         fWriter.reset(block, fBlockSize);
         fBytesNotified = 0;
     }
@@ skipping 205 matching lines @@
     }
 }
 
 void SkGPipeCanvas::drawPoints(PointMode mode, size_t count,
                                const SkPoint pts[], const SkPaint& paint) {
     if (count) {
         NOTIFY_SETUP(this);
         this->writePaint(paint);
         if (this->needOpBytes(4 + count * sizeof(SkPoint))) {
             this->writeOp(kDrawPoints_DrawOp, mode, 0);
-            fWriter.write32(count);
+            fWriter.write32(SkToU32(count));
             fWriter.write(pts, count * sizeof(SkPoint));
         }
     }
 }
 
 void SkGPipeCanvas::drawOval(const SkRect& rect, const SkPaint& paint) {
     NOTIFY_SETUP(this);
     this->writePaint(paint);
     if (this->needOpBytes(sizeof(SkRect))) {
         this->writeOp(kDrawOval_DrawOp);
@@ skipping 130 matching lines @@
     }
 }
 
 void SkGPipeCanvas::onDrawText(const void* text, size_t byteLength, SkScalar x, SkScalar y,
                                const SkPaint& paint) {
     if (byteLength) {
         NOTIFY_SETUP(this);
         this->writePaint(paint);
         if (this->needOpBytes(4 + SkAlign4(byteLength) + 2 * sizeof(SkScalar))) {
             this->writeOp(kDrawText_DrawOp);
-            fWriter.write32(byteLength);
+            fWriter.write32(SkToU32(byteLength));
             fWriter.writePad(text, byteLength);
             fWriter.writeScalar(x);
             fWriter.writeScalar(y);
         }
     }
 }
 
 void SkGPipeCanvas::onDrawPosText(const void* text, size_t byteLength, const SkPoint pos[],
                                   const SkPaint& paint) {
     if (byteLength) {
         NOTIFY_SETUP(this);
         this->writePaint(paint);
         int count = paint.textToGlyphs(text, byteLength, NULL);
         if (this->needOpBytes(4 + SkAlign4(byteLength) + 4 + count * sizeof(SkPoint))) {
             this->writeOp(kDrawPosText_DrawOp);
-            fWriter.write32(byteLength);
+            fWriter.write32(SkToU32(byteLength));
             fWriter.writePad(text, byteLength);
             fWriter.write32(count);
             fWriter.write(pos, count * sizeof(SkPoint));
         }
     }
 }
 
 void SkGPipeCanvas::onDrawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[],
                                    SkScalar constY, const SkPaint& paint) {
     if (byteLength) {
         NOTIFY_SETUP(this);
         this->writePaint(paint);
         int count = paint.textToGlyphs(text, byteLength, NULL);
         if (this->needOpBytes(4 + SkAlign4(byteLength) + 4 + count * sizeof(SkScalar) + 4)) {
             this->writeOp(kDrawPosTextH_DrawOp);
-            fWriter.write32(byteLength);
+            fWriter.write32(SkToU32(byteLength));
             fWriter.writePad(text, byteLength);
             fWriter.write32(count);
             fWriter.write(xpos, count * sizeof(SkScalar));
             fWriter.writeScalar(constY);
         }
     }
 }
 
 void SkGPipeCanvas::onDrawTextOnPath(const void* text, size_t byteLength, const SkPath& path,
                                      const SkMatrix* matrix, const SkPaint& paint) {
     if (byteLength) {
         NOTIFY_SETUP(this);
         unsigned flags = 0;
         size_t size = 4 + SkAlign4(byteLength) + path.writeToMemory(NULL);
         if (matrix) {
             flags |= kDrawTextOnPath_HasMatrix_DrawOpFlag;
             size += matrix->writeToMemory(NULL);
         }
         this->writePaint(paint);
         if (this->needOpBytes(size)) {
             this->writeOp(kDrawTextOnPath_DrawOp, flags, 0);
 
-            fWriter.write32(byteLength);
+            fWriter.write32(SkToU32(byteLength));
             fWriter.writePad(text, byteLength);
 
             fWriter.writePath(path);
             if (matrix) {
                 fWriter.writeMatrix(*matrix);
             }
         }
     }
 }
 
@@ skipping 58 matching lines @@
 void SkGPipeCanvas::drawData(const void* ptr, size_t size) {
     if (size && ptr) {
         NOTIFY_SETUP(this);
         unsigned data = 0;
         if (size < (1 << DRAWOPS_DATA_BITS)) {
             data = (unsigned)size;
         }
         if (this->needOpBytes(4 + SkAlign4(size))) {
             this->writeOp(kDrawData_DrawOp, 0, data);
             if (0 == data) {
-                fWriter.write32(size);
+                fWriter.write32(SkToU32(size));
             }
             fWriter.writePad(ptr, size);
         }
     }
 }
 
 void SkGPipeCanvas::beginCommentGroup(const char* description) {
     // ignore for now
 }
 
@@ skipping 129 matching lines @@
         }
         SkASSERT(index >= 0 && index <= fFlatDictionary.count());
         if (index != fCurrFlatIndex[i] || replaced) {
             *ptr++ = PaintOp_packOpFlagData(kFlatIndex_PaintOp, i, index);
             fCurrFlatIndex[i] = index;
         }
     }
 
     size_t size = (char*)ptr - (char*)storage;
     if (size && this->needOpBytes(size)) {
-        this->writeOp(kPaintOp_DrawOp, 0, size);
+        this->writeOp(kPaintOp_DrawOp, 0, SkToU32(size));
         fWriter.write(storage, size);
         for (size_t i = 0; i < size/4; i++) {
 //            SkDebugf("[%d] %08X\n", i, storage[i]);
         }
     }
 
     //
     //  Do these after we've written kPaintOp_DrawOp
 
     if (base.getAnnotation() != paint.getAnnotation()) {
         if (NULL == paint.getAnnotation()) {
             if (this->needOpBytes()) {
                 this->writeOp(kSetAnnotation_DrawOp, 0, 0);
             }
         } else {
             SkWriteBuffer buffer;
             paint.getAnnotation()->writeToBuffer(buffer);
             const size_t size = buffer.bytesWritten();
             if (this->needOpBytes(size)) {
-                this->writeOp(kSetAnnotation_DrawOp, 0, size);
+                this->writeOp(kSetAnnotation_DrawOp, 0, SkToU32(size));
                 buffer.writeToMemory(fWriter.reserve(size));
             }
         }
         base.setAnnotation(paint.getAnnotation());
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkGPipe.h"
@@ skipping 69 matching lines @@
     return fCanvas->shuttleBitmap(bitmap, slot);
 }
 
 void BitmapShuttle::removeCanvas() {
     if (NULL == fCanvas) {
         return;
     }
     fCanvas->unref();
     fCanvas = NULL;
 }