Stateful PathRenderer implementation

src/gpu/GrAAHairLinePathRenderer.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 "GrAAHairLinePathRenderer.h"
 
 #include "GrContext.h"
@@ skipping 808 matching lines @@
         add_quads(&quads[3*i], qSubdivs[i], toDevice, toSrc, &verts, devBounds);
     }
 
     // Start Conics
     for (int i = 0; i < conicCnt; ++i) {
         add_conics(&conics[3*i], cWeights[i], toDevice, toSrc, &verts, devBounds);
     }
     return true;
 }
 
-bool GrAAHairLinePathRenderer::canDrawPath(const SkPath& path,
-                                           const SkStrokeRec& stroke,
+bool GrAAHairLinePathRenderer::canDrawPath(const SkStrokeRec& stroke,
                                            const GrDrawTarget* target,
                                            bool antiAlias) const {
     if (!antiAlias) {
         return false;
     }
 
     if (!IsStrokeHairlineOrEquivalent(stroke,
                                       target->getDrawState().getViewMatrix(),
                                       NULL)) {
         return false;
     }
 
-    if (SkPath::kLine_SegmentMask == path.getSegmentMasks() ||
+    if (SkPath::kLine_SegmentMask == this->path().getSegmentMasks() ||
         target->caps()->shaderDerivativeSupport()) {
         return true;
     }
     return false;
 }
 
 template <class VertexType>
 bool check_bounds(GrDrawState* drawState, const SkRect& devBounds, void* vertices, int vCount)
 {
     SkRect tolDevBounds = devBounds;
@@ skipping 23 matching lines @@
             actualBounds.growToInclude(pos.fX, pos.fY);
         }
     }
     if (!first) {
         return tolDevBounds.contains(actualBounds);
     }
 
     return true;
 }
 
-bool GrAAHairLinePathRenderer::onDrawPath(const SkPath& path,
-                                          const SkStrokeRec& stroke,
+bool GrAAHairLinePathRenderer::onDrawPath(const SkStrokeRec& stroke,
                                           GrDrawTarget* target,
                                           bool antiAlias) {
     GrDrawState* drawState = target->drawState();
 
     SkScalar hairlineCoverage;
     if (IsStrokeHairlineOrEquivalent(stroke,
                                      target->getDrawState().getViewMatrix(),
                                      &hairlineCoverage)) {
         uint8_t newCoverage = SkScalarRoundToInt(hairlineCoverage *
                                                  target->getDrawState().getCoverage());
         target->drawState()->setCoverage(newCoverage);
     }
 
     SkIRect devClipBounds;
     target->getClip()->getConservativeBounds(drawState->getRenderTarget(), &devClipBounds);
 
     int lineCnt;
     int quadCnt;
     int conicCnt;
     PREALLOC_PTARRAY(128) lines;
     PREALLOC_PTARRAY(128) quads;
     PREALLOC_PTARRAY(128) conics;
     IntArray qSubdivs;
     FloatArray cWeights;
-    quadCnt = generate_lines_and_quads(path, drawState->getViewMatrix(), devClipBounds,
+    quadCnt = generate_lines_and_quads(this->path(), drawState->getViewMatrix(), devClipBounds,
                                        &lines, &quads, &conics, &qSubdivs, &cWeights);
     lineCnt = lines.count() / 2;
     conicCnt = conics.count() / 3;
 
     // do lines first
     if (lineCnt) {
         GrDrawTarget::AutoReleaseGeometry arg;
         SkRect devBounds;
 
-        if (!this->createLineGeom(path,
+        if (!this->createLineGeom(this->path(),
                                   target,
                                   lines,
                                   lineCnt,
                                   &arg,
                                   &devBounds)) {
             return false;
         }
 
         GrDrawTarget::AutoStateRestore asr;
 
@@ skipping 25 matching lines @@
                 lines += n;
             }
         }
     }
 
     // then quadratics/conics
     if (quadCnt || conicCnt) {
         GrDrawTarget::AutoReleaseGeometry arg;
         SkRect devBounds;
 
-        if (!this->createBezierGeom(path,
+        if (!this->createBezierGeom(this->path(),
                                     target,
                                     quads,
                                     quadCnt,
                                     conics,
                                     conicCnt,
                                     qSubdivs,
                                     cWeights,
                                     &arg,
                                     &devBounds)) {
             return false;
@@ skipping 53 matching lines @@
                                     &devBounds);
                 conics += n;
             }
         }
     }
 
     target->resetIndexSource();
 
     return true;
 }