diff --git a/gpu/include/GrConfig.h b/gpu/include/GrConfig.h
index 2fa0164..ff694da 100644
--- a/gpu/include/GrConfig.h
+++ b/gpu/include/GrConfig.h
@@ -299,13 +299,6 @@
 #endif
 
 /**
- *  GR_GL_LOG_CALLS controls whether each GL call is logged.
- */
-#if !defined(GR_GL_LOG_CALLS)
-    #define GR_GL_LOG_CALLS 0 
-#endif
-
-/**
  *  GR_STATIC_RECT_VB controls whether rects are drawn by issuing a vertex
  *  for each corner or using a static vb that is positioned by modifying the
  *  view / texture matrix.
diff --git a/gpu/include/GrGLConfig.h b/gpu/include/GrGLConfig.h
index 7b28fbb..d19f0b9 100644
--- a/gpu/include/GrGLConfig.h
+++ b/gpu/include/GrGLConfig.h
@@ -68,6 +68,19 @@
  *      3. Optionally define GR_GL_FUNC.
  *      4. Define GR_GL_PROC_ADDRESS.
  *      5. Optionally define GR_GL_PROC_ADDRESS_HEADER
+ *
+ *
+ * The following are optional defines that can be enabled as command line macros
+ * defines, in a IDE project, in a GrUserConfig.h file, or in a GL custom setup
+ * file (if one is in use). They don't require GR_GL_CUSTOM_SETUP or
+ * GR_GL_CUSTOM_SETUP_HEADER to be enabled:
+ *
+ * GR_GL_NO_CLIENT_SIDE_ARRAYS can be defined to 1 to disable the use of client
+ * side vertex and index arrays.
+ *
+ * GR_GL_LOG_CALLS if 1 GrPrintf every GL call (for debugging purposes) when the
+ * global gPrintGL is true (it is initially true).
+
  */
 
 #if GR_GL_CUSTOM_SETUP
@@ -98,6 +111,9 @@
     #include GR_GL_CUSTOM_SETUP_HEADER
 
 #else
+    #undef GR_GL_FUNC
+    #undef GR_GL_PROC_ADDRESS
+    #undef GR_GL_PROC_ADDRESS_HEADER
 
     #if GR_WIN32_BUILD
         #define GR_SUPPORT_GLDESKTOP        1
@@ -144,8 +160,8 @@
         #define GR_GL_PROC_ADDRESS(X)       eglGetProcAddress(#X)
         #define GR_GL_PROC_ADDRESS_HEADER   <EGL/egl.h>
     #elif GR_LINUX_BUILD
-        #ifndef GL_GLEXT_PROTOTYPES		
-	        #define GL_GLEXT_PROTOTYPES		
+        #ifndef GL_GLEXT_PROTOTYPES
+            #define GL_GLEXT_PROTOTYPES
         #endif
         #define GL_EXT_framebuffer_blit     0
         #include <GL/gl.h>
@@ -184,6 +200,14 @@
     #error "Must define GR_GL_PROC_ADDRESS"
 #endif
 
+#if !defined(GR_GL_LOG_CALLS)
+    #define GR_GL_LOG_CALLS 0
+#endif
+
+#if !defined(GR_GL_NO_CLIENT_SIDE_ARRAYS)
+    #define GR_GL_NO_CLIENT_SIDE_ARRAYS 1
+#endif
+
 ////////////////////////////////////////////////////////////////////////////////
 
 #if GR_SCALAR_IS_FIXED
diff --git a/gpu/include/GrGLConfig_chrome.h b/gpu/include/GrGLConfig_chrome.h
index e61a66c..490a07e 100644
--- a/gpu/include/GrGLConfig_chrome.h
+++ b/gpu/include/GrGLConfig_chrome.h
@@ -18,4 +18,6 @@
 // chrome always assumes BGRA
 #define GR_GL_32BPP_COLOR_FORMAT    GR_BGRA
 
+#define GR_GL_NO_CLIENT_SIDE_ARRAYS 1
+
 #endif
diff --git a/gpu/src/GrContext.cpp b/gpu/src/GrContext.cpp
index 3446e23..e224891 100644
--- a/gpu/src/GrContext.cpp
+++ b/gpu/src/GrContext.cpp
@@ -16,6 +16,7 @@
 
 
 #include "GrContext.h"
+#include "GrTypes.h"
 #include "GrTextureCache.h"
 #include "GrTextStrike.h"
 #include "GrMemory.h"
