Revert of Use the GrCacheable ID to eliminate the need for notifications to GrGpuGL when textures and RTs are…

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 "GrGLNameAllocator.h"
@@ skipping 102 matching lines @@
 
 static bool gPrintStartupSpew;
 
 GrGpuGL::GrGpuGL(const GrGLContext& ctx, GrContext* context)
     : GrGpu(context)
     , fGLContext(ctx) {
 
     SkASSERT(ctx.isInitialized());
     fCaps.reset(SkRef(ctx.caps()));
 
-    fHWBoundTextureInstanceIDs.reset(this->glCaps().maxFragmentTextureUnits());
+    fHWBoundTextures.reset(this->glCaps().maxFragmentTextureUnits());
     fHWPathTexGenSettings.reset(this->glCaps().maxFixedFunctionTextureCoords());
 
     GrGLClearErr(fGLContext.interface());
     if (gPrintStartupSpew) {
         const GrGLubyte* vendor;
         const GrGLubyte* renderer;
         const GrGLubyte* version;
         GL_CALL_RET(vendor, GetString(GR_GL_VENDOR));
         GL_CALL_RET(renderer, GetString(GR_GL_RENDERER));
         GL_CALL_RET(version, GetString(GR_GL_VERSION));
@@ skipping 132 matching lines @@
         GL_CALL(LineWidth(1));
     }
 
     if (resetBits & kAA_GrGLBackendState) {
         fHWAAState.invalidate();
     }
 
     fHWActiveTextureUnitIdx = -1; // invalid
 
     if (resetBits & kTextureBinding_GrGLBackendState) {
-        for (int s = 0; s < fHWBoundTextureInstanceIDs.count(); ++s) {
-            fHWBoundTextureInstanceIDs[s] = 0;
+        for (int s = 0; s < fHWBoundTextures.count(); ++s) {
+            fHWBoundTextures[s] = NULL;
         }
     }
 
     if (resetBits & kBlend_GrGLBackendState) {
         fHWBlendState.invalidate();
     }
 
     if (resetBits & kView_GrGLBackendState) {
         fHWScissorSettings.invalidate();
         fHWViewport.invalidate();
     }
 
     if (resetBits & kStencil_GrGLBackendState) {
         fHWStencilSettings.invalidate();
         fHWStencilTestEnabled = kUnknown_TriState;
     }
 
     // Vertex
     if (resetBits & kVertex_GrGLBackendState) {
         fHWGeometryState.invalidate();
     }
 
     if (resetBits & kRenderTarget_GrGLBackendState) {
-        fHWBoundRenderTargetInstanceID = 0;
+        fHWBoundRenderTarget = NULL;
     }
 
     if (resetBits & kPathRendering_GrGLBackendState) {
         if (this->caps()->pathRenderingSupport()) {
             fHWProjectionMatrixState.invalidate();
             // we don't use the model view matrix.
             GL_CALL(MatrixLoadIdentity(GR_GL_MODELVIEW));
 
             for (int i = 0; i < this->glCaps().maxFixedFunctionTextureCoords(); ++i) {
                 GL_CALL(PathTexGen(GR_GL_TEXTURE0 + i, GR_GL_NONE, 0, NULL));
@@ skipping 548 matching lines @@
                                      &msColorFormat,
                                      NULL,
                                      NULL)) {
             goto FAILED;
         }
     } else {
         desc->fRTFBOID = desc->fTexFBOID;
     }
 
     // below here we may bind the FBO
-    fHWBoundRenderTargetInstanceID = 0;
+    fHWBoundRenderTarget = NULL;
     if (desc->fRTFBOID != desc->fTexFBOID) {
         SkASSERT(desc->fSampleCnt > 0);
         GL_CALL(BindRenderbuffer(GR_GL_RENDERBUFFER,
                                desc->fMSColorRenderbufferID));
         if (!renderbuffer_storage_msaa(fGLContext,
                                        desc->fSampleCnt,
                                        msColorFormat,
                                        width, height)) {
             goto FAILED;
         }
@@ skipping 364 matching lines @@
             GrGLenum status;
             GL_CALL_RET(status, CheckFramebufferStatus(GR_GL_FRAMEBUFFER));
             SkASSERT(GR_GL_FRAMEBUFFER_COMPLETE == status);
 #endif
         }
         return true;
     } else {
         GrGLStencilBuffer* glsb = static_cast<GrGLStencilBuffer*>(sb);
         GrGLuint rb = glsb->renderbufferID();
 
-        fHWBoundRenderTargetInstanceID = 0;
+        fHWBoundRenderTarget = NULL;
         GL_CALL(BindFramebuffer(GR_GL_FRAMEBUFFER, fbo));
         GL_CALL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
                                         GR_GL_STENCIL_ATTACHMENT,
                                         GR_GL_RENDERBUFFER, rb));
         if (glsb->format().fPacked) {
             GL_CALL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
                                             GR_GL_DEPTH_ATTACHMENT,
                                             GR_GL_RENDERBUFFER, rb));
         } else {
             GL_CALL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
@@ skipping 185 matching lines @@
         return;
     }
     if (NULL == renderTarget) {
         renderTarget = this->drawState()->getRenderTarget();
         if (NULL == renderTarget) {
             return;
         }
     }
 
     GrGLRenderTarget* glRT = static_cast<GrGLRenderTarget*>(renderTarget);
