Update how we send draws to gpu backend to reduce state setting.

src/gpu/batches/GrPLSPathRenderer.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrPLSPathRenderer.h"
 
 #include "SkChunkAlloc.h"
@@ skipping 846 matching lines @@
             const SkPath* pathPtr = &args.fPath;
             SkTLazy<SkPath> tmpPath;
             if (viewMatrix->hasPerspective()) {
                 SkPath* tmpPathPtr = tmpPath.init(*pathPtr);
                 tmpPathPtr->setIsVolatile(true);
                 tmpPathPtr->transform(*viewMatrix);
                 viewMatrix = &SkMatrix::I();
                 pathPtr = tmpPathPtr;
             }
 
-            GrVertices grVertices;
+            GrMesh mesh;
 
             PLSVertices triVertices;
             PLSVertices quadVertices;
             if (!get_geometry(*pathPtr, *viewMatrix, triVertices, quadVertices, rp, bounds)) {
                 continue;
             }
 
             if (triVertices.count()) {
                 const GrVertexBuffer* triVertexBuffer;
                 int firstTriVertex;
                 size_t triStride = triangleProcessor->getVertexStride();
                 PLSVertex* triVerts = reinterpret_cast<PLSVertex*>(target->makeVertexSpace(
                         triStride, triVertices.count(), &triVertexBuffer, &firstTriVertex));
                 if (!triVerts) {
                     SkDebugf("Could not allocate vertices\n");
                     return;
                 }
                 for (int i = 0; i < triVertices.count(); ++i) {
                     triVerts[i] = triVertices[i];
                 }
-                grVertices.init(kTriangles_GrPrimitiveType, triVertexBuffer, firstTriVertex, 
-                                triVertices.count());
-                target->initDraw(triangleProcessor, this->pipeline());
-                target->draw(grVertices);
+                mesh.init(kTriangles_GrPrimitiveType, triVertexBuffer, firstTriVertex,
+                          triVertices.count());
+                target->initDraw(triangleProcessor);
+                target->draw(mesh);
             }
 
             if (quadVertices.count()) {
                 const GrVertexBuffer* quadVertexBuffer;
                 int firstQuadVertex;
                 size_t quadStride = quadProcessor->getVertexStride();
                 PLSVertex* quadVerts = reinterpret_cast<PLSVertex*>(target->makeVertexSpace(
                         quadStride, quadVertices.count(), &quadVertexBuffer, &firstQuadVertex));
                 if (!quadVerts) {
                     SkDebugf("Could not allocate vertices\n");
                     return;
                 }
                 for (int i = 0; i < quadVertices.count(); ++i) {
                     quadVerts[i] = quadVertices[i];
                 }
-                grVertices.init(kTriangles_GrPrimitiveType, quadVertexBuffer, firstQuadVertex, 
-                                quadVertices.count());
-                target->initDraw(quadProcessor, this->pipeline());
-                target->draw(grVertices);
+                mesh.init(kTriangles_GrPrimitiveType, quadVertexBuffer, firstQuadVertex,
+                          quadVertices.count());
+                target->initDraw(quadProcessor);
+                target->draw(mesh);
             }
 
             SkAutoTUnref<GrGeometryProcessor> finishProcessor(
                     PLSFinishEffect::Create(this->color(), 
                                             pathPtr->getFillType() == 
                                                                 SkPath::FillType::kEvenOdd_FillType,
                                             invert, 
                                             this->usesLocalCoords()));
             const GrVertexBuffer* rectVertexBuffer;
             size_t finishStride = finishProcessor->getVertexStride();
             int firstRectVertex;
             static const int kRectVertexCount = 6;
             SkPoint* rectVerts = reinterpret_cast<SkPoint*>(target->makeVertexSpace(
                     finishStride, kRectVertexCount, &rectVertexBuffer, &firstRectVertex));
             if (!rectVerts) {
                 SkDebugf("Could not allocate vertices\n");
                 return;
             }
             rectVerts[0] = { bounds.fLeft, bounds.fTop };
             rectVerts[1] = { bounds.fLeft, bounds.fBottom };
             rectVerts[2] = { bounds.fRight, bounds.fBottom };
             rectVerts[3] = { bounds.fLeft, bounds.fTop };
             rectVerts[4] = { bounds.fRight, bounds.fTop };
             rectVerts[5] = { bounds.fRight, bounds.fBottom };
 
-            grVertices.init(kTriangles_GrPrimitiveType, rectVertexBuffer, firstRectVertex, 
-                            kRectVertexCount);
-            target->initDraw(finishProcessor, this->pipeline());
-            target->draw(grVertices);
+            mesh.init(kTriangles_GrPrimitiveType, rectVertexBuffer, firstRectVertex,
+                      kRectVertexCount);
+            target->initDraw(finishProcessor);
+            target->draw(mesh);
         }
     }
 
     SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
 
 private:
     PLSPathBatch(const Geometry& geometry) : INHERITED(ClassID()) {
         fGeoData.push_back(geometry);
 
         // compute bounds
@@ skipping 52 matching lines @@
 DRAW_BATCH_TEST_DEFINE(PLSPathBatch) {
     PLSPathBatch::Geometry geometry;
     geometry.fColor = GrRandomColor(random);
     geometry.fViewMatrix = GrTest::TestMatrixInvertible(random);
     geometry.fPath = GrTest::TestPathConvex(random);
 
     return PLSPathBatch::Create(geometry);
 }
 
 #endif