@@ -343,7 +344,7 @@
 
     if (width >= 0) {
         // TODO: consider making static vertex buffers for these cases.
-        // Hairline could be done by just adding closing vertex to 
+        // Hairline could be done by just adding closing vertex to
         // unitSquareVertexBuffer()
         static const int worstCaseVertCount = 10;
         GrDrawTarget::AutoReleaseGeometry geo(fGpu, layout, worstCaseVertCount, 0);
@@ -387,13 +388,13 @@
             m.setAll(rect.width(), 0,             rect.fLeft,
                      0,            rect.height(), rect.fTop,
                      0,            0,             GrMatrix::I()[8]);
-            
+
             if (NULL != matrix) {
                 m.postConcat(*matrix);
             }
 
             fGpu->concatViewMatrix(m);
-        
+
             if (textured) {
                 fGpu->concatTextureMatrix(0, m);
             }
@@ -457,10 +458,10 @@
     GrPoint* pos = geo.positions();
     GrPoint* tex = pos + 1;
     static const size_t stride = 2 * sizeof(GrPoint);
-    pos[0].setRectFan(dstRect.fLeft, dstRect.fTop, 
+    pos[0].setRectFan(dstRect.fLeft, dstRect.fTop,
                       dstRect.fRight, dstRect.fBottom,
                       stride);
-    tex[0].setRectFan(srcRect.fLeft, srcRect.fTop, 
+    tex[0].setRectFan(srcRect.fLeft, srcRect.fTop,
                       srcRect.fRight, srcRect.fBottom,
                       stride);
 
@@ -546,14 +547,11 @@
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#define NEW_EVAL        1   // Use adaptive path tesselation
 #define STENCIL_OFF     0   // Always disable stencil (even when needed)
-#define CPU_TRANSFORM   0   // Transform path verts on CPU
-
-#if NEW_EVAL
-
 #define EVAL_TOL GR_Scalar1
 
+static const uint32_t MAX_POINTS_PER_CURVE = 1 << 10;
+
 static uint32_t quadratic_point_count(const GrPoint points[], GrScalar tol) {
     GrScalar d = points[1].distanceToLineSegmentBetween(points[0], points[2]);
     // TODO: fixed points sqrt
@@ -565,7 +563,7 @@
         // points.
         // 2^(log4(x)) = sqrt(x);
         d = ceilf(sqrtf(d/tol));
-        return GrNextPow2((uint32_t)d);
+        return GrMin(GrNextPow2((uint32_t)d), MAX_POINTS_PER_CURVE);
     }
 }
 
@@ -602,7 +600,7 @@
         return 1;
     } else {
         d = ceilf(sqrtf(d/tol));
-        return GrNextPow2((uint32_t)d);
+        return GrMin(GrNextPow2((uint32_t)d), MAX_POINTS_PER_CURVE);
     }
 }
 
@@ -636,45 +634,8 @@
     return a + b;
 }
 
-#else // !NEW_EVAL
-
-static GrScalar gr_eval_quad(const GrScalar coord[], GrScalar t) {
-    GrScalar A = coord[0] - 2 * coord[2] + coord[4];
-    GrScalar B = 2 * (coord[2] - coord[0]);
-    GrScalar C = coord[0];
-
-    return GrMul(GrMul(A, t) + B, t) + C;
-}
-
-static void gr_eval_quad_at(const GrPoint src[3], GrScalar t, GrPoint* pt) {
-    GrAssert(src);
-    GrAssert(pt);
-    GrAssert(t >= 0 && t <= GR_Scalar1);
-    pt->set(gr_eval_quad(&src[0].fX, t), gr_eval_quad(&src[0].fY, t));
-}
-
-static GrScalar gr_eval_cubic(const GrScalar coord[], GrScalar t) {
-    GrScalar A = coord[6] - coord[0] + 3 * (coord[2] - coord[4]);
-    GrScalar B = 3 * (coord[0] - 2 * coord[2] + coord[4]);
-    GrScalar C = 3 * (coord[2] - coord[0]);
-    GrScalar D = coord[0];
-
-    return GrMul(GrMul(GrMul(A, t) + B, t) + C, t) + D;
-}
-
-static void gr_eval_cubic_at(const GrPoint src[4], GrScalar t, GrPoint* pt) {
-    GrAssert(src);
-    GrAssert(pt);
-    GrAssert(t >= 0 && t <= GR_Scalar1);
-
-    pt->set(gr_eval_cubic(&src[0].fX, t), gr_eval_cubic(&src[0].fY, t));
-}
-
-#endif // !NEW_EVAL
-
 static int worst_case_point_count(GrPathIter* path,
                                   int* subpaths,
-                                  const GrMatrix& matrix,
                                   GrScalar tol) {
     int pointCount = 0;
     *subpaths = 1;
@@ -691,20 +652,10 @@
                 pointCount += 1;
                 break;
             case GrPathIter::kQuadratic_Command:
-#if NEW_EVAL
-                matrix.mapPoints(pts, pts, 3);
                 pointCount += quadratic_point_count(pts, tol);
-#else
-                pointCount += 9;
-#endif
                 break;
             case GrPathIter::kCubic_Command:
-#if NEW_EVAL
-                matrix.mapPoints(pts, pts, 4);
                 pointCount += cubic_point_count(pts, tol);
-#else
-                pointCount += 17;
-#endif
                 break;
             case GrPathIter::kMove_Command:
                 pointCount += 1;
@@ -752,7 +703,6 @@
 
     GrDrawTarget::AutoStateRestore asr(fGpu);
 
-#if NEW_EVAL
     GrMatrix viewM = fGpu->getViewMatrix();
     // In order to tesselate the path we get a bound on how much the matrix can
     // stretch when mapping to screen coordinates.
@@ -766,22 +716,12 @@
         // TODO: fixed point divide
         GrScalar sinv = 1 / stretch;
         tol = GrMul(tol, sinv);
-        viewM = GrMatrix::I();
     }
     GrScalar tolSqd = GrMul(tol, tol);
-#else
-    // pass to worst_case... but won't be used.
-    static const GrScalar tol = -1;
-#endif
 
     int subpathCnt;
     int maxPts = worst_case_point_count(path,
                                         &subpathCnt,
-#if CPU_TRANSFORM
-                                        cpuMatrix,
-#else
-                                        GrMatrix::I(),
-#endif
                                         tol);
     GrVertexLayout layout = 0;
 
@@ -800,10 +740,10 @@
     path->rewind();
 
     // TODO: use primitve restart if available rather than multiple draws
-    GrDrawTarget::PrimitiveType  type;
-    int                   passCount = 0;
-    GrDrawTarget::StencilPass    passes[3];
-    bool                  reverse = false;
+    GrDrawTarget::PrimitiveType type;
+    int                         passCount = 0;
+    GrDrawTarget::StencilPass   passes[3];
+    bool                        reverse = false;
 
     if (kHairLine_PathFill == fill) {
         type = GrDrawTarget::kLineStrip_PrimitiveType;
@@ -846,11 +786,6 @@
         }
     }
     fGpu->setReverseFill(reverse);
