diff --git a/src/gpu/gl/GrGLCreateDebugInterface.cpp b/src/gpu/gl/GrGLCreateDebugInterface.cpp
index 022cc56..9427f0f 100644
--- a/src/gpu/gl/GrGLCreateDebugInterface.cpp
+++ b/src/gpu/gl/GrGLCreateDebugInterface.cpp
@@ -12,9 +12,6 @@
 #include "SkTArray.h"
 #include "SkTDArray.h"
 
-// the OpenGLES 2.0 spec says this must be >= 2
-static const GrGLint kDefaultMaxTextureUnits = 8;
-
 // the OpenGLES 2.0 spec says this must be >= 128
 static const GrGLint kDefaultMaxVertexUniformVectors = 128;
 
@@ -28,21 +25,47 @@
 static const GrGLint kDefaultMaxVaryingVectors = 8;
 
 ////////////////////////////////////////////////////////////////////////////////
+// Each class derived from GrFakeRefObj should use this macro to add a
+// factory creation entry point. This entry point is used by the GrGLDebug
+// object to instantiate the various objects
+// all globally unique IDs
+#define GR_DEFINE_CREATOR(className)                        \
+    public:                                                 \
+    static GrFakeRefObj *create ## className() {            \
+        return SkNEW(className);                            \
+    }
+
+////////////////////////////////////////////////////////////////////////////////
+// Helper macro to make creating an object (where you need to get back a derived
+// type) easier
+#define GR_CREATE(className, classEnum)                     \
+    reinterpret_cast<className *>(GrDebugGL::getInstance()->createObj(classEnum))
+
+////////////////////////////////////////////////////////////////////////////////
+// Helper macro to make finding objects less painful
+#define GR_FIND(id, className, classEnum)                   \
+    reinterpret_cast<className *>(GrDebugGL::getInstance()->findObject(id, classEnum))
+
+
+
+////////////////////////////////////////////////////////////////////////////////
 // This object is used to track the OpenGL objects. We don't use real
 // reference counting (i.e., we don't free the objects when their ref count 
 // goes to 0) so that we can detect invalid memory accesses. The refs we
 // are tracking in this class are actually OpenGL's references to the objects
 // not "ours"
 // Each object also gets a unique globally identifying ID
