Use new API everywhere for GrDefaultGeoProcFactory

src/gpu/effects/GrDashingEffect.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrDashingEffect.h"
 
 #include "GrBatch.h"
@@ skipping 282 matching lines @@
         SkScalar fHalfDevStroke;
         SkScalar fDevBloatX;
         SkScalar fDevBloatY;
         bool fLineDone;
         bool fHasStartRect;
         bool fHasEndRect;
     };
 
     void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override {
         int instanceCount = fGeoData.count();
+        SkPaint::Cap cap = this->cap();
+        bool isRoundCap = SkPaint::kRound_Cap == cap;
+        DashCap capType = isRoundCap ? kRound_DashCap : kNonRound_DashCap;
 
-        SkMatrix invert;
-        if (this->usesLocalCoords() && !this->viewMatrix().invert(&invert)) {
-            SkDebugf("Failed to invert\n");
+        SkAutoTUnref<const GrGeometryProcessor> gp;
+        if (this->fullDash()) {
+            gp.reset(create_dash_gp(this->color(), this->aaMode(), capType, this->viewMatrix(),
+                                    this->usesLocalCoords()));
+        } else {
+            // Set up the vertex data for the line and start/end dashes
+            using namespace GrDefaultGeoProcFactory;
+            Color color(this->color());
+            Coverage coverage(this->coverageIgnored() ? Coverage::kNone_Type :
+                                                        Coverage::kSolid_Type);
+            if (this->usesLocalCoords()) {
+                LocalCoords localCoords(LocalCoords::kUsePosition_Type);
+                gp.reset(CreateForDeviceSpace(color, coverage, localCoords, this->viewMatrix()));
+            } else {
+                LocalCoords localCoords(LocalCoords::kUnused_Type);
+                gp.reset(GrDefaultGeoProcFactory::Create(color, coverage, localCoords));
+            }
+        }
+
+        if (!gp) {
+            SkDebugf("Could not create GrGeometryProcessor\n");
             return;
         }
 
-        SkPaint::Cap cap = this->cap();
-
-        SkAutoTUnref<const GrGeometryProcessor> gp;
-
-        bool isRoundCap = SkPaint::kRound_Cap == cap;
-        DashCap capType = isRoundCap ? kRound_DashCap : kNonRound_DashCap;
-        if (this->fullDash()) {
-            gp.reset(create_dash_gp(this->color(), this->aaMode(), capType, invert,
-                                    this->usesLocalCoords()));
-        } else {
-            // Set up the vertex data for the line and start/end dashes
-            gp.reset(GrDefaultGeoProcFactory::Create(GrDefaultGeoProcFactory::kPosition_GPType,
-                                                     this->color(),
-                                                     this->usesLocalCoords(),
-                                                     this->coverageIgnored(),
-                                                     SkMatrix::I(),
-                                                     invert));
-        }
-
         batchTarget->initDraw(gp, pipeline);
 
         // useAA here means Edge AA or MSAA
         bool useAA = this->aaMode() != kBW_DashAAMode;
         bool fullDash = this->fullDash();
 
         // We do two passes over all of the dashes.  First we setup the start, end, and bounds,
         // rectangles.  We preserve all of this work in the rects / draws arrays below.  Then we
         // iterate again over these decomposed dashes to generate vertices
         SkSTArray<128, SkRect, true> rects;
@@ skipping 863 matching lines @@
     return DashingLineEffect::Create(GrRandomColor(d->fRandom),
                                      aaMode, GrTest::TestMatrix(d->fRandom),
                                      d->fRandom->nextBool());
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 static GrGeometryProcessor* create_dash_gp(GrColor color,
                                            DashAAMode dashAAMode,
                                            DashCap cap,
-                                           const SkMatrix& localMatrix,
+                                           const SkMatrix& viewMatrix,
                                            bool usesLocalCoords) {
+    SkMatrix invert;
+    if (usesLocalCoords && !viewMatrix.invert(&invert)) {
+        SkDebugf("Failed to invert\n");
+        return NULL;
+    }
+
     switch (cap) {
         case kRound_DashCap:
-            return DashingCircleEffect::Create(color, dashAAMode, localMatrix, usesLocalCoords);
+            return DashingCircleEffect::Create(color, dashAAMode, invert, usesLocalCoords);
         case kNonRound_DashCap:
-            return DashingLineEffect::Create(color, dashAAMode, localMatrix, usesLocalCoords);
-        default:
-            SkFAIL("Unexpected dashed cap.");
+            return DashingLineEffect::Create(color, dashAAMode, invert, usesLocalCoords);
     }
     return NULL;
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifdef GR_TEST_UTILS
 
 BATCH_TEST_DEFINE(DashBatch) {
     GrColor color = GrRandomColor(random);
@@ skipping 64 matching lines @@
     info.fIntervals = intervals;
     info.fCount = 2;
     info.fPhase = phase;
     SkDEBUGCODE(bool success = ) strokeInfo.setDashInfo(info);
     SkASSERT(success);
 
     return create_batch(color, viewMatrix, pts, useAA, strokeInfo, msaaRT);
 }
 
 #endif