"NULL !=" = NULL

src/gpu/GrDrawTarget.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.
  */
 
 
 
@@ skipping 14 matching lines @@
     fPrimitiveType  = di.fPrimitiveType;
     fStartVertex    = di.fStartVertex;
     fStartIndex     = di.fStartIndex;
     fVertexCount    = di.fVertexCount;
     fIndexCount     = di.fIndexCount;
 
     fInstanceCount          = di.fInstanceCount;
     fVerticesPerInstance    = di.fVerticesPerInstance;
     fIndicesPerInstance     = di.fIndicesPerInstance;
 
-    if (NULL != di.fDevBounds) {
+    if (di.fDevBounds) {
         SkASSERT(di.fDevBounds == &di.fDevBoundsStorage);
         fDevBoundsStorage = di.fDevBoundsStorage;
         fDevBounds = &fDevBoundsStorage;
     } else {
         fDevBounds = NULL;
     }
 
     fDstCopy = di.fDstCopy;
 
     return *this;
@@ skipping 38 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 
 #define DEBUG_INVAL_BUFFER 0xdeadcafe
 #define DEBUG_INVAL_START_IDX -1
 
 GrDrawTarget::GrDrawTarget(GrContext* context)
     : fClip(NULL)
     , fContext(context)
     , fGpuTraceMarkerCount(0) {
-    SkASSERT(NULL != context);
+    SkASSERT(context);
 
     fDrawState = &fDefaultDrawState;
     // We assume that fDrawState always owns a ref to the object it points at.
     fDefaultDrawState.ref();
     GeometrySrcState& geoSrc = fGeoSrcStateStack.push_back();
 #ifdef SK_DEBUG
     geoSrc.fVertexCount = DEBUG_INVAL_START_IDX;
     geoSrc.fVertexBuffer = (GrVertexBuffer*)DEBUG_INVAL_BUFFER;
     geoSrc.fIndexCount = DEBUG_INVAL_START_IDX;
     geoSrc.fIndexBuffer = (GrIndexBuffer*)DEBUG_INVAL_BUFFER;
@@ skipping 23 matching lines @@
 void GrDrawTarget::setClip(const GrClipData* clip) {
     clipWillBeSet(clip);
     fClip = clip;
 }
 
 const GrClipData* GrDrawTarget::getClip() const {
     return fClip;
 }
 
 void GrDrawTarget::setDrawState(GrDrawState*  drawState) {
-    SkASSERT(NULL != fDrawState);
+    SkASSERT(fDrawState);
     if (NULL == drawState) {
         drawState = &fDefaultDrawState;
     }
     if (fDrawState != drawState) {
         fDrawState->unref();
         drawState->ref();
         fDrawState = drawState;
     }
 }
 
 bool GrDrawTarget::reserveVertexSpace(size_t vertexSize,
                                       int vertexCount,
                                       void** vertices) {
     GeometrySrcState& geoSrc = fGeoSrcStateStack.back();
     bool acquired = false;
     if (vertexCount > 0) {
-        SkASSERT(NULL != vertices);
+        SkASSERT(vertices);
         this->releasePreviousVertexSource();
         geoSrc.fVertexSrc = kNone_GeometrySrcType;
 
         acquired = this->onReserveVertexSpace(vertexSize,
                                               vertexCount,
                                               vertices);
     }
     if (acquired) {
         geoSrc.fVertexSrc = kReserved_GeometrySrcType;
         geoSrc.fVertexCount = vertexCount;
         geoSrc.fVertexSize = vertexSize;
-    } else if (NULL != vertices) {
+    } else if (vertices) {
         *vertices = NULL;
     }
     return acquired;
 }
 
 bool GrDrawTarget::reserveIndexSpace(int indexCount,
                                      void** indices) {
     GeometrySrcState& geoSrc = fGeoSrcStateStack.back();
     bool acquired = false;
     if (indexCount > 0) {
-        SkASSERT(NULL != indices);
+        SkASSERT(indices);
         this->releasePreviousIndexSource();
         geoSrc.fIndexSrc = kNone_GeometrySrcType;
 
         acquired = this->onReserveIndexSpace(indexCount, indices);
     }
     if (acquired) {
         geoSrc.fIndexSrc = kReserved_GeometrySrcType;
         geoSrc.fIndexCount = indexCount;
-    } else if (NULL != indices) {
+    } else if (indices) {
         *indices = NULL;
     }
     return acquired;
 
 }
 
 bool GrDrawTarget::reserveVertexAndIndexSpace(int vertexCount,
                                               int indexCount,
                                               void** vertices,
                                               void** indices) {
@@ skipping 13 matching lines @@
                 this->resetVertexSource();
             }
             return false;
         }
     }
     return true;
 }
 
 bool GrDrawTarget::geometryHints(int32_t* vertexCount,
                                  int32_t* indexCount) const {
-    if (NULL != vertexCount) {
+    if (vertexCount) {
         *vertexCount = -1;
     }
-    if (NULL != indexCount) {
+    if (indexCount) {
         *indexCount = -1;
     }
     return false;
 }
 
 void GrDrawTarget::releasePreviousVertexSource() {
     GeometrySrcState& geoSrc = fGeoSrcStateStack.back();
     switch (geoSrc.fVertexSrc) {
         case kNone_GeometrySrcType:
             break;
@@ skipping 145 matching lines @@
                 break;
             case kBuffer_GeometrySrcType:
                 maxValidIndex = static_cast<int>(geoSrc.fIndexBuffer->gpuMemorySize() / sizeof(uint16_t));
                 break;
         }
         if (maxIndex > maxValidIndex) {
             SkFAIL("Index reads outside valid index range.");
         }
     }
 
-    SkASSERT(NULL != drawState.getRenderTarget());
+    SkASSERT(drawState.getRenderTarget());
 
     if (drawState.hasGeometryProcessor()) {
         const GrEffect* effect = drawState.getGeometryProcessor()->getEffect();
         int numTextures = effect->numTextures();
         for (int t = 0; t < numTextures; ++t) {
             GrTexture* texture = effect->texture(t);
             SkASSERT(texture->asRenderTarget() != drawState.getRenderTarget());
         }
     }
 
@@ skipping 24 matching lines @@
 
 bool GrDrawTarget::setupDstReadIfNecessary(GrDeviceCoordTexture* dstCopy, const SkRect* drawBounds) {
     if (this->caps()->dstReadInShaderSupport() || !this->getDrawState().willEffectReadDstColor()) {
         return true;
     }
     GrRenderTarget* rt = this->drawState()->getRenderTarget();
     SkIRect copyRect;
     const GrClipData* clip = this->getClip();
     clip->getConservativeBounds(rt, &copyRect);
 
-    if (NULL != drawBounds) {
+    if (drawBounds) {
         SkIRect drawIBounds;
         drawBounds->roundOut(&drawIBounds);
         if (!copyRect.intersect(drawIBounds)) {
 #ifdef SK_DEBUG
             GrPrintf("Missed an early reject. Bailing on draw from setupDstReadIfNecessary.\n");
 #endif
             return false;
         }
     } else {
 #ifdef SK_DEBUG
@@ skipping 35 matching lines @@
         info.fPrimitiveType = type;
         info.fStartVertex   = startVertex;
         info.fStartIndex    = startIndex;
         info.fVertexCount   = vertexCount;
         info.fIndexCount    = indexCount;
 
         info.fInstanceCount         = 0;
         info.fVerticesPerInstance   = 0;
         info.fIndicesPerInstance    = 0;
 
-        if (NULL != devBounds) {
+        if (devBounds) {
             info.setDevBounds(*devBounds);
         }
         // TODO: We should continue with incorrect blending.
         if (!this->setupDstReadIfNecessary(&info)) {
             return;
         }
         this->onDraw(info);
     }
 }
 
 void GrDrawTarget::drawNonIndexed(GrPrimitiveType type,
                                   int startVertex,
                                   int vertexCount,
                                   const SkRect* devBounds) {
     if (vertexCount > 0 && this->checkDraw(type, startVertex, -1, vertexCount, -1)) {
         DrawInfo info;
         info.fPrimitiveType = type;
         info.fStartVertex   = startVertex;
         info.fStartIndex    = 0;
         info.fVertexCount   = vertexCount;
         info.fIndexCount    = 0;
 
         info.fInstanceCount         = 0;
         info.fVerticesPerInstance   = 0;
         info.fIndicesPerInstance    = 0;
 
-        if (NULL != devBounds) {
+        if (devBounds) {
             info.setDevBounds(*devBounds);
         }
         // TODO: We should continue with incorrect blending.
         if (!this->setupDstReadIfNecessary(&info)) {
             return;
         }
         this->onDraw(info);
     }
 }
 
 void GrDrawTarget::stencilPath(const GrPath* path, SkPath::FillType fill) {
     // TODO: extract portions of checkDraw that are relevant to path stenciling.
-    SkASSERT(NULL != path);
+    SkASSERT(path);
     SkASSERT(this->caps()->pathRenderingSupport());
     SkASSERT(!SkPath::IsInverseFillType(fill));
     this->onStencilPath(path, fill);
 }
 
 void GrDrawTarget::drawPath(const GrPath* path, SkPath::FillType fill) {
     // TODO: extract portions of checkDraw that are relevant to path rendering.
-    SkASSERT(NULL != path);
+    SkASSERT(path);
     SkASSERT(this->caps()->pathRenderingSupport());
     const GrDrawState* drawState = &getDrawState();
 
     SkRect devBounds;
     if (SkPath::IsInverseFillType(fill)) {
         devBounds = SkRect::MakeWH(SkIntToScalar(drawState->getRenderTarget()->width()),
                                    SkIntToScalar(drawState->getRenderTarget()->height()));
     } else {
         devBounds = path->getBounds();
     }
     SkMatrix viewM = drawState->getViewMatrix();
     viewM.mapRect(&devBounds);
 
     GrDeviceCoordTexture dstCopy;
     if (!this->setupDstReadIfNecessary(&dstCopy, &devBounds)) {
         return;
     }
 
     this->onDrawPath(path, fill, dstCopy.texture() ? &dstCopy : NULL);
 }
 
 void GrDrawTarget::drawPaths(const GrPathRange* pathRange,
                              const uint32_t indices[], int count,
                              const float transforms[], PathTransformType transformsType,
                              SkPath::FillType fill) {
     SkASSERT(this->caps()->pathRenderingSupport());
-    SkASSERT(NULL != pathRange);
-    SkASSERT(NULL != indices);
-    SkASSERT(NULL != transforms);
+    SkASSERT(pathRange);
+    SkASSERT(indices);
+    SkASSERT(transforms);
 
     // Don't compute a bounding box for setupDstReadIfNecessary(), we'll opt
     // instead for it to just copy the entire dst. Realistically this is a moot
     // point, because any context that supports NV_path_rendering will also
     // support NV_blend_equation_advanced.
     GrDeviceCoordTexture dstCopy;
     if (!this->setupDstReadIfNecessary(&dstCopy, NULL)) {
         return;
     }
 
@@ skipping 59 matching lines @@
     }
 
     DrawInfo info;
     info.fPrimitiveType = type;
     info.fStartIndex = 0;
     info.fStartVertex = 0;
     info.fIndicesPerInstance = indicesPerInstance;
     info.fVerticesPerInstance = verticesPerInstance;
 
     // Set the same bounds for all the draws.
-    if (NULL != devBounds) {
+    if (devBounds) {
         info.setDevBounds(*devBounds);
     }
     // TODO: We should continue with incorrect blending.
     if (!this->setupDstReadIfNecessary(&info)) {
         return;
     }
 
     while (instanceCount) {
         info.fInstanceCount = SkTMin(instanceCount, maxInstancesPerDraw);
         info.fVertexCount = info.fInstanceCount * verticesPerInstance;
@@ skipping 28 matching lines @@
         drawState->setVertexAttribs<gBWRectPosUVAttribs>(1, sizeof(SkPoint));
     }
 }
 
 };
 
 void GrDrawTarget::onDrawRect(const SkRect& rect,
                               const SkRect* localRect,
                               const SkMatrix* localMatrix) {
 
-    set_vertex_attributes(this->drawState(), NULL != localRect);
+    set_vertex_attributes(this->drawState(), SkToBool(localRect));
 
     AutoReleaseGeometry geo(this, 4, 0);
     if (!geo.succeeded()) {
         GrPrintf("Failed to get space for vertices!\n");
         return;
     }
 
     size_t vstride = this->drawState()->getVertexStride();
     geo.positions()->setRectFan(rect.fLeft, rect.fTop, rect.fRight, rect.fBottom, vstride);
-    if (NULL != localRect) {
+    if (localRect) {
         SkPoint* coords = GrTCast<SkPoint*>(GrTCast<intptr_t>(geo.vertices()) +
                                             sizeof(SkPoint));
         coords->setRectFan(localRect->fLeft, localRect->fTop,
                            localRect->fRight, localRect->fBottom,
                            vstride);
-        if (NULL != localMatrix) {
+        if (localMatrix) {
             localMatrix->mapPointsWithStride(coords, vstride, 4);
         }
     }
     SkRect bounds;
     this->getDrawState().getViewMatrix().mapRect(&bounds, rect);
 
     this->drawNonIndexed(kTriangleFan_GrPrimitiveType, 0, 4, &bounds);
 }
 
 void GrDrawTarget::clipWillBeSet(const GrClipData* clipData) {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 GrDrawTarget::AutoStateRestore::AutoStateRestore() {
     fDrawTarget = NULL;
 }
 
 GrDrawTarget::AutoStateRestore::AutoStateRestore(GrDrawTarget* target,
                                                  ASRInit init,
                                                  const SkMatrix* vm) {
     fDrawTarget = NULL;
     this->set(target, init, vm);
 }
 
 GrDrawTarget::AutoStateRestore::~AutoStateRestore() {
-    if (NULL != fDrawTarget) {
+    if (fDrawTarget) {
         fDrawTarget->setDrawState(fSavedState);
         fSavedState->unref();
     }
 }
 
 void GrDrawTarget::AutoStateRestore::set(GrDrawTarget* target, ASRInit init, const SkMatrix* vm) {
     SkASSERT(NULL == fDrawTarget);
     fDrawTarget = target;
     fSavedState = target->drawState();
     SkASSERT(fSavedState);
@@ skipping 59 matching lines @@
 GrDrawTarget::AutoReleaseGeometry::~AutoReleaseGeometry() {
     this->reset();
 }
 
 bool GrDrawTarget::AutoReleaseGeometry::set(GrDrawTarget*  target,
                                             int vertexCount,
                                             int indexCount) {
     this->reset();
     fTarget = target;
     bool success = true;
-    if (NULL != fTarget) {
+    if (fTarget) {
         fTarget = target;
         success = target->reserveVertexAndIndexSpace(vertexCount,
                                                      indexCount,
                                                      &fVertices,
                                                      &fIndices);
         if (!success) {
             fTarget = NULL;
             this->reset();
         }
     }
-    SkASSERT(success == (NULL != fTarget));
+    SkASSERT(success == SkToBool(fTarget));
     return success;
 }
 
 void GrDrawTarget::AutoReleaseGeometry::reset() {
-    if (NULL != fTarget) {
-        if (NULL != fVertices) {
+    if (fTarget) {
+        if (fVertices) {
             fTarget->resetVertexSource();
         }
-        if (NULL != fIndices) {
+        if (fIndices) {
             fTarget->resetIndexSource();
         }
         fTarget = NULL;
     }
     fVertices = NULL;
     fIndices = NULL;
 }
 
 GrDrawTarget::AutoClipRestore::AutoClipRestore(GrDrawTarget* target, const SkIRect& newClip) {
     fTarget = target;
@@ skipping 54 matching lines @@
     // The above clipping steps may have inverted the rect if it didn't intersect either the src or
     // dst bounds.
     return !clippedSrcRect->isEmpty();
 }
 }
 
 bool GrDrawTarget::copySurface(GrSurface* dst,
                                GrSurface* src,
                                const SkIRect& srcRect,
                                const SkIPoint& dstPoint) {
-    SkASSERT(NULL != dst);
-    SkASSERT(NULL != src);
+    SkASSERT(dst);
+    SkASSERT(src);
 
     SkIRect clippedSrcRect;
     SkIPoint clippedDstPoint;
     // If the rect is outside the src or dst then we've already succeeded.
     if (!clip_srcrect_and_dstpoint(dst,
                                    src,
                                    srcRect,
                                    dstPoint,
                                    &clippedSrcRect,
                                    &clippedDstPoint)) {
         SkASSERT(this->canCopySurface(dst, src, srcRect, dstPoint));
         return true;
     }
 
     bool result = this->onCopySurface(dst, src, clippedSrcRect, clippedDstPoint);
     SkASSERT(result == this->canCopySurface(dst, src, clippedSrcRect, clippedDstPoint));
     return result;
 }
 
 bool GrDrawTarget::canCopySurface(GrSurface* dst,
                                   GrSurface* src,
                                   const SkIRect& srcRect,
                                   const SkIPoint& dstPoint) {
-    SkASSERT(NULL != dst);
-    SkASSERT(NULL != src);
+    SkASSERT(dst);
+    SkASSERT(src);
 
     SkIRect clippedSrcRect;
     SkIPoint clippedDstPoint;
     // If the rect is outside the src or dst then we're guaranteed success
     if (!clip_srcrect_and_dstpoint(dst,
                                    src,
                                    srcRect,
                                    dstPoint,
                                    &clippedSrcRect,
                                    &clippedDstPoint)) {
         return true;
     }
     return this->onCanCopySurface(dst, src, clippedSrcRect, clippedDstPoint);
 }
 
 bool GrDrawTarget::onCanCopySurface(GrSurface* dst,
                                     GrSurface* src,
                                     const SkIRect& srcRect,
                                     const SkIPoint& dstPoint) {
     // Check that the read/write rects are contained within the src/dst bounds.
     SkASSERT(!srcRect.isEmpty());
     SkASSERT(SkIRect::MakeWH(src->width(), src->height()).contains(srcRect));
     SkASSERT(dstPoint.fX >= 0 && dstPoint.fY >= 0);
     SkASSERT(dstPoint.fX + srcRect.width() <= dst->width() &&
              dstPoint.fY + srcRect.height() <= dst->height());
 
-    return !dst->isSameAs(src) && NULL != dst->asRenderTarget() && NULL != src->asTexture();
+    return !dst->isSameAs(src) && dst->asRenderTarget() && src->asTexture();
 }
 
 bool GrDrawTarget::onCopySurface(GrSurface* dst,
                                  GrSurface* src,
                                  const SkIRect& srcRect,
                                  const SkIPoint& dstPoint) {
     if (!GrDrawTarget::onCanCopySurface(dst, src, srcRect, dstPoint)) {
         return false;
     }
 
@@ skipping 162 matching lines @@
     SkASSERT(!fConfigTextureSupport[kUnknown_GrPixelConfig]);
 
     for (size_t i = 1; i < SK_ARRAY_COUNT(kConfigNames); ++i)  {
         r.appendf("%s is uploadable to a texture: %s\n",
                   kConfigNames[i],
                   gNY[fConfigTextureSupport[i]]);
     }
 
     return r;
 }