-class GrFakeRefObj
-{
+class GrFakeRefObj {
 public:
-    GrFakeRefObj(GrGLuint ID) 
+    GrFakeRefObj() 
         : fRef(0)
         , fHighRefCount(0)
-        , fID(ID)
         , fMarkedForDeletion(false)
         , fDeleted(false) {
+
+        static int fNextID = 0;  // source for globally unique IDs - 0 is reserved!
+
+        fID = ++fNextID;
     }
     virtual ~GrFakeRefObj() {};
 
@@ -71,13 +94,13 @@
     void setMarkedForDeletion() { fMarkedForDeletion = true; }
     bool getMarkedForDeletion() const { return fMarkedForDeletion; }
 
-    // setDeleted should only ever appear in deleteAction methods!
-    void setDeleted()           { fDeleted = true; }
     bool getDeleted() const     { return fDeleted; }
 
     // The deleteAction fires if the object has been marked for deletion but
     // couldn't be deleted earlier due to refs
-    virtual void deleteAction() = 0;
+    virtual void deleteAction() {
+        this->setDeleted();
+    }
 
 protected:
 private:
@@ -88,14 +111,18 @@
     // The deleted flag is only set when OpenGL thinks the object is deleted
     // It is obviously still allocated w/in this framework
     bool        fDeleted;
+
+    // setDeleted should only ever appear in the deleteAction method!
+    void setDeleted()           { fDeleted = true; }
 };
 
 ////////////////////////////////////////////////////////////////////////////////
-class GrBufferObj : public GrFakeRefObj
-{
+class GrBufferObj : public GrFakeRefObj {
+    GR_DEFINE_CREATOR(GrBufferObj);
+
 public:
-    GrBufferObj(GrGLuint ID) 
-        : GrFakeRefObj(ID)
+    GrBufferObj() 
+        : GrFakeRefObj()
         , fDataPtr(NULL)
         , fMapped(false)
         , fBound(false)
@@ -142,7 +169,8 @@
 
         // buffers are automatically unmapped when deleted
         this->resetMapped();
-        this->setDeleted();
+
+        this->INHERITED::deleteAction();
     }
 
 
@@ -159,24 +187,20 @@
 };
 
 ////////////////////////////////////////////////////////////////////////////////
-class GrRenderBufferObj : public GrFakeRefObj
-{
+// A common base class for render buffers and textures
+class GrFBBindable : public GrFakeRefObj {
+
 public:
-    GrRenderBufferObj(GrGLuint ID)
-        : GrFakeRefObj(ID)
-        , fBound(false) {
+    GrFBBindable() 
+        : GrFakeRefObj() {
     }
 
-    virtual ~GrRenderBufferObj() {
+    virtual ~GrFBBindable() {
         GrAlwaysAssert(0 == fColorReferees.count());
         GrAlwaysAssert(0 == fDepthReferees.count());
         GrAlwaysAssert(0 == fStencilReferees.count());
     }
 
-    void setBound()         { fBound = true; }
-    void resetBound()       { fBound = false; }
-    bool getBound() const   { return fBound; }
-
     void setColorBound(GrFakeRefObj *referee) { 
         fColorReferees.append(1, &referee);
     }
@@ -225,30 +249,147 @@
         return 0 != fStencilReferees.count();
     }
 
+
+protected:
+private:
+    SkTDArray<GrFakeRefObj *> fColorReferees;   // frame buffers that use this as a color buffer (via "glFramebufferRenderbuffer" or "glFramebufferTexture2D")
+    SkTDArray<GrFakeRefObj *> fDepthReferees;   // frame buffers that use this as a depth buffer (via "glFramebufferRenderbuffer" or "glFramebufferTexture2D")
+    SkTDArray<GrFakeRefObj *> fStencilReferees; // frame buffers that use this as a stencil buffer (via "glFramebufferRenderbuffer" or "glFramebufferTexture2D")
+
+    typedef GrFakeRefObj INHERITED;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+class GrRenderBufferObj : public GrFBBindable {
+    GR_DEFINE_CREATOR(GrRenderBufferObj);
+
+public:
+    GrRenderBufferObj()
+        : GrFBBindable()
+        , fBound(false) {
+    }
+
+    void setBound()         { fBound = true; }
+    void resetBound()       { fBound = false; }
+    bool getBound() const   { return fBound; }
+
     virtual void deleteAction() SK_OVERRIDE {
 
-        this->setDeleted();
+        this->INHERITED::deleteAction();
     }
 
 protected:
 private:
     bool fBound;           // is this render buffer currently bound via "glBindRenderbuffer"?
 
-    SkTDArray<GrFakeRefObj *> fColorReferees;   // frame buffers that use this as a color buffer (via "glFramebufferRenderbuffer")
-    SkTDArray<GrFakeRefObj *> fDepthReferees;   // frame buffers that use this as a depth buffer (via "glFramebufferRenderbuffer")
-    SkTDArray<GrFakeRefObj *> fStencilReferees; // frame buffers that use this as a stencil buffer (via "glFramebufferRenderbuffer")
+    typedef GrFBBindable INHERITED;
+};
+
+class GrTextureUnitObj;
+
+////////////////////////////////////////////////////////////////////////////////
+class GrTextureObj : public GrFBBindable {
+    GR_DEFINE_CREATOR(GrTextureObj);
+
+public:
+    GrTextureObj() 
+        : GrFBBindable() {
+    }
+
+    virtual ~GrTextureObj() {
+        GrAlwaysAssert(0 == fTextureUnitReferees.count());
+    }
+
+    void setBound(GrTextureUnitObj *referee) { 
+        fTextureUnitReferees.append(1, &referee);
+    }
+
+    void resetBound(GrTextureUnitObj *referee) { 
+        int index = fTextureUnitReferees.find(referee);
+        GrAlwaysAssert(0 <= index);
+        fTextureUnitReferees.removeShuffle(index);
+    }
+    bool getBound(GrTextureUnitObj *referee) const { 
+        int index = fTextureUnitReferees.find(referee);
+        return 0 <= index;
+    }
+    bool getBound() const { 
+        return 0 != fTextureUnitReferees.count();
+    }
+
+    virtual void deleteAction() SK_OVERRIDE {
+
+        this->INHERITED::deleteAction();
+    }
+
+protected:
+
+private:
+    SkTDArray<GrTextureUnitObj *> fTextureUnitReferees;   // texture units that bind this texture (via "glBindTexture")
+
+    typedef GrFBBindable INHERITED;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// Although texture unit objects are allocated & deallocated like the other
+// GL emulation objects they are derived from GrFakeRefObj to provide some
+// uniformity in how the GrDebugGL class manages resources
+class GrTextureUnitObj : public GrFakeRefObj {
+    GR_DEFINE_CREATOR(GrTextureUnitObj);
+
+public:
+    GrTextureUnitObj()
+        : GrFakeRefObj()
+        , fNumber(0)
+        , fTexture(NULL) {
+    }
+
+    void setNumber(GrGLenum number) {
+        fNumber = number;
+    }
+    GrGLenum getNumber() const { return fNumber; }
+
+    void setTexture(GrTextureObj *texture)  { 
+
+        if (fTexture) {
+            GrAlwaysAssert(fTexture->getBound(this));
+            fTexture->resetBound(this);
+
+            GrAlwaysAssert(!fTexture->getDeleted());
+            fTexture->unref();
+        }
+
+        fTexture = texture; 
+
+        if (fTexture) {
+            GrAlwaysAssert(!fTexture->getDeleted());
+            fTexture->ref();
+
+            GrAlwaysAssert(!fTexture->getBound(this));
+            fTexture->setBound(this);
+        }
+    }
+
+    GrTextureObj *getTexture()                  { return fTexture; }
+
+protected:
+private:
+    GrGLenum fNumber;
+    GrTextureObj *fTexture;
 
     typedef GrFakeRefObj INHERITED;
 };
 
+
 ////////////////////////////////////////////////////////////////////////////////
 // TODO: when a framebuffer obj is bound the GL_SAMPLES query must return 0
 // TODO: GL_STENCIL_BITS must also be redirected to the framebuffer
-class GrFrameBufferObj : public GrFakeRefObj
-{
+class GrFrameBufferObj : public GrFakeRefObj {
+    GR_DEFINE_CREATOR(GrFrameBufferObj);
+
 public:
-    GrFrameBufferObj(GrGLuint ID)
-        : GrFakeRefObj(ID)
+    GrFrameBufferObj()
+        : GrFakeRefObj()
         , fBound(false)
         , fColorBuffer(NULL)
         , fDepthBuffer(NULL)
@@ -265,7 +406,7 @@
     void resetBound()       { fBound = false; }
     bool getBound() const   { return fBound; }
 
-    void setColor(GrRenderBufferObj *buffer) {
+    void setColor(GrFBBindable *buffer) {
         if (fColorBuffer) {
             // automatically break the binding of the old buffer
             GrAlwaysAssert(fColorBuffer->getColorBound(this));
@@ -283,9 +424,9 @@
             fColorBuffer->setColorBound(this);
         }
     }
-    GrRenderBufferObj *getColor()       { return fColorBuffer; }
+    GrFBBindable *getColor()       { return fColorBuffer; }
 
-    void setDepth(GrRenderBufferObj *buffer) {
+    void setDepth(GrFBBindable *buffer) {
         if (fDepthBuffer) {
             // automatically break the binding of the old buffer
             GrAlwaysAssert(fDepthBuffer->getDepthBound(this));
@@ -303,9 +444,9 @@
             fDepthBuffer->setDepthBound(this);
         }
     }
-    GrRenderBufferObj *getDepth()       { return fDepthBuffer; }
+    GrFBBindable *getDepth()       { return fDepthBuffer; }
 
-    void setStencil(GrRenderBufferObj *buffer) {
+    void setStencil(GrFBBindable *buffer) {
         if (fStencilBuffer) {
             // automatically break the binding of the old buffer
             GrAlwaysAssert(fStencilBuffer->getStencilBound(this));
@@ -323,39 +464,42 @@
             fStencilBuffer->setStencilBound(this);
         }
     }
-    GrRenderBufferObj *getStencil()     { return fStencilBuffer; }
+    GrFBBindable *getStencil()     { return fStencilBuffer; }
 
     virtual void deleteAction() SK_OVERRIDE {
 
         setColor(NULL);
         setDepth(NULL);
         setStencil(NULL);
-        this->setDeleted();
+
+        this->INHERITED::deleteAction();
     }
 
 protected:
 private:
     bool fBound;        // is this frame buffer currently bound via "glBindFramebuffer"?
-    GrRenderBufferObj * fColorBuffer;
-    GrRenderBufferObj * fDepthBuffer;
-    GrRenderBufferObj * fStencilBuffer;
+    GrFBBindable * fColorBuffer;
+    GrFBBindable * fDepthBuffer;
+    GrFBBindable * fStencilBuffer;
 
     typedef GrFakeRefObj INHERITED;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
-class GrShaderObj : public GrFakeRefObj
-{
-public:
-    GrShaderObj(GrGLuint ID, GrGLenum type) 
-        : GrFakeRefObj(ID)
-        , fType(type)   {}
+class GrShaderObj : public GrFakeRefObj {
+    GR_DEFINE_CREATOR(GrShaderObj);
 
+public:
+    GrShaderObj() 
+        : GrFakeRefObj()
+        , fType(GR_GL_VERTEX_SHADER)   {}
+
+    void setType(GrGLenum type) { fType = type; }
     GrGLenum getType()  { return fType; }
 
     virtual void deleteAction() SK_OVERRIDE {
 
-        this->setDeleted();
+        this->INHERITED::deleteAction();
     }
 
 protected:
@@ -367,11 +511,12 @@
 
 
 ////////////////////////////////////////////////////////////////////////////////
-class GrProgramObj : public GrFakeRefObj
-{
+class GrProgramObj : public GrFakeRefObj {
+    GR_DEFINE_CREATOR(GrProgramObj);
+
 public:
-    GrProgramObj(GrGLuint ID) 
-        : GrFakeRefObj(ID)
+    GrProgramObj() 
+        : GrFakeRefObj()
         , fInUse(false) {}
 
     void AttachShader(GrShaderObj *shader) {
@@ -388,7 +533,7 @@
         }
         fShaders.reset();
 
-        this->setDeleted();
+        this->INHERITED::deleteAction();
     }
 
     // TODO: this flag system won't work w/ multiple contexts!
@@ -408,99 +553,30 @@
 ////////////////////////////////////////////////////////////////////////////////
 // This is the main debugging object. It is a singleton and keeps track of
 // all the other debug objects.
-class GrDebugGL
-{
+class GrDebugGL {
 public:
-    // TODO: merge findBuffer, findFrameBuffer, findShader & findProgram??
-    GrBufferObj *findBuffer(GrGLuint ID) {
-        GrFakeRefObj *obj = this->findObject(ID);
-        if (NULL == obj) {
-            return NULL;
-        }
+    typedef enum GrObjTypes {
+        kTexture_ObjTypes = 0,
+        kBuffer_ObjTypes,
+        kRenderBuffer_ObjTypes,
+        kFrameBuffer_ObjTypes,
+        kShader_ObjTypes,
+        kProgram_ObjTypes,
+        kTextureUnit_ObjTypes,
+        kObjTypeCount
+    };
 
-        return reinterpret_cast<GrBufferObj *>(obj);
+    GrFakeRefObj *createObj(GrObjTypes type) {
+        GrFakeRefObj *temp = (*gFactoryFunc[type])();
+
+        fObjects.push_back(temp);
+
+        return temp;
     }
 
-    GrFrameBufferObj *findFrameBuffer(GrGLuint ID) {
-        GrFakeRefObj *obj = this->findObject(ID);
-        if (NULL == obj) {
-            return NULL;
-        }
-
-        return reinterpret_cast<GrFrameBufferObj *>(obj);
-    }
-
-    GrRenderBufferObj *findRenderBuffer(GrGLuint ID) {
-        GrFakeRefObj *obj = this->findObject(ID);
-        if (NULL == obj) {
-            return NULL;
-        }
-
-        return reinterpret_cast<GrRenderBufferObj *>(obj);
-    }
-
-    GrShaderObj *findShader(GrGLuint ID) {
-        GrFakeRefObj *obj = this->findObject(ID);
-        if (NULL == obj) {
-            return NULL;
-        }
-
-        return reinterpret_cast<GrShaderObj *>(obj);
-    }
-
-    GrProgramObj *findProgram(GrGLuint ID) {
-        GrFakeRefObj *obj = this->findObject(ID);
-        if (NULL == obj) {
-            return NULL;
-        }
-
-        return reinterpret_cast<GrProgramObj *>(obj);
-    }
-
-    // TODO: merge createBuffer, createShader, createProgram??
-    GrBufferObj *createBuffer() {
-        GrBufferObj *buffer = new GrBufferObj(++fNextID);
-
-        fObjects.push_back(buffer);
-
-        return buffer;
-    }
-
-    GrFrameBufferObj *createFrameBuffer() {
-        GrFrameBufferObj *buffer = new GrFrameBufferObj(++fNextID);
-
-        fObjects.push_back(buffer);
-
-        return buffer;
-    }
-
-    GrRenderBufferObj *createRenderBuffer() {
-        GrRenderBufferObj *buffer = new GrRenderBufferObj(++fNextID);
-
-        fObjects.push_back(buffer);
-
-        return buffer;
-    }
-
-    GrShaderObj *createShader(GrGLenum type) {
-        GrShaderObj *shader = new GrShaderObj(++fNextID, type);
-
-        fObjects.push_back(shader);
-
-        return shader;
-    }
-
-    GrProgramObj *createProgram() {
-        GrProgramObj *program = new GrProgramObj(++fNextID);
-
-        fObjects.push_back(program);
-
-        return program;
-    }
-
-    GrFakeRefObj *findObject(GrGLuint ID) {
+    GrFakeRefObj *findObject(GrGLuint ID, GrObjTypes type) {
         for (int i = 0; i < fObjects.count(); ++i) {
-            if (fObjects[i]->getID() == ID) {
+            if (fObjects[i]->getID() == ID) { // && fObjects[i]->getType() == type) {
                 // The application shouldn't be accessing objects
                 // that (as far as OpenGL knows) were already deleted 
                 GrAlwaysAssert(!fObjects[i]->getDeleted());
@@ -512,13 +588,17 @@
         return NULL;
     }
 
-    
-    void setMaxTextureUnits(GrGLuint maxTextureUnits) { fMaxTextureUnits = maxTextureUnits; }
-    GrGLuint getMaxTextureUnits() const { return fMaxTextureUnits; }
+    GrGLuint getMaxTextureUnits() const { return kDefaultMaxTextureUnits; }
 
     void setCurTextureUnit(GrGLuint curTextureUnit) { fCurTextureUnit = curTextureUnit; }
     GrGLuint getCurTextureUnit() const { return fCurTextureUnit; }
 
+    GrTextureUnitObj *getTextureUnit(int iUnit) {
+        GrAlwaysAssert(0 <= iUnit && kDefaultMaxTextureUnits > iUnit);
+
+        return fTextureUnits[iUnit];
+    }
+
     void setArrayBuffer(GrBufferObj *arrayBuffer) { 
         if (fArrayBuffer) {
             // automatically break the binding of the old buffer
@@ -564,6 +644,10 @@
 
     GrBufferObj *getElementArrayBuffer()                            { return fElementArrayBuffer; }
 
+    void setTexture(GrTextureObj *texture)  { 
+        fTextureUnits[fCurTextureUnit]->setTexture(texture);
+    }
+
     void setFrameBuffer(GrFrameBufferObj *frameBuffer)  { 
         if (fFrameBuffer) {
             GrAlwaysAssert(fFrameBuffer->getBound());
@@ -645,6 +729,9 @@
 protected:
 
 private:
+    // the OpenGLES 2.0 spec says this must be >= 2
+    static const GrGLint kDefaultMaxTextureUnits = 8;
+
     GrGLuint        fMaxTextureUnits;
     GrGLuint        fCurTextureUnit;
     GrBufferObj *   fArrayBuffer;
@@ -652,8 +739,12 @@
     GrFrameBufferObj *fFrameBuffer;
     GrRenderBufferObj *fRenderBuffer;
     GrProgramObj *  fProgram;
+    GrTextureObj *  fTexture;
+    GrTextureUnitObj *fTextureUnits[kDefaultMaxTextureUnits];
 
-    static int fNextID;                     // source for globally unique IDs
+    typedef GrFakeRefObj *(*Create)();
+
+    static Create gFactoryFunc[kObjTypeCount];
 
     static GrDebugGL Obj;
 
@@ -661,16 +752,29 @@
     SkTArray<GrFakeRefObj *> fObjects;
 
     GrDebugGL() 
-        : fMaxTextureUnits(kDefaultMaxTextureUnits)
-        , fCurTextureUnit(0)
+        : fCurTextureUnit(0)
         , fArrayBuffer(NULL)
         , fElementArrayBuffer(NULL)
         , fFrameBuffer(NULL)
         , fRenderBuffer(NULL)
-        , fProgram(NULL) {
+        , fProgram(NULL)
+        , fTexture(NULL) {
+
+        for (int i = 0; i < kDefaultMaxTextureUnits; ++i) {
+            fTextureUnits[i] = GR_CREATE(GrTextureUnitObj, GrDebugGL::kTextureUnit_ObjTypes);
+            fTextureUnits[i]->ref();
+
+            fTextureUnits[i]->setNumber(i);
+        }
     }
 
     ~GrDebugGL() {
+        // unref & delete the texture units first so they don't show up on the leak report
+        for (int i = 0; i < kDefaultMaxTextureUnits; ++i) {
+            fTextureUnits[i]->unref();
+            fTextureUnits[i]->deleteAction();
+        }
+
         this->report();
 
         for (int i = 0; i < fObjects.count(); ++i) {
@@ -683,27 +787,39 @@
         fFrameBuffer = NULL;
         fRenderBuffer = NULL;
         fProgram = NULL;
+        fTexture = NULL;
     }
 };
 
-int GrDebugGL::fNextID = 0;
 GrDebugGL GrDebugGL::Obj;
+GrDebugGL::Create GrDebugGL::gFactoryFunc[kObjTypeCount] = {
+    GrTextureObj::createGrTextureObj,
+    GrBufferObj::createGrBufferObj,
+    GrRenderBufferObj::createGrRenderBufferObj,
+    GrFrameBufferObj::createGrFrameBufferObj,
+    GrShaderObj::createGrShaderObj,
+    GrProgramObj::createGrProgramObj,
+    GrTextureUnitObj::createGrTextureUnitObj,
+};
+
 
 ////////////////////////////////////////////////////////////////////////////////
 GrGLvoid GR_GL_FUNCTION_TYPE debugGLActiveTexture(GrGLenum texture) {
     
-//    GrAlwaysAssert(0 <= texture);
-//    GrAlwaysAssert(texture < GrDebugGL::getInstance()->getMaxTextureUnits());
+    // Ganesh offsets the texture unit indices
+    texture -= GR_GL_TEXTURE0;
+    GrAlwaysAssert(texture < GrDebugGL::getInstance()->getMaxTextureUnits());
 
     GrDebugGL::getInstance()->setCurTextureUnit(texture);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 GrGLvoid GR_GL_FUNCTION_TYPE debugGLAttachShader(GrGLuint programID, GrGLuint shaderID) {
-    GrProgramObj *program = GrDebugGL::getInstance()->findProgram(programID);
+
+    GrProgramObj *program = GR_FIND(programID, GrProgramObj, GrDebugGL::kProgram_ObjTypes);
     GrAlwaysAssert(program);
 
-    GrShaderObj *shader = GrDebugGL::getInstance()->findShader(shaderID);
+    GrShaderObj *shader = GR_FIND(shaderID, GrShaderObj, GrDebugGL::kShader_ObjTypes);
     GrAlwaysAssert(shader);
 
     program->AttachShader(shader);
@@ -711,7 +827,19 @@
 
 GrGLvoid GR_GL_FUNCTION_TYPE debugGLBeginQuery(GrGLenum target, GrGLuint id) {}
 GrGLvoid GR_GL_FUNCTION_TYPE debugGLBindAttribLocation(GrGLuint program, GrGLuint index, const char* name) {}
-GrGLvoid GR_GL_FUNCTION_TYPE debugGLBindTexture(GrGLenum target, GrGLuint texture) {}
+
+////////////////////////////////////////////////////////////////////////////////
+GrGLvoid GR_GL_FUNCTION_TYPE debugGLBindTexture(GrGLenum target, GrGLuint textureID) {
+
+    // we don't use cube maps
+    GrAlwaysAssert(target == GR_GL_TEXTURE_2D); // || target == GR_GL_TEXTURE_CUBE_MAP);
+
+    // a textureID of 0 is acceptable - it binds to the default texture target
+    GrTextureObj *texture = GR_FIND(textureID, GrTextureObj, GrDebugGL::kTexture_ObjTypes);
+
+    GrDebugGL::getInstance()->setTexture(texture);
+}
+
 GrGLvoid GR_GL_FUNCTION_TYPE debugGLBlendColor(GrGLclampf red, GrGLclampf green, GrGLclampf blue, GrGLclampf alpha) {}
 GrGLvoid GR_GL_FUNCTION_TYPE debugGLBindFragDataLocation(GrGLuint program, GrGLuint colorNumber, const GrGLchar* name) {}
 GrGLvoid GR_GL_FUNCTION_TYPE debugGLBlendFunc(GrGLenum sfactor, GrGLenum dfactor) {}
@@ -804,7 +932,7 @@
 GrGLvoid GR_GL_FUNCTION_TYPE debugGLUseProgram(GrGLuint programID) {
 
     // A programID of 0 is legal
-    GrProgramObj *program = GrDebugGL::getInstance()->findProgram(programID);
+    GrProgramObj *program = GR_FIND(programID, GrProgramObj, GrDebugGL::kProgram_ObjTypes);
 
     GrDebugGL::getInstance()->useProgram(program);
 }
@@ -818,7 +946,7 @@
     GrAlwaysAssert(GR_GL_FRAMEBUFFER == target);
 
     // a frameBufferID of 0 is acceptable - it binds to the default frame buffer
-    GrFrameBufferObj *frameBuffer = GrDebugGL::getInstance()->findFrameBuffer(frameBufferID);
+    GrFrameBufferObj *frameBuffer = GR_FIND(frameBufferID, GrFrameBufferObj, GrDebugGL::kFrameBuffer_ObjTypes);
 
     GrDebugGL::getInstance()->setFrameBuffer(frameBuffer);
 }
@@ -828,11 +956,67 @@
     GrAlwaysAssert(GR_GL_RENDERBUFFER == target);
 
     // a renderBufferID of 0 is acceptable - it unbinds the bound render buffer
-    GrRenderBufferObj *renderBuffer = GrDebugGL::getInstance()->findRenderBuffer(renderBufferID);
+    GrRenderBufferObj *renderBuffer = GR_FIND(renderBufferID, GrRenderBufferObj, GrDebugGL::kRenderBuffer_ObjTypes);
 
     GrDebugGL::getInstance()->setRenderBuffer(renderBuffer);
 }
 
+GrGLvoid GR_GL_FUNCTION_TYPE debugGLDeleteTextures(GrGLsizei n, const GrGLuint* textures) {
+
+    // first potentially unbind the texture
+    // TODO: move this into GrDebugGL as unBindTexture?
+    for (unsigned int i = 0; i < GrDebugGL::getInstance()->getMaxTextureUnits(); ++i)
+    {
+        GrTextureUnitObj *pTU = GrDebugGL::getInstance()->getTextureUnit(i);
+
+        if (pTU->getTexture()) {
+            for (int j = 0; j < n; ++j) {
+
+                if (textures[j] == pTU->getTexture()->getID()) {
+                    // this ID is the current texture - revert the binding to 0
+                    pTU->setTexture(NULL);
+                }
+            }
+        }
+    }
+
+    // TODO: fuse the following block with DeleteRenderBuffers?
+    // Open GL will remove a deleted render buffer from the active frame buffer but not
+    // from any other frame buffer
+    if (GrDebugGL::getInstance()->getFrameBuffer()) {
+
+        GrFrameBufferObj *frameBuffer = GrDebugGL::getInstance()->getFrameBuffer();
+
+        for (int i = 0; i < n; ++i) {
+
+            if (NULL != frameBuffer->getColor() && textures[i] == frameBuffer->getColor()->getID()) {
+                frameBuffer->setColor(NULL);
+            } 
+            if (NULL != frameBuffer->getDepth() && textures[i] == frameBuffer->getDepth()->getID()) {
+                frameBuffer->setDepth(NULL);
+            }
+            if (NULL != frameBuffer->getStencil() && textures[i] == frameBuffer->getStencil()->getID()) {
+                frameBuffer->setStencil(NULL);
+            }
+        }
+    }
+
+    // then actually "delete" the buffers
+    for (int i = 0; i < n; ++i) {
+        GrTextureObj *buffer = GR_FIND(textures[i], GrTextureObj, GrDebugGL::kTexture_ObjTypes);
+        GrAlwaysAssert(buffer);
+
+        // OpenGL gives no guarantees if a texture is deleted while attached to
+        // something other than the currently bound frame buffer
+        GrAlwaysAssert(!buffer->getBound());
+
+        GrAlwaysAssert(!buffer->getDeleted());
+        buffer->deleteAction();
+    }
+
+}
+
+
 GrGLvoid GR_GL_FUNCTION_TYPE debugGLDeleteFramebuffers(GrGLsizei n, const GrGLuint *frameBuffers) {
 
     // first potentially unbind the buffers
@@ -848,7 +1032,7 @@
 
     // then actually "delete" the buffers
     for (int i = 0; i < n; ++i) {
-        GrFrameBufferObj *buffer = GrDebugGL::getInstance()->findFrameBuffer(frameBuffers[i]);
+        GrFrameBufferObj *buffer = GR_FIND(frameBuffers[i], GrFrameBufferObj, GrDebugGL::kFrameBuffer_ObjTypes);
         GrAlwaysAssert(buffer);
 
         GrAlwaysAssert(!buffer->getDeleted());
@@ -869,6 +1053,7 @@
         }
     }
 
+    // TODO: fuse the following block with DeleteTextures?
     // Open GL will remove a deleted render buffer from the active frame buffer but not
     // from any other frame buffer
     if (GrDebugGL::getInstance()->getFrameBuffer()) {
@@ -891,7 +1076,7 @@
 
     // then actually "delete" the buffers
     for (int i = 0; i < n; ++i) {
-        GrRenderBufferObj *buffer = GrDebugGL::getInstance()->findRenderBuffer(renderBuffers[i]);
+        GrRenderBufferObj *buffer = GR_FIND(renderBuffers[i], GrRenderBufferObj, GrDebugGL::kRenderBuffer_ObjTypes);
         GrAlwaysAssert(buffer);
 
         // OpenGL gives no guarantees if a render buffer is deleted while attached to
@@ -918,7 +1103,7 @@
     GrAlwaysAssert(NULL != framebuffer);
 
     // a renderBufferID of 0 is acceptable - it unbinds the current render buffer
-    GrRenderBufferObj *renderbuffer = GrDebugGL::getInstance()->findRenderBuffer(renderBufferID);
+    GrRenderBufferObj *renderbuffer = GR_FIND(renderBufferID, GrRenderBufferObj, GrDebugGL::kRenderBuffer_ObjTypes);
 
     switch (attachment) {
     case GR_GL_COLOR_ATTACHMENT0:
@@ -937,7 +1122,44 @@
 
 }
 
-GrGLvoid GR_GL_FUNCTION_TYPE debugGLFramebufferTexture2D(GrGLenum target, GrGLenum attachment, GrGLenum textarget, GrGLuint texture, GrGLint level) {}
+////////////////////////////////////////////////////////////////////////////////
+GrGLvoid GR_GL_FUNCTION_TYPE debugGLFramebufferTexture2D(GrGLenum target, GrGLenum attachment, GrGLenum textarget, GrGLuint textureID, GrGLint level) {
+
+    GrAlwaysAssert(GR_GL_FRAMEBUFFER == target);
+    GrAlwaysAssert(GR_GL_COLOR_ATTACHMENT0 == attachment || 
+                   GR_GL_DEPTH_ATTACHMENT == attachment || 
+                   GR_GL_STENCIL_ATTACHMENT == attachment);
+    GrAlwaysAssert(GR_GL_TEXTURE_2D == textarget);
+
+    GrFrameBufferObj *framebuffer = GrDebugGL::getInstance()->getFrameBuffer();
+    // A texture cannot be attached to the default framebuffer
+    GrAlwaysAssert(NULL != framebuffer);
+
+    // A textureID of 0 is allowed - it unbinds the currently bound texture
+    GrTextureObj *texture = GR_FIND(textureID, GrTextureObj, GrDebugGL::kTexture_ObjTypes);
+    if (texture) {
+        // The texture shouldn't be bound to a texture unit - this could lead to a feedback loop
+        GrAlwaysAssert(!texture->getBound());
+    }
+
+    GrAlwaysAssert(0 == level);
+
+    switch (attachment) {
+    case GR_GL_COLOR_ATTACHMENT0:
+        framebuffer->setColor(texture);
+        break;
+    case GR_GL_DEPTH_ATTACHMENT:
+        framebuffer->setDepth(texture);
+        break;
+    case GR_GL_STENCIL_ATTACHMENT:
+        framebuffer->setStencil(texture);
+        break;
+    default:
+        GrAlwaysAssert(false);
+        break;
+    };
+}
+
 GrGLvoid GR_GL_FUNCTION_TYPE debugGLGetFramebufferAttachmentParameteriv(GrGLenum target, GrGLenum attachment, GrGLenum pname, GrGLint* params) {}
 GrGLvoid GR_GL_FUNCTION_TYPE debugGLGetRenderbufferParameteriv(GrGLenum target, GrGLenum pname, GrGLint* params) {}
 GrGLvoid GR_GL_FUNCTION_TYPE debugGLRenderbufferStorage(GrGLenum target, GrGLenum internalformat, GrGLsizei width, GrGLsizei height) {}
@@ -947,12 +1169,15 @@
 GrGLvoid GR_GL_FUNCTION_TYPE debugGLBindFragDataLocationIndexed(GrGLuint program, GrGLuint colorNumber, GrGLuint index, const GrGLchar * name) {}
 
 GrGLenum GR_GL_FUNCTION_TYPE debugGLCheckFramebufferStatus(GrGLenum target) {
+
+    GrAlwaysAssert(GR_GL_FRAMEBUFFER == target);
+
     return GR_GL_FRAMEBUFFER_COMPLETE;
 }
 
 GrGLuint GR_GL_FUNCTION_TYPE debugGLCreateProgram() {
 
-    GrProgramObj *program = GrDebugGL::getInstance()->createProgram();
+    GrProgramObj *program = GR_CREATE(GrProgramObj, GrDebugGL::kProgram_ObjTypes);
 
     return program->getID();
 }
@@ -961,14 +1186,15 @@
     
     GrAlwaysAssert(GR_GL_VERTEX_SHADER == type || GR_GL_FRAGMENT_SHADER == type);
 
-    GrShaderObj *shader = GrDebugGL::getInstance()->createShader(type);
+    GrShaderObj *shader = GR_CREATE(GrShaderObj, GrDebugGL::kShader_ObjTypes);
+    shader->setType(type);
 
     return shader->getID();
 }
 
 GrGLvoid GR_GL_FUNCTION_TYPE debugGLDeleteProgram(GrGLuint programID) {
 
-    GrProgramObj *program = GrDebugGL::getInstance()->findProgram(programID);
+    GrProgramObj *program = GR_FIND(programID, GrProgramObj, GrDebugGL::kProgram_ObjTypes);
     GrAlwaysAssert(program);
 
     if (program->getRefCount()) {
@@ -981,7 +1207,7 @@
 
 GrGLvoid GR_GL_FUNCTION_TYPE debugGLDeleteShader(GrGLuint shaderID) {
 
-    GrShaderObj *shader = GrDebugGL::getInstance()->findShader(shaderID);
+    GrShaderObj *shader = GR_FIND(shaderID, GrShaderObj, GrDebugGL::kShader_ObjTypes);
     GrAlwaysAssert(shader);
 
     if (shader->getRefCount()) {
@@ -1000,42 +1226,43 @@
     }
 }
 
+GrGLvoid debugGenObjs(GrDebugGL::GrObjTypes type, GrGLsizei n, GrGLuint* ids) {
+
+   for (int i = 0; i < n; ++i) {
+        GrFakeRefObj *obj = GrDebugGL::getInstance()->createObj(type);
+        GrAlwaysAssert(obj);
+        ids[i] = obj->getID();
+    }
+}
+
 GrGLvoid GR_GL_FUNCTION_TYPE debugGLGenBuffers(GrGLsizei n, GrGLuint* ids) {
 
-    for (int i = 0; i < n; ++i) {
-        GrBufferObj *buffer = GrDebugGL::getInstance()->createBuffer();
-        GrAlwaysAssert(buffer);
-        ids[i] = buffer->getID();
-    }
+    debugGenObjs(GrDebugGL::kBuffer_ObjTypes, n, ids);
 }
 
 GrGLvoid GR_GL_FUNCTION_TYPE debugGLGenFramebuffers(GrGLsizei n, GrGLuint* ids) {
 
-    for (int i = 0; i < n; ++i) {
-        GrFrameBufferObj *buffer = GrDebugGL::getInstance()->createFrameBuffer();
-        GrAlwaysAssert(buffer);
-        ids[i] = buffer->getID();
-    }
+    debugGenObjs(GrDebugGL::kFrameBuffer_ObjTypes, n, ids);
 }
 
 GrGLvoid GR_GL_FUNCTION_TYPE debugGLGenRenderbuffers(GrGLsizei n, GrGLuint* ids) {
 
-    for (int i = 0; i < n; ++i) {
-        GrRenderBufferObj *buffer = GrDebugGL::getInstance()->createRenderBuffer();
-        GrAlwaysAssert(buffer);
-        ids[i] = buffer->getID();
-    }
+    debugGenObjs(GrDebugGL::kRenderBuffer_ObjTypes, n, ids);
+}
+
+GrGLvoid GR_GL_FUNCTION_TYPE debugGLGenTextures(GrGLsizei n, GrGLuint* ids) {
+
+    debugGenObjs(GrDebugGL::kTexture_ObjTypes, n, ids);
 }
 
 // same delete function for all glDelete*(GLsize i, const GLuint*) except buffers
 GrGLvoid GR_GL_FUNCTION_TYPE debugGLDeleteIds(GrGLsizei n, const GrGLuint* ids) {}
 
-
 GrGLvoid GR_GL_FUNCTION_TYPE debugGLBindBuffer(GrGLenum target, GrGLuint bufferID) {
 
     GrAlwaysAssert(GR_GL_ARRAY_BUFFER == target || GR_GL_ELEMENT_ARRAY_BUFFER == target);
 
-    GrBufferObj *buffer = GrDebugGL::getInstance()->findBuffer(bufferID);
+    GrBufferObj *buffer = GR_FIND(bufferID, GrBufferObj, GrDebugGL::kBuffer_ObjTypes);
     // 0 is a permissable bufferID - it unbinds the current buffer
 
     switch (target) {
@@ -1070,7 +1297,7 @@
 
     // then actually "delete" the buffers
     for (int i = 0; i < n; ++i) {
-        GrBufferObj *buffer = GrDebugGL::getInstance()->findBuffer(ids[i]);
+        GrBufferObj *buffer = GR_FIND(ids[i], GrBufferObj, GrDebugGL::kBuffer_ObjTypes);
         GrAlwaysAssert(buffer);
 
         GrAlwaysAssert(!buffer->getDeleted());
@@ -1333,12 +1560,59 @@
     return ++gUniLocation;
 }
 
+////////////////////////////////////////////////////////////////////////////////
+struct GrDebugGLInterface : public GrGLInterface {
+
+public:
+    GrDebugGLInterface()
+        : fWrapped(NULL) {
+    }
+
+    void setWrapped(GrGLInterface *interface) {
+        fWrapped.reset(interface);
+    }
+
+    // TODO: there are some issues w/ wrapping another GL interface inside the
+    // debug interface:
+    //      Since none of the "gl" methods are member functions they don't get
+    //      a "this" pointer through which to access "fWrapped"
+    //      This could be worked around by having all of them access the 
+    //      "glInterface" pointer - i.e., treating the debug interface as a 
+    //      true singleton
+    //
+    //      The problem with this is that we also want to handle OpenGL 
+    //      contexts. The natural way to do this is to have multiple debug 
+    //      interfaces. Each of which represents a separate context. The 
+    //      static ID count would still uniquify IDs across all of them. 
+    //      The problem then is that we couldn't treat the debug GL 
+    //      interface as a singleton (since there would be one for each 
+    //      context).
+    //
+    //      The solution to this is probably to alter SkDebugGlContext's 
+    //      "makeCurrent" method to make a call like "makeCurrent(this)" to 
+    //      the debug GL interface (assuming that the application will create 
+    //      multiple SkGLContext's) to let it switch between the active 
+    //      context. Everything in the GrDebugGL object would then need to be 
+    //      moved to a GrContextObj and the GrDebugGL object would just switch 
+    //      between them. Note that this approach would also require that 
+    //      SkDebugGLContext wrap an arbitrary other context
+    //      and then pass the wrapped interface to the debug GL interface.
+
+protected:
+private:
+
+    SkAutoTUnref<GrGLInterface> fWrapped;
+
+    typedef GrGLInterface INHERITED;
+};
+
+////////////////////////////////////////////////////////////////////////////////
 const GrGLInterface* GrGLCreateDebugInterface() {
     // The gl functions are not context-specific so we create one global 
     // interface
     static SkAutoTUnref<GrGLInterface> glInterface;
     if (!glInterface.get()) {
-        GrGLInterface* interface = new GrGLInterface;
+        GrGLInterface* interface = new GrDebugGLInterface;
         glInterface.reset(interface);
         interface->fBindingsExported = kDesktop_GrGLBinding;
         interface->fActiveTexture = debugGLActiveTexture;
@@ -1365,7 +1639,7 @@
         interface->fDeleteProgram = debugGLDeleteProgram;
         interface->fDeleteQueries = debugGLDeleteIds;
         interface->fDeleteShader = debugGLDeleteShader;
-        interface->fDeleteTextures = debugGLDeleteIds;
+        interface->fDeleteTextures = debugGLDeleteTextures;
         interface->fDepthMask = debugGLDepthMask;
         interface->fDisable = debugGLDisable;
         interface->fDisableVertexAttribArray = debugGLDisableVertexAttribArray;
@@ -1381,7 +1655,7 @@
         interface->fFrontFace = debugGLFrontFace;
         interface->fGenBuffers = debugGLGenBuffers;
         interface->fGenQueries = debugGLGenIds;
-        interface->fGenTextures = debugGLGenIds;
+        interface->fGenTextures = debugGLGenTextures;
         interface->fGetBufferParameteriv = debugGLGetBufferParameteriv;
         interface->fGetError = debugGLGetError;
         interface->fGetIntegerv = debugGLGetIntegerv;
diff --git a/src/gpu/gl/GrGpuGL.cpp b/src/gpu/gl/GrGpuGL.cpp
index 69880e5..10b42c0 100644
--- a/src/gpu/gl/GrGpuGL.cpp
+++ b/src/gpu/gl/GrGpuGL.cpp
@@ -983,6 +983,9 @@
 #if GR_COLLECT_STATS
         ++fStats.fRenderTargetCreateCnt;
 #endif
+        // unbind the texture from the texture unit before binding it to the frame buffer
+        GL_CALL(BindTexture(GR_GL_TEXTURE_2D, 0));
+
         if (!this->createRenderTargetObjects(glTexDesc.fWidth,
                                              glTexDesc.fHeight,
                                              glTexDesc.fTextureID,