"NULL !=" = NULL

src/gpu/gl/GrGpuGL_program.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 "GrGpuGL.h"
 
 #include "GrEffect.h"
@@ skipping 12 matching lines @@
 struct GrGpuGL::ProgramCache::Entry {
     SK_DECLARE_INST_COUNT_ROOT(Entry);
     Entry() : fProgram(NULL), fLRUStamp(0) {}
 
     SkAutoTUnref<GrGLProgram>   fProgram;
     unsigned int                fLRUStamp;
 };
 
 struct GrGpuGL::ProgramCache::ProgDescLess {
     bool operator() (const GrGLProgramDesc& desc, const Entry* entry) {
-        SkASSERT(NULL != entry->fProgram.get());
+        SkASSERT(entry->fProgram.get());
         return GrGLProgramDesc::Less(desc, entry->fProgram->getDesc());
     }
 
     bool operator() (const Entry* entry, const GrGLProgramDesc& desc) {
-        SkASSERT(NULL != entry->fProgram.get());
+        SkASSERT(entry->fProgram.get());
         return GrGLProgramDesc::Less(entry->fProgram->getDesc(), desc);
     }
 };
 
 GrGpuGL::ProgramCache::ProgramCache(GrGpuGL* gpu)
     : fCount(0)
     , fCurrLRUStamp(0)
     , fGpu(gpu)
 #ifdef PROGRAM_CACHE_STATS
     , fTotalRequests(0)
