Improve handling of FF vertex array state

src/gpu/gl/GrGLVertexArray.cpp

Index: src/gpu/gl/GrGLVertexArray.cpp
diff --git a/src/gpu/gl/GrGLVertexArray.cpp b/src/gpu/gl/GrGLVertexArray.cpp
index bf3d3b5e981240d85ca099980419374f84a308a9..605ec3327b3ad03e735c53aa339646ebeefa5536 100644
--- a/src/gpu/gl/GrGLVertexArray.cpp
+++ b/src/gpu/gl/GrGLVertexArray.cpp
@@ -49,7 +49,39 @@ void GrGLAttribArrayState::set(const GrGpuGL* gpu,
     }
 }
 
-void GrGLAttribArrayState::disableUnusedAttribArrays(const GrGpuGL* gpu, uint64_t usedMask) {
+void GrGLAttribArrayState::setFixedFunctionVertexArray(const GrGpuGL* gpu,
+                                                       GrGLVertexBuffer* buffer,
+                                                       GrGLint size,
+                                                       GrGLenum type,
+                                                       GrGLsizei stride,
+                                                       GrGLvoid* offset) {
+    SkASSERT(gpu->glCaps().fixedFunctionSupport());
+    AttribArrayState* array = &fFixedFunctionVertexArray;
+    if (!array->fEnableIsValid || !array->fEnabled) {
+        GR_GL_CALL(gpu->glInterface(), EnableClientState(GR_GL_VERTEX_ARRAY));
+        array->fEnableIsValid = true;
+        array->fEnabled = true;
+    }
+    if (!array->fAttribPointerIsValid ||
+        array->fVertexBufferID != buffer->bufferID() ||
+        array->fSize != size ||
+        array->fStride != stride ||
+        array->fOffset != offset) {
+
+        buffer->bind();
+        GR_GL_CALL(gpu->glInterface(), VertexPointer(size,
+                                                     type,
+                                                     stride,
+                                                     offset));
+        array->fAttribPointerIsValid = true;
+        array->fVertexBufferID = buffer->bufferID();
+        array->fSize = size;
+        array->fStride = stride;
+        array->fOffset = offset;
+    }
+}
+
+void GrGLAttribArrayState::disableUnusedArrays(const GrGpuGL* gpu, uint64_t usedMask, bool usingFFVertexArray) {
     int count = fAttribArrayStates.count();
     for (int i = 0; i < count; ++i) {
         if (!(usedMask & 0x1)) {
@@ -58,10 +90,41 @@ void GrGLAttribArrayState::disableUnusedAttribArrays(const GrGpuGL* gpu, uint64_
                 fAttribArrayStates[i].fEnableIsValid = true;
                 fAttribArrayStates[i].fEnabled = false;
             }
+        } else {
+            SkASSERT(fAttribArrayStates[i].fEnableIsValid && fAttribArrayStates[i].fEnabled);
         }
         // if the count is greater than 64 then this will become 0 and we will disable arrays 64+.
         usedMask >>= 1;
     }
+
+    // Deal with fixed-function vertex arrays.
+    if (gpu->glCaps().fixedFunctionSupport()) {
+        if (!usingFFVertexArray) {
+            if (!fFixedFunctionVertexArray.fEnableIsValid || fFixedFunctionVertexArray.fEnabled) {
+                GR_GL_CALL(gpu->glInterface(), DisableClientState(GR_GL_VERTEX_ARRAY));
+                fFixedFunctionVertexArray.fEnableIsValid = true;
+                fFixedFunctionVertexArray.fEnabled = false;
+            }
+        } else {
+            SkASSERT(fFixedFunctionVertexArray.fEnableIsValid && fFixedFunctionVertexArray.fEnabled);
+        }
+        // When we use fixed function vertex processing we always use the vertex array and none of
+        // the other arrays.
+        if (!fUnusedFixedFunctionArraysDisabled) {
+            GR_GL_CALL(gpu->glInterface(), DisableClientState(GR_GL_NORMAL_ARRAY));
+            GR_GL_CALL(gpu->glInterface(), DisableClientState(GR_GL_COLOR_ARRAY));
+            GR_GL_CALL(gpu->glInterface(), DisableClientState(GR_GL_SECONDARY_COLOR_ARRAY));
+            GR_GL_CALL(gpu->glInterface(), DisableClientState(GR_GL_INDEX_ARRAY));
+            GR_GL_CALL(gpu->glInterface(), DisableClientState(GR_GL_EDGE_FLAG_ARRAY));
+            for (int i = 0; i < gpu->glCaps().maxFixedFunctionTextureCoords(); ++i) {
+                GR_GL_CALL(gpu->glInterface(), ClientActiveTexture(GR_GL_TEXTURE0 + i));
+                GR_GL_CALL(gpu->glInterface(), DisableClientState(GR_GL_TEXTURE_COORD_ARRAY));
+            }
+            fUnusedFixedFunctionArraysDisabled = true;
+        }
+    } else {
+        SkASSERT(!usingFFVertexArray);
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -115,9 +178,6 @@ void GrGLVertexArray::notifyIndexBufferDelete(GrGLuint bufferID) {
  }
 
 void GrGLVertexArray::invalidateCachedState() {
-    int count = fAttribArrays.count();
-    for (int i = 0; i < count; ++i) {
-        fAttribArrays.invalidate();
-    }
+    fAttribArrays.invalidate();
     fIndexBufferIDIsValid = false;
 }