-#if CPU_TRANSFORM
-    GrMatrix cpuMatrix;
-    fGpu->getViewMatrix(&cpuMatrix);
-    fGpu->setViewMatrix(GrMatrix::I());
-#endif
 
     GrPoint pts[4];
 
@@ -859,10 +794,6 @@
 
     for (;;) {
         GrPathIter::Command cmd = path->next(pts);
-#if CPU_TRANSFORM
-        int numPts = GrPathIter::NumCommandPoints(cmd);
-        cpuMatrix.mapPoints(pts, pts, numPts);
-#endif
         switch (cmd) {
             case GrPathIter::kMove_Command:
                 if (!first) {
@@ -878,42 +809,15 @@
                 vert++;
                 break;
             case GrPathIter::kQuadratic_Command: {
-#if NEW_EVAL
-
                 generate_quadratic_points(pts[0], pts[1], pts[2],
                                           tolSqd, &vert,
                                           quadratic_point_count(pts, tol));
-#else
-                const int n = 8;
-                const GrScalar dt = GR_Scalar1 / n;
-                GrScalar t = dt;
-                for (int i = 1; i < n; i++) {
-                    gr_eval_quad_at(pts, t, (GrPoint*)vert);
-                    t += dt;
-                    vert++;
-                }
-                vert->set(pts[2].fX, pts[2].fY);
-                vert++;
-#endif
                 break;
             }
             case GrPathIter::kCubic_Command: {
-#if NEW_EVAL
                 generate_cubic_points(pts[0], pts[1], pts[2], pts[3],
-                                      tolSqd, &vert,
+                                      tolSqd, &vert, 
                                       cubic_point_count(pts, tol));
-#else
-                const int n = 16;
-                const GrScalar dt = GR_Scalar1 / n;
-                GrScalar t = dt;
-                for (int i = 1; i < n; i++) {
-                    gr_eval_cubic_at(pts, t, (GrPoint*)vert);
-                    t += dt;
-                    vert++;
-                }
-                vert->set(pts[3].fX, pts[3].fY);
-                vert++;
-#endif
                 break;
             }
             case GrPathIter::kClose_Command:
@@ -1139,7 +1043,7 @@
     uint32_t bits = 0;
     uint16_t width = key->width();
     uint16_t height = key->height();
-    
+
 
     if (!fGpu->npotTextureTileSupport()) {
         bool isPow2 = GrIsPow2(width) && GrIsPow2(height);
diff --git a/gpu/src/GrGpuGL.cpp b/gpu/src/GrGpuGL.cpp
index d366953..7a83ac8 100644
--- a/gpu/src/GrGpuGL.cpp
+++ b/gpu/src/GrGpuGL.cpp
@@ -47,8 +47,6 @@
     GL_ONE_MINUS_DST_ALPHA,
 };
 
-
-
 ///////////////////////////////////////////////////////////////////////////////
 
 static bool gPrintStartupSpew;
@@ -88,6 +86,14 @@
 }
 
 GrGpuGL::GrGpuGL() {
+
+#if GR_GL_NO_CLIENT_SIDE_ARRAYS
+    fClientArrayVB = NULL;
+    fClientArrayIB = NULL;
+    fOversizeVBDrawCnt = 0;
+    fOversizeIBDrawCnt = 0;
+#endif
+
     if (gPrintStartupSpew) {
         GrPrintf("------------------------- create GrGpuGL %p --------------\n",
                  this);
@@ -366,6 +372,10 @@
 }
 
 GrGpuGL::~GrGpuGL() {
+#if GR_GL_NO_CLIENT_SIDE_ARRAYS
+    GrSafeUnref(fClientArrayVB);
+    GrSafeUnref(fClientArrayIB);
+#endif
 }
 
 void GrGpuGL::resetContextHelper() {
@@ -425,6 +435,7 @@
     fHWGeometryState.fVertexBuffer = NULL;
     GR_GL(BindBuffer(GL_ARRAY_BUFFER, 0));
     GR_GL(BindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0));
+    fHWGeometryState.fArrayPtrsDirty = true;
 
     fHWDrawState.fRenderTarget = NULL;
 }
@@ -434,6 +445,64 @@
     resetContextHelper();
 }
 
+#if GR_GL_NO_CLIENT_SIDE_ARRAYS
+void GrGpuGL::putClientVertexDataInBuffer(const void* vertexData, size_t vertexDataSize) {
+    static const size_t MIN_VB_SIZE = 1 << 11;
+    static const int MAX_OVERSIZE_VB_DRAWS = 100;
+
+    if (NULL != vertexData) {
+        size_t currMinVBSize = GrMax(MIN_VB_SIZE, vertexDataSize);
+        // if we don't have a VB, its too small, or too big, create a new one
+        if (NULL == fClientArrayVB ||
+            fClientArrayVB->size() < currMinVBSize  ||
+            (fOversizeVBDrawCnt >= MAX_OVERSIZE_VB_DRAWS &&
+             currMinVBSize == MIN_VB_SIZE &&
+             fClientArrayVB->size() > MIN_VB_SIZE)) {
+
+            if (fHWGeometryState.fVertexBuffer == fClientArrayVB) {
+                fHWGeometryState.fVertexBuffer = NULL;
+                fHWGeometryState.fArrayPtrsDirty = true;
+            }
+            GrSafeUnref(fClientArrayVB);
+            fClientArrayVB = (GrGLVertexBuffer*)createVertexBuffer(currMinVBSize, true);
+            fOversizeVBDrawCnt = 0;
+                GrPrintf("Realloc VB 0%08x\n", currMinVBSize);
+        }
+        fClientArrayVB->updateData(vertexData, vertexDataSize);
+        if (currMinVBSize == MIN_VB_SIZE && fClientArrayVB->size() > MIN_VB_SIZE) {
+            ++fOversizeVBDrawCnt;
+        }
+    }
+}
+
+void GrGpuGL::putClientIndexDataInBuffer(const void* indexData, size_t indexDataSize) {
+    static const size_t MIN_IB_SIZE = 1 << 8;
+    static const int MAX_OVERSIZE_IB_DRAWS = 100;
+
+    if (NULL != indexData) {
+        size_t currMinIBSize = GrMax(MIN_IB_SIZE, indexDataSize);
+        // if we don't have a IB, its too small, or too big, create a new one
+        if (NULL == fClientArrayIB ||
+            fClientArrayIB->size() < currMinIBSize  ||
+            (fOversizeIBDrawCnt >= MAX_OVERSIZE_IB_DRAWS &&
+             currMinIBSize == MIN_IB_SIZE &&
+             fClientArrayIB->size() > MIN_IB_SIZE)) {
+
+            if (fHWGeometryState.fIndexBuffer == fClientArrayIB) {
+                fHWGeometryState.fIndexBuffer = NULL;
+            }
+            GrSafeUnref(fClientArrayIB);
+            fClientArrayIB = (GrGLIndexBuffer*)createIndexBuffer(currMinIBSize, true);
+            fOversizeIBDrawCnt = 0;
+        }
+        fClientArrayIB->updateData(indexData, indexDataSize);
+        if (currMinIBSize == MIN_IB_SIZE && fClientArrayIB->size() > MIN_IB_SIZE) {
+            ++fOversizeIBDrawCnt;
+        }
+    }
+}
+#endif
+
 GrRenderTarget* GrGpuGL::createPlatformRenderTarget(
                                                 intptr_t platformRenderTarget,
                                                 int width, int height) {
@@ -921,6 +990,7 @@
     GR_GL(GenBuffers(1, &id));
     if (id) {
         GR_GL(BindBuffer(GL_ARRAY_BUFFER, id));
+        fHWGeometryState.fArrayPtrsDirty = true;
         GrGLClearErr();
         // make sure driver can allocate memory for this buffer
         GR_GL_NO_ERR(BufferData(GL_ARRAY_BUFFER, size, NULL,
@@ -1132,12 +1202,20 @@
     GrAssert((size_t)type < GR_ARRAY_COUNT(gPrimitiveType2GLMode));
 
     GLvoid* indices = (GLvoid*)(sizeof(uint16_t) * startIndex);
+
+#if GR_GL_NO_CLIENT_SIDE_ARRAYS
+    if (kBuffer_GeometrySrcType != fGeometrySrc.fIndexSrc) {
+        // we accounted for the startIndex when shoving data into a vb
+        indices = NULL;
+    }
+#else
     if (kReserved_GeometrySrcType == fGeometrySrc.fIndexSrc) {
         indices = (GLvoid*)((intptr_t)indices + (intptr_t)fIndices.get());
     } else if (kArray_GeometrySrcType == fGeometrySrc.fIndexSrc) {
         indices = (GLvoid*)((intptr_t)indices +
                             (intptr_t)fGeometrySrc.fIndexArray);
     }
+#endif
 
     GR_GL(DrawElements(gPrimitiveType2GLMode[type], indexCount,
                        GL_UNSIGNED_SHORT, indices));
@@ -1537,7 +1615,10 @@
 }
 
 void GrGpuGL::notifyVertexBufferBind(const GrGLVertexBuffer* buffer) {
-    fHWGeometryState.fVertexBuffer = buffer;
+    if (fHWGeometryState.fVertexBuffer != buffer) {
+        fHWGeometryState.fArrayPtrsDirty = true;
+        fHWGeometryState.fVertexBuffer = buffer;
+    }
 }
 
 void GrGpuGL::notifyVertexBufferDelete(const GrGLVertexBuffer* buffer) {
@@ -1547,6 +1628,7 @@
     if (fHWGeometryState.fVertexBuffer == buffer) {
         // deleting bound buffer does implied bind to 0
         fHWGeometryState.fVertexBuffer = NULL;
+        fHWGeometryState.fArrayPtrsDirty = true;
     }
 }
 
@@ -1692,3 +1774,85 @@
             return false;
     }
 }
+
+
+const GLvoid* GrGpuGL::setBuffersAndGetVertexStart(int vertexStride, int startVertex,
+                                                   int startIndex, int vertexCount,
+                                                   int indexCount) {
+    const GLvoid* posPtr = (GLvoid*)(vertexStride * startVertex);
+
+    if (kBuffer_GeometrySrcType == fGeometrySrc.fVertexSrc) {
+        GrAssert(NULL != fGeometrySrc.fVertexBuffer);
+        GrAssert(!fGeometrySrc.fVertexBuffer->isLocked());
+        if (fHWGeometryState.fVertexBuffer != fGeometrySrc.fVertexBuffer) {
+            GrGLVertexBuffer* buf =
+                            (GrGLVertexBuffer*)fGeometrySrc.fVertexBuffer;
+            GR_GL(BindBuffer(GL_ARRAY_BUFFER, buf->bufferID()));
+            fHWGeometryState.fArrayPtrsDirty = true;
+            fHWGeometryState.fVertexBuffer = fGeometrySrc.fVertexBuffer;
+        }
+    } else {
+        if (kArray_GeometrySrcType == fGeometrySrc.fVertexSrc) {
+            posPtr = (void*)((intptr_t)fGeometrySrc.fVertexArray +
+                             (intptr_t)posPtr);
+        } else {
+            GrAssert(kReserved_GeometrySrcType == fGeometrySrc.fVertexSrc);
+            posPtr = (void*)((intptr_t)fVertices.get() + (intptr_t)posPtr);
+        }
+    #if GR_GL_NO_CLIENT_SIDE_ARRAYS
+        putClientVertexDataInBuffer(posPtr, vertexCount * vertexStride);
+        posPtr = NULL;
+        if (fHWGeometryState.fVertexBuffer != fClientArrayVB) {
+            GR_GL(BindBuffer(GL_ARRAY_BUFFER, fClientArrayVB->bufferID()));
+            fHWGeometryState.fArrayPtrsDirty = true;
+            fHWGeometryState.fVertexBuffer = fClientArrayVB;
+        }
+    #else
+        if (NULL != fHWGeometryState.fVertexBuffer) {
+            GR_GL(BindBuffer(GL_ARRAY_BUFFER, 0));
+            fHWGeometryState.fArrayPtrsDirty = true;
+            fHWGeometryState.fVertexBuffer = NULL;
+        }
+    #endif
+    }
+
+    if (0 != indexCount) {
+
+        if (kBuffer_GeometrySrcType == fGeometrySrc.fIndexSrc) {
+            GrAssert(NULL != fGeometrySrc.fIndexBuffer);
+            GrAssert(!fGeometrySrc.fIndexBuffer->isLocked());
+            if (fHWGeometryState.fIndexBuffer != fGeometrySrc.fIndexBuffer) {
+                GrGLIndexBuffer* buf =
+                (GrGLIndexBuffer*)fGeometrySrc.fIndexBuffer;
+                GR_GL(BindBuffer(GL_ELEMENT_ARRAY_BUFFER, buf->bufferID()));
+                fHWGeometryState.fIndexBuffer = fGeometrySrc.fIndexBuffer;
+            }
+        }
+        #if GR_GL_NO_CLIENT_SIDE_ARRAYS
+        else {
+            const uint16_t* indices;
+            if (kArray_GeometrySrcType == fGeometrySrc.fIndexSrc) {
+                indices = reinterpret_cast<const uint16_t*>(fGeometrySrc.fIndexArray);
+            } else {
+                GrAssert(kReserved_GeometrySrcType == fGeometrySrc.fIndexSrc);
+                indices = reinterpret_cast<const uint16_t*>(fIndices.get());
+            }
+            // we shove just the referenced part of the index data into the begining
+            // of the buffer and drawIndexedHelper ignores startIndex.
+            putClientIndexDataInBuffer(indices + startIndex, indexCount  * sizeof(uint16_t));
+            if (fHWGeometryState.fIndexBuffer != fClientArrayIB) {
+                GR_GL(BindBuffer(GL_ELEMENT_ARRAY_BUFFER, fClientArrayIB->bufferID()));
+                fHWGeometryState.fIndexBuffer = fClientArrayIB;
+            }
+        }
+        #else
+        else if (NULL != fHWGeometryState.fIndexBuffer) {
+            // we rely on drawIndexedHelper to pass to client side
+            // ptr to DrawElements
+            GR_GL(BindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0));
+            fHWGeometryState.fIndexBuffer = NULL;
+        }
+        #endif
+    }
+    return posPtr;
+}
diff --git a/gpu/src/GrGpuGL.h b/gpu/src/GrGpuGL.h
index 0ba405d..e46c2ce 100644
--- a/gpu/src/GrGpuGL.h
+++ b/gpu/src/GrGpuGL.h
@@ -66,6 +66,7 @@
         GrVertexLayout          fVertexLayout;
         const GrVertexBuffer*   fVertexBuffer;
         const GrIndexBuffer*    fIndexBuffer;
+        bool                    fArrayPtrsDirty;
     } fHWGeometryState;
 
     DrState   fHWDrawState;
