Revert of Some Vulkan memory fixes and cleanup

src/gpu/vk/GrVkMemory.h

 /*
 * Copyright 2015 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
 
 #ifndef GrVkMemory_DEFINED
 #define GrVkMemory_DEFINED
 
@@ skipping 75 matching lines @@
     VkDeviceSize   fSize;
     VkDeviceSize   fAlignment;
     VkDeviceSize   fFreeSize;
     VkDeviceSize   fLargestBlockSize;
     VkDeviceSize   fLargestBlockOffset;
     FreeList       fFreeList;
 };
 
 class GrVkSubHeap : public GrVkFreeListAlloc {
 public:
-    GrVkSubHeap(const GrVkGpu* gpu, uint32_t memoryTypeIndex, uint32_t heapIndex,
+    GrVkSubHeap(const GrVkGpu* gpu, uint32_t memoryTypeIndex,
                 VkDeviceSize size, VkDeviceSize alignment);
     ~GrVkSubHeap();
 
     uint32_t memoryTypeIndex() const { return fMemoryTypeIndex; }
     VkDeviceMemory memory() { return fAlloc; }
 
     bool alloc(VkDeviceSize requestedSize, GrVkAlloc* alloc);
     void free(const GrVkAlloc& alloc);
 
 private:
     const GrVkGpu* fGpu;
     uint32_t       fMemoryTypeIndex;
-    uint32_t       fHeapIndex;
     VkDeviceMemory fAlloc;
 
     typedef GrVkFreeListAlloc INHERITED;
 };
 
 class GrVkHeap {
 public:
     enum Strategy {
         kSubAlloc_Strategy,       // alloc large subheaps and suballoc within them
         kSingleAlloc_Strategy     // alloc/recycle an individual subheap per object
     };
 
     GrVkHeap(const GrVkGpu* gpu, Strategy strategy, VkDeviceSize subHeapSize)
         : fGpu(gpu)
         , fSubHeapSize(subHeapSize)
         , fAllocSize(0)
         , fUsedSize(0) {
         if (strategy == kSubAlloc_Strategy) {
             fAllocFunc = &GrVkHeap::subAlloc;
         } else {
             fAllocFunc = &GrVkHeap::singleAlloc;
         }
     }
 
     ~GrVkHeap() {}
 
     VkDeviceSize allocSize() const { return fAllocSize; }
     VkDeviceSize usedSize() const { return fUsedSize; }
 
-    bool alloc(VkDeviceSize size, VkDeviceSize alignment, uint32_t memoryTypeIndex,
-               uint32_t heapIndex, GrVkAlloc* alloc) {
+    bool alloc(VkDeviceSize size, VkDeviceSize alignment, uint32_t memoryTypeIndex, 
+               GrVkAlloc* alloc) {
         SkASSERT(size > 0);
-        return (*this.*fAllocFunc)(size, alignment, memoryTypeIndex, heapIndex, alloc);
+        return (*this.*fAllocFunc)(size, alignment, memoryTypeIndex, alloc);
     }
     bool free(const GrVkAlloc& alloc);
 
 private:
-    typedef bool (GrVkHeap::*AllocFunc)(VkDeviceSize size, VkDeviceSize alignment,
-                                        uint32_t memoryTypeIndex, uint32_t heapIndex,
-                                        GrVkAlloc* alloc);
+    typedef bool (GrVkHeap::*AllocFunc)(VkDeviceSize size, VkDeviceSize alignment, 
+                                        uint32_t memoryTypeIndex, GrVkAlloc* alloc);
 
-    bool subAlloc(VkDeviceSize size, VkDeviceSize alignment,
-                  uint32_t memoryTypeIndex, uint32_t heapIndex,
-                  GrVkAlloc* alloc);
+    bool subAlloc(VkDeviceSize size, VkDeviceSize alignment, 
+                  uint32_t memoryTypeIndex, GrVkAlloc* alloc);
     bool singleAlloc(VkDeviceSize size, VkDeviceSize alignment,
-                     uint32_t memoryTypeIndex, uint32_t heapIndex,
-                     GrVkAlloc* alloc);
+                     uint32_t memoryTypeIndex, GrVkAlloc* alloc);
 
     const GrVkGpu*         fGpu;
     VkDeviceSize           fSubHeapSize;
     VkDeviceSize           fAllocSize;
     VkDeviceSize           fUsedSize;
     AllocFunc              fAllocFunc;
     SkTArray<SkAutoTDelete<GrVkSubHeap>> fSubHeaps;
 };
 #endif