Consolidate GPU buffer implementations

src/gpu/vk/GrVkBuffer.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrVkBuffer.h"
 #include "GrVkGpu.h"
 #include "GrVkMemory.h"
@@ skipping 11 matching lines @@
     VkBuffer       buffer;
     VkDeviceMemory alloc;
 
     // create the buffer object
     VkBufferCreateInfo bufInfo;
     memset(&bufInfo, 0, sizeof(VkBufferCreateInfo));
     bufInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
     bufInfo.flags = 0;
     bufInfo.size = desc.fSizeInBytes;
     switch (desc.fType) {
-    case kVertex_Type:
+    case kVertex_GrBufferType:
         bufInfo.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
         break;
-    case kIndex_Type:
+    case kIndex_GrBufferType:
         bufInfo.usage = VK_BUFFER_USAGE_INDEX_BUFFER_BIT;
         break;
-    case kUniform_Type:
+    case kUniform_GrBufferType:
         bufInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
         break;
-    case kCopyRead_Type:
+    case kXferCpuToGpu_GrBufferType:
         bufInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
         break;
-    case kCopyWrite_Type:
+    case kXferGpuToCpu_GrBufferType:
         bufInfo.usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT;
         break;
 
     }
     bufInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
     bufInfo.queueFamilyIndexCount = 0;
     bufInfo.pQueueFamilyIndices = nullptr;
 
     VkResult err;
     err = VK_CALL(gpu, CreateBuffer(gpu->device(), &bufInfo, nullptr, &buffer));
@@ skipping 15 matching lines @@
     const GrVkBuffer::Resource* resource = new GrVkBuffer::Resource(buffer, alloc);
     if (!resource) {
         VK_CALL(gpu, DestroyBuffer(gpu->device(), buffer, nullptr));
         VK_CALL(gpu, FreeMemory(gpu->device(), alloc, nullptr));
         return nullptr;
     }
 
     return resource;
 }
 