@@ -88,6 +89,12 @@
 
     void setTextureUnit(int unitIdx);
 
+    // binds appropriate vertex and index buffers and returns either the ptr
+    // to client memory or offset into a VB of the first vertex
+    const GLvoid* setBuffersAndGetVertexStart(int vertexStride, int startVertex,
+                                              int startIndex, int vertexCount,
+                                              int indexCount);
+
     // flushes state that is common to fixed and programmable GL
     // dither
     // line smoothing
@@ -111,6 +118,13 @@
 
     GrGLExts fExts;
 
+#if GR_GL_NO_CLIENT_SIDE_ARRAYS
+    void putClientVertexDataInBuffer(const void* vertexData, 
+                                     size_t vertexDataSize);
+    void putClientIndexDataInBuffer(const void* indexData, 
+                                    size_t indexDataSize);
+#endif
+
 private:
     void resetContextHelper();
 
@@ -160,6 +174,13 @@
     int fActiveTextureUnitIdx;
 
     typedef GrGpu INHERITED;
+
+#if GR_GL_NO_CLIENT_SIDE_ARRAYS
+    GrGLVertexBuffer* fClientArrayVB;
+    GrGLIndexBuffer*  fClientArrayIB;
+    int               fOversizeVBDrawCnt;
+    int               fOversizeIBDrawCnt;
+#endif
 };
 
 bool has_gl_extension(const char* ext);
