Improve tracking of bound FBOs in GrGLGpu.

src/gpu/gl/GrGLGpu.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 GrGLGpu_DEFINED
 #define GrGLGpu_DEFINED
 
@@ skipping 226 matching lines @@
 
     void initFSAASupport();
 
     // determines valid stencil formats
     void initStencilFormats();
 
     // sets a texture unit to use for texture operations other than binding a texture to a program.
     // ensures that such operations don't negatively interact with tracking bound textures.
     void setScratchTextureUnit();
 
-    // bounds is region that may be modified and therefore has to be resolved.
-    // NULL means whole target. Can be an empty rect.
-    void flushRenderTarget(GrGLRenderTarget*, const SkIRect* bounds);
+    // Enumerates the reasons for binding an FBO.
+    enum FBOBinding {
+        kDraw_FBOBinding,
+        kClear_FBOBinding,
+        kDiscard_FBOBinding,
+        kChangeAttachments_FBOBinding,
+        kReadPixels_FBOBinding,
+        kCopyTexSrc_FBOBinding,
+        kBlitSrc_FBOBinding,
+        kBlitDst_FBOBinding,
+    };
+
+    // binds the FBO and returns the GL enum of the framebuffer target it was bound to.
+    GrGLenum bindFBO(FBOBinding, const GrGLFBO*);
+
+    // Tracks dirty area for resolve, and tracks whether mip maps need rebuilding. bounds is the
+    // region that may be modified. NULL means whole surface. Can be an empty rect.
+    void markSurfaceContentsDirty(GrSurface*, const SkIRect* bounds);
+
+    void setViewport(const GrGLIRect& viewport);
 
     void flushStencil(const GrStencilSettings&);
+
     void flushHWAAState(GrRenderTarget* rt, bool useHWAA);
 
     bool configToGLFormats(GrPixelConfig config,
                            bool getSizedInternal,
                            GrGLenum* internalFormat,
                            GrGLenum* externalFormat,
                            GrGLenum* externalType);
     // helper for onCreateTexture and writeTexturePixels
     bool uploadTexData(const GrSurfaceDesc& desc,
                        bool isNewTexture,
@@ skipping 10 matching lines @@
     // with new data.
     bool uploadCompressedTexData(const GrSurfaceDesc& desc,
                                  const void* data,
                                  bool isNewTexture = true,
                                  int left = 0, int top = 0,
                                  int width = -1, int height = -1);
 
     bool createRenderTargetObjects(const GrSurfaceDesc&, bool budgeted, GrGLuint texID, 
                                    GrGLRenderTarget::IDDesc*);
 
-    enum TempFBOTarget {
-        kSrc_TempFBOTarget,
-        kDst_TempFBOTarget
-    };
+    static const FBOBinding kInvalidFBOBinding = static_cast<FBOBinding>(-1);
 
-    GrGLuint bindSurfaceAsFBO(GrSurface* surface, GrGLenum fboTarget, GrGLIRect* viewport,
-                              TempFBOTarget tempFBOTarget);
+    // Binds a surface as an FBO. A temporary FBO ID may be used if the surface is not already
+    // a render target. Afterwards unbindSurfaceAsFBOForCopy must be called with the value returned.
+    FBOBinding bindSurfaceAsFBOForCopy(GrSurface*, FBOBinding, GrGLIRect* viewport);
 
-    void unbindTextureFromFBO(GrGLenum fboTarget);
+    // Must be matched with bindSurfaceAsFBOForCopy.
+    void unbindSurfaceAsFBOForCopy(FBOBinding);
 
     GrGLContext fGLContext;
 
     // GL program-related state
     ProgramCache*               fProgramCache;
     SkAutoTUnref<GrGLProgram>   fCurrentProgram;
 
     ///////////////////////////////////////////////////////////////////////////
     ///@name Caching of GL State
     ///@{
     int                         fHWActiveTextureUnitIdx;
     GrGLuint                    fHWProgramID;
 
     enum TriState {
         kNo_TriState,
         kYes_TriState,
         kUnknown_TriState
     };
 
-    GrGLuint                    fTempSrcFBOID;
-    GrGLuint                    fTempDstFBOID;
-
-    GrGLuint                    fStencilClearFBOID;
+    SkAutoTUnref<GrGLFBO> fTempSrcFBO;
+    SkAutoTUnref<GrGLFBO> fTempDstFBO;
+    SkAutoTUnref<GrGLFBO> fStencilClearFBO;
 
     // last scissor / viewport scissor state seen by the GL.
     struct {
         TriState    fEnabled;
         GrGLIRect   fRect;
         void invalidate() {
             fEnabled = kUnknown_TriState;
             fRect.invalidate();
         }
     } fHWScissorSettings;
@@ skipping 125 matching lines @@
 
     TriState fMSAAEnabled;
 
     GrStencilSettings           fHWStencilSettings;
     TriState                    fHWStencilTestEnabled;
 
 
     GrPipelineBuilder::DrawFace fHWDrawFace;
     TriState                    fHWWriteToColor;
     TriState                    fHWDitherEnabled;
-    uint32_t                    fHWBoundRenderTargetUniqueID;
     SkTArray<uint32_t, true>    fHWBoundTextureUniqueIDs;
 
+    // Track fbo binding state for GL_DRAW_FRAMEBUFFER and GL_READ_FRAMEBUFFER
+    struct HWFBOBinding {
+        SkAutoTUnref<const GrGLFBO> fFBO;
+        void invalidate() { fFBO.reset(NULL); }
+    } fHWFBOBinding[2];
+
     ///@}
 
     // we record what stencil format worked last time to hopefully exit early
     // from our loop that tries stencil formats and calls check fb status.
     int fLastSuccessfulStencilFmtIdx;
 
     typedef GrGpu INHERITED;
     friend class GrGLPathRendering; // For accessing setTextureUnit.
 };
 
 #endif