+GrVkBuffer::GrVkBuffer(GrVkGpu* gpu, const Desc& desc, const GrVkBuffer::Resource* resource)
+    : INHERITED(gpu, desc.fType, desc.fSizeInBytes, desc.fAccessPattern, false),
+      fDesc(desc),
+      fResource(resource),
+      fMapPtr(nullptr) {
+}
+
+GrVkGpu* GrVkBuffer::vkGpu() const {
+    return static_cast<GrVkGpu*>(this->getGpu());
+}
 
 void GrVkBuffer::addMemoryBarrier(const GrVkGpu* gpu,
                                   VkAccessFlags srcAccessMask,
                                   VkAccessFlags dstAccesMask,
                                   VkPipelineStageFlags srcStageMask,
                                   VkPipelineStageFlags dstStageMask,
                                   bool byRegion) const {
     VkBufferMemoryBarrier bufferMemoryBarrier = {
         VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // sType
         NULL,                                    // pNext
@@ skipping 10 matching lines @@
     gpu->addBufferMemoryBarrier(srcStageMask, dstStageMask, byRegion, &bufferMemoryBarrier);
 }
 
 void GrVkBuffer::Resource::freeGPUData(const GrVkGpu* gpu) const {
     SkASSERT(fBuffer);
     SkASSERT(fAlloc);
     VK_CALL(gpu, DestroyBuffer(gpu->device(), fBuffer, nullptr));
     VK_CALL(gpu, FreeMemory(gpu->device(), fAlloc, nullptr));
 }
 
-void GrVkBuffer::vkRelease(const GrVkGpu* gpu) {
-    VALIDATE();
-    fResource->unref(gpu);
-    fResource = nullptr;
-    fMapPtr = nullptr;
-    VALIDATE();
+void GrVkBuffer::onRelease() {
+    if (!this->wasDestroyed()) {
+        VALIDATE();
+        fResource->unref(this->vkGpu());
+        fResource = nullptr;
+        fMapPtr = nullptr;
+        VALIDATE();
+    }
+    INHERITED::onRelease();
 }
 
-void GrVkBuffer::vkAbandon() {
+void GrVkBuffer::onAbandon() {
     fResource->unrefAndAbandon();
     fMapPtr = nullptr;
     VALIDATE();
+    INHERITED::onAbandon();
 }
 
-void* GrVkBuffer::vkMap(const GrVkGpu* gpu) {
+void GrVkBuffer::onMap() {
+    if (this->wasDestroyed()) {
+        return;
+    }
+
     VALIDATE();
     SkASSERT(!this->vkIsMapped());
 
     if (!fResource->unique()) {
         // in use by the command buffer, so we need to create a new one
-        fResource->unref(gpu);
-        fResource = Create(gpu, fDesc);
+        fResource->unref(this->vkGpu());
+        fResource = Create(this->vkGpu(), fDesc);
     }
 
-    VkResult err = VK_CALL(gpu, MapMemory(gpu->device(), alloc(), 0, VK_WHOLE_SIZE, 0, &fMapPtr));
+    VkResult err = VK_CALL(this->vkGpu(), MapMemory(this->vkGpu()->device(), alloc(), 0,
+                                                    VK_WHOLE_SIZE, 0, &fMapPtr));
     if (err) {
         fMapPtr = nullptr;
     }
 
     VALIDATE();
-    return fMapPtr;
 }
 
-void GrVkBuffer::vkUnmap(const GrVkGpu* gpu) {
+void GrVkBuffer::onUnmap() {
     VALIDATE();
     SkASSERT(this->vkIsMapped());
 
-    VK_CALL(gpu, UnmapMemory(gpu->device(), alloc()));
+    VK_CALL(this->vkGpu(), UnmapMemory(this->vkGpu()->device(), alloc()));
 
     fMapPtr = nullptr;
 }
 
 bool GrVkBuffer::vkIsMapped() const {
     VALIDATE();
     return SkToBool(fMapPtr);
 }
 
-bool GrVkBuffer::vkUpdateData(const GrVkGpu* gpu, const void* src, size_t srcSizeInBytes) {
+bool GrVkBuffer::onUpdateData(const void* src, size_t srcSizeInBytes) {
+    if (this->wasDestroyed()) {
+        return false;
+    }
+
     SkASSERT(!this->vkIsMapped());
     VALIDATE();
     if (srcSizeInBytes > fDesc.fSizeInBytes) {
         return false;
     }
 
     if (!fResource->unique()) {
         // in use by the command buffer, so we need to create a new one
-        fResource->unref(gpu);
-        fResource = Create(gpu, fDesc);
+        fResource->unref(this->vkGpu());
+        fResource = Create(this->vkGpu(), fDesc);
     }
 
     void* mapPtr;
-    VkResult err = VK_CALL(gpu, MapMemory(gpu->device(), alloc(), 0, srcSizeInBytes, 0, &mapPtr));
+    VkResult err = VK_CALL(this->vkGpu(), MapMemory(this->vkGpu()->device(), alloc(), 0,
+                                                    srcSizeInBytes, 0, &mapPtr));
 
     if (VK_SUCCESS != err) {
         return false;
     }
 
     memcpy(mapPtr, src, srcSizeInBytes);
 
-    VK_CALL(gpu, UnmapMemory(gpu->device(), alloc()));
+    VK_CALL(this->vkGpu(), UnmapMemory(this->vkGpu()->device(), alloc()));
 
     return true;
 }
 
 void GrVkBuffer::validate() const {
-    SkASSERT(!fResource || kVertex_Type == fDesc.fType || kIndex_Type == fDesc.fType
-             || kCopyRead_Type == fDesc.fType || kCopyWrite_Type == fDesc.fType
-             || kUniform_Type == fDesc.fType);
+    SkASSERT(!fResource || kVertex_GrBufferType == fDesc.fType ||
+             kIndex_GrBufferType == fDesc.fType ||
+             kXferCpuToGpu_GrBufferType == fDesc.fType ||
+             kXferGpuToCpu_GrBufferType == fDesc.fType ||
+             kUniform_GrBufferType == fDesc.fType);
 }