diff --git a/gpu/src/GrGpuGLFixed.cpp b/gpu/src/GrGpuGLFixed.cpp
index 3fd8d5c..a028cba 100644
--- a/gpu/src/GrGpuGLFixed.cpp
+++ b/gpu/src/GrGpuGLFixed.cpp
@@ -263,44 +263,9 @@
                                                     oldTexCoordOffsets,
                                                     &oldColorOffset);
 
-    const GLvoid* posPtr = (GLvoid*)(newStride * startVertex);
-
-    if (kBuffer_GeometrySrcType == fGeometrySrc.fVertexSrc) {
-        GrAssert(NULL != fGeometrySrc.fVertexBuffer);
-        GrAssert(!fGeometrySrc.fVertexBuffer->isLocked());
-        if (fHWGeometryState.fVertexBuffer != fGeometrySrc.fVertexBuffer) {
-            GrGLVertexBuffer* buf =
-                            (GrGLVertexBuffer*)fGeometrySrc.fVertexBuffer;
-            GR_GL(BindBuffer(GL_ARRAY_BUFFER, buf->bufferID()));
-            fHWGeometryState.fVertexBuffer = fGeometrySrc.fVertexBuffer;
-        }
-    } else {
-        if (kArray_GeometrySrcType == fGeometrySrc.fVertexSrc) {
-            posPtr = (void*)((intptr_t)fGeometrySrc.fVertexArray +
-                             (intptr_t)posPtr);
-        } else {
-            GrAssert(kReserved_GeometrySrcType == fGeometrySrc.fVertexSrc);
-            posPtr = (void*)((intptr_t)fVertices.get() + (intptr_t)posPtr);
-        }
-        if (NULL != fHWGeometryState.fVertexBuffer) {
-            GR_GL(BindBuffer(GL_ARRAY_BUFFER, 0));
-            fHWGeometryState.fVertexBuffer = NULL;
-        }
-    }
-
-    if (kBuffer_GeometrySrcType == fGeometrySrc.fIndexSrc) {
-        GrAssert(NULL != fGeometrySrc.fIndexBuffer);
-        GrAssert(!fGeometrySrc.fIndexBuffer->isLocked());
-        if (fHWGeometryState.fIndexBuffer != fGeometrySrc.fIndexBuffer) {
-            GrGLIndexBuffer* buf =
-            (GrGLIndexBuffer*)fGeometrySrc.fIndexBuffer;
-            GR_GL(BindBuffer(GL_ELEMENT_ARRAY_BUFFER, buf->bufferID()));
-            fHWGeometryState.fIndexBuffer = fGeometrySrc.fIndexBuffer;
-        }
-    } else if (NULL != fHWGeometryState.fIndexBuffer) {
-        GR_GL(BindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0));
-        fHWGeometryState.fIndexBuffer = NULL;
-    }
+    const GLvoid* posPtr = setBuffersAndGetVertexStart(newStride, startVertex,
+                                                       startIndex, vertexCount,
+                                                       indexCount);
 
     GLenum scalarType;
     if (fGeometrySrc.fVertexLayout & kTextFormat_VertexLayoutBit) {
@@ -317,7 +282,7 @@
     bool strideChange = newStride != oldStride;
     bool posChange = baseChange || scalarChange || strideChange;
 
-    if (posChange) {
+    if (posChange || fHWGeometryState.fArrayPtrsDirty) {
         GR_GL(VertexPointer(2, scalarType, newStride, posPtr));
         fHWGeometryState.fPositionPtr = posPtr;
     }
@@ -330,8 +295,9 @@
             if (oldTexCoordOffsets[s] < 0) {
                 GR_GL(ClientActiveTexture(GL_TEXTURE0+s));
                 GR_GL(EnableClientState(GL_TEXTURE_COORD_ARRAY));
-            }
-            if (posChange || newTexCoordOffsets[s] != oldTexCoordOffsets[s]) {
+                GR_GL(TexCoordPointer(2, scalarType, newStride, texCoordPtr));
+            } else if (fHWGeometryState.fArrayPtrsDirty || posChange ||
+                       newTexCoordOffsets[s] != oldTexCoordOffsets[s]) {
                 GR_GL(ClientActiveTexture(GL_TEXTURE0+s));
                 GR_GL(TexCoordPointer(2, scalarType, newStride, texCoordPtr));
             }
@@ -345,8 +311,9 @@
         GLvoid* colorPtr = (int8_t*)posPtr + newColorOffset;
         if (oldColorOffset <= 0) {
             GR_GL(EnableClientState(GL_COLOR_ARRAY));
-        }
-        if (posChange || newColorOffset != oldColorOffset) {
+            GR_GL(ColorPointer(4, GL_UNSIGNED_BYTE, newStride, colorPtr));
+        } else if (fHWGeometryState.fArrayPtrsDirty || posChange ||
+                   newColorOffset != oldColorOffset) {
             GR_GL(ColorPointer(4, GL_UNSIGNED_BYTE, newStride, colorPtr));
         }
     } else if (oldColorOffset > 0) {
@@ -354,6 +321,7 @@
     }
 
     fHWGeometryState.fVertexLayout = fGeometrySrc.fVertexLayout;
+    fHWGeometryState.fArrayPtrsDirty = false;
 }
 
 #endif
