Revert of Improve tracking of bound FBOs in GrGLGpu.

src/gpu/gl/GrGLRenderTarget.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #ifndef GrGLRenderTarget_DEFINED
 #define GrGLRenderTarget_DEFINED
 
 #include "GrGLIRect.h"
 #include "GrRenderTarget.h"
 #include "SkScalar.h"
 
 class GrGLGpu;
 
-/** Represents a GL FBO object. It has a gen ID which is valid whenever the FBO ID owned by the
-    object is valid. The gen IDs are not recycled after FBOs are freed, unlike FBO IDs, and so
-    can be used to uniquely identity FBO ID instantiations. If this object owns an FBO ID, the ID
-    must be deleted or abandoned before this object is freed. FBO IDs should never be owned by
-    more than one instance. */
-class GrGLFBO : public SkNVRefCnt<GrGLFBO> {
-public:
-    SK_DECLARE_INST_COUNT(GrGLFBO);
-
-    /** Initializes to an FBO. The FBO should already be valid in the relevant GL context. */
-    GrGLFBO(GrGLint id) : fID(id), fIsValid(true) {}
-
-    /** Initializes to an FBO ID generated using the interface. */
-    GrGLFBO(const GrGLInterface* gl) {
-        GR_GL_CALL(gl, GenFramebuffers(1, &fID));
-        fIsValid = SkToBool(fID);
-    }
-
-    ~GrGLFBO() { SkASSERT(!this->isValid()); }
-
-    /** Has this object been released or abandoned? */
-    bool isValid() const { return fIsValid; }
-    
-    GrGLint fboID() const { SkASSERT(this->isValid()); return fID; }
-
-    bool isDefaultFramebuffer() const { return fIsValid && 0 == fID; }
-
-    /** Give up ownership of the FBO ID owned by this object without deleting it. */
-    void abandon();
-
-    /** Delete and give up ownership of the the FBO ID if it is valid. */
-    void release(const GrGLInterface*);
-
-private:
-    static uint32_t NextGenID() {
-        static int32_t gGenID = SK_InvalidGenID + 1;
-        return static_cast<uint32_t>(sk_atomic_inc(&gGenID));
-    }
-
-    GrGLuint    fID;
-    bool        fIsValid;
-
-    typedef SkRefCnt INHERITED;
-};
-
-//////////////////////////////////////////////////////////////////////////////
-
-/** GL-specific subclass of GrRenderTarget. */
 class GrGLRenderTarget : public GrRenderTarget {
 public:
+    // set fTexFBOID to this value to indicate that it is multisampled but
+    // Gr doesn't know how to resolve it.
+    enum { kUnresolvableFBOID = 0 };
+
     struct IDDesc {
-        SkAutoTUnref<GrGLFBO>       fRenderFBO;
-        SkAutoTUnref<GrGLFBO>       fTextureFBO;
+        GrGLuint                    fRTFBOID;
+        GrGLuint                    fTexFBOID;
         GrGLuint                    fMSColorRenderbufferID;
         GrGpuResource::LifeCycle    fLifeCycle;
     };
 
     GrGLRenderTarget(GrGLGpu*, const GrSurfaceDesc&, const IDDesc&);
 
     void setViewport(const GrGLIRect& rect) { fViewport = rect; }
     const GrGLIRect& getViewport() const { return fViewport; }
 
-    // For multisampled renderbuffer render targets, these will return different GrGLFBO objects. If
-    // the render target is not texturable, textureFBO() returns NULL. If the render target auto
-    // resolves to a texture, the same object is returned.
-
-    // FBO that should be rendered into. Always non-NULL unless this resource is destroyed
-    // (this->wasDestroyed()).
-    const GrGLFBO* renderFBO() const {
-        SkASSERT(fRenderFBO && fRenderFBO->isValid());
-        return fRenderFBO;
-    }
-
-    // FBO that has the target's texture ID attached. The return value may be:
-    //      * NULL when this render target is not a texture,
-    //      * the same as renderFBO() when this surface is not multisampled or auto-resolves,
-    //      * or different than renderFBO() when it requires explicit resolving via
-    //        glBlitFramebuffer.
-    const GrGLFBO* textureFBO() const {
-        SkASSERT(!fTextureFBO || fTextureFBO->isValid());
-        return fTextureFBO;
-    }
+    // The following two functions return the same ID when a
+    // texture/render target is multisampled, and different IDs when
+    // it is.
+    // FBO ID used to render into
+    GrGLuint renderFBOID() const { return fRTFBOID; }
+    // FBO ID that has texture ID attached.
+    GrGLuint textureFBOID() const { return fTexFBOID; }
 
     // override of GrRenderTarget
     ResolveType getResolveType() const SK_OVERRIDE {
-        if (!this->isMultisampled() || this->renderFBO() == this->textureFBO()) {
+        if (!this->isMultisampled() ||
+            fRTFBOID == fTexFBOID) {
             // catches FBO 0 and non MSAA case
             return kAutoResolves_ResolveType;
-        } else if (!this->textureFBO()) {
+        } else if (kUnresolvableFBOID == fTexFBOID) {
             return kCantResolve_ResolveType;
         } else {
             return kCanResolve_ResolveType;
         }
     }
 
     /** When we don't own the FBO ID we don't attempt to modify its attachments. */
     bool canAttemptStencilAttachment() const SK_OVERRIDE { return !fIsWrapped; }
 
 protected:
     // The public constructor registers this object with the cache. However, only the most derived
     // class should register with the cache. This constructor does not do the registration and
     // rather moves that burden onto the derived class.
     enum Derived { kDerived };
     GrGLRenderTarget(GrGLGpu*, const GrSurfaceDesc&, const IDDesc&, Derived);
 
     void init(const GrSurfaceDesc&, const IDDesc&);
 
     void onAbandon() SK_OVERRIDE;
     void onRelease() SK_OVERRIDE;
 
     // In protected because subclass GrGLTextureRenderTarget calls this version.
     size_t onGpuMemorySize() const SK_OVERRIDE;
 
 private:
-    SkAutoTUnref<GrGLFBO>   fRenderFBO;
-    SkAutoTUnref<GrGLFBO>   fTextureFBO;
-    GrGLuint                fMSColorRenderbufferID;
+    GrGLuint      fRTFBOID;
+    GrGLuint      fTexFBOID;
+    GrGLuint      fMSColorRenderbufferID;
 
     // We track this separately from GrGpuResource because this may be both a texture and a render
     // target, and the texture may be wrapped while the render target is not.
-    bool                    fIsWrapped;
+    bool fIsWrapped;
 
     // when we switch to this render target we want to set the viewport to
     // only render to content area (as opposed to the whole allocation) and
     // we want the rendering to be at top left (GL has origin in bottom left)
-    GrGLIRect               fViewport;
+    GrGLIRect fViewport;
 
     // onGpuMemorySize() needs to know what how many color values are owned per pixel. However,
     // abandon and release zero out the IDs and the cache needs to know the size even after those
     // actions.
-    uint8_t                 fColorValuesPerPixel;
+    uint8_t fColorValuesPerPixel;
 
     typedef GrRenderTarget INHERITED;
 };
 
 #endif