remove view matrix from context

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 85 matching lines @@
     fPathRendererChain = NULL;
     fSoftwarePathRenderer = NULL;
     fResourceCache2 = NULL;
     fFontCache = NULL;
     fDrawBuffer = NULL;
     fDrawBufferVBAllocPool = NULL;
     fDrawBufferIBAllocPool = NULL;
     fFlushToReduceCacheSize = false;
     fAARectRenderer = NULL;
     fOvalRenderer = NULL;
-    fViewMatrix.reset();
     fMaxTextureSizeOverride = 1 << 20;
 }
 
 bool GrContext::init(GrBackend backend, GrBackendContext backendContext) {
     SkASSERT(NULL == fGpu);
 
     fGpu = GrGpu::Create(backend, backendContext, this);
     if (NULL == fGpu) {
         return false;
     }
     this->initCommon();
     return true;
 }
 
 void GrContext::initCommon() {
     fResourceCache2 = SkNEW(GrResourceCache2);
     fResourceCache2->setOverBudgetCallback(OverBudgetCB, this);
 
     fFontCache = SkNEW_ARGS(GrFontCache, (fGpu));
 
     fLayerCache.reset(SkNEW_ARGS(GrLayerCache, (this)));
 
     fAARectRenderer = SkNEW_ARGS(GrAARectRenderer, (fGpu));
-    fOvalRenderer = SkNEW(GrOvalRenderer);
+    fOvalRenderer = SkNEW_ARGS(GrOvalRenderer, (fGpu));
 
     fDidTestPMConversions = false;
 
     this->setupDrawBuffer();
 }
 
 GrContext::~GrContext() {
     if (NULL == fGpu) {
         return;
     }
@@ skipping 393 matching lines @@
 
 void GrContext::clear(const SkIRect* rect,
                       const GrColor color,
                       bool canIgnoreRect,
                       GrRenderTarget* renderTarget) {
     ASSERT_OWNED_RESOURCE(renderTarget);
     SkASSERT(renderTarget);
 
     AutoCheckFlush acf(this);
     GR_CREATE_TRACE_MARKER_CONTEXT("GrContext::clear", this);
-    GrDrawTarget* target = this->prepareToDraw(NULL, NULL, &acf);
+    GrDrawTarget* target = this->prepareToDraw(NULL, NULL, NULL, &acf);
     if (NULL == target) {
         return;
     }
     target->clear(rect, color, canIgnoreRect, renderTarget);
 }
 
-void GrContext::drawPaint(const GrPaint& origPaint) {
+void GrContext::drawPaint(const GrPaint& origPaint, const SkMatrix& viewMatrix) {
     // set rect to be big enough to fill the space, but not super-huge, so we
     // don't overflow fixed-point implementations
     SkRect r;
     r.setLTRB(0, 0,
               SkIntToScalar(getRenderTarget()->width()),
               SkIntToScalar(getRenderTarget()->height()));
-    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)) {
+    if (!viewMatrix.hasPerspective()) {
+        SkMatrix inverse;
+        if (!viewMatrix.invert(&inverse)) {
             SkDebugf("Could not invert matrix\n");
             return;
         }
         inverse.mapRect(&r);
     } else {
-        if (!am.setIdentity(this, paint.writable())) {
+        if (!paint.writable()->localCoordChangeInverse(viewMatrix)) {
             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);
+    this->drawRect(*paint, viewMatrix.hasPerspective() ? SkMatrix::I() : viewMatrix, r);
 }
 
 #ifdef SK_DEVELOPER
 void GrContext::dumpFontCache() const {
     fFontCache->dump();
 }
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ skipping 69 matching lines @@
 
     return true;
 }
 
 static inline bool rect_contains_inclusive(const SkRect& rect, const SkPoint& point) {
     return point.fX >= rect.fLeft && point.fX <= rect.fRight &&
            point.fY >= rect.fTop && point.fY <= rect.fBottom;
 }
 
 void GrContext::drawRect(const GrPaint& paint,
+                         const SkMatrix& viewMatrix,
                          const SkRect& rect,
                          const GrStrokeInfo* strokeInfo) {
     if (strokeInfo && strokeInfo->isDashed()) {
         SkPath path;
         path.addRect(rect);
-        this->drawPath(paint, path, *strokeInfo);
+        this->drawPath(paint, viewMatrix, path, *strokeInfo);
         return;
     }
 
     AutoCheckFlush acf(this);
     GrDrawState drawState;
-    GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &acf);
+    GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &viewMatrix, &acf);
     if (NULL == target) {
         return;
     }
 
     GR_CREATE_TRACE_MARKER("GrContext::drawRect", target);
     SkScalar width = NULL == strokeInfo ? -1 : strokeInfo->getStrokeRec().getWidth();
     SkMatrix matrix = drawState.getViewMatrix();
 
     // Check if this is a full RT draw and can be replaced with a clear. We don't bother checking
     // cases where the RT is fully inside a stroke.
@@ skipping 96 matching lines @@
         }
 
         target->drawNonIndexed(&drawState, gp, primType, 0, vertCount);
     } else {
         // filled BW rect
         target->drawSimpleRect(&drawState, color, rect);
     }
 }
 
 void GrContext::drawRectToRect(const GrPaint& paint,
+                               const SkMatrix& viewMatrix,
                                const SkRect& dstRect,
-                               const SkRect& localRect,
-                               const SkMatrix* localMatrix) {
+                               const SkRect& localRect) {
     AutoCheckFlush acf(this);
     GrDrawState drawState;
-    GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &acf);
+    GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &viewMatrix, &acf);
     if (NULL == target) {
         return;
     }
 
     GR_CREATE_TRACE_MARKER("GrContext::drawRectToRect", target);
 