diff --git a/gpu/src/GrGpuGLShaders.cpp b/gpu/src/GrGpuGLShaders.cpp
index 053479f..b3bfc9a 100644
--- a/gpu/src/GrGpuGLShaders.cpp
+++ b/gpu/src/GrGpuGLShaders.cpp
@@ -855,44 +855,9 @@
                                                     oldTexCoordOffsets,
                                                     &oldColorOffset);
 
-    const GLvoid* posPtr = (GLvoid*)(newStride * startVertex);
-
-    if (kBuffer_GeometrySrcType == fGeometrySrc.fVertexSrc) {
-        GrAssert(NULL != fGeometrySrc.fVertexBuffer);
-        GrAssert(!fGeometrySrc.fVertexBuffer->isLocked());
-        if (fHWGeometryState.fVertexBuffer != fGeometrySrc.fVertexBuffer) {
-            GrGLVertexBuffer* buf =
-            (GrGLVertexBuffer*)fGeometrySrc.fVertexBuffer;
-            GR_GL(BindBuffer(GL_ARRAY_BUFFER, buf->bufferID()));
-            fHWGeometryState.fVertexBuffer = fGeometrySrc.fVertexBuffer;
-        }
-    } else {
-        if (kArray_GeometrySrcType == fGeometrySrc.fVertexSrc) {
-            posPtr = (void*)((intptr_t)fGeometrySrc.fVertexArray +
-                             (intptr_t)posPtr);
-        } else {
-            GrAssert(kReserved_GeometrySrcType == fGeometrySrc.fVertexSrc);
-            posPtr = (void*)((intptr_t)fVertices.get() + (intptr_t)posPtr);
-        }
-        if (NULL != fHWGeometryState.fVertexBuffer) {
-            GR_GL(BindBuffer(GL_ARRAY_BUFFER, 0));
-            fHWGeometryState.fVertexBuffer = NULL;
-        }
-    }
-
-    if (kBuffer_GeometrySrcType == fGeometrySrc.fIndexSrc) {
-        GrAssert(NULL != fGeometrySrc.fIndexBuffer);
-        GrAssert(!fGeometrySrc.fIndexBuffer->isLocked());
-        if (fHWGeometryState.fIndexBuffer != fGeometrySrc.fIndexBuffer) {
-            GrGLIndexBuffer* buf =
-            (GrGLIndexBuffer*)fGeometrySrc.fIndexBuffer;
-            GR_GL(BindBuffer(GL_ELEMENT_ARRAY_BUFFER, buf->bufferID()));
-            fHWGeometryState.fIndexBuffer = fGeometrySrc.fIndexBuffer;
-        }
-    } else if (NULL != fHWGeometryState.fIndexBuffer) {
-        GR_GL(BindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0));
-        fHWGeometryState.fIndexBuffer = NULL;
-    }
+    const GLvoid* posPtr = setBuffersAndGetVertexStart(newStride, startVertex,
+                                                       startIndex, vertexCount,
+                                                       indexCount);
 
     GLenum scalarType;
     bool texCoordNorm;
