Replace uses of GR_DEBUGCODE by SkDEBUGCODE.

src/gpu/GrDrawState.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrDrawState_DEFINED
 #define GrDrawState_DEFINED
 
@@ skipping 12 matching lines @@
 #include "effects/GrSimpleTextureEffect.h"
 
 #include "SkMatrix.h"
 #include "SkXfermode.h"
 
 class GrDrawState : public GrRefCnt {
 public:
     SK_DECLARE_INST_COUNT(GrDrawState)
 
     GrDrawState() {
-        GR_DEBUGCODE(fBlockEffectRemovalCnt = 0;)
+        SkDEBUGCODE(fBlockEffectRemovalCnt = 0;)
         this->reset();
     }
 
     GrDrawState(const SkMatrix& initialViewMatrix) {
-        GR_DEBUGCODE(fBlockEffectRemovalCnt = 0;)
+        SkDEBUGCODE(fBlockEffectRemovalCnt = 0;)
         this->reset(initialViewMatrix);
     }
 
     /**
      * Copies another draw state.
      **/
     GrDrawState(const GrDrawState& state) : INHERITED() {
-        GR_DEBUGCODE(fBlockEffectRemovalCnt = 0;)
+        SkDEBUGCODE(fBlockEffectRemovalCnt = 0;)
         *this = state;
     }
 
     /**
      * Copies another draw state with a preconcat to the view matrix.
      **/
     GrDrawState(const GrDrawState& state, const SkMatrix& preConcatMatrix) {
-        GR_DEBUGCODE(fBlockEffectRemovalCnt = 0;)
+        SkDEBUGCODE(fBlockEffectRemovalCnt = 0;)
         *this = state;
         if (!preConcatMatrix.isIdentity()) {
             for (int i = 0; i < fColorStages.count(); ++i) {
                 fColorStages[i].localCoordChange(preConcatMatrix);
             }
             for (int i = 0; i < fCoverageStages.count(); ++i) {
                 fCoverageStages[i].localCoordChange(preConcatMatrix);
             }
         }
     }
@@ skipping 347 matching lines @@
         ~AutoRestoreEffects() { this->set(NULL); }
 
         void set(GrDrawState* ds) {
             if (NULL != fDrawState) {
                 int n = fDrawState->fColorStages.count() - fColorEffectCnt;
                 SkASSERT(n >= 0);
                 fDrawState->fColorStages.pop_back_n(n);
                 n = fDrawState->fCoverageStages.count() - fCoverageEffectCnt;
                 SkASSERT(n >= 0);
                 fDrawState->fCoverageStages.pop_back_n(n);
-                GR_DEBUGCODE(--fDrawState->fBlockEffectRemovalCnt;)
+                SkDEBUGCODE(--fDrawState->fBlockEffectRemovalCnt;)
             }
             fDrawState = ds;
             if (NULL != ds) {
                 fColorEffectCnt = ds->fColorStages.count();
                 fCoverageEffectCnt = ds->fCoverageStages.count();
-                GR_DEBUGCODE(++ds->fBlockEffectRemovalCnt;)
+                SkDEBUGCODE(++ds->fBlockEffectRemovalCnt;)
             }
         }
 
     private:
         GrDrawState* fDrawState;
         int fColorEffectCnt;
         int fCoverageEffectCnt;
     };
 
     int numColorStages() const { return fColorStages.count(); }
@@ skipping 535 matching lines @@
 public:
     /**
      * DeferredState contains all of the data of a GrDrawState but does not hold refs on GrResource
      * objects. Resources are allowed to hit zero ref count while in DeferredStates. Their internal
      * dispose mechanism returns them to the cache. This allows recycling resources through the
      * the cache while they are in a deferred draw queue.
      */
     class DeferredState {
     public:
         DeferredState() : fRenderTarget(NULL) {
-            GR_DEBUGCODE(fInitialized = false;)
+            SkDEBUGCODE(fInitialized = false;)
         }
         // TODO: Remove this when DeferredState no longer holds a ref to the RT
         ~DeferredState() { SkSafeUnref(fRenderTarget); }
 
         void saveFrom(const GrDrawState& drawState) {
             fCommon = drawState.fCommon;
             // TODO: Here we will copy the GrRenderTarget pointer without taking a ref.
             fRenderTarget = drawState.fRenderTarget.get();
             SkSafeRef(fRenderTarget);
             // Here we ref the effects directly rather than the effect-refs. TODO: When the effect-
             // ref gets fully unref'ed it will cause the underlying effect to unref its resources
             // and recycle them to the cache (if no one else is holding a ref to the resources).
             fStages.reset(drawState.fColorStages.count() + drawState.fCoverageStages.count());
             fColorStageCnt = drawState.fColorStages.count();
             for (int i = 0; i < fColorStageCnt; ++i) {
                 fStages[i].saveFrom(drawState.fColorStages[i]);
             }
             for (int i = 0; i < drawState.fCoverageStages.count(); ++i) {
                 fStages[i + fColorStageCnt].saveFrom(drawState.fCoverageStages[i]);
             }
-            GR_DEBUGCODE(fInitialized = true;)
+            SkDEBUGCODE(fInitialized = true;)
         }
 
         void restoreTo(GrDrawState* drawState) {
             SkASSERT(fInitialized);
             drawState->fCommon = fCommon;
             drawState->setRenderTarget(fRenderTarget);
             // reinflate color/cov stage arrays.
             drawState->fColorStages.reset();
             for (int i = 0; i < fColorStageCnt; ++i) {
                 SkNEW_APPEND_TO_TARRAY(&drawState->fColorStages, GrEffectStage, (fStages[i]));
@@ skipping 30 matching lines @@
         }
 
     private:
         typedef SkAutoSTArray<8, GrEffectStage::DeferredStage> DeferredStageArray;
 
         GrRenderTarget*                       fRenderTarget;
         CommonState                           fCommon;
         int                                   fColorStageCnt;
         DeferredStageArray                    fStages;
 
-        GR_DEBUGCODE(bool fInitialized;)
+        SkDEBUGCODE(bool fInitialized;)
     };
 
 private:
 
     SkAutoTUnref<GrRenderTarget>        fRenderTarget;
     CommonState                         fCommon;
 
     typedef SkSTArray<4, GrEffectStage> EffectStageArray;
     EffectStageArray                    fColorStages;
     EffectStageArray                    fCoverageStages;
 
     // Some of the auto restore objects assume that no effects are removed during their lifetime.
     // This is used to assert that this condition holds.
-    GR_DEBUGCODE(int fBlockEffectRemovalCnt;)
+    SkDEBUGCODE(int fBlockEffectRemovalCnt;)
 
     /**
      *  Sets vertex attributes for next draw.
      *
      *  @param attribs    the array of vertex attributes to set.
      *  @param count      the number of attributes being set, limited to kMaxVertexAttribCnt.
      */
     void setVertexAttribs(const GrVertexAttrib attribs[], int count);
 
     typedef GrRefCnt INHERITED;
 };
 
 GR_MAKE_BITFIELD_OPS(GrDrawState::BlendOptFlags);
 
 #endif