@@ skipping 21 matching lines @@
                                             0.f);
         int cacheHits = fTotalRequests - fCacheMisses;
         SkDebugf("Hash miss %%: %f\n", (cacheHits > 0) ? 100.f * fHashMisses / cacheHits : 0.f);
         SkDebugf("---------------------\n");
     }
 #endif
 }
 
 void GrGpuGL::ProgramCache::abandon() {
     for (int i = 0; i < fCount; ++i) {
-        SkASSERT(NULL != fEntries[i]->fProgram.get());
+        SkASSERT(fEntries[i]->fProgram.get());
         fEntries[i]->fProgram->abandon();
         SkDELETE(fEntries[i]);
     }
     fCount = 0;
 }
 
 int GrGpuGL::ProgramCache::search(const GrGLProgramDesc& desc) const {
     ProgDescLess less;
     return SkTSearch(fEntries, fCount, desc, sizeof(Entry*), less);
 }
 
 GrGLProgram* GrGpuGL::ProgramCache::getProgram(const GrGLProgramDesc& desc,
                                                const GrEffectStage* geometryProcessor,
                                                const GrEffectStage* colorStages[],
                                                const GrEffectStage* coverageStages[]) {
 #ifdef PROGRAM_CACHE_STATS
     ++fTotalRequests;
 #endif
 
     Entry* entry = NULL;
 
     uint32_t hashIdx = desc.getChecksum();
     hashIdx ^= hashIdx >> 16;
     if (kHashBits <= 8) {
         hashIdx ^= hashIdx >> 8;
     }
     hashIdx &=((1 << kHashBits) - 1);
     Entry* hashedEntry = fHashTable[hashIdx];
-    if (NULL != hashedEntry && hashedEntry->fProgram->getDesc() == desc) {
-        SkASSERT(NULL != hashedEntry->fProgram);
+    if (hashedEntry && hashedEntry->fProgram->getDesc() == desc) {
+        SkASSERT(hashedEntry->fProgram);
         entry = hashedEntry;
     }
 
     int entryIdx;
     if (NULL == entry) {
         entryIdx = this->search(desc);
         if (entryIdx >= 0) {
             entry = fEntries[entryIdx];
 #ifdef PROGRAM_CACHE_STATS
             ++fHashMisses;
@@ skipping 47 matching lines @@
         } else if (purgeIdx < entryIdx) {
             //  If the entries array looks like this:
             //       aaaaPbbbbbEccccc
             //  we rearrange it to look like this:
             //       aaaabbbbbPEccccc
             size_t copySize = (entryIdx - purgeIdx - 1) * sizeof(Entry*);
             memmove(fEntries + purgeIdx, fEntries + purgeIdx + 1, copySize);
             fEntries[entryIdx - 1] = entry;
         }
 #ifdef SK_DEBUG
-        SkASSERT(NULL != fEntries[0]->fProgram.get());
+        SkASSERT(fEntries[0]->fProgram.get());
         for (int i = 0; i < fCount - 1; ++i) {
-            SkASSERT(NULL != fEntries[i + 1]->fProgram.get());
+            SkASSERT(fEntries[i + 1]->fProgram.get());
             const GrGLProgramDesc& a = fEntries[i]->fProgram->getDesc();
             const GrGLProgramDesc& b = fEntries[i + 1]->fProgram->getDesc();
             SkASSERT(GrGLProgramDesc::Less(a, b));
             SkASSERT(!GrGLProgramDesc::Less(b, a));
         }
 #endif
     }
 
     fHashTable[hashIdx] = entry;
     entry->fLRUStamp = fCurrLRUStamp;
 
     if (SK_MaxU32 == fCurrLRUStamp) {
         // wrap around! just trash our LRU, one time hit.
         for (int i = 0; i < fCount; ++i) {
             fEntries[i]->fLRUStamp = 0;
         }
     }
     ++fCurrLRUStamp;
     return entry->fProgram;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 #define GL_CALL(X) GR_GL_CALL(this->glInterface(), X)
 
 bool GrGpuGL::flushGraphicsState(DrawType type, const GrDeviceCoordTexture* dstCopy) {
     const GrDrawState& drawState = this->getDrawState();
 
     // GrGpu::setupClipAndFlushState should have already checked this and bailed if not true.
-    SkASSERT(NULL != drawState.getRenderTarget());
+    SkASSERT(drawState.getRenderTarget());
 
     if (kStencilPath_DrawType == type) {
         const GrRenderTarget* rt = this->getDrawState().getRenderTarget();
         SkISize size;
         size.set(rt->width(), rt->height());
         this->glPathRendering()->setProjectionMatrix(drawState.getViewMatrix(), size, rt->origin());
     } else {
         this->flushMiscFixedFunctionState();
 
         GrBlendCoeff srcCoeff;
@@ skipping 86 matching lines @@
         case kReserved_GeometrySrcType:
             this->finalizeReservedVertices();
             vertexOffsetInBytes += geoPoolState.fPoolStartVertex * this->getGeomSrc().fVertexSize;
             vbuf = (GrGLVertexBuffer*) geoPoolState.fPoolVertexBuffer;
             break;
         default:
             vbuf = NULL; // suppress warning
             SkFAIL("Unknown geometry src type!");
     }
 
-    SkASSERT(NULL != vbuf);
+    SkASSERT(vbuf);
     SkASSERT(!vbuf->isMapped());
     vertexOffsetInBytes += vbuf->baseOffset();
 
     GrGLIndexBuffer* ibuf = NULL;
     if (info.isIndexed()) {
-        SkASSERT(NULL != indexOffsetInBytes);
+        SkASSERT(indexOffsetInBytes);
 
         switch (this->getGeomSrc().fIndexSrc) {
         case kBuffer_GeometrySrcType:
             *indexOffsetInBytes = 0;
             ibuf = (GrGLIndexBuffer*)this->getGeomSrc().fIndexBuffer;
             break;
         case kArray_GeometrySrcType:
         case kReserved_GeometrySrcType:
             this->finalizeReservedIndices();
             *indexOffsetInBytes = geoPoolState.fPoolStartIndex * sizeof(GrGLushort);
             ibuf = (GrGLIndexBuffer*) geoPoolState.fPoolIndexBuffer;
             break;
         default:
             ibuf = NULL; // suppress warning
             SkFAIL("Unknown geometry src type!");
         }
 
-        SkASSERT(NULL != ibuf);
+        SkASSERT(ibuf);
         SkASSERT(!ibuf->isMapped());
         *indexOffsetInBytes += ibuf->baseOffset();
     }
     GrGLAttribArrayState* attribState =
         fHWGeometryState.bindArrayAndBuffersToDraw(this, vbuf, ibuf);
 
     if (fCurrentProgram->hasVertexShader()) {
         int vertexAttribCount = this->getDrawState().getVertexAttribCount();
         uint32_t usedAttribArraysMask = 0;
         const GrVertexAttrib* vertexAttrib = this->getDrawState().getVertexAttribs();
@@ skipping 13 matching lines @@
                              GrGLAttribTypeToLayout(attribType).fType,
                              GrGLAttribTypeToLayout(attribType).fNormalized,
                              stride,
                              reinterpret_cast<GrGLvoid*>(
                                  vertexOffsetInBytes + vertexAttrib->fOffset));
             }
         }
         attribState->disableUnusedArrays(this, usedAttribArraysMask);
     }
 }