aa rect renderer takes a gpu on construction

BUG=skia:

Review URL: https://codereview.chromium.org/683483004

4 files changed, 49 insertions, 62 deletions

diff --git a/src/gpu/GrAARectRenderer.cpp b/src/gpu/GrAARectRenderer.cpp
index 18bba5a1b8..d4aad406c6 100644
--- a/src/gpu/GrAARectRenderer.cpp
+++ b/src/gpu/GrAARectRenderer.cpp
@@ -391,35 +391,34 @@ static const int kIndicesPerBevelStrokeRect = SK_ARRAY_COUNT(gBevelStrokeAARectI
 static const int kVertsPerBevelStrokeRect = 24;
 static const int kNumBevelStrokeRectsInIndexBuffer = 256;
 
-int GrAARectRenderer::aaStrokeRectIndexCount(bool miterStroke) {
+static int aa_stroke_rect_index_count(bool miterStroke) {
     return miterStroke ? SK_ARRAY_COUNT(gMiterStrokeAARectIdx) :
                          SK_ARRAY_COUNT(gBevelStrokeAARectIdx);
 }
 
-GrIndexBuffer* GrAARectRenderer::aaStrokeRectIndexBuffer(GrGpu* gpu, bool miterStroke) {
+GrIndexBuffer* GrAARectRenderer::aaStrokeRectIndexBuffer(bool miterStroke) {
     if (miterStroke) {
         if (NULL == fAAMiterStrokeRectIndexBuffer) {
             fAAMiterStrokeRectIndexBuffer =
-                    gpu->createInstancedIndexBuffer(gMiterStrokeAARectIdx,
-                                                    kIndicesPerMiterStrokeRect,
-                                                    kNumMiterStrokeRectsInIndexBuffer,
-                                                    kVertsPerMiterStrokeRect);
+                    fGpu->createInstancedIndexBuffer(gMiterStrokeAARectIdx,
+                                                     kIndicesPerMiterStrokeRect,
+                                                     kNumMiterStrokeRectsInIndexBuffer,
+                                                     kVertsPerMiterStrokeRect);
         }
         return fAAMiterStrokeRectIndexBuffer;
     } else {
         if (NULL == fAABevelStrokeRectIndexBuffer) {
             fAABevelStrokeRectIndexBuffer =
-                    gpu->createInstancedIndexBuffer(gBevelStrokeAARectIdx,
-                                                    kIndicesPerBevelStrokeRect,
-                                                    kNumBevelStrokeRectsInIndexBuffer,
-                                                    kVertsPerBevelStrokeRect);
+                    fGpu->createInstancedIndexBuffer(gBevelStrokeAARectIdx,
+                                                     kIndicesPerBevelStrokeRect,
+                                                     kNumBevelStrokeRectsInIndexBuffer,
+                                                     kVertsPerBevelStrokeRect);
         }
         return fAABevelStrokeRectIndexBuffer;
     }
 }
 
-void GrAARectRenderer::geometryFillAARect(GrGpu* gpu,
-                                          GrDrawTarget* target,
+void GrAARectRenderer::geometryFillAARect(GrDrawTarget* target,
                                           const SkRect& rect,
                                           const SkMatrix& combinedMatrix,
                                           const SkRect& devRect) {
@@ -439,10 +438,10 @@ void GrAARectRenderer::geometryFillAARect(GrGpu* gpu,
     }
 
     if (NULL == fAAFillRectIndexBuffer) {
-        fAAFillRectIndexBuffer = gpu->createInstancedIndexBuffer(gFillAARectIdx,
-                                                                 kIndicesPerAAFillRect,
-                                                                 kNumAAFillRectsInIndexBuffer,
-                                                                 kVertsPerAAFillRect);
+        fAAFillRectIndexBuffer = fGpu->createInstancedIndexBuffer(gFillAARectIdx,
+                                                                  kIndicesPerAAFillRect,
+                                                                  kNumAAFillRectsInIndexBuffer,
+                                                                  kVertsPerAAFillRect);
     }
     GrIndexBuffer* indexBuffer = fAAFillRectIndexBuffer;
     if (NULL == indexBuffer) {
@@ -582,8 +581,7 @@ extern const GrVertexAttrib gAAAARectVertexAttribs[] = {
 
 };
 
-void GrAARectRenderer::shaderFillAARect(GrGpu* gpu,
-                                        GrDrawTarget* target,
+void GrAARectRenderer::shaderFillAARect(GrDrawTarget* target,
                                         const SkRect& rect,
                                         const SkMatrix& combinedMatrix) {
     GrDrawState* drawState = target->drawState();
@@ -639,13 +637,12 @@ void GrAARectRenderer::shaderFillAARect(GrGpu* gpu,
     verts[2].fPos = SkPoint::Make(devBounds.fRight, devBounds.fBottom);
     verts[3].fPos = SkPoint::Make(devBounds.fRight, devBounds.fTop);
 
-    target->setIndexSourceToBuffer(gpu->getContext()->getQuadIndexBuffer());
+    target->setIndexSourceToBuffer(fGpu->getContext()->getQuadIndexBuffer());
     target->drawIndexedInstances(kTriangles_GrPrimitiveType, 1, 4, 6);
     target->resetIndexSource();
 }
 
-void GrAARectRenderer::shaderFillAlignedAARect(GrGpu* gpu,
-                                               GrDrawTarget* target,
+void GrAARectRenderer::shaderFillAlignedAARect(GrDrawTarget* target,
                                                const SkRect& rect,
                                                const SkMatrix& combinedMatrix) {
     GrDrawState* drawState = target->drawState();
@@ -696,13 +693,12 @@ void GrAARectRenderer::shaderFillAlignedAARect(GrGpu* gpu,
     verts[3].fOffset = SkPoint::Make(widthHeight.fX, -widthHeight.fY);
     verts[3].fWidthHeight = widthHeight;
 
-    target->setIndexSourceToBuffer(gpu->getContext()->getQuadIndexBuffer());
+    target->setIndexSourceToBuffer(fGpu->getContext()->getQuadIndexBuffer());
     target->drawIndexedInstances(kTriangles_GrPrimitiveType, 1, 4, 6);
     target->resetIndexSource();
 }
 
-void GrAARectRenderer::strokeAARect(GrGpu* gpu,
-                                    GrDrawTarget* target,
+void GrAARectRenderer::strokeAARect(GrDrawTarget* target,
                                     const SkRect& rect,
                                     const SkMatrix& combinedMatrix,
                                     const SkRect& devRect,
@@ -749,7 +745,7 @@ void GrAARectRenderer::strokeAARect(GrGpu* gpu,
     }
 
     if (spare <= 0 && miterStroke) {
-        this->fillAARect(gpu, target, devOutside, SkMatrix::I(), devOutside);
+        this->fillAARect(target, devOutside, SkMatrix::I(), devOutside);
         return;
     }
 
@@ -766,11 +762,10 @@ void GrAARectRenderer::strokeAARect(GrGpu* gpu,
         devOutsideAssist.outset(0, ry);
     }
 
-    this->geometryStrokeAARect(gpu, target, devOutside, devOutsideAssist, devInside, miterStroke);
+    this->geometryStrokeAARect(target, devOutside, devOutsideAssist, devInside, miterStroke);
 }
 
-void GrAARectRenderer::geometryStrokeAARect(GrGpu* gpu,
-                                            GrDrawTarget* target,
+void GrAARectRenderer::geometryStrokeAARect(GrDrawTarget* target,
                                             const SkRect& devOutside,
                                             const SkRect& devOutsideAssist,
                                             const SkRect& devInside,
@@ -793,7 +788,7 @@ void GrAARectRenderer::geometryStrokeAARect(GrGpu* gpu,
         GrPrintf("Failed to get space for vertices!\n");
         return;
     }
-    GrIndexBuffer* indexBuffer = this->aaStrokeRectIndexBuffer(gpu, miterStroke);
+    GrIndexBuffer* indexBuffer = this->aaStrokeRectIndexBuffer(miterStroke);
     if (NULL == indexBuffer) {
         GrPrintf("Failed to create index buffer!\n");
         return;
@@ -900,12 +895,11 @@ void GrAARectRenderer::geometryStrokeAARect(GrGpu* gpu,
 
     target->setIndexSourceToBuffer(indexBuffer);
     target->drawIndexedInstances(kTriangles_GrPrimitiveType, 1,
-                                 totalVertexNum, aaStrokeRectIndexCount(miterStroke));
+                                 totalVertexNum, aa_stroke_rect_index_count(miterStroke));
     target->resetIndexSource();
 }
 
-void GrAARectRenderer::fillAANestedRects(GrGpu* gpu,
-                                         GrDrawTarget* target,
+void GrAARectRenderer::fillAANestedRects(GrDrawTarget* target,
                                          const SkRect rects[2],
                                          const SkMatrix& combinedMatrix) {
     SkASSERT(combinedMatrix.rectStaysRect());
@@ -917,9 +911,9 @@ void GrAARectRenderer::fillAANestedRects(GrGpu* gpu,
     combinedMatrix.mapPoints((SkPoint*)&devInside, (const SkPoint*)&rects[1], 2);
 
     if (devInside.isEmpty()) {
-        this->fillAARect(gpu, target, devOutside, SkMatrix::I(), devOutside);
+        this->fillAARect(target, devOutside, SkMatrix::I(), devOutside);
         return;
     }
 
-    this->geometryStrokeAARect(gpu, target, devOutside, devOutsideAssist, devInside, true);
+    this->geometryStrokeAARect(target, devOutside, devOutsideAssist, devInside, true);
 }
diff --git a/src/gpu/GrAARectRenderer.h b/src/gpu/GrAARectRenderer.h
index b276823434..c6e3976b7f 100644
--- a/src/gpu/GrAARectRenderer.h
+++ b/src/gpu/GrAARectRenderer.h
@@ -24,8 +24,9 @@ class GrAARectRenderer : public SkRefCnt {
 public:
     SK_DECLARE_INST_COUNT(GrAARectRenderer)
 
-    GrAARectRenderer()
-    : fAAFillRectIndexBuffer(NULL)
+    GrAARectRenderer(GrGpu* gpu)
+    : fGpu(gpu)
+    , fAAFillRectIndexBuffer(NULL)
     , fAAMiterStrokeRectIndexBuffer(NULL)
     , fAABevelStrokeRectIndexBuffer(NULL) {
     }
@@ -39,8 +40,7 @@ public:
     // TODO: potentialy fuse the fill & stroke methods and differentiate
     // between them by passing in stroke (==NULL means fill).
 
-    void fillAARect(GrGpu* gpu,
-                    GrDrawTarget* target,
+    void fillAARect(GrDrawTarget* target,
                     const SkRect& rect,
                     const SkMatrix& combinedMatrix,
                     const SkRect& devRect) {
@@ -53,54 +53,48 @@ public:
                                    rect, combinedMatrix);
         }
 #else
-        this->geometryFillAARect(gpu, target, rect, combinedMatrix, devRect);
+        this->geometryFillAARect(target, rect, combinedMatrix, devRect);
 #endif
     }
 
-    void strokeAARect(GrGpu* gpu,
-                      GrDrawTarget* target,
+    void strokeAARect(GrDrawTarget* target,
                       const SkRect& rect,
                       const SkMatrix& combinedMatrix,
                       const SkRect& devRect,
                       const SkStrokeRec& stroke);
 
     // First rect is outer; second rect is inner
-    void fillAANestedRects(GrGpu* gpu,
-                           GrDrawTarget* target,
+    void fillAANestedRects(GrDrawTarget* target,
                            const SkRect rects[2],
                            const SkMatrix& combinedMatrix);
 
 private:
-    GrIndexBuffer*              fAAFillRectIndexBuffer;
-    GrIndexBuffer*              fAAMiterStrokeRectIndexBuffer;
-    GrIndexBuffer*              fAABevelStrokeRectIndexBuffer;
-
-    static int aaStrokeRectIndexCount(bool miterStroke);
-    GrIndexBuffer* aaStrokeRectIndexBuffer(GrGpu* gpu, bool miterStroke);
+    GrIndexBuffer* aaStrokeRectIndexBuffer(bool miterStroke);
 
-    void geometryFillAARect(GrGpu* gpu,
-                            GrDrawTarget* target,
+    void geometryFillAARect(GrDrawTarget* target,
                             const SkRect& rect,
                             const SkMatrix& combinedMatrix,
                             const SkRect& devRect);
 
-    void shaderFillAARect(GrGpu* gpu,
-                          GrDrawTarget* target,
+    void shaderFillAARect(GrDrawTarget* target,
                           const SkRect& rect,
                           const SkMatrix& combinedMatrix);
 
-    void shaderFillAlignedAARect(GrGpu* gpu,
-                                 GrDrawTarget* target,
+    void shaderFillAlignedAARect(GrDrawTarget* target,
                                  const SkRect& rect,
                                  const SkMatrix& combinedMatrix);
 
-    void geometryStrokeAARect(GrGpu* gpu,
-                              GrDrawTarget* target,
+    void geometryStrokeAARect(GrDrawTarget* target,
                               const SkRect& devOutside,
                               const SkRect& devOutsideAssist,
                               const SkRect& devInside,
                               bool miterStroke);
 
+    GrGpu*                      fGpu;
+    GrIndexBuffer*              fAAFillRectIndexBuffer;
+    GrIndexBuffer*              fAAMiterStrokeRectIndexBuffer;
+    GrIndexBuffer*              fAABevelStrokeRectIndexBuffer;
+
     typedef SkRefCnt INHERITED;
 };
 
diff --git a/src/gpu/GrClipMaskManager.cpp b/src/gpu/GrClipMaskManager.cpp
index 1d193a59d9..d753258868 100644
--- a/src/gpu/GrClipMaskManager.cpp
+++ b/src/gpu/GrClipMaskManager.cpp
@@ -398,7 +398,6 @@ bool GrClipMaskManager::drawElement(GrTexture* target,
             // the entire mask bounds and writes 0 outside the rect.
             if (element->isAA()) {
                 this->getContext()->getAARectRenderer()->fillAARect(fGpu,
-                                                                    fGpu,
                                                                     element->getRect(),
                                                                     SkMatrix::I(),
                                                                     element->getRect());
diff --git a/src/gpu/GrContext.cpp b/src/gpu/GrContext.cpp
index b4bcfd3134..2eaf63c305 100755
--- a/src/gpu/GrContext.cpp
+++ b/src/gpu/GrContext.cpp
@@ -146,7 +146,7 @@ bool GrContext::init(GrBackend backend, GrBackendContext backendContext) {
 
     fLastDrawWasBuffered = kNo_BufferedDraw;
 
-    fAARectRenderer = SkNEW(GrAARectRenderer);
+    fAARectRenderer = SkNEW_ARGS(GrAARectRenderer, (fGpu));
     fOvalRenderer = SkNEW(GrOvalRenderer);
 
     fDidTestPMConversions = false;
@@ -779,12 +779,12 @@ void GrContext::drawRect(const GrPaint& paint,
             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;
@@ -1174,7 +1174,7 @@ void GrContext::drawPath(const GrPaint& paint, const SkPath& path, const GrStrok
                 return;
             }
 
-            fAARectRenderer->fillAANestedRects(this->getGpu(), target, rects, origViewMatrix);
+            fAARectRenderer->fillAANestedRects(target, rects, origViewMatrix);
             return;
         }
     }