Use stream usage for dynamic vertex data.

src/gpu/gl/GrGLBufferImpl.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGLBufferImpl.h"
 #include "GrGpuGL.h"
 
 #define GL_CALL(GPU, X) GR_GL_CALL(GPU->glInterface(), X)
 
 #if GR_DEBUG
 #define VALIDATE() this->validate()
 #else
 #define VALIDATE() do {} while(false)
 #endif
 

[robertphillips, 2013/03/13 15:20:54]

GR_?
Comment as to why we even have this #define?

[bsalomon, 2013/03/13 15:29:22]

It's not exposed outside this cpp so I don't think it needs a prefix.
Will add:
// GL_STREAM_DRAW triggers an optimization in Chromium's GPU 
// process where a client's vertex objects are implemented 
// as client-side-arrays on tile-deferred architectures.

+#define DYNAMIC_USAGE_PARAM GR_GL_STREAM_DRAW
+
 GrGLBufferImpl::GrGLBufferImpl(GrGpuGL* gpu, const Desc& desc, GrGLenum bufferType)
     : fDesc(desc)
     , fBufferType(bufferType)
     , fLockPtr(NULL) {
     if (0 == desc.fID) {
         fCPUData = sk_malloc_flags(desc.fSizeInBytes, SK_MALLOC_THROW);
     } else {
         fCPUData = NULL;
     }
     VALIDATE();
@@ skipping 40 matching lines @@
     VALIDATE();
     GrAssert(!this->isLocked());
     if (0 == fDesc.fID) {
         fLockPtr = fCPUData;
     } else if (gpu->getCaps().bufferLockSupport()) {
         this->bind(gpu);
         // Let driver know it can discard the old data
         GL_CALL(gpu, BufferData(fBufferType,
                                 fDesc.fSizeInBytes,
                                 NULL,
-                                fDesc.fDynamic ? GR_GL_DYNAMIC_DRAW : GR_GL_STATIC_DRAW));
+                                fDesc.fDynamic ? DYNAMIC_USAGE_PARAM : GR_GL_STATIC_DRAW));
         GR_GL_CALL_RET(gpu->glInterface(),
                        fLockPtr,
                        MapBuffer(fBufferType, GR_GL_WRITE_ONLY));
     }
     return fLockPtr;
 }
 
 void GrGLBufferImpl::unlock(GrGpuGL* gpu) {
     VALIDATE();
     GrAssert(this->isLocked());
@@ skipping 14 matching lines @@
     GrAssert(!this->isLocked());
     VALIDATE();
     if (srcSizeInBytes > fDesc.fSizeInBytes) {
         return false;
     }
     if (0 == fDesc.fID) {
         memcpy(fCPUData, src, srcSizeInBytes);
         return true;
     }
     this->bind(gpu);
-    GrGLenum usage = fDesc.fDynamic ? GR_GL_DYNAMIC_DRAW : GR_GL_STATIC_DRAW;
+    GrGLenum usage = fDesc.fDynamic ? DYNAMIC_USAGE_PARAM : GR_GL_STATIC_DRAW;
 
 #if GR_GL_USE_BUFFER_DATA_NULL_HINT
     if (fDesc.fSizeInBytes == srcSizeInBytes) {
         GL_CALL(gpu, BufferData(fBufferType, srcSizeInBytes, src, usage));
     } else {
         // Before we call glBufferSubData we give the driver a hint using
         // glBufferData with NULL. This makes the old buffer contents
         // inaccessible to future draws. The GPU may still be processing
         // draws that reference the old contents. With this hint it can
         // assign a different allocation for the new contents to avoid
@@ skipping 26 matching lines @@
 #endif
     return true;
 }
 
 void GrGLBufferImpl::validate() const {
     GrAssert(GR_GL_ARRAY_BUFFER == fBufferType || GR_GL_ELEMENT_ARRAY_BUFFER == fBufferType);
     GrAssert((0 == fDesc.fID) == (NULL != fCPUData));
     GrAssert(0 != fDesc.fID || !fDesc.fIsWrapped);
     GrAssert(NULL == fCPUData || NULL == fLockPtr || fCPUData == fLockPtr);
 }