Add transfer buffer to GLCaps

src/gpu/gl/GrGLGpu.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "GrGLGpu.h"
 #include "GrGLGLSL.h"
@@ skipping 1462 matching lines @@
                 return nullptr;
             }
             GrIndexBuffer* indexBuffer = new GrGLIndexBuffer(this, desc);
             return indexBuffer;
         }
         return nullptr;
     }
 }
 
 GrTransferBuffer* GrGLGpu::onCreateTransferBuffer(size_t size, TransferType type) {
+    GrGLCaps::TransferBufferType xferBufferType = this->ctxInfo().caps()->transferBufferType();
+    if (GrGLCaps::kNone_TransferBufferType == xferBufferType) {
+        return nullptr;
+    }
+
     GrGLTransferBuffer::Desc desc;
     bool toGpu = (kCpuToGpu_TransferType == type);
     desc.fUsage = toGpu ? GrGLBufferImpl::kStreamDraw_Usage : GrGLBufferImpl::kStreamRead_Usage;
 
     desc.fSizeInBytes = size;
     
-    // TODO: check caps to see if we can create a PBO, and which kind
     GL_CALL(GenBuffers(1, &desc.fID));
     if (desc.fID) {
         CLEAR_ERROR_BEFORE_ALLOC(this->glInterface());
-        // make sure driver can allocate memory for this buffer
-        GrGLenum type = toGpu ? GR_GL_PIXEL_UNPACK_BUFFER : GR_GL_PIXEL_PACK_BUFFER;
+        // make sure driver can allocate memory for this bmapuffer
+        GrGLenum type;
+        if (GrGLCaps::kPBO_TransferBufferType == xferBufferType) {
+            type = toGpu ? GR_GL_PIXEL_UNPACK_BUFFER : GR_GL_PIXEL_PACK_BUFFER;
+        } else if (GrGLCaps::kChromium_TransferBufferType == xferBufferType) {
+            type = toGpu ? GR_GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM
+                         : GR_GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM;
+        } else {
+            SkASSERT(false);
+        }
         GL_ALLOC_CALL(this->glInterface(),
                       BufferData(type,
                                  (GrGLsizeiptr) desc.fSizeInBytes,
                                  nullptr,  // data ptr
                                  (toGpu ? GR_GL_STREAM_DRAW : GR_GL_STREAM_READ)));
         if (CHECK_ALLOC_ERROR(this->glInterface()) != GR_GL_NO_ERROR) {
             GL_CALL(DeleteBuffers(1, &desc.fID));
             return nullptr;
         }
         GrTransferBuffer* transferBuffer = new GrGLTransferBuffer(this, desc, type);
@@ skipping 138 matching lines @@
         SkDEBUGFAIL("Failed to generate GL program descriptor");
     }
 }
 
 void GrGLGpu::bindBuffer(GrGLuint id, GrGLenum type) {
     this->handleDirtyContext();
     if (GR_GL_ARRAY_BUFFER == type) {
         this->bindVertexBuffer(id);
     } else if (GR_GL_ELEMENT_ARRAY_BUFFER == type) {
         this->bindIndexBufferAndDefaultVertexArray(id);
+    } else {
+        GR_GL_CALL(this->glInterface(), BindBuffer(type, id));
     }
 }
 
 void GrGLGpu::releaseBuffer(GrGLuint id, GrGLenum type) {
     this->handleDirtyContext();
     GL_CALL(DeleteBuffers(1, &id));
     if (GR_GL_ARRAY_BUFFER == type) {
         this->notifyVertexBufferDelete(id);
     } else if (GR_GL_ELEMENT_ARRAY_BUFFER == type) {
         this->notifyIndexBufferDelete(id);
     }
 }
 
 static GrGLenum get_gl_usage(GrGLBufferImpl::Usage usage) {
     static const GrGLenum grToGL[] = {
         GR_GL_STATIC_DRAW,   // GrGLBufferImpl::kStaticDraw_Usage
         DYNAMIC_USAGE_PARAM, // GrGLBufferImpl::kDynamicDraw_Usage
         GR_GL_STREAM_DRAW,   // GrGLBufferImpl::kStreamDraw_Usage
         GR_GL_STREAM_READ,   // GrGLBufferImpl::kStreamRead_Usage
     };
     static_assert(SK_ARRAY_COUNT(grToGL) == GrGLBufferImpl::kUsageCount, "array_size_mismatch");
 
     return grToGL[usage];
 }
 
 void* GrGLGpu::mapBuffer(GrGLuint id, GrGLenum type, GrGLBufferImpl::Usage usage, 
                          size_t currentSize, size_t requestedSize) {
     void* mapPtr = nullptr;
     GrGLenum glUsage = get_gl_usage(usage);
+    bool readOnly = (GrGLBufferImpl::kStreamRead_Usage == usage);
+
     // Handling dirty context is done in the bindBuffer call
     switch (this->glCaps().mapBufferType()) {
         case GrGLCaps::kNone_MapBufferType:
             break;
         case GrGLCaps::kMapBuffer_MapBufferType:
             this->bindBuffer(id, type);
             // Let driver know it can discard the old data
             if (GR_GL_USE_BUFFER_DATA_NULL_HINT || currentSize != requestedSize) {
                 GL_CALL(BufferData(type, requestedSize, nullptr, glUsage));
             }
-            GL_CALL_RET(mapPtr, MapBuffer(type, GR_GL_WRITE_ONLY));
+            GL_CALL_RET(mapPtr, MapBuffer(type, readOnly ? GR_GL_READ_ONLY : GR_GL_WRITE_ONLY));
             break;
         case GrGLCaps::kMapBufferRange_MapBufferType: {
             this->bindBuffer(id, type);
             // Make sure the GL buffer size agrees with fDesc before mapping.
             if (currentSize != requestedSize) {
                 GL_CALL(BufferData(type, requestedSize, nullptr, glUsage));
             }
-            static const GrGLbitfield kAccess = GR_GL_MAP_INVALIDATE_BUFFER_BIT |
-                                                GR_GL_MAP_WRITE_BIT;
-            GL_CALL_RET(mapPtr, MapBufferRange(type, 0, requestedSize, kAccess));
+            static const GrGLbitfield kWriteAccess = GR_GL_MAP_INVALIDATE_BUFFER_BIT |

[jvanverth1, 2015/12/07 14:27:04]

I realized over the weekend that I need to fix this for the glyph atlas --
otherwise you can write some data into the buffer, transfer it, then try to
write some more and end up invalidating it. But that will be in the next change.

+                                                     GR_GL_MAP_WRITE_BIT;
+            GL_CALL_RET(mapPtr, MapBufferRange(type, 0, requestedSize, readOnly ? 
+                                                                       GR_GL_MAP_READ_BIT :                                                       
+                                                                       kWriteAccess));
             break;
         }
         case GrGLCaps::kChromium_MapBufferType:
             this->bindBuffer(id, type);
             // Make sure the GL buffer size agrees with fDesc before mapping.
             if (currentSize != requestedSize) {
                 GL_CALL(BufferData(type, requestedSize, nullptr, glUsage));
             }
-            GL_CALL_RET(mapPtr, MapBufferSubData(type, 0, requestedSize, GR_GL_WRITE_ONLY));
+            GL_CALL_RET(mapPtr, MapBufferSubData(type, 0, requestedSize, readOnly ? 
+                                                                         GR_GL_READ_ONLY : 
+                                                                         GR_GL_WRITE_ONLY));
             break;
     }
     return mapPtr;
 }
 
 void GrGLGpu::bufferData(GrGLuint id, GrGLenum type, GrGLBufferImpl::Usage usage, 
                          size_t currentSize, const void* src, size_t srcSizeInBytes) {
     SkASSERT(srcSizeInBytes <= currentSize);
     // bindbuffer handles dirty context
     this->bindBuffer(id, type);
@@ skipping 1881 matching lines @@
             this->setVertexArrayID(gpu, 0);
         }
         int attrCount = gpu->glCaps().maxVertexAttributes();
         if (fDefaultVertexArrayAttribState.count() != attrCount) {
             fDefaultVertexArrayAttribState.resize(attrCount);
         }
         attribState = &fDefaultVertexArrayAttribState;
     }
     return attribState;
 }