Revert of Track GL buffer state based on unique resource ID

src/gpu/GrResourceProvider.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 "GrResourceProvider.h"
 
 #include "GrBuffer.h"
@@ skipping 14 matching lines @@
 }
 
 const GrBuffer* GrResourceProvider::createInstancedIndexBuffer(const uint16_t* pattern,
                                                                int patternSize,
                                                                int reps,
                                                                int vertCount,
                                                                const GrUniqueKey& key) {
     size_t bufferSize = patternSize * reps * sizeof(uint16_t);
 
     // This is typically used in GrBatchs, so we assume kNoPendingIO.
-    GrBuffer* buffer = this->createBuffer(bufferSize, kIndex_GrBufferType, kStatic_GrAccessPattern,
+    GrBuffer* buffer = this->createBuffer(kIndex_GrBufferType, bufferSize, kStatic_GrAccessPattern,
                                           kNoPendingIO_Flag);
     if (!buffer) {
         return nullptr;
     }
     uint16_t* data = (uint16_t*) buffer->map();
     bool useTempData = (nullptr == data);
     if (useTempData) {
         data = new uint16_t[reps * patternSize];
     }
     for (int i = 0; i < reps; ++i) {
@@ skipping 35 matching lines @@
     return this->gpu()->pathRendering()->createPathRange(gen, stroke);
 }
 
 GrPathRange* GrResourceProvider::createGlyphs(const SkTypeface* tf, const SkDescriptor* desc,
                                               const GrStrokeInfo& stroke) {
 
     SkASSERT(this->gpu()->pathRendering());
     return this->gpu()->pathRendering()->createGlyphs(tf, desc, stroke);
 }
 
-GrBuffer* GrResourceProvider::createBuffer(size_t size, GrBufferType intendedType,
+GrBuffer* GrResourceProvider::createBuffer(GrBufferType type, size_t size,
                                            GrAccessPattern accessPattern, uint32_t flags) {
     if (this->isAbandoned()) {
         return nullptr;
     }
 
     if (kDynamic_GrAccessPattern == accessPattern) {
         // bin by pow2 with a reasonable min
         static const uint32_t MIN_SIZE = 1 << 12;
         size = SkTMax(MIN_SIZE, GrNextPow2(SkToUInt(size)));
 
         GrScratchKey key;
-        GrBuffer::ComputeScratchKeyForDynamicBuffer(size, intendedType, &key);
+        GrBuffer::ComputeScratchKeyForDynamicBuffer(type, size, &key);
         uint32_t scratchFlags = 0;
         if (flags & kNoPendingIO_Flag) {
             scratchFlags = GrResourceCache::kRequireNoPendingIO_ScratchFlag;
         } else {
             scratchFlags = GrResourceCache::kPreferNoPendingIO_ScratchFlag;
         }
         GrGpuResource* resource = this->cache()->findAndRefScratchResource(key, size, scratchFlags);
         if (resource) {
             return static_cast<GrBuffer*>(resource);
         }
     }
-    return this->gpu()->createBuffer(size, intendedType, accessPattern);
+    return this->gpu()->createBuffer(type, size, accessPattern);
 }
 
 GrBatchAtlas* GrResourceProvider::createAtlas(GrPixelConfig config,
                                               int width, int height,
                                               int numPlotsX, int numPlotsY,
                                               GrBatchAtlas::EvictionFunc func, void* data) {
     GrSurfaceDesc desc;
     desc.fFlags = kNone_GrSurfaceFlags;
     desc.fWidth = width;
     desc.fHeight = height;
@@ skipping 59 matching lines @@
     return rt->renderTargetPriv().getStencilAttachment();
 }
 
 GrRenderTarget* GrResourceProvider::wrapBackendTextureAsRenderTarget(
         const GrBackendTextureDesc& desc) {
     if (this->isAbandoned()) {
         return nullptr;
     }
     return this->gpu()->wrapBackendTextureAsRenderTarget(desc);
 }