@@ -912,7 +877,7 @@
     bool strideChange = newStride != oldStride;
     bool posChange = baseChange || scalarChange || strideChange;
 
-    if (posChange) {
+    if (fHWGeometryState.fArrayPtrsDirty || posChange) {
         GR_GL(VertexAttribPointer(GR_GL_POS_ATTR_LOCATION, 2, scalarType,
                                   false, newStride, posPtr));
         fHWGeometryState.fPositionPtr = posPtr;
@@ -923,8 +888,10 @@
         GLvoid* texCoordPtr = (int8_t*)posPtr + newTexCoordOffsets[0];
         if (oldTexCoordOffsets[0] <= 0) {
             GR_GL(EnableVertexAttribArray(GR_GL_TEX_ATTR_LOCATION));
-        }
-        if (posChange || newTexCoordOffsets[0] != oldTexCoordOffsets[0]) {
+            GR_GL(VertexAttribPointer(GR_GL_TEX_ATTR_LOCATION, 2, scalarType,
+                                      texCoordNorm, newStride, texCoordPtr));
+        } else if (fHWGeometryState.fArrayPtrsDirty || posChange ||
+            newTexCoordOffsets[0] != oldTexCoordOffsets[0]) {
             GR_GL(VertexAttribPointer(GR_GL_TEX_ATTR_LOCATION, 2, scalarType,
                                       texCoordNorm, newStride, texCoordPtr));
         }
@@ -936,8 +903,12 @@
         GLvoid* colorPtr = (int8_t*)posPtr + newColorOffset;
         if (oldColorOffset <= 0) {
             GR_GL(EnableVertexAttribArray(GR_GL_COL_ATTR_LOCATION));
+            GR_GL(VertexAttribPointer(GR_GL_COL_ATTR_LOCATION, 4,
+                                      GL_UNSIGNED_BYTE,
+                                      true, newStride, colorPtr));
         }
-        if (posChange || newColorOffset != oldColorOffset) {
+        if (fHWGeometryState.fArrayPtrsDirty || posChange ||
+            newColorOffset != oldColorOffset) {
             GR_GL(VertexAttribPointer(GR_GL_COL_ATTR_LOCATION, 4,
                                       GL_UNSIGNED_BYTE,
                                       true, newStride, colorPtr));
@@ -947,5 +918,6 @@
     }
 
     fHWGeometryState.fVertexLayout = fGeometrySrc.fVertexLayout;
+    fHWGeometryState.fArrayPtrsDirty = false;
 }
 #endif
diff --git a/gpu/src/GrGpuGLShaders2.cpp b/gpu/src/GrGpuGLShaders2.cpp
index 9aa327a..81f83c9 100644
--- a/gpu/src/GrGpuGLShaders2.cpp
+++ b/gpu/src/GrGpuGLShaders2.cpp
@@ -988,11 +988,11 @@
     if (kPoints_PrimitiveType != primType) {
         desc->fOptFlags |= ProgramDesc::kNotPoints_OptFlagBit;
     }
-#if GR_AGGRESSIVE_SHADER_OPTS
-    if (!(desc->fVertexLayout & kColor_VertexLayoutBit) &&
-        (0xffffffff == fCurrDrawState.fColor)) {
-        desc->fOptFlags |= ProgramDesc::kVertexColorAllOnes_OptFlagBit;
-    }
+#if GR_AGGRESSIVE_SHADER_OPTS
+    if (!(desc->fVertexLayout & kColor_VertexLayoutBit) &&
+        (0xffffffff == fCurrDrawState.fColor)) {
+        desc->fOptFlags |= ProgramDesc::kVertexColorAllOnes_OptFlagBit;
+    }
 #endif
 
     for (int s = 0; s < kNumStages; ++s) {
@@ -1094,7 +1094,7 @@
     fProgram = NULL;
     fProgramCache = new ProgramCache();
 
-#if GR_DEBUG
+#if 0
     ProgramUnitTest();
 #endif
 }
@@ -1332,43 +1332,9 @@
                                                   oldTexCoordOffsets,
                                                   &oldColorOffset);
 
-    const GLvoid* posPtr = (GLvoid*)(newStride * startVertex);
-
-    if (kBuffer_GeometrySrcType == fGeometrySrc.fVertexSrc) {
-        GrAssert(NULL != fGeometrySrc.fVertexBuffer);
-        GrAssert(!fGeometrySrc.fVertexBuffer->isLocked());
-        if (fHWGeometryState.fVertexBuffer != fGeometrySrc.fVertexBuffer) {
-            GrGLVertexBuffer* buf =
-                                (GrGLVertexBuffer*)fGeometrySrc.fVertexBuffer;
-            GR_GL(BindBuffer(GL_ARRAY_BUFFER, buf->bufferID()));
-            fHWGeometryState.fVertexBuffer = fGeometrySrc.fVertexBuffer;
-        }
-    } else {
-        if (kArray_GeometrySrcType == fGeometrySrc.fVertexSrc) {
-            posPtr = (void*)((intptr_t)fGeometrySrc.fVertexArray +
-                             (intptr_t)posPtr);
-        } else {
-            GrAssert(kReserved_GeometrySrcType == fGeometrySrc.fVertexSrc);
-            posPtr = (void*)((intptr_t)fVertices.get() + (intptr_t)posPtr);
-        }
-        if (NULL != fHWGeometryState.fVertexBuffer) {
-            GR_GL(BindBuffer(GL_ARRAY_BUFFER, 0));
-            fHWGeometryState.fVertexBuffer = NULL;
-        }
-    }
-
-    if (kBuffer_GeometrySrcType == fGeometrySrc.fIndexSrc) {
-        GrAssert(NULL != fGeometrySrc.fIndexBuffer);
-        GrAssert(!fGeometrySrc.fIndexBuffer->isLocked());
-        if (fHWGeometryState.fIndexBuffer != fGeometrySrc.fIndexBuffer) {
-            GrGLIndexBuffer* buf = (GrGLIndexBuffer*)fGeometrySrc.fIndexBuffer;
-            GR_GL(BindBuffer(GL_ELEMENT_ARRAY_BUFFER, buf->bufferID()));
-            fHWGeometryState.fIndexBuffer = fGeometrySrc.fIndexBuffer;
-        }
-    } else if (NULL != fHWGeometryState.fIndexBuffer) {
-        GR_GL(BindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0));
-        fHWGeometryState.fIndexBuffer = NULL;
-    }
+    const GLvoid* posPtr = setBuffersAndGetVertexStart(newStride, startVertex, 
+                                                       startIndex, vertexCount,
+                                                       indexCount);
 
     GLenum scalarType;
     bool texCoordNorm;