-    target->drawRect(&drawState, paint.getColor(), dstRect, &localRect, localMatrix);
+    target->drawRect(&drawState, paint.getColor(), dstRect, &localRect, NULL);
 }
 
 static const GrGeometryProcessor* set_vertex_attributes(const SkPoint* texCoords,
                                                         const GrColor* colors,
                                                         int* colorOffset,
                                                         int* texOffset,
                                                         GrColor color) {
     *texOffset = -1;
     *colorOffset = -1;
     uint32_t flags = GrDefaultGeoProcFactory::kPosition_GPType;
     if (texCoords && colors) {
         *colorOffset = sizeof(SkPoint);
         *texOffset = sizeof(SkPoint) + sizeof(GrColor);
         flags |= GrDefaultGeoProcFactory::kColor_GPType |
                  GrDefaultGeoProcFactory::kLocalCoord_GPType;
     } else if (texCoords) {
         *texOffset = sizeof(SkPoint);
         flags |= GrDefaultGeoProcFactory::kLocalCoord_GPType;
     } else if (colors) {
         *colorOffset = sizeof(SkPoint);
         flags |= GrDefaultGeoProcFactory::kColor_GPType;
     }
     return GrDefaultGeoProcFactory::Create(color, flags);
 }
 
 void GrContext::drawVertices(const GrPaint& paint,
+                             const SkMatrix& viewMatrix,
                              GrPrimitiveType primitiveType,
                              int vertexCount,
                              const SkPoint positions[],
                              const SkPoint texCoords[],
                              const GrColor colors[],
                              const uint16_t indices[],
                              int indexCount) {
     AutoCheckFlush acf(this);
     GrDrawState drawState;
     GrDrawTarget::AutoReleaseGeometry geo; // must be inside AutoCheckFlush scope
 
-    GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &acf);
+    GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &viewMatrix, &acf);
     if (NULL == target) {
         return;
     }
 
     GR_CREATE_TRACE_MARKER("GrContext::drawVertices", target);
 
     int colorOffset = -1, texOffset = -1;
     SkAutoTUnref<const GrGeometryProcessor> gp(
             set_vertex_attributes(texCoords, colors, &colorOffset, &texOffset, paint.getColor()));
 