-    if (renderTarget->getInstanceID() != fHWBoundRenderTargetInstanceID) {
-        fHWBoundRenderTargetInstanceID = 0;
+    if (renderTarget != fHWBoundRenderTarget) {
+        fHWBoundRenderTarget = NULL;
         GL_CALL(BindFramebuffer(GR_GL_FRAMEBUFFER, glRT->renderFBOID()));
     }
     switch (this->glCaps().invalidateFBType()) {
         case GrGLCaps::kNone_FBFetchType:
             SkFAIL("Should never get here.");
             break;
         case GrGLCaps::kInvalidate_InvalidateFBType:
             if (0 == glRT->renderFBOID()) {
                 //  When rendering to the default framebuffer the legal values for attachments
                 //  are GL_COLOR, GL_DEPTH, GL_STENCIL, ... rather than the various FBO attachment
@@ skipping 242 matching lines @@
     }
     return true;
 }
 
 void GrGpuGL::flushRenderTarget(const SkIRect* bound) {
 
     GrGLRenderTarget* rt =
         static_cast<GrGLRenderTarget*>(this->drawState()->getRenderTarget());
     SkASSERT(NULL != rt);
 
-    uint64_t rtID = rt->getInstanceID();
-    if (fHWBoundRenderTargetInstanceID != rtID) {
+    if (fHWBoundRenderTarget != rt) {
         GL_CALL(BindFramebuffer(GR_GL_FRAMEBUFFER, rt->renderFBOID()));
 #ifdef SK_DEBUG
         // don't do this check in Chromium -- this is causing
         // lots of repeated command buffer flushes when the compositor is
         // rendering with Ganesh, which is really slow; even too slow for
         // Debug mode.
         if (!this->glContext().isChromium()) {
             GrGLenum status;
             GL_CALL_RET(status, CheckFramebufferStatus(GR_GL_FRAMEBUFFER));
             if (status != GR_GL_FRAMEBUFFER_COMPLETE) {
                 GrPrintf("GrGpuGL::flushRenderTarget glCheckFramebufferStatus %x\n", status);
             }
         }
 #endif
-        fHWBoundRenderTargetInstanceID = rtID;
+        fHWBoundRenderTarget = rt;
         const GrGLIRect& vp = rt->getViewport();
         if (fHWViewport != vp) {
             vp.pushToGLViewport(this->glInterface());
             fHWViewport = vp;
         }
     }
     if (NULL == bound || !bound->isEmpty()) {
         rt->flagAsNeedingResolve(bound);
     }
 
@@ skipping 246 matching lines @@
 void GrGpuGL::onResolveRenderTarget(GrRenderTarget* target) {
     GrGLRenderTarget* rt = static_cast<GrGLRenderTarget*>(target);
     if (rt->needsResolve()) {
         // Some extensions automatically resolves the texture when it is read.
         if (this->glCaps().usesMSAARenderBuffers()) {
             SkASSERT(rt->textureFBOID() != rt->renderFBOID());
             GL_CALL(BindFramebuffer(GR_GL_READ_FRAMEBUFFER, rt->renderFBOID()));
             GL_CALL(BindFramebuffer(GR_GL_DRAW_FRAMEBUFFER, rt->textureFBOID()));
             // make sure we go through flushRenderTarget() since we've modified
             // the bound DRAW FBO ID.
-            fHWBoundRenderTargetInstanceID = 0;
+            fHWBoundRenderTarget = NULL;
             const GrGLIRect& vp = rt->getViewport();
             const SkIRect dirtyRect = rt->getResolveRect();
             GrGLIRect r;
             r.setRelativeTo(vp, dirtyRect.fLeft, dirtyRect.fTop,
                             dirtyRect.width(), dirtyRect.height(), target->origin());
 
             GrAutoTRestore<ScissorState> asr;
             if (GrGLCaps::kES_Apple_MSFBOType == this->glCaps().msFBOType()) {
                 // Apple's extension uses the scissor as the blit bounds.
                 asr.reset(&fScissorState);
@@ skipping 273 matching lines @@
     SkASSERT(NULL != texture);
 
     // If we created a rt/tex and rendered to it without using a texture and now we're texturing
     // from the rt it will still be the last bound texture, but it needs resolving. So keep this
     // out of the "last != next" check.
     GrGLRenderTarget* texRT =  static_cast<GrGLRenderTarget*>(texture->asRenderTarget());
     if (NULL != texRT) {
         this->onResolveRenderTarget(texRT);
     }
 
-    uint64_t textureID = texture->getInstanceID();
-    if (fHWBoundTextureInstanceIDs[unitIdx] != textureID) {
+    if (fHWBoundTextures[unitIdx] != texture) {
         this->setTextureUnit(unitIdx);
         GL_CALL(BindTexture(GR_GL_TEXTURE_2D, texture->textureID()));
-        fHWBoundTextureInstanceIDs[unitIdx] = textureID;
+        fHWBoundTextures[unitIdx] = texture;
     }
 
     ResetTimestamp timestamp;
     const GrGLTexture::TexParams& oldTexParams = texture->getCachedTexParams(&timestamp);
     bool setAll = timestamp < this->getResetTimestamp();
     GrGLTexture::TexParams newTexParams;
 
     static GrGLenum glMinFilterModes[] = {
         GR_GL_NEAREST,
         GR_GL_LINEAR,
@@ skipping 207 matching lines @@
             case GrDrawState::kBoth_DrawFace:
                 GL_CALL(Disable(GR_GL_CULL_FACE));
                 break;
             default:
                 SkFAIL("Unknown draw face.");
         }
         fHWDrawFace = drawState.getDrawFace();
     }
 }
 
+void GrGpuGL::notifyRenderTargetDelete(GrRenderTarget* renderTarget) {
+    SkASSERT(NULL != renderTarget);
+    if (fHWBoundRenderTarget == renderTarget) {
+        fHWBoundRenderTarget = NULL;
+    }
+}
+
+void GrGpuGL::notifyTextureDelete(GrGLTexture* texture) {
+    for (int s = 0; s < fHWBoundTextures.count(); ++s) {
+        if (fHWBoundTextures[s] == texture) {
+            // deleting bound texture does implied bind to 0
+            fHWBoundTextures[s] = NULL;
+       }
+    }
+}
+
+
 GrGLuint GrGpuGL::createGLPathObject() {
     if (NULL == fPathNameAllocator.get()) {
         static const int range = 65536;
         GrGLuint firstName;
         GL_CALL_RET(firstName, GenPaths(range));
         fPathNameAllocator.reset(SkNEW_ARGS(GrGLNameAllocator, (firstName, firstName + range)));
     }
 
     GrGLuint name = fPathNameAllocator->allocateName();
     if (0 == name) {
@@ skipping 150 matching lines @@
             *externalType = GR_GL_FLOAT;
             break;
 
         default:
             return false;
     }
     return true;
 }
 
 void GrGpuGL::setTextureUnit(int unit) {
-    SkASSERT(unit >= 0 && unit < fHWBoundTextureInstanceIDs.count());
+    SkASSERT(unit >= 0 && unit < fHWBoundTextures.count());
     if (unit != fHWActiveTextureUnitIdx) {
         GL_CALL(ActiveTexture(GR_GL_TEXTURE0 + unit));
         fHWActiveTextureUnitIdx = unit;
     }
 }
 
 void GrGpuGL::setScratchTextureUnit() {
     // Bind the last texture unit since it is the least likely to be used by GrGLProgram.
-    int lastUnitIdx = fHWBoundTextureInstanceIDs.count() - 1;
+    int lastUnitIdx = fHWBoundTextures.count() - 1;
     if (lastUnitIdx != fHWActiveTextureUnitIdx) {
         GL_CALL(ActiveTexture(GR_GL_TEXTURE0 + lastUnitIdx));
         fHWActiveTextureUnitIdx = lastUnitIdx;
     }
     // clear out the this field so that if a program does use this unit it will rebind the correct
     // texture.
-    fHWBoundTextureInstanceIDs[lastUnitIdx] = 0;
+    fHWBoundTextures[lastUnitIdx] = NULL;
 }
 
 namespace {
 // Determines whether glBlitFramebuffer could be used between src and dst.
 inline bool can_blit_framebuffer(const GrSurface* dst,
                                  const GrSurface* src,
                                  const GrGpuGL* gpu,
                                  bool* wouldNeedTempFBO = NULL) {
     if (gpu->glCaps().isConfigRenderable(dst->config(), dst->desc().fSampleCnt > 0) &&
         gpu->glCaps().isConfigRenderable(src->config(), src->desc().fSampleCnt > 0) &&
@@ skipping 116 matching lines @@
     bool copied = false;
     bool wouldNeedTempFBO = false;
     if (can_copy_texsubimage(dst, src, this, &wouldNeedTempFBO) &&
         (!wouldNeedTempFBO || !inheritedCouldCopy)) {
         GrGLuint srcFBO;
         GrGLIRect srcVP;
         srcFBO = bind_surface_as_fbo(this->glInterface(), src, GR_GL_FRAMEBUFFER, &srcVP);
         GrGLTexture* dstTex = static_cast<GrGLTexture*>(dst->asTexture());
         SkASSERT(NULL != dstTex);
         // We modified the bound FBO
-        fHWBoundRenderTargetInstanceID = 0;
+        fHWBoundRenderTarget = NULL;
         GrGLIRect srcGLRect;
         srcGLRect.setRelativeTo(srcVP,
                                 srcRect.fLeft,
                                 srcRect.fTop,
                                 srcRect.width(),
                                 srcRect.height(),
                                 src->origin());
 
         this->setScratchTextureUnit();
         GL_CALL(BindTexture(GR_GL_TEXTURE_2D, dstTex->textureID()));
@@ skipping 21 matching lines @@
         }
 
         if (!selfOverlap) {
             GrGLuint dstFBO;
             GrGLuint srcFBO;
             GrGLIRect dstVP;
             GrGLIRect srcVP;
             dstFBO = bind_surface_as_fbo(this->glInterface(), dst, GR_GL_DRAW_FRAMEBUFFER, &dstVP);
             srcFBO = bind_surface_as_fbo(this->glInterface(), src, GR_GL_READ_FRAMEBUFFER, &srcVP);
             // We modified the bound FBO
-            fHWBoundRenderTargetInstanceID = 0;
+            fHWBoundRenderTarget = NULL;
             GrGLIRect srcGLRect;
             GrGLIRect dstGLRect;
             srcGLRect.setRelativeTo(srcVP,
                                     srcRect.fLeft,
                                     srcRect.fTop,
                                     srcRect.width(),
                                     srcRect.height(),
                                     src->origin());
             dstGLRect.setRelativeTo(dstVP,
                                     dstRect.fLeft,
@@ skipping 105 matching lines @@
             this->setVertexArrayID(gpu, 0);
         }
         int attrCount = gpu->glCaps().maxVertexAttributes();
         if (fDefaultVertexArrayAttribState.count() != attrCount) {
             fDefaultVertexArrayAttribState.resize(attrCount);
         }
         attribState = &fDefaultVertexArrayAttribState;
     }
     return attribState;
 }