Replace uses of GR_DEBUG by SK_DEBUG.

src/gpu/GrGpu.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 "GrGpu.h"
@@ skipping 22 matching lines @@
     , fResetBits(kAll_GrBackendState)
     , fVertexPool(NULL)
     , fIndexPool(NULL)
     , fVertexPoolUseCnt(0)
     , fIndexPoolUseCnt(0)
     , fQuadIndexBuffer(NULL) {
 
     fClipMaskManager.setGpu(this);
 
     fGeomPoolStateStack.push_back();
-#if GR_DEBUG
+#if SK_DEBUG
     GeometryPoolState& poolState = fGeomPoolStateStack.back();
     poolState.fPoolVertexBuffer = (GrVertexBuffer*)DEBUG_INVAL_BUFFER;
     poolState.fPoolStartVertex = DEBUG_INVAL_START_IDX;
     poolState.fPoolIndexBuffer = (GrIndexBuffer*)DEBUG_INVAL_BUFFER;
     poolState.fPoolStartIndex = DEBUG_INVAL_START_IDX;
 #endif
 
     for (int i = 0; i < kGrPixelConfigCnt; ++i) {
         fConfigRenderSupport[i] = false;
     };
@@ skipping 44 matching lines @@
 
 void GrGpu::removeResource(GrResource* resource) {
     SkASSERT(NULL != resource);
     SkASSERT(this == resource->getGpu());
 
     fResourceList.remove(resource);
 }
 
 
 void GrGpu::unimpl(const char msg[]) {
-#if GR_DEBUG
+#if SK_DEBUG
     GrPrintf("--- GrGpu unimplemented(\"%s\")\n", msg);
 #endif
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 GrTexture* GrGpu::createTexture(const GrTextureDesc& desc,
                                 const void* srcData, size_t rowBytes) {
     if (kUnknown_GrPixelConfig == desc.fConfig) {
         return NULL;
@@ skipping 193 matching lines @@
     const GeometrySrcState& geoSrc = this->getGeomSrc();
     if (kArray_GeometrySrcType == geoSrc.fVertexSrc ||
         kReserved_GeometrySrcType == geoSrc.fVertexSrc) {
         this->finalizeReservedVertices();
     }
     if (kArray_GeometrySrcType == geoSrc.fIndexSrc ||
         kReserved_GeometrySrcType == geoSrc.fIndexSrc) {
         this->finalizeReservedIndices();
     }
     GeometryPoolState& newState = fGeomPoolStateStack.push_back();
-#if GR_DEBUG
+#if SK_DEBUG
     newState.fPoolVertexBuffer = (GrVertexBuffer*)DEBUG_INVAL_BUFFER;
     newState.fPoolStartVertex = DEBUG_INVAL_START_IDX;
     newState.fPoolIndexBuffer = (GrIndexBuffer*)DEBUG_INVAL_BUFFER;
     newState.fPoolStartIndex = DEBUG_INVAL_START_IDX;
 #else
     (void) newState; // silence compiler warning
 #endif
 }
 
 void GrGpu::geometrySourceWillPop(const GeometrySrcState& restoredState) {
@@ skipping 115 matching lines @@
     const GeometrySrcState& geoSrc = this->getGeomSrc();
     SkASSERT(kReserved_GeometrySrcType == geoSrc.fIndexSrc);
     size_t bytes = geoSrc.fIndexCount * sizeof(uint16_t);
     fIndexPool->putBack(bytes);
     --fIndexPoolUseCnt;
 }
 
 void GrGpu::onSetVertexSourceToArray(const void* vertexArray, int vertexCount) {
     this->prepareVertexPool();
     GeometryPoolState& geomPoolState = fGeomPoolStateStack.back();
-#if GR_DEBUG
+#if SK_DEBUG
     bool success =
 #endif
     fVertexPool->appendVertices(this->getVertexSize(),
                                 vertexCount,
                                 vertexArray,
                                 &geomPoolState.fPoolVertexBuffer,
                                 &geomPoolState.fPoolStartVertex);
     ++fVertexPoolUseCnt;
     GR_DEBUGASSERT(success);
 }
 
 void GrGpu::onSetIndexSourceToArray(const void* indexArray, int indexCount) {
     this->prepareIndexPool();
     GeometryPoolState& geomPoolState = fGeomPoolStateStack.back();
-#if GR_DEBUG
+#if SK_DEBUG
     bool success =
 #endif
     fIndexPool->appendIndices(indexCount,
                               indexArray,
                               &geomPoolState.fPoolIndexBuffer,
                               &geomPoolState.fPoolStartIndex);
     ++fIndexPoolUseCnt;
     GR_DEBUGASSERT(success);
 }
 
 void GrGpu::releaseVertexArray() {
     // if vertex source was array, we stowed data in the pool
     const GeometrySrcState& geoSrc = this->getGeomSrc();
     SkASSERT(kArray_GeometrySrcType == geoSrc.fVertexSrc);
     size_t bytes = geoSrc.fVertexCount * geoSrc.fVertexSize;
     fVertexPool->putBack(bytes);
     --fVertexPoolUseCnt;
 }
 
 void GrGpu::releaseIndexArray() {
     // if index source was array, we stowed data in the pool
     const GeometrySrcState& geoSrc = this->getGeomSrc();
     SkASSERT(kArray_GeometrySrcType == geoSrc.fIndexSrc);
     size_t bytes = geoSrc.fIndexCount * sizeof(uint16_t);
     fIndexPool->putBack(bytes);
     --fIndexPoolUseCnt;
 }