Split drawing functionality out of GrContext and into new GrDrawContext

src/gpu/GrAARectRenderer.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAARectRenderer.h"
 #include "GrBatch.h"
 #include "GrBatchTarget.h"
@@ skipping 295 matching lines @@
 };
 
 namespace {
 // Should the coverage be multiplied into the color attrib or use a separate attrib.
 enum CoverageAttribType {
     kUseColor_CoverageAttribType,
     kUseCoverage_CoverageAttribType,
 };
 }
 
-void GrAARectRenderer::geometryFillAARect(GrDrawTarget* target,
+void GrAARectRenderer::GeometryFillAARect(GrDrawTarget* target,
                                           GrPipelineBuilder* pipelineBuilder,
                                           GrColor color,
                                           const SkMatrix& viewMatrix,
                                           const SkRect& rect,
                                           const SkRect& devRect) {
     AAFillRectBatch::Geometry geometry;
     geometry.fRect = rect;
     geometry.fViewMatrix = viewMatrix;
     geometry.fDevRect = devRect;
     geometry.fColor = color;
 
 
     SkAutoTUnref<GrBatch> batch(AAFillRectBatch::Create(geometry));
     target->drawBatch(pipelineBuilder, batch);
 }
 
-void GrAARectRenderer::strokeAARect(GrDrawTarget* target,
+void GrAARectRenderer::StrokeAARect(GrDrawTarget* target,
                                     GrPipelineBuilder* pipelineBuilder,
                                     GrColor color,
                                     const SkMatrix& viewMatrix,
                                     const SkRect& rect,
                                     const SkRect& devRect,
                                     const SkStrokeRec& stroke) {
     SkVector devStrokeSize;
     SkScalar width = stroke.getWidth();
     if (width > 0) {
         devStrokeSize.set(width, width);
@@ skipping 20 matching lines @@
 
     bool miterStroke = true;
     // For hairlines, make bevel and round joins appear the same as mitered ones.
     // small miter limit means right angles show bevel...
     if ((width > 0) && (stroke.getJoin() != SkPaint::kMiter_Join ||
                         stroke.getMiter() < SK_ScalarSqrt2)) {
         miterStroke = false;
     }
 
     if (spare <= 0 && miterStroke) {
-        this->fillAARect(target, pipelineBuilder, color, viewMatrix, devOutside, devOutside);
+        FillAARect(target, pipelineBuilder, color, viewMatrix, devOutside, devOutside);
         return;
     }
 
     SkRect devInside(devRect);
     devInside.inset(rx, ry);
 
     SkRect devOutsideAssist(devRect);
 
     // For bevel-stroke, use 2 SkRect instances(devOutside and devOutsideAssist)
     // to draw the outer of the rect. Because there are 8 vertices on the outer
     // edge, while vertex number of inner edge is 4, the same as miter-stroke.
     if (!miterStroke) {
         devOutside.inset(0, ry);
         devOutsideAssist.outset(0, ry);
     }
 
-    this->geometryStrokeAARect(target, pipelineBuilder, color, viewMatrix, devOutside,
-                               devOutsideAssist, devInside, miterStroke);
+    GeometryStrokeAARect(target, pipelineBuilder, color, viewMatrix, devOutside,
+                         devOutsideAssist, devInside, miterStroke);
 }
 
 GR_DECLARE_STATIC_UNIQUE_KEY(gMiterIndexBufferKey);
 GR_DECLARE_STATIC_UNIQUE_KEY(gBevelIndexBufferKey);
 
 class AAStrokeRectBatch : public GrBatch {
 public:
     // TODO support AA rotated stroke rects by copying around view matrices
     struct Geometry {
         GrColor fColor;
@@ skipping 363 matching lines @@
         bool fColorIgnored;
         bool fCoverageIgnored;
         bool fMiterStroke;
         bool fCanTweakAlphaForCoverage;
     };
 
     BatchTracker fBatch;
     SkSTArray<1, Geometry, true> fGeoData;
 };
 
-void GrAARectRenderer::geometryStrokeAARect(GrDrawTarget* target,
+void GrAARectRenderer::GeometryStrokeAARect(GrDrawTarget* target,
                                             GrPipelineBuilder* pipelineBuilder,
                                             GrColor color,
                                             const SkMatrix& viewMatrix,
                                             const SkRect& devOutside,
                                             const SkRect& devOutsideAssist,
                                             const SkRect& devInside,
                                             bool miterStroke) {
     AAStrokeRectBatch::Geometry geometry;
     geometry.fColor = color;
     geometry.fDevOutside = devOutside;
     geometry.fDevOutsideAssist = devOutsideAssist;
     geometry.fDevInside = devInside;
     geometry.fMiterStroke = miterStroke;
 
     SkAutoTUnref<GrBatch> batch(AAStrokeRectBatch::Create(geometry, viewMatrix));
     target->drawBatch(pipelineBuilder, batch);
 }
 
-void GrAARectRenderer::fillAANestedRects(GrDrawTarget* target,
+void GrAARectRenderer::FillAANestedRects(GrDrawTarget* target,
                                          GrPipelineBuilder* pipelineBuilder,
                                          GrColor color,
                                          const SkMatrix& viewMatrix,
                                          const SkRect rects[2]) {
     SkASSERT(viewMatrix.rectStaysRect());
     SkASSERT(!rects[0].isEmpty() && !rects[1].isEmpty());
 
     SkRect devOutside, devInside;
     viewMatrix.mapRect(&devOutside, rects[0]);
     viewMatrix.mapRect(&devInside, rects[1]);
 
     if (devInside.isEmpty()) {
-        this->fillAARect(target, pipelineBuilder, color, viewMatrix, devOutside, devOutside);
+        FillAARect(target, pipelineBuilder, color, viewMatrix, devOutside, devOutside);
         return;
     }
 
-    this->geometryStrokeAARect(target, pipelineBuilder, color, viewMatrix, devOutside,
-                               devOutside, devInside, true);
+    GeometryStrokeAARect(target, pipelineBuilder, color, viewMatrix, devOutside,
+                         devOutside, devInside, true);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifdef GR_TEST_UTILS
 
 BATCH_TEST_DEFINE(AAFillRectBatch) {
     AAFillRectBatch::Geometry geo;
     geo.fColor = GrRandomColor(random);
     geo.fViewMatrix = GrTest::TestMatrix(random);
@@ skipping 18 matching lines @@
     geo.fColor = GrRandomColor(random);
     geo.fDevOutside = outside;
     geo.fDevOutsideAssist = outsideAssist;
     geo.fDevInside = inside;
     geo.fMiterStroke = miterStroke;
 
     return AAStrokeRectBatch::Create(geo, GrTest::TestMatrix(random));
 }
 
 #endif