aa rect renderer takes a gpu on construction

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 128 matching lines @@
                                                   MAX_RESOURCE_CACHE_BYTES));
     fResourceCache->setOverbudgetCallback(OverbudgetCB, this);
     fResourceCache2 = SkNEW(GrResourceCache2);
 
     fFontCache = SkNEW_ARGS(GrFontCache, (fGpu));
 
     fLayerCache.reset(SkNEW_ARGS(GrLayerCache, (this)));
 
     fLastDrawWasBuffered = kNo_BufferedDraw;
 
-    fAARectRenderer = SkNEW(GrAARectRenderer);
+    fAARectRenderer = SkNEW_ARGS(GrAARectRenderer, (fGpu));
     fOvalRenderer = SkNEW(GrOvalRenderer);
 
     fDidTestPMConversions = false;
 
     this->setupDrawBuffer();
 
     return true;
 }
 
 GrContext::~GrContext() {
@@ skipping 612 matching lines @@
     bool doAA = needAA && apply_aa_to_rect(target, rect, width, matrix, &devBoundRect);
 
     const SkStrokeRec& strokeRec = strokeInfo->getStrokeRec();
 
     if (doAA) {
         GrDrawState::AutoViewMatrixRestore avmr;
         if (!avmr.setIdentity(target->drawState())) {
             return;
         }
         if (width >= 0) {
-            fAARectRenderer->strokeAARect(this->getGpu(), target, rect,
+            fAARectRenderer->strokeAARect(target, rect,
                                           matrix, devBoundRect,
                                           strokeRec);
         } else {
             // filled AA rect
-            fAARectRenderer->fillAARect(this->getGpu(), target,
+            fAARectRenderer->fillAARect(target,
                                         rect, matrix, devBoundRect);
         }
         return;
     }
 
     if (width >= 0) {
         // TODO: consider making static vertex buffers for these cases.
         // Hairline could be done by just adding closing vertex to
         // unitSquareVertexBuffer()
 
@@ skipping 369 matching lines @@
         // Concave AA paths are expensive - try to avoid them for special cases
         SkRect rects[2];
 
         if (is_nested_rects(target, path, strokeRec, rects)) {
             SkMatrix origViewMatrix = drawState->getViewMatrix();
             GrDrawState::AutoViewMatrixRestore avmr;
             if (!avmr.setIdentity(target->drawState())) {
                 return;
             }
 
-            fAARectRenderer->fillAANestedRects(this->getGpu(), target, rects, origViewMatrix);
+            fAARectRenderer->fillAANestedRects(target, rects, origViewMatrix);
             return;
         }
     }
 
     SkRect ovalRect;
     bool isOval = path.isOval(&ovalRect);
 
     if (!isOval || path.isInverseFillType()
         || !fOvalRenderer->drawOval(target, this, paint.isAntiAlias(), ovalRect, strokeRec)) {
         this->internalDrawPath(target, paint.isAntiAlias(), path, strokeInfo);
@@ skipping 613 matching lines @@
     fResourceCache->printStats();
 }
 #endif
 
 #if GR_GPU_STATS
 const GrContext::GPUStats* GrContext::gpuStats() const {
     return fGpu->gpuStats();
 }
 #endif