Push creation of default GP to the caller

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 "../GrAARectRenderer.h"
 
 #include "GrGeometryProcessor.h"
-#include "gl/builders/GrGLProgramBuilder.h"
-#include "gl/GrGLProcessor.h"
-#include "gl/GrGLGeometryProcessor.h"
-#include "gl/GrGLSL.h"
 #include "GrContext.h"
 #include "GrCoordTransform.h"
+#include "GrDefaultGeoProcFactory.h"
 #include "GrDrawTarget.h"
 #include "GrDrawTargetCaps.h"
 #include "GrInvariantOutput.h"
 #include "GrProcessor.h"
-#include "GrGpu.h"
 #include "GrStrokeInfo.h"
 #include "GrTBackendProcessorFactory.h"
 #include "SkGr.h"
+#include "gl/GrGLGeometryProcessor.h"
+#include "gl/GrGLProcessor.h"
+#include "gl/GrGLSL.h"
+#include "gl/builders/GrGLProgramBuilder.h"
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // Returns whether or not the gpu can fast path the dash line effect.
 static bool can_fast_path_dash(const SkPoint pts[2], const GrStrokeInfo& strokeInfo,
                                const GrDrawTarget& target, const SkMatrix& viewMatrix) {
     if (target.getDrawState().getRenderTarget()->isMultisampled()) {
         return false;
     }
 
@@ skipping 26 matching lines @@
     return true;
 }
 
 namespace {
 
 struct DashLineVertex {
     SkPoint fPos;
     SkPoint fDashPos;
 };
 
-extern const GrVertexAttrib gDashLineNoAAVertexAttribs[] = {
-    { kVec2f_GrVertexAttribType, 0,                 kPosition_GrVertexAttribBinding }
-};
-
 extern const GrVertexAttrib gDashLineVertexAttribs[] = {
     { kVec2f_GrVertexAttribType, 0,                 kPosition_GrVertexAttribBinding },
     { kVec2f_GrVertexAttribType, sizeof(SkPoint),   kGeometryProcessor_GrVertexAttribBinding },
 };
 
 };
 static void calc_dash_scaling(SkScalar* parallelScale, SkScalar* perpScale,
                             const SkMatrix& viewMatrix, const SkPoint pts[2]) {
     SkVector vecSrc = pts[1] - pts[0];
     SkScalar magSrc = vecSrc.length();
@@ skipping 56 matching lines @@
         if (0 == info.fIntervals[0]) {
             *endingInt -= 0.01f; // make sure we capture the last zero size pnt (used if has caps)
         }
         return *endingInt - info.fIntervals[0];
     }
     return 0;
 }
 
 static void setup_dashed_rect(const SkRect& rect, DashLineVertex* verts, int idx, const SkMatrix& matrix,
                        SkScalar offset, SkScalar bloat, SkScalar len, SkScalar stroke) {
-
         SkScalar startDashX = offset - bloat;
         SkScalar endDashX = offset + len + bloat;
         SkScalar startDashY = -stroke - bloat;
         SkScalar endDashY = stroke + bloat;
         verts[idx].fDashPos = SkPoint::Make(startDashX , startDashY);
         verts[idx + 1].fDashPos = SkPoint::Make(startDashX, endDashY);
         verts[idx + 2].fDashPos = SkPoint::Make(endDashX, endDashY);
         verts[idx + 3].fDashPos = SkPoint::Make(endDashX, startDashY);
-
         verts[idx].fPos = SkPoint::Make(rect.fLeft, rect.fTop);
         verts[idx + 1].fPos = SkPoint::Make(rect.fLeft, rect.fBottom);
         verts[idx + 2].fPos = SkPoint::Make(rect.fRight, rect.fBottom);
         verts[idx + 3].fPos = SkPoint::Make(rect.fRight, rect.fTop);
-
         matrix.mapPointsWithStride(&verts[idx].fPos, sizeof(DashLineVertex), 4);
 }
 
+static void setup_dashed_rect_pos(const SkRect& rect, int idx, const SkMatrix& matrix,
+                                  SkPoint* verts) {
+    verts[idx] = SkPoint::Make(rect.fLeft, rect.fTop);
+    verts[idx + 1] = SkPoint::Make(rect.fLeft, rect.fBottom);
+    verts[idx + 2] = SkPoint::Make(rect.fRight, rect.fBottom);
+    verts[idx + 3] = SkPoint::Make(rect.fRight, rect.fTop);
+    matrix.mapPoints(&verts[idx], 4);
+}
 
 bool GrDashingEffect::DrawDashLine(const SkPoint pts[2], const GrPaint& paint,
                                    const GrStrokeInfo& strokeInfo, GrGpu* gpu,
                                    GrDrawTarget* target, const SkMatrix& vm) {
 
     if (!can_fast_path_dash(pts, strokeInfo, *target, vm)) {
         return false;
     }
 
     const SkPathEffect::DashInfo& info = strokeInfo.getDashInfo();
@@ skipping 152 matching lines @@
         lineDone = true;
 
         SkPoint devicePts[2];
         vm.mapPoints(devicePts, ptsRot, 2);
         SkScalar lineLength = SkPoint::Distance(devicePts[0], devicePts[1]);
         if (hasCap) {
             lineLength += 2.f * halfDevStroke;
         }
         devIntervals[0] = lineLength;
     }
