"NULL !=" = NULL

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 24 matching lines @@
     (block).fBuffer->unmap();                                                             \
 } while (false)
 
 GrBufferAllocPool::GrBufferAllocPool(GrGpu* gpu,
                                      BufferType bufferType,
                                      bool frequentResetHint,
                                      size_t blockSize,
                                      int preallocBufferCnt) :
         fBlocks(SkTMax(8, 2*preallocBufferCnt)) {
 
-    SkASSERT(NULL != gpu);
+    SkASSERT(gpu);
     fGpu = gpu;
     fGpu->ref();
     fGpuIsReffed = true;
 
     fBufferType = bufferType;
     fFrequentResetHint = frequentResetHint;
     fBufferPtr = NULL;
     fMinBlockSize = SkTMax(GrBufferAllocPool_MIN_BLOCK_SIZE, blockSize);
 
     fBytesInUse = 0;
 
     fPreallocBuffersInUse = 0;
     fPreallocBufferStartIdx = 0;
     for (int i = 0; i < preallocBufferCnt; ++i) {
         GrGeometryBuffer* buffer = this->createBuffer(fMinBlockSize);
-        if (NULL != buffer) {
+        if (buffer) {
             *fPreallocBuffers.append() = buffer;
         }
     }
 }
 
 GrBufferAllocPool::~GrBufferAllocPool() {
     VALIDATE();
     if (fBlocks.count()) {
         GrGeometryBuffer* buffer = fBlocks.back().fBuffer;
         if (buffer->isMapped()) {
@@ skipping 37 matching lines @@
     // we may have created a large cpu mirror of a large VB. Reset the size
     // to match our pre-allocated VBs.
     fCpuData.reset(fMinBlockSize);
     SkASSERT(0 == fPreallocBuffersInUse);
     VALIDATE();
 }
 
 void GrBufferAllocPool::unmap() {
     VALIDATE();
 
-    if (NULL != fBufferPtr) {
+    if (fBufferPtr) {
         BufferBlock& block = fBlocks.back();
         if (block.fBuffer->isMapped()) {
             UNMAP_BUFFER(block);
         } else {
             size_t flushSize = block.fBuffer->gpuMemorySize() - block.fBytesFree;
             this->flushCpuData(fBlocks.back(), flushSize);
         }
         fBufferPtr = NULL;
     }
     VALIDATE();
 }
 
 #ifdef SK_DEBUG
 void GrBufferAllocPool::validate(bool unusedBlockAllowed) const {
-    if (NULL != fBufferPtr) {
+    if (fBufferPtr) {
         SkASSERT(!fBlocks.empty());
         if (fBlocks.back().fBuffer->isMapped()) {
             GrGeometryBuffer* buf = fBlocks.back().fBuffer;
             SkASSERT(buf->mapPtr() == fBufferPtr);
         } else {
             SkASSERT(fCpuData.get() == fBufferPtr);
         }
     } else {
         SkASSERT(fBlocks.empty() || !fBlocks.back().fBuffer->isMapped());
     }
@@ skipping 16 matching lines @@
     }
 }
 #endif
 
 void* GrBufferAllocPool::makeSpace(size_t size,
                                    size_t alignment,
                                    const GrGeometryBuffer** buffer,
                                    size_t* offset) {
     VALIDATE();
 
-    SkASSERT(NULL != buffer);
-    SkASSERT(NULL != offset);
+    SkASSERT(buffer);
+    SkASSERT(offset);
 
-    if (NULL != fBufferPtr) {
+    if (fBufferPtr) {
         BufferBlock& back = fBlocks.back();
         size_t usedBytes = back.fBuffer->gpuMemorySize() - back.fBytesFree;
         size_t pad = GrSizeAlignUpPad(usedBytes,
                                       alignment);
         if ((size + pad) <= back.fBytesFree) {
             usedBytes += pad;
             *offset = usedBytes;
             *buffer = back.fBuffer;
             back.fBytesFree -= size + pad;
             fBytesInUse += size + pad;
             VALIDATE();
             return (void*)(reinterpret_cast<intptr_t>(fBufferPtr) + usedBytes);
         }
     }
 
     // We could honor the space request using by a partial update of the current
     // VB (if there is room). But we don't currently use draw calls to GL that
     // allow the driver to know that previously issued draws won't read from
     // the part of the buffer we update. Also, the GL buffer implementation
     // may be cheating on the actual buffer size by shrinking the buffer on
     // updateData() if the amount of data passed is less than the full buffer
     // size.
 
     if (!createBlock(size)) {
         return NULL;
     }
-    SkASSERT(NULL != fBufferPtr);
+    SkASSERT(fBufferPtr);
 
     *offset = 0;
     BufferBlock& back = fBlocks.back();
     *buffer = back.fBuffer;
     back.fBytesFree -= size;
     fBytesInUse += size;
     VALIDATE();
     return fBufferPtr;
 }
 
 int GrBufferAllocPool::currentBufferItems(size_t itemSize) const {
     VALIDATE();
-    if (NULL != fBufferPtr) {
+    if (fBufferPtr) {
         const BufferBlock& back = fBlocks.back();
         size_t usedBytes = back.fBuffer->gpuMemorySize() - back.fBytesFree;
         size_t pad = GrSizeAlignUpPad(usedBytes, itemSize);
         return static_cast<int>((back.fBytesFree - pad) / itemSize);
     } else if (fPreallocBuffersInUse < fPreallocBuffers.count()) {
         return static_cast<int>(fMinBlockSize / itemSize);
     }
     return 0;
 }
 
@@ skipping 63 matching lines @@
         ++fPreallocBuffersInUse;
     } else {
         block.fBuffer = this->createBuffer(size);
         if (NULL == block.fBuffer) {
             fBlocks.pop_back();
             return false;
         }
     }
 
     block.fBytesFree = size;
-    if (NULL != fBufferPtr) {
+    if (fBufferPtr) {
         SkASSERT(fBlocks.count() > 1);
         BufferBlock& prev = fBlocks.fromBack(1);
         if (prev.fBuffer->isMapped()) {
             UNMAP_BUFFER(prev);
         } else {
             this->flushCpuData(prev, prev.fBuffer->gpuMemorySize() - prev.fBytesFree);
         }
         fBufferPtr = NULL;
     }
 
@@ skipping 40 matching lines @@
         }
     }
     SkASSERT(!block.fBuffer->isMapped());
     block.fBuffer->unref();
     fBlocks.pop_back();
     fBufferPtr = NULL;
 }
 
 void GrBufferAllocPool::flushCpuData(const BufferBlock& block, size_t flushSize) {
     GrGeometryBuffer* buffer = block.fBuffer;
-    SkASSERT(NULL != buffer);
+    SkASSERT(buffer);
     SkASSERT(!buffer->isMapped());
     SkASSERT(fCpuData.get() == fBufferPtr);
     SkASSERT(flushSize <= buffer->gpuMemorySize());
     VALIDATE(true);
 
     if (GrDrawTargetCaps::kNone_MapFlags != fGpu->caps()->mapBufferFlags() &&
         flushSize > GR_GEOM_BUFFER_MAP_THRESHOLD) {
         void* data = buffer->map();
-        if (NULL != data) {
+        if (data) {
             memcpy(data, fBufferPtr, flushSize);
             UNMAP_BUFFER(block);
             return;
         }
     }
     buffer->updateData(fBufferPtr, flushSize);
     VALIDATE(true);
 }
 
 GrGeometryBuffer* GrBufferAllocPool::createBuffer(size_t size) {
@@ skipping 17 matching lines @@
                     bufferSize,
                     preallocBufferCnt) {
 }
 
 void* GrVertexBufferAllocPool::makeSpace(size_t vertexSize,
                                          int vertexCount,
                                          const GrVertexBuffer** buffer,
                                          int* startVertex) {
 
     SkASSERT(vertexCount >= 0);
-    SkASSERT(NULL != buffer);
-    SkASSERT(NULL != startVertex);
+    SkASSERT(buffer);
+    SkASSERT(startVertex);
 
     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 = 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) {
+    if (space) {
         memcpy(space,
                vertices,
                vertexSize * vertexCount);
         return true;
     } else {
         return false;
     }
 }
 
 int GrVertexBufferAllocPool::preallocatedBufferVertices(size_t vertexSize) const {
@@ skipping 15 matching lines @@
                     frequentResetHint,
                     bufferSize,
                     preallocBufferCnt) {
 }
 
 void* GrIndexBufferAllocPool::makeSpace(int indexCount,
                                         const GrIndexBuffer** buffer,
                                         int* startIndex) {
 
     SkASSERT(indexCount >= 0);
-    SkASSERT(NULL != buffer);
-    SkASSERT(NULL != startIndex);
+    SkASSERT(buffer);
+    SkASSERT(startIndex);
 
     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 = 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) {
+    if (space) {
         memcpy(space, indices, sizeof(uint16_t) * indexCount);
         return true;
     } else {
         return false;
     }
 }
 
 int GrIndexBufferAllocPool::preallocatedBufferIndices() const {
     return static_cast<int>(INHERITED::preallocatedBufferSize() / sizeof(uint16_t));
 }
 
 int GrIndexBufferAllocPool::currentBufferIndices() const {
     return currentBufferItems(sizeof(uint16_t));
 }