Replace uses of GR_DEBUG by SK_DEBUG.

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 27 matching lines @@
         fDevBounds = &fDevBoundsStorage;
     } else {
         fDevBounds = NULL;
     }
 
     fDstCopy = di.fDstCopy;
 
     return *this;
 }
 
-#if GR_DEBUG
+#ifdef SK_DEBUG
 bool GrDrawTarget::DrawInfo::isInstanced() const {
     if (fInstanceCount > 0) {
         SkASSERT(0 == fIndexCount % fIndicesPerInstance);
         SkASSERT(0 == fVertexCount % fVerticesPerInstance);
         SkASSERT(fIndexCount / fIndicesPerInstance == fInstanceCount);
         SkASSERT(fVertexCount / fVerticesPerInstance == fInstanceCount);
         // there is no way to specify a non-zero start index to drawIndexedInstances().
         SkASSERT(0 == fStartIndex);
         return true;
     } else {
@@ skipping 30 matching lines @@
 
 GrDrawTarget::GrDrawTarget(GrContext* context)
     : fClip(NULL)
     , fContext(context) {
     SkASSERT(NULL != context);
 
     fDrawState = &fDefaultDrawState;
     // We assume that fDrawState always owns a ref to the object it points at.
     fDefaultDrawState.ref();
     GeometrySrcState& geoSrc = fGeoSrcStateStack.push_back();
-#if GR_DEBUG
+#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;
 #endif
     geoSrc.fVertexSrc = kNone_GeometrySrcType;
     geoSrc.fIndexSrc  = kNone_GeometrySrcType;
 }
 
 GrDrawTarget::~GrDrawTarget() {
@@ skipping 122 matching lines @@
         case kNone_GeometrySrcType:
             break;
         case kArray_GeometrySrcType:
             this->releaseVertexArray();
             break;
         case kReserved_GeometrySrcType:
             this->releaseReservedVertexSpace();
             break;
         case kBuffer_GeometrySrcType:
             geoSrc.fVertexBuffer->unref();
-#if GR_DEBUG
+#ifdef SK_DEBUG
             geoSrc.fVertexBuffer = (GrVertexBuffer*)DEBUG_INVAL_BUFFER;
 #endif
             break;
         default:
             GrCrash("Unknown Vertex Source Type.");
             break;
     }
 }
 
 void GrDrawTarget::releasePreviousIndexSource() {
     GeometrySrcState& geoSrc = fGeoSrcStateStack.back();
     switch (geoSrc.fIndexSrc) {
         case kNone_GeometrySrcType:   // these two don't require
             break;
         case kArray_GeometrySrcType:
             this->releaseIndexArray();
             break;
         case kReserved_GeometrySrcType:
             this->releaseReservedIndexSpace();
             break;
         case kBuffer_GeometrySrcType:
             geoSrc.fIndexBuffer->unref();
-#if GR_DEBUG
+#ifdef SK_DEBUG
             geoSrc.fIndexBuffer = (GrIndexBuffer*)DEBUG_INVAL_BUFFER;
 #endif
             break;
         default:
             GrCrash("Unknown Index Source Type.");
             break;
     }
 }
 
 void GrDrawTarget::setVertexSourceToArray(const void* vertexArray,
@@ skipping 42 matching lines @@
     this->releasePreviousIndexSource();
     GeometrySrcState& geoSrc = fGeoSrcStateStack.back();
     geoSrc.fIndexSrc = kNone_GeometrySrcType;
 }
 
 void GrDrawTarget::pushGeometrySource() {
     this->geometrySourceWillPush();
     GeometrySrcState& newState = fGeoSrcStateStack.push_back();
     newState.fIndexSrc = kNone_GeometrySrcType;
     newState.fVertexSrc = kNone_GeometrySrcType;
-#if GR_DEBUG
+#ifdef SK_DEBUG
     newState.fVertexCount  = ~0;
     newState.fVertexBuffer = (GrVertexBuffer*)~0;
     newState.fIndexCount   = ~0;
     newState.fIndexBuffer = (GrIndexBuffer*)~0;
 #endif
 }
 
 void GrDrawTarget::popGeometrySource() {
     // if popping last element then pops are unbalanced with pushes
     SkASSERT(fGeoSrcStateStack.count() > 1);
 
     this->geometrySourceWillPop(fGeoSrcStateStack.fromBack(1));
     this->releasePreviousVertexSource();
     this->releasePreviousIndexSource();
     fGeoSrcStateStack.pop_back();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 bool GrDrawTarget::checkDraw(GrPrimitiveType type, int startVertex,
                              int startIndex, int vertexCount,
                              int indexCount) const {
     const GrDrawState& drawState = this->getDrawState();
-#if GR_DEBUG
+#ifdef SK_DEBUG
     const GeometrySrcState& geoSrc = fGeoSrcStateStack.back();
     int maxVertex = startVertex + vertexCount;
     int maxValidVertex;
     switch (geoSrc.fVertexSrc) {
         case kNone_GeometrySrcType:
             GrCrash("Attempting to draw without vertex src.");
         case kReserved_GeometrySrcType: // fallthrough
         case kArray_GeometrySrcType:
             maxValidVertex = geoSrc.fVertexCount;
             break;
@@ skipping 55 matching lines @@
         return true;
     }
     GrRenderTarget* rt = this->drawState()->getRenderTarget();
 
     const GrClipData* clip = this->getClip();
     SkIRect copyRect;
     clip->getConservativeBounds(this->getDrawState().getRenderTarget(), &copyRect);
     SkIRect drawIBounds;
     if (info->getDevIBounds(&drawIBounds)) {
         if (!copyRect.intersect(drawIBounds)) {
-#if GR_DEBUG
+#ifdef SK_DEBUG
             GrPrintf("Missed an early reject. Bailing on draw from setupDstReadIfNecessary.\n");
 #endif
             return false;
         }
     } else {
-#if GR_DEBUG
+#ifdef SK_DEBUG
         //GrPrintf("No dev bounds when dst copy is made.\n");
 #endif
     }
 
     // MSAA consideration: When there is support for reading MSAA samples in the shader we could
     // have per-sample dst values by making the copy multisampled.
     GrTextureDesc desc;
     this->initCopySurfaceDstDesc(rt, &desc);
     desc.fWidth = copyRect.width();
     desc.fHeight = copyRect.height();
@@ skipping 545 matching lines @@
     GrPrintf("Geometry Shader Support     : %s\n", gNY[fGeometryShaderSupport]);
     GrPrintf("Dual Source Blending Support: %s\n", gNY[fDualSourceBlendingSupport]);
     GrPrintf("Buffer Lock Support         : %s\n", gNY[fBufferLockSupport]);
     GrPrintf("Path Stenciling Support     : %s\n", gNY[fPathStencilingSupport]);
     GrPrintf("Dst Read In Shader Support  : %s\n", gNY[fDstReadInShaderSupport]);
     GrPrintf("Reuse Scratch Textures      : %s\n", gNY[fReuseScratchTextures]);
     GrPrintf("Max Texture Size            : %d\n", fMaxTextureSize);
     GrPrintf("Max Render Target Size      : %d\n", fMaxRenderTargetSize);
     GrPrintf("Max Sample Count            : %d\n", fMaxSampleCount);
 }