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

src/gpu/GrMesh.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
-#ifndef GrVertices_DEFINED
-#define GrVertices_DEFINED
+#ifndef GrMesh_DEFINED
+#define GrMesh_DEFINED
 
 #include "GrIndexBuffer.h"
 #include "GrVertexBuffer.h"
 
-class GrNonInstancedVertices {
+class GrNonInstancedMesh {
 public:
     GrPrimitiveType primitiveType() const { return fPrimitiveType; }
     int startVertex() const { return fStartVertex; }
     int startIndex() const { return fStartIndex; }
     int vertexCount() const { return fVertexCount; }
     int indexCount() const { return fIndexCount; }
     bool isIndexed() const { return fIndexCount > 0; }
 
     const GrVertexBuffer* vertexBuffer() const { return fVertexBuffer.get(); }
     const GrIndexBuffer* indexBuffer() const { return fIndexBuffer.get(); }
 
 protected:
     GrPrimitiveType         fPrimitiveType;
     int                     fStartVertex;
     int                     fStartIndex;
     int                     fVertexCount;
     int                     fIndexCount;
     GrPendingIOResource<const GrVertexBuffer, kRead_GrIOType> fVertexBuffer;
     GrPendingIOResource<const GrIndexBuffer, kRead_GrIOType>  fIndexBuffer;
-    friend class GrVertices;
+    friend class GrMesh;
 };
 
 /**
  * Used to communicate index and vertex buffers, counts, and offsets for a draw from GrBatch to
  * GrGpu. It also holds the primitive type for the draw. TODO: Consider moving ownership of this
  * and draw-issuing responsibility to GrPrimitiveProcessor. The rest of the vertex info lives there
  * already (stride, attribute mappings).
  */
-class GrVertices : public GrNonInstancedVertices {
+class GrMesh : public GrNonInstancedMesh {
 public:
-    GrVertices() {}
-    GrVertices(const GrVertices& di) { (*this) = di; }
-    GrVertices& operator =(const GrVertices& di);
+    GrMesh() {}
+    GrMesh(const GrMesh& di) { (*this) = di; }
+    GrMesh& operator =(const GrMesh& di);
 
     void init(GrPrimitiveType primType, const GrVertexBuffer* vertexBuffer, int startVertex,
                 int vertexCount) {
         SkASSERT(vertexBuffer);
         SkASSERT(vertexCount);
         SkASSERT(startVertex >= 0);
         fPrimitiveType = primType;
         fVertexBuffer.reset(vertexBuffer);
         fIndexBuffer.reset(nullptr);
         fStartVertex = startVertex;
@@ skipping 66 matching lines @@
 
     /** These return 0 if initInstanced was not used to initialize the GrVertices. */
     int verticesPerInstance() const { return fVerticesPerInstance; }
     int indicesPerInstance() const { return fIndicesPerInstance; }
     int instanceCount() const { return fInstanceCount; }
 
     bool isInstanced() const { return fInstanceCount > 0; }
 
     class Iterator {
     public:
-        const GrNonInstancedVertices* init(const GrVertices& vertices) {
-            fVertices = &vertices;
-            if (vertices.fInstanceCount <= vertices.fMaxInstancesPerDraw) {
+        const GrNonInstancedMesh* init(const GrMesh& mesh) {
+            fMesh = &mesh;
+            if (mesh.fInstanceCount <= mesh.fMaxInstancesPerDraw) {
                 fInstancesRemaining = 0;
                 // Note, this also covers the non-instanced case!
-                return &vertices;
+                return &mesh;
             }
-            SkASSERT(vertices.isInstanced());
-            fInstanceBatch.fIndexBuffer.reset(vertices.fIndexBuffer.get());
-            fInstanceBatch.fVertexBuffer.reset(vertices.fVertexBuffer.get());
-            fInstanceBatch.fIndexCount = vertices.fMaxInstancesPerDraw *
-                                         vertices.fIndicesPerInstance;
-            fInstanceBatch.fVertexCount = vertices.fMaxInstancesPerDraw *
-                                          vertices.fVerticesPerInstance;
-            fInstanceBatch.fPrimitiveType = vertices.fPrimitiveType;
-            fInstanceBatch.fStartIndex = vertices.fStartIndex;
-            fInstanceBatch.fStartVertex = vertices.fStartVertex;
-            fInstancesRemaining = vertices.fInstanceCount - vertices.fMaxInstancesPerDraw;
+            SkASSERT(mesh.isInstanced());
+            fInstanceBatch.fIndexBuffer.reset(mesh.fIndexBuffer.get());
+            fInstanceBatch.fVertexBuffer.reset(mesh.fVertexBuffer.get());
+            fInstanceBatch.fIndexCount = mesh.fMaxInstancesPerDraw *
+                                         mesh.fIndicesPerInstance;
+            fInstanceBatch.fVertexCount = mesh.fMaxInstancesPerDraw *
+                                          mesh.fVerticesPerInstance;
+            fInstanceBatch.fPrimitiveType = mesh.fPrimitiveType;
+            fInstanceBatch.fStartIndex = mesh.fStartIndex;
+            fInstanceBatch.fStartVertex = mesh.fStartVertex;
+            fInstancesRemaining = mesh.fInstanceCount - mesh.fMaxInstancesPerDraw;
             return &fInstanceBatch;
         }
 
-        const GrNonInstancedVertices* next() {
+        const GrNonInstancedMesh* next() {
             if (!fInstancesRemaining) {
                 return nullptr;
             }
             fInstanceBatch.fStartVertex += fInstanceBatch.fVertexCount;
-            int instances = SkTMin(fInstancesRemaining, fVertices->fMaxInstancesPerDraw);
-            fInstanceBatch.fIndexCount = instances * fVertices->fIndicesPerInstance;
-            fInstanceBatch.fVertexCount = instances * fVertices->fVerticesPerInstance;
+            int instances = SkTMin(fInstancesRemaining, fMesh->fMaxInstancesPerDraw);
+            fInstanceBatch.fIndexCount = instances * fMesh->fIndicesPerInstance;
+            fInstanceBatch.fVertexCount = instances * fMesh->fVerticesPerInstance;
             fInstancesRemaining -= instances;
             return &fInstanceBatch;
         }
     private:
-        GrNonInstancedVertices fInstanceBatch;
-        const GrVertices* fVertices;
+        GrNonInstancedMesh fInstanceBatch;
+        const GrMesh* fMesh;
         int fInstancesRemaining;
     };
 
 private:
     int                     fInstanceCount;
     int                     fVerticesPerInstance;
     int                     fIndicesPerInstance;
     int                     fMaxInstancesPerDraw;
 };
 
 #endif