Revert of Track GL buffer state based on unique resource ID

src/gpu/GrBuffer.h

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrBuffer_DEFINED
 #define GrBuffer_DEFINED
 
 #include "GrGpuResource.h"
 
 class GrGpu;
 
 class GrBuffer : public GrGpuResource {
 public:
     /**
      * Computes a scratch key for a buffer with a "dynamic" access pattern. (Buffers with "static"
      * and "stream" access patterns are disqualified by nature from being cached and reused.)
      */
-    static void ComputeScratchKeyForDynamicBuffer(size_t size, GrBufferType intendedType,
+    static void ComputeScratchKeyForDynamicBuffer(GrBufferType type, size_t size,
                                                   GrScratchKey* key) {
         static const GrScratchKey::ResourceType kType = GrScratchKey::GenerateResourceType();
         GrScratchKey::Builder builder(key, kType, 1 + (sizeof(size_t) + 3) / 4);
         // TODO: There's not always reason to cache a buffer by type. In some (all?) APIs it's just
         // a chunk of memory we can use/reuse for any type of data. We really only need to
         // differentiate between the "read" types (e.g. kGpuToCpu_BufferType) and "draw" types.
-        builder[0] = intendedType;
+        builder[0] = type;
         builder[1] = (uint32_t)size;
         if (sizeof(size_t) > 4) {
             builder[2] = (uint32_t)((uint64_t)size >> 32);
         }
     }
 
+    GrBufferType type() const { return fType; }
+
     GrAccessPattern accessPattern() const { return fAccessPattern; }
 
     /**
      * Returns true if the buffer is a wrapper around a CPU array. If true it
      * indicates that map will always succeed and will be free.
      */
     bool isCPUBacked() const { return fCPUBacked; }
 
     /**
      * Maps the buffer to be written by the CPU.
@@ skipping 56 matching lines @@
      *
      * @return returns true if the update succeeds, false otherwise.
      */
     bool updateData(const void* src, size_t srcSizeInBytes) {
         SkASSERT(!this->isMapped());
         SkASSERT(srcSizeInBytes <= fGpuMemorySize);
         return this->onUpdateData(src, srcSizeInBytes);
     }
 
 protected:
-    GrBuffer(GrGpu* gpu, size_t gpuMemorySize, GrBufferType intendedType,
-             GrAccessPattern accessPattern, bool cpuBacked)
+    GrBuffer(GrGpu* gpu, GrBufferType type, size_t gpuMemorySize, GrAccessPattern accessPattern,
+             bool cpuBacked)
         : INHERITED(gpu, kCached_LifeCycle),
           fMapPtr(nullptr),
+          fType(type),
           fGpuMemorySize(gpuMemorySize), // TODO: Zero for cpu backed buffers?
           fAccessPattern(accessPattern),
           fCPUBacked(cpuBacked) {
         if (!fCPUBacked && SkIsPow2(fGpuMemorySize) && kDynamic_GrAccessPattern == fAccessPattern) {
             GrScratchKey key;
-            ComputeScratchKeyForDynamicBuffer(fGpuMemorySize, intendedType, &key);
+            ComputeScratchKeyForDynamicBuffer(fType, fGpuMemorySize, &key);
             this->setScratchKey(key);
         }
     }
 
     void* fMapPtr;
 
 private:
     virtual size_t onGpuMemorySize() const { return fGpuMemorySize; }
 
     virtual void onMap() = 0;
     virtual void onUnmap() = 0;
     virtual bool onUpdateData(const void* src, size_t srcSizeInBytes) = 0;
 
+    GrBufferType      fType;
     size_t            fGpuMemorySize;
     GrAccessPattern   fAccessPattern;
     bool              fCPUBacked;
 
     typedef GrGpuResource INHERITED;
 };
 
 #endif