@@ skipping 27 matching lines @@
         }
         target->drawIndexed(&drawState, gp, primitiveType, 0, 0, vertexCount, indexCount);
     } else {
         target->drawNonIndexed(&drawState, gp, primitiveType, 0, vertexCount);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrContext::drawRRect(const GrPaint& paint,
+                          const SkMatrix& viewMatrix,
                           const SkRRect& rrect,
                           const GrStrokeInfo& strokeInfo) {
     if (rrect.isEmpty()) {
        return;
     }
 
     if (strokeInfo.isDashed()) {
         SkPath path;
         path.addRRect(rrect);
-        this->drawPath(paint, path, strokeInfo);
+        this->drawPath(paint, viewMatrix, path, strokeInfo);
         return;
     }
 
     AutoCheckFlush acf(this);
     GrDrawState drawState;
-    GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &acf);
+    GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &viewMatrix, &acf);
     if (NULL == target) {
         return;
     }
 
     GR_CREATE_TRACE_MARKER("GrContext::drawRRect", target);
 
     const SkStrokeRec& strokeRec = strokeInfo.getStrokeRec();
 
     GrColor color = paint.getColor();
-    if (!fOvalRenderer->drawRRect(target, &drawState, color, this, paint.isAntiAlias(), rrect,
+    if (!fOvalRenderer->drawRRect(target, &drawState, color, paint.isAntiAlias(), rrect,
                                   strokeRec)) {
         SkPath path;
         path.addRRect(rrect);
-        this->internalDrawPath(target, &drawState, color, paint.isAntiAlias(), path, strokeInfo);
+        this->internalDrawPath(target, &drawState, viewMatrix, color, paint.isAntiAlias(), path,
+                               strokeInfo);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrContext::drawDRRect(const GrPaint& paint,
+                           const SkMatrix& viewMatrix,
                            const SkRRect& outer,
                            const SkRRect& inner) {
     if (outer.isEmpty()) {
        return;
     }
 
     AutoCheckFlush acf(this);
     GrDrawState drawState;
-    GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &acf);
+    GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &viewMatrix, &acf);
 
     GR_CREATE_TRACE_MARKER("GrContext::drawDRRect", target);
 
     GrColor color = paint.getColor();
-    if (!fOvalRenderer->drawDRRect(target, &drawState, color, this, paint.isAntiAlias(), outer,
-                                   inner)) {
+    if (!fOvalRenderer->drawDRRect(target, &drawState, color, paint.isAntiAlias(), outer, inner)) {
         SkPath path;
         path.addRRect(inner);
         path.addRRect(outer);
         path.setFillType(SkPath::kEvenOdd_FillType);
 
         GrStrokeInfo fillRec(SkStrokeRec::kFill_InitStyle);
-        this->internalDrawPath(target, &drawState, color, paint.isAntiAlias(), path, fillRec);
+        this->internalDrawPath(target, &drawState, viewMatrix, color, paint.isAntiAlias(), path,
+                               fillRec);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrContext::drawOval(const GrPaint& paint,
+                         const SkMatrix& viewMatrix,
                          const SkRect& oval,
                          const GrStrokeInfo& strokeInfo) {
     if (oval.isEmpty()) {
        return;
     }
 
     if (strokeInfo.isDashed()) {
         SkPath path;
         path.addOval(oval);
-        this->drawPath(paint, path, strokeInfo);
+        this->drawPath(paint, viewMatrix, path, strokeInfo);
         return;
     }
 
     AutoCheckFlush acf(this);
     GrDrawState drawState;
-    GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &acf);
+    GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &viewMatrix, &acf);
     if (NULL == target) {
         return;
     }
 
     GR_CREATE_TRACE_MARKER("GrContext::drawOval", target);
 
     const SkStrokeRec& strokeRec = strokeInfo.getStrokeRec();
 
     GrColor color = paint.getColor();
-    if (!fOvalRenderer->drawOval(target, &drawState, color, this, paint.isAntiAlias(), oval,
-                                 strokeRec)) {
+    if (!fOvalRenderer->drawOval(target, &drawState, color, paint.isAntiAlias(), oval, strokeRec)) {
         SkPath path;
         path.addOval(oval);
-        this->internalDrawPath(target, &drawState, color, paint.isAntiAlias(), path, strokeInfo);
+        this->internalDrawPath(target, &drawState, viewMatrix, color, paint.isAntiAlias(), path,
+                               strokeInfo);
     }
 }
 
 // Can 'path' be drawn as a pair of filled nested rectangles?
 static bool is_nested_rects(GrDrawTarget* target,
                             GrDrawState* drawState,
                             GrColor color,
                             const SkPath& path,
                             const SkStrokeRec& stroke,
                             SkRect rects[2]) {
@@ skipping 40 matching lines @@
             allGoE1 = false;
         }
         if (!SkScalarNearlyEqual(margin, temp)) {
             allEq = false;
         }
     }
 
     return allEq || allGoE1;
 }
 
-void GrContext::drawPath(const GrPaint& paint, const SkPath& path, const GrStrokeInfo& strokeInfo) {
+void GrContext::drawPath(const GrPaint& paint,
+                         const SkMatrix& viewMatrix,
+                         const SkPath& path,
+                         const GrStrokeInfo& strokeInfo) {
 
     if (path.isEmpty()) {
        if (path.isInverseFillType()) {
-           this->drawPaint(paint);
+           this->drawPaint(paint, viewMatrix);
        }
        return;
     }
 
     GrColor color = paint.getColor();
     if (strokeInfo.isDashed()) {
         SkPoint pts[2];
         if (path.isLine(pts)) {
             AutoCheckFlush acf(this);
             GrDrawState drawState;
-            GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &acf);
+            GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &viewMatrix, &acf);
             if (NULL == target) {
                 return;
             };
 
             SkMatrix origViewMatrix = drawState.getViewMatrix();
             GrDrawState::AutoViewMatrixRestore avmr;
             if (avmr.setIdentity(&drawState)) {
                 if (GrDashingEffect::DrawDashLine(fGpu, target, &drawState, color, pts, paint,
                                                   strokeInfo, origViewMatrix)) {
                     return;
                 }
             }
         }
 
         // Filter dashed path into new path with the dashing applied
         const SkPathEffect::DashInfo& info = strokeInfo.getDashInfo();
         SkTLazy<SkPath> effectPath;
         GrStrokeInfo newStrokeInfo(strokeInfo, false);
         SkStrokeRec* stroke = newStrokeInfo.getStrokeRecPtr();
         if (SkDashPath::FilterDashPath(effectPath.init(), path, stroke, NULL, info)) {
-            this->drawPath(paint, *effectPath.get(), newStrokeInfo);
+            this->drawPath(paint, viewMatrix, *effectPath.get(), newStrokeInfo);
             return;
         }
 
-        this->drawPath(paint, path, newStrokeInfo);
+        this->drawPath(paint, viewMatrix, path, newStrokeInfo);
         return;
     }
 
     // Note that internalDrawPath may sw-rasterize the path into a scratch texture.
     // Scratch textures can be recycled after they are returned to the texture
     // cache. This presents a potential hazard for buffered drawing. However,
     // the writePixels that uploads to the scratch will perform a flush so we're
     // OK.
     AutoCheckFlush acf(this);
     GrDrawState drawState;
-    GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &acf);
+    GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &viewMatrix, &acf);
     if (NULL == target) {
         return;
     }
 
     GR_CREATE_TRACE_MARKER1("GrContext::drawPath", target, "Is Convex", path.isConvex());
 
     const SkStrokeRec& strokeRec = strokeInfo.getStrokeRec();
 
     bool useCoverageAA = paint.isAntiAlias() && !drawState.getRenderTarget()->isMultisampled();
 
