Make GrResourceCache2 responsible for calling release, abandon, and ~.

src/gpu/gl/GrGpuGL.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 "GrGpuGL.h"
 #include "GrGLStencilBuffer.h"
@@ skipping 1113 matching lines @@
 bool GrGpuGL::createStencilBufferForRenderTarget(GrRenderTarget* rt,
                                                  int width, int height) {
 
     // All internally created RTs are also textures. We don't create
     // SBs for a client's standalone RT (that is a RT that isn't also a texture).
     SkASSERT(rt->asTexture());
     SkASSERT(width >= rt->width());
     SkASSERT(height >= rt->height());
 
     int samples = rt->numSamples();
-    GrGLuint sbID;
-    GL_CALL(GenRenderbuffers(1, &sbID));
-    if (!sbID) {
-        return false;
-    }
+    GrGLuint sbID = 0;
 
     int stencilFmtCnt = this->glCaps().stencilFormats().count();
     for (int i = 0; i < stencilFmtCnt; ++i) {
+        if (!sbID) {
+            GL_CALL(GenRenderbuffers(1, &sbID));
+        }
+        if (!sbID) {
+            return false;
+        }
         GL_CALL(BindRenderbuffer(GR_GL_RENDERBUFFER, sbID));
         // we start with the last stencil format that succeeded in hopes
         // that we won't go through this loop more than once after the
         // first (painful) stencil creation.
         int sIdx = (i + fLastSuccessfulStencilFmtIdx) % stencilFmtCnt;
-        const GrGLCaps::StencilFormat& sFmt =
-                this->glCaps().stencilFormats()[sIdx];
+        const GrGLCaps::StencilFormat& sFmt = this->glCaps().stencilFormats()[sIdx];
         CLEAR_ERROR_BEFORE_ALLOC(this->glInterface());
         // we do this "if" so that we don't call the multisample
         // version on a GL that doesn't have an MSAA extension.
         bool created;
         if (samples > 0) {
             created = renderbuffer_storage_msaa(fGLContext,
                                                 samples,
                                                 sFmt.fInternalFormat,
                                                 width, height);
         } else {
-            GL_ALLOC_CALL(this->glInterface(),
-                          RenderbufferStorage(GR_GL_RENDERBUFFER,
-                                              sFmt.fInternalFormat,
-                                              width, height));
-            created =
-                (GR_GL_NO_ERROR == check_alloc_error(rt->desc(), this->glInterface()));
+            GL_ALLOC_CALL(this->glInterface(), RenderbufferStorage(GR_GL_RENDERBUFFER,
+                                                                   sFmt.fInternalFormat,
+                                                                   width, height));
+            created = (GR_GL_NO_ERROR == check_alloc_error(rt->desc(), this->glInterface()));
         }
         if (created) {
             // After sized formats we attempt an unsized format and take
             // whatever sizes GL gives us. In that case we query for the size.
             GrGLStencilBuffer::Format format = sFmt;
             get_stencil_rb_sizes(this->glInterface(), &format);
             static const bool kIsWrapped = false;
             SkAutoTUnref<GrStencilBuffer> sb(SkNEW_ARGS(GrGLStencilBuffer,
                                                   (this, kIsWrapped, sbID, width, height,
                                                   samples, format)));
+            // If we fail we have to create a new render buffer ID since we gave this one to the
+            // GrGLStencilBuffer object.
+            sbID = 0; 
             if (this->attachStencilBufferToRenderTarget(sb, rt)) {
                 fLastSuccessfulStencilFmtIdx = sIdx;
                 sb->transferToCache();
                 rt->setStencilBuffer(sb);
                 return true;
-           }
-           sb->abandon(); // otherwise we lose sbID
+            }
         }
     }
     GL_CALL(DeleteRenderbuffers(1, &sbID));
     return false;
 }
 
 bool GrGpuGL::attachStencilBufferToRenderTarget(GrStencilBuffer* sb, GrRenderTarget* rt) {
     GrGLRenderTarget* glrt = static_cast<GrGLRenderTarget*>(rt);
 
     GrGLuint fbo = glrt->renderFBOID();
@@ skipping 1362 matching lines @@
             this->setVertexArrayID(gpu, 0);
         }
         int attrCount = gpu->glCaps().maxVertexAttributes();
         if (fDefaultVertexArrayAttribState.count() != attrCount) {
             fDefaultVertexArrayAttribState.resize(attrCount);
         }
         attribState = &fDefaultVertexArrayAttribState;
     }
     return attribState;
 }