Cleanup: Go with SkDebugf instead of GrPrintf.

src/gpu/GrContext.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 "GrContext.h"
 
@@ skipping 595 matching lines @@
     SkMatrix inverse;
     SkTCopyOnFirstWrite<GrPaint> paint(origPaint);
     AutoMatrix am;
     GR_CREATE_TRACE_MARKER_CONTEXT("GrContext::drawPaint", this);
 
     // We attempt to map r by the inverse matrix and draw that. mapRect will
     // map the four corners and bound them with a new rect. This will not
     // produce a correct result for some perspective matrices.
     if (!this->getMatrix().hasPerspective()) {
         if (!fViewMatrix.invert(&inverse)) {
-            GrPrintf("Could not invert matrix\n");
+            SkDebugf("Could not invert matrix\n");
             return;
         }
         inverse.mapRect(&r);
     } else {
         if (!am.setIdentity(this, paint.writable())) {
-            GrPrintf("Could not invert matrix\n");
+            SkDebugf("Could not invert matrix\n");
             return;
         }
     }
     // by definition this fills the entire clip, no need for AA
     if (paint->isAntiAlias()) {
         paint.writable()->setAntiAlias(false);
     }
     this->drawRect(*paint, r);
 }
 
@@ skipping 21 matching lines @@
     verts[3].set(rect.fRight + rad, rect.fTop - rad);
     verts[4].set(rect.fRight - rad, rect.fBottom - rad);
     verts[5].set(rect.fRight + rad, rect.fBottom + rad);
     verts[6].set(rect.fLeft + rad, rect.fBottom - rad);
     verts[7].set(rect.fLeft - rad, rect.fBottom + rad);
     verts[8] = verts[0];
     verts[9] = verts[1];
 }
 
 static inline bool is_irect(const SkRect& r) {
-  return SkScalarIsInt(r.fLeft)  && SkScalarIsInt(r.fTop) &&    
-         SkScalarIsInt(r.fRight) && SkScalarIsInt(r.fBottom);   
+  return SkScalarIsInt(r.fLeft)  && SkScalarIsInt(r.fTop) &&
+         SkScalarIsInt(r.fRight) && SkScalarIsInt(r.fBottom);
 }
 
 static bool apply_aa_to_rect(GrDrawTarget* target,
                              const SkRect& rect,
                              SkScalar strokeWidth,
                              const SkMatrix& combinedMatrix,
                              SkRect* devBoundRect) {
     if (!target->getDrawState().canTweakAlphaForCoverage() &&
         target->shouldDisableCoverageAAForBlend()) {
 #ifdef SK_DEBUG
-        //GrPrintf("Turning off AA to correctly apply blend.\n");
+        //SkDebugf("Turning off AA to correctly apply blend.\n");
 #endif
         return false;
     }
     const GrDrawState& drawState = target->getDrawState();
     if (drawState.getRenderTarget()->isMultisampled()) {
         return false;
     }
 
 #if defined(SHADER_AA_FILL_RECT) || !defined(IGNORE_ROT_AA_RECT_OPT)
     if (strokeWidth >= 0) {
@@ skipping 106 matching lines @@
     if (width >= 0) {
         // TODO: consider making static vertex buffers for these cases.
         // Hairline could be done by just adding closing vertex to
         // unitSquareVertexBuffer()
 
         static const int worstCaseVertCount = 10;
         target->drawState()->setDefaultVertexAttribs();
         GrDrawTarget::AutoReleaseGeometry geo(target, worstCaseVertCount, 0);
 
         if (!geo.succeeded()) {
-            GrPrintf("Failed to get space for vertices!\n");
+            SkDebugf("Failed to get space for vertices!\n");
             return;
         }
 
         GrPrimitiveType primType;
         int vertCount;
         SkPoint* vertex = geo.positions();
 
         if (width > 0) {
             vertCount = 10;
             primType = kTriangleStrip_GrPrimitiveType;
@@ skipping 95 matching lines @@
     GrDrawState* drawState = target->drawState();
 
     GR_CREATE_TRACE_MARKER("GrContext::drawVertices", target);
 
     int colorOffset = -1, texOffset = -1;
     set_vertex_attributes(drawState, texCoords, colors, &colorOffset, &texOffset);
 
     size_t VertexStride = drawState->getVertexStride();
     if (sizeof(SkPoint) != VertexStride) {
         if (!geo.set(target, vertexCount, 0)) {
-            GrPrintf("Failed to get space for vertices!\n");
+            SkDebugf("Failed to get space for vertices!\n");
             return;
         }
         void* curVertex = geo.vertices();
 
         for (int i = 0; i < vertexCount; ++i) {
             *((SkPoint*)curVertex) = positions[i];
 
             if (texOffset >= 0) {
                 *(SkPoint*)((intptr_t)curVertex + texOffset) = texCoords[i];
             }
@@ skipping 296 matching lines @@
                 }
             }
         }
 
         // This time, allow SW renderer
         pr = this->getPathRenderer(*pathPtr, *stroke, target, true, type);
     }
 
     if (NULL == pr) {
 #ifdef SK_DEBUG
-        GrPrintf("Unable to find path renderer compatible with path.\n");
+        SkDebugf("Unable to find path renderer compatible with path.\n");
 #endif
         return;
     }
 
     pr->drawPath(*pathPtr, *stroke, target, useCoverageAA);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrContext::flush(int flagsBitfield) {
@@ skipping 365 matching lines @@
     }
     ASSERT_OWNED_RESOURCE(fRenderTarget.get());
     if (paint) {
         SkASSERT(are);
         SkASSERT(acf);
         are->set(fDrawState);
         fDrawState->setFromPaint(*paint, fViewMatrix, fRenderTarget.get());
 #if GR_DEBUG_PARTIAL_COVERAGE_CHECK
         if ((paint->hasMask() || 0xff != paint->fCoverage) &&
             !fDrawState->couldApplyCoverage(fGpu->caps())) {
-            GrPrintf("Partial pixel coverage will be incorrectly blended.\n");
+            SkDebugf("Partial pixel coverage will be incorrectly blended.\n");
         }
 #endif
         // Clear any vertex attributes configured for the previous use of the
         // GrDrawState which can effect which blend optimizations are in effect.
         fDrawState->setDefaultVertexAttribs();
     } else {
         fDrawState->reset(fViewMatrix);
         fDrawState->setRenderTarget(fRenderTarget.get());
     }
     GrDrawTarget* target;
@@ skipping 168 matching lines @@
     fResourceCache->printStats();
 }
 #endif
 
 #if GR_GPU_STATS
 const GrContext::GPUStats* GrContext::gpuStats() const {
     return fGpu->gpuStats();
 }
 #endif