Start cleaning up 64bit Win warnings

src/gpu/GrBufferAllocPool.cpp

 
 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "GrBufferAllocPool.h"
@@ skipping 185 matching lines @@
     VALIDATE();
     return fBufferPtr;
 }
 
 int GrBufferAllocPool::currentBufferItems(size_t itemSize) const {
     VALIDATE();
     if (NULL != fBufferPtr) {
         const BufferBlock& back = fBlocks.back();
         size_t usedBytes = back.fBuffer->sizeInBytes() - back.fBytesFree;
         size_t pad = GrSizeAlignUpPad(usedBytes, itemSize);
-        return (back.fBytesFree - pad) / itemSize;
+        return static_cast<int>((back.fBytesFree - pad) / itemSize);
     } else if (fPreallocBuffersInUse < fPreallocBuffers.count()) {
-        return fMinBlockSize / itemSize;
+        return static_cast<int>(fMinBlockSize / itemSize);
     }
     return 0;
 }
 
 int GrBufferAllocPool::preallocatedBuffersRemaining() const {
     return fPreallocBuffers.count() - fPreallocBuffersInUse;
 }
 
 int GrBufferAllocPool::preallocatedBufferCount() const {
     return fPreallocBuffers.count();
@@ skipping 178 matching lines @@
 
     size_t offset = 0; // assign to suppress warning
     const GrGeometryBuffer* geomBuffer = NULL; // assign to suppress warning
     void* ptr = INHERITED::makeSpace(vertexSize * vertexCount,
                                      vertexSize,
                                      &geomBuffer,
                                      &offset);
 
     *buffer = (const GrVertexBuffer*) geomBuffer;
     SkASSERT(0 == offset % vertexSize);
-    *startVertex = offset / vertexSize;
+    *startVertex = static_cast<int>(offset / vertexSize);
     return ptr;
 }
 
 bool GrVertexBufferAllocPool::appendVertices(size_t vertexSize,
                                              int vertexCount,
                                              const void* vertices,
                                              const GrVertexBuffer** buffer,
                                              int* startVertex) {
     void* space = makeSpace(vertexSize, vertexCount, buffer, startVertex);
     if (NULL != space) {
         memcpy(space,
                vertices,
                vertexSize * vertexCount);
         return true;
     } else {
         return false;
     }
 }
 
 int GrVertexBufferAllocPool::preallocatedBufferVertices(size_t vertexSize) const {
-    return INHERITED::preallocatedBufferSize() / vertexSize;
+    return static_cast<int>(INHERITED::preallocatedBufferSize() / vertexSize);
 }
 
 int GrVertexBufferAllocPool::currentBufferVertices(size_t vertexSize) const {
     return currentBufferItems(vertexSize);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 GrIndexBufferAllocPool::GrIndexBufferAllocPool(GrGpu* gpu,
                                                bool frequentResetHint,
@@ skipping 16 matching lines @@
 
     size_t offset = 0; // assign to suppress warning
     const GrGeometryBuffer* geomBuffer = NULL; // assign to suppress warning
     void* ptr = INHERITED::makeSpace(indexCount * sizeof(uint16_t),
                                      sizeof(uint16_t),
                                      &geomBuffer,
                                      &offset);
 
     *buffer = (const GrIndexBuffer*) geomBuffer;
     SkASSERT(0 == offset % sizeof(uint16_t));
-    *startIndex = offset / sizeof(uint16_t);
+    *startIndex = static_cast<int>(offset / sizeof(uint16_t));
     return ptr;
 }
 
 bool GrIndexBufferAllocPool::appendIndices(int indexCount,
                                            const void* indices,
                                            const GrIndexBuffer** buffer,
                                            int* startIndex) {
     void* space = makeSpace(indexCount, buffer, startIndex);
     if (NULL != space) {
         memcpy(space, indices, sizeof(uint16_t) * indexCount);
         return true;
     } else {
         return false;
     }
 }
 
 int GrIndexBufferAllocPool::preallocatedBufferIndices() const {
-    return INHERITED::preallocatedBufferSize() / sizeof(uint16_t);
+    return static_cast<int>(INHERITED::preallocatedBufferSize() / sizeof(uint16_t));
 }
 
 int GrIndexBufferAllocPool::currentBufferIndices() const {
     return currentBufferItems(sizeof(uint16_t));
 }