-    if (devIntervals[1] > 0.f || useAA) {
+    bool fullDash = devIntervals[1] > 0.f || useAA;
+    if (fullDash) {
         SkPathEffect::DashInfo devInfo;
         devInfo.fPhase = devPhase;
         devInfo.fCount = 2;
         devInfo.fIntervals = devIntervals;
         GrPrimitiveEdgeType edgeType= useAA ? kFillAA_GrProcessorEdgeType :
             kFillBW_GrProcessorEdgeType;
         bool isRoundCap = SkPaint::kRound_Cap == cap;
         GrDashingEffect::DashCap capType = isRoundCap ? GrDashingEffect::kRound_DashCap :
                                                         GrDashingEffect::kNonRound_DashCap;
         drawState->setGeometryProcessor(
                 GrDashingEffect::Create(edgeType, devInfo, strokeWidth, capType))->unref();
 
         // Set up the vertex data for the line and start/end dashes
         drawState->setVertexAttribs<gDashLineVertexAttribs>(SK_ARRAY_COUNT(gDashLineVertexAttribs),
                                                             sizeof(DashLineVertex));
     } else {
         // Set up the vertex data for the line and start/end dashes
-        drawState->setVertexAttribs<gDashLineNoAAVertexAttribs>(
-                SK_ARRAY_COUNT(gDashLineNoAAVertexAttribs), sizeof(DashLineVertex));
+        drawState->setGeometryProcessor(
+                GrDefaultGeoProcFactory::CreateAndSetAttribs(
+                        drawState,
+                        GrDefaultGeoProcFactory::kPosition_GPType))->unref();
     }
 
     int totalRectCnt = 0;
 
     totalRectCnt += !lineDone ? 1 : 0;
     totalRectCnt += hasStartRect ? 1 : 0;
     totalRectCnt += hasEndRect ? 1 : 0;
 
     GrDrawTarget::AutoReleaseGeometry geo(target, totalRectCnt * 4, 0);
     if (!geo.succeeded()) {
         SkDebugf("Failed to get space for vertices!\n");
         return false;
     }
 
-    DashLineVertex* verts = reinterpret_cast<DashLineVertex*>(geo.vertices());
-
     int curVIdx = 0;
 
     if (SkPaint::kRound_Cap == cap && 0 != srcStrokeWidth) {
         // need to adjust this for round caps to correctly set the dashPos attrib on vertices
         startOffset -= halfDevStroke;
     }
 
     // Draw interior part of dashed line
     if (!lineDone) {
         SkPoint devicePts[2];
         vm.mapPoints(devicePts, ptsRot, 2);
         SkScalar lineLength = SkPoint::Distance(devicePts[0], devicePts[1]);
         if (hasCap) {
             lineLength += 2.f * halfDevStroke;
         }
 
         SkRect bounds;
         bounds.set(ptsRot[0].fX, ptsRot[0].fY, ptsRot[1].fX, ptsRot[1].fY);
         bounds.outset(bloatX + strokeAdj, bloatY + halfSrcStroke);
-        setup_dashed_rect(bounds, verts, curVIdx, combinedMatrix, startOffset, devBloat,
-                          lineLength, halfDevStroke);
+        if (fullDash) {
+            DashLineVertex* verts = reinterpret_cast<DashLineVertex*>(geo.vertices());
+            setup_dashed_rect(bounds, verts, curVIdx, combinedMatrix, startOffset, devBloat,
+                                      lineLength, halfDevStroke);
+        } else {
+            SkPoint* verts = reinterpret_cast<SkPoint*>(geo.vertices());
+            setup_dashed_rect_pos(bounds, curVIdx, combinedMatrix, verts);
+        }
         curVIdx += 4;
     }
 
     if (hasStartRect) {
         SkASSERT(useAA);  // so that we know bloatX and bloatY have been set
         startRect.outset(bloatX, bloatY);
-        setup_dashed_rect(startRect, verts, curVIdx, combinedMatrix, startOffset, devBloat,
-                          devIntervals[0], halfDevStroke);
+        if (fullDash) {
+            DashLineVertex* verts = reinterpret_cast<DashLineVertex*>(geo.vertices());
+            setup_dashed_rect(startRect, verts, curVIdx, combinedMatrix, startOffset, devBloat,
+                              devIntervals[0], halfDevStroke);
+        } else {
+            SkPoint* verts = reinterpret_cast<SkPoint*>(geo.vertices());
+            setup_dashed_rect_pos(startRect, curVIdx, combinedMatrix, verts);
+        }
+
         curVIdx += 4;
     }
 
     if (hasEndRect) {
         SkASSERT(useAA);  // so that we know bloatX and bloatY have been set
         endRect.outset(bloatX, bloatY);
-        setup_dashed_rect(endRect, verts, curVIdx, combinedMatrix, startOffset, devBloat,
-                          devIntervals[0], halfDevStroke);
+        if (fullDash) {
+            DashLineVertex* verts = reinterpret_cast<DashLineVertex*>(geo.vertices());
+            setup_dashed_rect(endRect, verts, curVIdx, combinedMatrix, startOffset, devBloat,
+                              devIntervals[0], halfDevStroke);
+        } else {
+            SkPoint* verts = reinterpret_cast<SkPoint*>(geo.vertices());
+            setup_dashed_rect_pos(endRect, curVIdx, combinedMatrix, verts);
+        }
+
     }
 
     target->setIndexSourceToBuffer(gpu->getContext()->getQuadIndexBuffer());
     target->drawIndexedInstances(kTriangles_GrPrimitiveType, totalRectCnt, 4, 6);
     target->resetIndexSource();
     return true;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
@@ skipping 424 matching lines @@
     switch (cap) {
         case GrDashingEffect::kRound_DashCap:
             return DashingCircleEffect::Create(edgeType, info, SkScalarHalf(strokeWidth));
         case GrDashingEffect::kNonRound_DashCap:
             return DashingLineEffect::Create(edgeType, info, strokeWidth);
         default:
             SkFAIL("Unexpected dashed cap.");
     }
     return NULL;
 }