@@ skipping 10 matching lines @@
 
             fAARectRenderer->fillAANestedRects(target, &drawState, color, rects, origViewMatrix);
             return;
         }
     }
 
     SkRect ovalRect;
     bool isOval = path.isOval(&ovalRect);
 
     if (!isOval || path.isInverseFillType()
-        || !fOvalRenderer->drawOval(target, &drawState, color, this, paint.isAntiAlias(), ovalRect,
+        || !fOvalRenderer->drawOval(target, &drawState, color, paint.isAntiAlias(), ovalRect,
                                     strokeRec)) {
-        this->internalDrawPath(target, &drawState, color, paint.isAntiAlias(), path, strokeInfo);
+        this->internalDrawPath(target, &drawState, viewMatrix, color, paint.isAntiAlias(), path,
+                               strokeInfo);
     }
 }
 
 void GrContext::internalDrawPath(GrDrawTarget* target,
                                  GrDrawState* drawState,
+                                 const SkMatrix& viewMatrix,
                                  GrColor color,
                                  bool useAA,
                                  const SkPath& path,
                                  const GrStrokeInfo& strokeInfo) {
     SkASSERT(!path.isEmpty());
 
     GR_CREATE_TRACE_MARKER("GrContext::internalDrawPath", target);
 
 
     // An Assumption here is that path renderer would use some form of tweaking
@@ skipping 10 matching lines @@
                         GrPathRendererChain::kColor_DrawType;
 
     const SkPath* pathPtr = &path;
     SkTLazy<SkPath> tmpPath;
     SkTCopyOnFirstWrite<SkStrokeRec> stroke(strokeInfo.getStrokeRec());
 
     // Try a 1st time without stroking the path and without allowing the SW renderer
     GrPathRenderer* pr = this->getPathRenderer(target, drawState, *pathPtr, *stroke, false, type);
 
     if (NULL == pr) {
-        if (!GrPathRenderer::IsStrokeHairlineOrEquivalent(*stroke, this->getMatrix(), NULL)) {
+        if (!GrPathRenderer::IsStrokeHairlineOrEquivalent(*stroke, viewMatrix, NULL)) {
             // It didn't work the 1st time, so try again with the stroked path
             if (stroke->applyToPath(tmpPath.init(), *pathPtr)) {
                 pathPtr = tmpPath.get();
                 stroke.writable()->setFillStyle();
                 if (pathPtr->isEmpty()) {
                     return;
                 }
             }
         }
 
@@ skipping 136 matching lines @@
     }
 
     SkMatrix matrix;
     matrix.setTranslate(SkIntToScalar(left), SkIntToScalar(top));
 
     // This function can be called in the midst of drawing another object (e.g., when uploading a
     // SW-rasterized clip while issuing a draw). So we push the current geometry state before
     // drawing a rect to the render target.
     // The bracket ensures we pop the stack if we wind up flushing below.
     {
-        GrDrawTarget* drawTarget = this->prepareToDraw(NULL, NULL, NULL);
+        GrDrawTarget* drawTarget = this->prepareToDraw(NULL, NULL, NULL, NULL);
         GrDrawTarget::AutoGeometryPush agp(drawTarget);
 
         GrDrawState drawState(matrix);
         drawState.addColorProcessor(fp);
         drawState.setRenderTarget(renderTarget);
         drawTarget->drawSimpleRect(&drawState, GrColor_WHITE,SkRect::MakeWH(SkIntToScalar(width),
                                                                             SkIntToScalar(height)));
     }
 
     if (kFlushWrites_PixelOp & pixelOpsFlags) {
@@ skipping 160 matching lines @@
     GrRenderTarget* rt = surface->asRenderTarget();
     if (fGpu && rt) {
         fGpu->resolveRenderTarget(rt);
     }
 }
 
 void GrContext::discardRenderTarget(GrRenderTarget* renderTarget) {
     SkASSERT(renderTarget);
     ASSERT_OWNED_RESOURCE(renderTarget);
     AutoCheckFlush acf(this);
-    GrDrawTarget* target = this->prepareToDraw(NULL, NULL, &acf);
+    GrDrawTarget* target = this->prepareToDraw(NULL, NULL, NULL, &acf);
     if (NULL == target) {
         return;
     }
     target->discard(renderTarget);
 }
 
 void GrContext::copySurface(GrSurface* dst, GrSurface* src, const SkIRect& srcRect,
                             const SkIPoint& dstPoint, uint32_t pixelOpsFlags) {
     if (NULL == src || NULL == dst) {
         return;
     }
     ASSERT_OWNED_RESOURCE(src);
     ASSERT_OWNED_RESOURCE(dst);
 
     // Since we're going to the draw target and not GPU, no need to check kNoFlush
     // here.
 
-    GrDrawTarget* target = this->prepareToDraw(NULL, NULL, NULL);
+    GrDrawTarget* target = this->prepareToDraw(NULL, NULL, NULL, NULL);
     if (NULL == target) {
         return;
     }
     target->copySurface(dst, src, srcRect, dstPoint);
 
     if (kFlushWrites_PixelOp & pixelOpsFlags) {
         this->flush();
     }
 }
 
 void GrContext::flushSurfaceWrites(GrSurface* surface) {
     if (surface->surfacePriv().hasPendingWrite()) {
         this->flush();
     }
 }
 
 GrDrawTarget* GrContext::prepareToDraw(GrDrawState* ds,
                                        const GrPaint* paint,
+                                       const SkMatrix* viewMatrix,
                                        const AutoCheckFlush* acf) {
     if (NULL == fGpu) {
         return NULL;
     }
 
     ASSERT_OWNED_RESOURCE(fRenderTarget.get());
     if (ds) {
+        SkASSERT(viewMatrix);
         if (paint) {
             SkASSERT(acf);
-            ds->setFromPaint(*paint, fViewMatrix, fRenderTarget.get());
+            ds->setFromPaint(*paint, *viewMatrix, fRenderTarget.get());
 #if GR_DEBUG_PARTIAL_COVERAGE_CHECK
             if ((paint->hasMask()) &&
                 !fDrawState->canUseFracCoveragePrimProc(paint.getColor(), fGpu->caps())) {
                 SkDebugf("Partial pixel coverage will be incorrectly blended.\n");
             }
 #endif
         } else {
-            ds->reset(fViewMatrix);
+            ds->reset(*viewMatrix);
             ds->setRenderTarget(fRenderTarget.get());
         }
         ds->setState(GrDrawState::kClip_StateBit, fClip && !fClip->fClipStack->isWideOpen());
     }
     fDrawBuffer->setClip(fClip);
     return fDrawBuffer;
 }
 
 /*
  * This method finds a path renderer that can draw the specified path on
@@ skipping 65 matching lines @@
         SkNEW_ARGS(GrIndexBufferAllocPool, (fGpu, false,
                                    DRAW_BUFFER_IBPOOL_BUFFER_SIZE,
                                    DRAW_BUFFER_IBPOOL_PREALLOC_BUFFERS));
 
     fDrawBuffer = SkNEW_ARGS(GrInOrderDrawBuffer, (fGpu,
                                                    fDrawBufferVBAllocPool,
                                                    fDrawBufferIBAllocPool));
 }
 
 GrDrawTarget* GrContext::getTextTarget() {
-    return this->prepareToDraw(NULL, NULL, NULL);
+    return this->prepareToDraw(NULL, NULL, NULL, NULL);
 }
 
 const GrIndexBuffer* GrContext::getQuadIndexBuffer() const {
     return fGpu->getQuadIndexBuffer();
 }
 
 namespace {
 void test_pm_conversions(GrContext* ctx, int* pmToUPMValue, int* upmToPMValue) {
     GrConfigConversionEffect::PMConversion pmToUPM;
     GrConfigConversionEffect::PMConversion upmToPM;
@@ skipping 63 matching lines @@
     fResourceCache2->printStats();
 }
 #endif
 
 #if GR_GPU_STATS
 const GrContext::GPUStats* GrContext::gpuStats() const {
     return fGpu->gpuStats();
 }
 #endif