@@ -1388,7 +1354,7 @@
     bool strideChange = newStride != oldStride;
     bool posChange = baseChange || scalarChange || strideChange;
 
-    if (posChange) {
+    if (fHWGeometryState.fArrayPtrsDirty || posChange) {
         GR_GL(VertexAttribPointer(POS_ATTR_LOCATION, 2, scalarType,
                                   false, newStride, posPtr));
         fHWGeometryState.fPositionPtr = posPtr;
@@ -1399,8 +1365,10 @@
             GLvoid* texCoordPtr = (int8_t*)posPtr + newTexCoordOffsets[t];
             if (oldTexCoordOffsets[t] <= 0) {
                 GR_GL(EnableVertexAttribArray(TEX_ATTR_LOCATION(t)));
-            }
-            if (posChange || newTexCoordOffsets[t] != oldTexCoordOffsets[t]) {
+                GR_GL(VertexAttribPointer(TEX_ATTR_LOCATION(t), 2, scalarType,
+                                          texCoordNorm, newStride, texCoordPtr));
+            } else if (fHWGeometryState.fArrayPtrsDirty || posChange || 
+                newTexCoordOffsets[t] != oldTexCoordOffsets[t]) {
                 GR_GL(VertexAttribPointer(TEX_ATTR_LOCATION(t), 2, scalarType,
                                           texCoordNorm, newStride, texCoordPtr));
             }
@@ -1413,8 +1381,11 @@
         GLvoid* colorPtr = (int8_t*)posPtr + newColorOffset;
         if (oldColorOffset <= 0) {
             GR_GL(EnableVertexAttribArray(COL_ATTR_LOCATION));
-        }
-        if (posChange || newColorOffset != oldColorOffset) {
+            GR_GL(VertexAttribPointer(COL_ATTR_LOCATION, 4,
+                                      GL_UNSIGNED_BYTE,
+                                      true, newStride, colorPtr));
+        } else if (fHWGeometryState.fArrayPtrsDirty || posChange || 
+            newColorOffset != oldColorOffset) {
             GR_GL(VertexAttribPointer(COL_ATTR_LOCATION, 4,
                                       GL_UNSIGNED_BYTE,
                                       true, newStride, colorPtr));
@@ -1427,3 +1398,4 @@
 }
 #endif
 
+