diff --git a/src/libGLESv2/Context.cpp b/src/libGLESv2/Context.cpp
index 79b47c8..879a560 100644
--- a/src/libGLESv2/Context.cpp
+++ b/src/libGLESv2/Context.cpp
@@ -1105,7 +1105,7 @@
     return mResourceManager->getTexture(handle);
 }
 
-Renderbuffer *Context::getRenderbuffer(GLuint handle)
+FramebufferAttachment *Context::getRenderbuffer(GLuint handle)
 {
     return mResourceManager->getRenderbuffer(handle);
 }
@@ -1440,7 +1440,7 @@
         return;
     }
 
-    Renderbuffer *renderbufferObject = mState.renderbuffer.get();
+    FramebufferAttachment *renderbufferObject = mState.renderbuffer.get();
     renderbufferObject->setStorage(renderbuffer);
 }
 
@@ -1884,7 +1884,7 @@
       case GL_ALPHA_BITS:
         {
             gl::Framebuffer *framebuffer = getDrawFramebuffer();
-            gl::Renderbuffer *colorbuffer = framebuffer->getFirstColorbuffer();
+            gl::FramebufferAttachment *colorbuffer = framebuffer->getFirstColorbuffer();
 
             if (colorbuffer)
             {
@@ -1905,7 +1905,7 @@
       case GL_DEPTH_BITS:
         {
             gl::Framebuffer *framebuffer = getDrawFramebuffer();
-            gl::Renderbuffer *depthbuffer = framebuffer->getDepthbuffer();
+            gl::FramebufferAttachment *depthbuffer = framebuffer->getDepthbuffer();
 
             if (depthbuffer)
             {
@@ -1920,7 +1920,7 @@
       case GL_STENCIL_BITS:
         {
             gl::Framebuffer *framebuffer = getDrawFramebuffer();
-            gl::Renderbuffer *stencilbuffer = framebuffer->getStencilbuffer();
+            gl::FramebufferAttachment *stencilbuffer = framebuffer->getStencilbuffer();
 
             if (stencilbuffer)
             {
@@ -3348,12 +3348,12 @@
     Framebuffer *framebuffer = getReadFramebuffer();
     ASSERT(framebuffer && framebuffer->completeness() == GL_FRAMEBUFFER_COMPLETE);
 
-    Renderbuffer *renderbuffer = framebuffer->getReadColorbuffer();
-    ASSERT(renderbuffer);
+    FramebufferAttachment *attachment = framebuffer->getReadColorbuffer();
+    ASSERT(attachment);
 
-    *internalFormat = renderbuffer->getActualFormat();
-    *format = gl::GetFormat(renderbuffer->getActualFormat(), mClientVersion);
-    *type = gl::GetType(renderbuffer->getActualFormat(), mClientVersion);
+    *internalFormat = attachment->getActualFormat();
+    *format = gl::GetFormat(attachment->getActualFormat(), mClientVersion);
+    *type = gl::GetType(attachment->getActualFormat(), mClientVersion);
 }
 
 void Context::detachBuffer(GLuint buffer)
@@ -3393,7 +3393,7 @@
 
     // [OpenGL ES 2.0.24] section 4.4 page 112:
     // If a texture object is deleted while its image is attached to the currently bound framebuffer, then it is
-    // as if FramebufferTexture2D had been called, with a texture of 0, for each attachment point to which this
+    // as if Texture2DAttachment had been called, with a texture of 0, for each attachment point to which this
     // image was attached in the currently bound framebuffer.
 
     Framebuffer *readFramebuffer = getReadFramebuffer();
@@ -3883,17 +3883,17 @@
     Framebuffer *drawFramebuffer = getDrawFramebuffer();
     for (unsigned int i = 0; i < IMPLEMENTATION_MAX_DRAW_BUFFERS; i++)
     {
-        Renderbuffer *renderBuffer = drawFramebuffer->getColorbuffer(i);
-        if (renderBuffer && renderBuffer->isTexture())
+        FramebufferAttachment *attachment = drawFramebuffer->getColorbuffer(i);
+        if (attachment && attachment->isTexture())
         {
-            (*outSerialArray)[serialCount++] = renderBuffer->getTextureSerial();
+            (*outSerialArray)[serialCount++] = attachment->getTextureSerial();
         }
     }
 
-    Renderbuffer *depthStencilBuffer = drawFramebuffer->getDepthOrStencilbuffer();
-    if (depthStencilBuffer && depthStencilBuffer->isTexture())
+    FramebufferAttachment *depthStencilAttachment = drawFramebuffer->getDepthOrStencilbuffer();
+    if (depthStencilAttachment && depthStencilAttachment->isTexture())
     {
-        (*outSerialArray)[serialCount++] = depthStencilBuffer->getTextureSerial();
+        (*outSerialArray)[serialCount++] = depthStencilAttachment->getTextureSerial();
     }
 
     std::sort(outSerialArray->begin(), outSerialArray->begin() + serialCount);
@@ -3958,43 +3958,43 @@
 
             if (attachments[i] >= GL_COLOR_ATTACHMENT0 && attachments[i] <= GL_COLOR_ATTACHMENT15)
             {
-                gl::Renderbuffer *renderBuffer = frameBuffer->getColorbuffer(attachments[i] - GL_COLOR_ATTACHMENT0);
-                if (renderBuffer)
+                gl::FramebufferAttachment *attachment = frameBuffer->getColorbuffer(attachments[i] - GL_COLOR_ATTACHMENT0);
+                if (attachment)
                 {
-                    renderTarget = renderBuffer->getRenderTarget();
+                    renderTarget = attachment->getRenderTarget();
                 }
             }
             else if (attachments[i] == GL_COLOR)
             {
-                 gl::Renderbuffer *renderBuffer = frameBuffer->getColorbuffer(0);
-                 if (renderBuffer)
+                 gl::FramebufferAttachment *attachment = frameBuffer->getColorbuffer(0);
+                 if (attachment)
                  {
-                     renderTarget = renderBuffer->getRenderTarget();
+                     renderTarget = attachment->getRenderTarget();
                  }
             }
             else
             {
-                gl::Renderbuffer *renderBuffer = NULL;
+                gl::FramebufferAttachment *attachment = NULL;
                 switch (attachments[i])
                 {
                   case GL_DEPTH_ATTACHMENT:
                   case GL_DEPTH:
-                    renderBuffer = frameBuffer->getDepthbuffer();
+                    attachment = frameBuffer->getDepthbuffer();
                     break;
                   case GL_STENCIL_ATTACHMENT:
                   case GL_STENCIL:
-                    renderBuffer = frameBuffer->getStencilbuffer();
+                    attachment = frameBuffer->getStencilbuffer();
                     break;
                   case GL_DEPTH_STENCIL_ATTACHMENT:
-                    renderBuffer = frameBuffer->getDepthOrStencilbuffer();
+                    attachment = frameBuffer->getDepthOrStencilbuffer();
                     break;
                   default:
                     UNREACHABLE();
                 }
 
-                if (renderBuffer)
+                if (attachment)
                 {
-                    renderTarget = renderBuffer->getDepthStencil();
+                    renderTarget = attachment->getDepthStencil();
                 }
             }
 
diff --git a/src/libGLESv2/Context.h b/src/libGLESv2/Context.h
index b3c8a3f..ab79004 100644
--- a/src/libGLESv2/Context.h
+++ b/src/libGLESv2/Context.h
@@ -50,7 +50,7 @@
 class Texture3D;
 class Texture2DArray;
 class Framebuffer;
-class Renderbuffer;
+class FramebufferAttachment;
 class RenderbufferStorage;
 class Colorbuffer;
 class Depthbuffer;
@@ -100,7 +100,7 @@
     BindingPointer<Buffer> arrayBuffer;
     GLuint readFramebuffer;
     GLuint drawFramebuffer;
-    BindingPointer<Renderbuffer> renderbuffer;
+    BindingPointer<FramebufferAttachment> renderbuffer;
     GLuint currentProgram;
 
     VertexAttribCurrentValueData vertexAttribCurrentValues[MAX_VERTEX_ATTRIBS]; // From glVertexAttrib
@@ -331,7 +331,7 @@
     Program *getProgram(GLuint handle) const;
     Texture *getTexture(GLuint handle);
     Framebuffer *getFramebuffer(GLuint handle) const;
-    Renderbuffer *getRenderbuffer(GLuint handle);
+    FramebufferAttachment *getRenderbuffer(GLuint handle);
     VertexArray *getVertexArray(GLuint handle) const;
     Sampler *getSampler(GLuint handle) const;
     Query *getQuery(GLuint handle, bool create, GLenum type);
diff --git a/src/libGLESv2/Framebuffer.cpp b/src/libGLESv2/Framebuffer.cpp
index 97d37d0..b78419f 100644
--- a/src/libGLESv2/Framebuffer.cpp
+++ b/src/libGLESv2/Framebuffer.cpp
@@ -42,7 +42,7 @@
     mStencilbuffer.set(NULL, GL_NONE, 0, 0);
 }
 
-Renderbuffer *Framebuffer::lookupRenderbuffer(GLenum type, GLuint handle, GLint level, GLint layer) const
+FramebufferAttachment *Framebuffer::lookupAttachment(GLenum type, GLuint handle, GLint level, GLint layer) const
 {
     gl::Context *context = gl::getContext();
 
@@ -59,7 +59,7 @@
             Texture *texture = context->getTexture(handle);
             if (texture && texture->getTarget() == GL_TEXTURE_2D)
             {
-                return static_cast<Texture2D*>(texture)->getRenderbuffer(level);
+                return static_cast<Texture2D*>(texture)->getAttachment(level);
             }
             else
             {
@@ -77,7 +77,7 @@
             Texture *texture = context->getTexture(handle);
             if (texture && texture->getTarget() == GL_TEXTURE_CUBE_MAP)
             {
-                return static_cast<TextureCubeMap*>(texture)->getRenderbuffer(type, level);
+                return static_cast<TextureCubeMap*>(texture)->getAttachment(type, level);
             }
             else
             {
@@ -90,7 +90,7 @@
             Texture *texture = context->getTexture(handle);
             if (texture && texture->getTarget() == GL_TEXTURE_3D)
             {
-                return static_cast<Texture3D*>(texture)->getRenderbuffer(level, layer);
+                return static_cast<Texture3D*>(texture)->getAttachment(level, layer);
             }
             else
             {
@@ -103,7 +103,7 @@
             Texture *texture = context->getTexture(handle);
             if (texture && texture->getTarget() == GL_TEXTURE_2D_ARRAY)
             {
-                return static_cast<Texture2DArray*>(texture)->getRenderbuffer(level, layer);
+                return static_cast<Texture2DArray*>(texture)->getAttachment(level, layer);
             }
             else
             {
@@ -120,10 +120,10 @@
 void Framebuffer::setColorbuffer(unsigned int colorAttachment, GLenum type, GLuint colorbuffer, GLint level, GLint layer)
 {
     ASSERT(colorAttachment < IMPLEMENTATION_MAX_DRAW_BUFFERS);
-    Renderbuffer *renderBuffer = lookupRenderbuffer(type, colorbuffer, level, layer);
-    if (renderBuffer)
+    FramebufferAttachment *attachment = lookupAttachment(type, colorbuffer, level, layer);
+    if (attachment)
     {
-        mColorbuffers[colorAttachment].set(renderBuffer, type, level, layer);
+        mColorbuffers[colorAttachment].set(attachment, type, level, layer);
     }
     else
     {
@@ -133,10 +133,10 @@
 
 void Framebuffer::setDepthbuffer(GLenum type, GLuint depthbuffer, GLint level, GLint layer)
 {
-    Renderbuffer *renderBuffer = lookupRenderbuffer(type, depthbuffer, level, layer);
-    if (renderBuffer)
+    FramebufferAttachment *attachment = lookupAttachment(type, depthbuffer, level, layer);
+    if (attachment)
     {
-        mDepthbuffer.set(renderBuffer, type, level, layer);
+        mDepthbuffer.set(attachment, type, level, layer);
     }
     else
     {
@@ -146,10 +146,10 @@
 
 void Framebuffer::setStencilbuffer(GLenum type, GLuint stencilbuffer, GLint level, GLint layer)
 {
-    Renderbuffer *renderBuffer = lookupRenderbuffer(type, stencilbuffer, level, layer);
-    if (renderBuffer)
+    FramebufferAttachment *attachment = lookupAttachment(type, stencilbuffer, level, layer);
+    if (attachment)
     {
-        mStencilbuffer.set(renderBuffer, type, level, layer);
+        mStencilbuffer.set(attachment, type, level, layer);
     }
     else
     {
@@ -159,11 +159,11 @@
 
 void Framebuffer::setDepthStencilBuffer(GLenum type, GLuint depthStencilBuffer, GLint level, GLint layer)
 {
-    Renderbuffer *renderBuffer = lookupRenderbuffer(type, depthStencilBuffer, level, layer);
-    if (renderBuffer && renderBuffer->getDepthSize() > 0 && renderBuffer->getStencilSize() > 0)
+    FramebufferAttachment *attachment = lookupAttachment(type, depthStencilBuffer, level, layer);
+    if (attachment && attachment->getDepthSize() > 0 && attachment->getStencilSize() > 0)
     {
-        mDepthbuffer.set(renderBuffer, type, level, layer);
-        mStencilbuffer.set(renderBuffer, type, level, layer);
+        mDepthbuffer.set(attachment, type, level, layer);
+        mStencilbuffer.set(attachment, type, level, layer);
     }
     else
     {
@@ -219,7 +219,7 @@
 {
     ASSERT(colorAttachment < IMPLEMENTATION_MAX_DRAW_BUFFERS);
 
-    Renderbuffer *colorbuffer = mColorbuffers[colorAttachment].get();
+    FramebufferAttachment *colorbuffer = mColorbuffers[colorAttachment].get();
 
     if (colorbuffer)
     {
@@ -231,7 +231,7 @@
 
 unsigned int Framebuffer::getDepthbufferSerial() const
 {
-    Renderbuffer *depthbuffer = mDepthbuffer.get();
+    FramebufferAttachment *depthbuffer = mDepthbuffer.get();
 
     if (depthbuffer)
     {
@@ -243,7 +243,7 @@
 
 unsigned int Framebuffer::getStencilbufferSerial() const
 {
-    Renderbuffer *stencilbuffer = mStencilbuffer.get();
+    FramebufferAttachment *stencilbuffer = mStencilbuffer.get();
 
     if (stencilbuffer)
     {
@@ -253,30 +253,30 @@
     return 0;
 }
 
-Renderbuffer *Framebuffer::getColorbuffer(unsigned int colorAttachment) const
+FramebufferAttachment *Framebuffer::getColorbuffer(unsigned int colorAttachment) const
 {
     ASSERT(colorAttachment < IMPLEMENTATION_MAX_DRAW_BUFFERS);
     return mColorbuffers[colorAttachment].get();
 }
 
-Renderbuffer *Framebuffer::getDepthbuffer() const
+FramebufferAttachment *Framebuffer::getDepthbuffer() const
 {
     return mDepthbuffer.get();
 }
 
-Renderbuffer *Framebuffer::getStencilbuffer() const
+FramebufferAttachment *Framebuffer::getStencilbuffer() const
 {
     return mStencilbuffer.get();
 }
 
-Renderbuffer *Framebuffer::getDepthStencilBuffer() const
+FramebufferAttachment *Framebuffer::getDepthStencilBuffer() const
 {
     return (mDepthbuffer.id() == mStencilbuffer.id()) ? mDepthbuffer.get() : NULL;
 }
 
-Renderbuffer *Framebuffer::getDepthOrStencilbuffer() const
+FramebufferAttachment *Framebuffer::getDepthOrStencilbuffer() const
 {
-    Renderbuffer *depthstencilbuffer = mDepthbuffer.get();
+    FramebufferAttachment *depthstencilbuffer = mDepthbuffer.get();
     
     if (!depthstencilbuffer)
     {
@@ -286,7 +286,7 @@
     return depthstencilbuffer;
 }
 
-Renderbuffer *Framebuffer::getReadColorbuffer() const
+FramebufferAttachment *Framebuffer::getReadColorbuffer() const
 {
     // Will require more logic if glReadBuffers is supported
     return mColorbuffers[0].get();
@@ -298,7 +298,7 @@
     return mColorbuffers[0].type();
 }
 
-Renderbuffer *Framebuffer::getFirstColorbuffer() const
+FramebufferAttachment *Framebuffer::getFirstColorbuffer() const
 {
     for (unsigned int colorAttachment = 0; colorAttachment < IMPLEMENTATION_MAX_DRAW_BUFFERS; colorAttachment++)
     {
@@ -427,7 +427,7 @@
 {
     if (mStencilbuffer.type() != GL_NONE)
     {
-        const Renderbuffer *stencilbufferObject = getStencilbuffer();
+        const FramebufferAttachment *stencilbufferObject = getStencilbuffer();
 
         if (stencilbufferObject)
         {
@@ -464,7 +464,7 @@
     {
         if (mColorbuffers[colorAttachment].type() != GL_NONE)
         {
-            const Renderbuffer *colorbuffer = getColorbuffer(colorAttachment);
+            const FramebufferAttachment *colorbuffer = getColorbuffer(colorAttachment);
 
             if (!colorbuffer)
             {
@@ -549,8 +549,8 @@
         }
     }
 
-    const Renderbuffer *depthbuffer = NULL;
-    const Renderbuffer *stencilbuffer = NULL;
+    const FramebufferAttachment *depthbuffer = NULL;
+    const FramebufferAttachment *stencilbuffer = NULL;
 
     if (mDepthbuffer.type() != GL_NONE)
     {
@@ -690,9 +690,9 @@
 DefaultFramebuffer::DefaultFramebuffer(rx::Renderer *renderer, Colorbuffer *colorbuffer, DepthStencilbuffer *depthStencil)
     : Framebuffer(renderer)
 {
-    mColorbuffers[0].set(new Renderbuffer(mRenderer, 0, colorbuffer), GL_RENDERBUFFER, 0, 0);
+    mColorbuffers[0].set(new FramebufferAttachment(mRenderer, 0, colorbuffer), GL_RENDERBUFFER, 0, 0);
 
-    Renderbuffer *depthStencilRenderbuffer = new Renderbuffer(mRenderer, 0, depthStencil);
+    FramebufferAttachment *depthStencilRenderbuffer = new FramebufferAttachment(mRenderer, 0, depthStencil);
     mDepthbuffer.set(depthStencilRenderbuffer, (depthStencilRenderbuffer->getDepthSize() != 0) ? GL_RENDERBUFFER : GL_NONE, 0, 0);
     mStencilbuffer.set(depthStencilRenderbuffer, (depthStencilRenderbuffer->getStencilSize() != 0) ? GL_RENDERBUFFER : GL_NONE, 0, 0);
 
diff --git a/src/libGLESv2/Framebuffer.h b/src/libGLESv2/Framebuffer.h
index c0d8ee8..1a5e2b6 100644
--- a/src/libGLESv2/Framebuffer.h
+++ b/src/libGLESv2/Framebuffer.h
@@ -21,7 +21,7 @@
 
 namespace gl
 {
-class Renderbuffer;
+class FramebufferAttachment;
 class Colorbuffer;
 class Depthbuffer;
 class Stencilbuffer;
@@ -46,14 +46,14 @@
     unsigned int getDepthbufferSerial() const;
     unsigned int getStencilbufferSerial() const;
 
-    Renderbuffer *getColorbuffer(unsigned int colorAttachment) const;
-    Renderbuffer *getDepthbuffer() const;
-    Renderbuffer *getStencilbuffer() const;
-    Renderbuffer *getDepthStencilBuffer() const;
-    Renderbuffer *getDepthOrStencilbuffer() const;
-    Renderbuffer *getReadColorbuffer() const;
+    FramebufferAttachment *getColorbuffer(unsigned int colorAttachment) const;
+    FramebufferAttachment *getDepthbuffer() const;
+    FramebufferAttachment *getStencilbuffer() const;
+    FramebufferAttachment *getDepthStencilBuffer() const;
+    FramebufferAttachment *getDepthOrStencilbuffer() const;
+    FramebufferAttachment *getReadColorbuffer() const;
     GLenum getReadColorbufferType() const;
-    Renderbuffer *getFirstColorbuffer() const;
+    FramebufferAttachment *getFirstColorbuffer() const;
 
     GLenum getColorbufferType(unsigned int colorAttachment) const;
     GLenum getDepthbufferType() const;
@@ -87,19 +87,19 @@
     virtual GLenum completeness() const;
 
   protected:
-    FramebufferTextureBindingPointer<Renderbuffer> mColorbuffers[IMPLEMENTATION_MAX_DRAW_BUFFERS];
+    FramebufferTextureBindingPointer<FramebufferAttachment> mColorbuffers[IMPLEMENTATION_MAX_DRAW_BUFFERS];
     GLenum mDrawBufferStates[IMPLEMENTATION_MAX_DRAW_BUFFERS];
     GLenum mReadBufferState;
 
-    FramebufferTextureBindingPointer<Renderbuffer> mDepthbuffer;
-    FramebufferTextureBindingPointer<Renderbuffer> mStencilbuffer;
+    FramebufferTextureBindingPointer<FramebufferAttachment> mDepthbuffer;
+    FramebufferTextureBindingPointer<FramebufferAttachment> mStencilbuffer;
 
     rx::Renderer *mRenderer;
 
   private:
     DISALLOW_COPY_AND_ASSIGN(Framebuffer);
 
-    Renderbuffer *lookupRenderbuffer(GLenum type, GLuint handle, GLint level, GLint layer) const;
+    FramebufferAttachment *lookupAttachment(GLenum type, GLuint handle, GLint level, GLint layer) const;
 };
 
 class DefaultFramebuffer : public Framebuffer
diff --git a/src/libGLESv2/Renderbuffer.cpp b/src/libGLESv2/Renderbuffer.cpp
index 2851908..ce822ec 100644
--- a/src/libGLESv2/Renderbuffer.cpp
+++ b/src/libGLESv2/Renderbuffer.cpp
@@ -22,341 +22,341 @@
 {
 unsigned int RenderbufferStorage::mCurrentSerial = 1;
 
-RenderbufferInterface::RenderbufferInterface()
+FramebufferAttachmentInterface::FramebufferAttachmentInterface()
 {
 }
 
-// The default case for classes inherited from RenderbufferInterface is not to
-// need to do anything upon the reference count to the parent Renderbuffer incrementing
+// The default case for classes inherited from FramebufferAttachmentInterface is not to
+// need to do anything upon the reference count to the parent FramebufferAttachment incrementing
 // or decrementing. 
-void RenderbufferInterface::addProxyRef(const Renderbuffer *proxy)
+void FramebufferAttachmentInterface::addProxyRef(const FramebufferAttachment *proxy)
 {
 }
 
-void RenderbufferInterface::releaseProxy(const Renderbuffer *proxy)
+void FramebufferAttachmentInterface::releaseProxy(const FramebufferAttachment *proxy)
 {
 }
 
-///// RenderbufferTexture2D Implementation ////////
+///// Texture2DAttachment Implementation ////////
 
-RenderbufferTexture2D::RenderbufferTexture2D(Texture2D *texture, GLint level) : mLevel(level)
+Texture2DAttachment::Texture2DAttachment(Texture2D *texture, GLint level) : mLevel(level)
 {
     mTexture2D.set(texture);
 }
 
-RenderbufferTexture2D::~RenderbufferTexture2D()
+Texture2DAttachment::~Texture2DAttachment()
 {
     mTexture2D.set(NULL);
 }
 
 // Textures need to maintain their own reference count for references via
 // Renderbuffers acting as proxies. Here, we notify the texture of a reference.
-void RenderbufferTexture2D::addProxyRef(const Renderbuffer *proxy)
+void Texture2DAttachment::addProxyRef(const FramebufferAttachment *proxy)
 {
     mTexture2D->addProxyRef(proxy);
 }
 
-void RenderbufferTexture2D::releaseProxy(const Renderbuffer *proxy)
+void Texture2DAttachment::releaseProxy(const FramebufferAttachment *proxy)
 {
     mTexture2D->releaseProxy(proxy);
 }
 
-rx::RenderTarget *RenderbufferTexture2D::getRenderTarget()
+rx::RenderTarget *Texture2DAttachment::getRenderTarget()
 {
     return mTexture2D->getRenderTarget(mLevel);
 }
 
-rx::RenderTarget *RenderbufferTexture2D::getDepthStencil()
+rx::RenderTarget *Texture2DAttachment::getDepthStencil()
 {
     return mTexture2D->getDepthSencil(mLevel);
 }
 
-rx::TextureStorage *RenderbufferTexture2D::getTextureStorage()
+rx::TextureStorage *Texture2DAttachment::getTextureStorage()
 {
     return mTexture2D->getNativeTexture()->getStorageInstance();
 }
 
-GLsizei RenderbufferTexture2D::getWidth() const
+GLsizei Texture2DAttachment::getWidth() const
 {
     return mTexture2D->getWidth(mLevel);
 }
 
-GLsizei RenderbufferTexture2D::getHeight() const
+GLsizei Texture2DAttachment::getHeight() const
 {
     return mTexture2D->getHeight(mLevel);
 }
 
-GLenum RenderbufferTexture2D::getInternalFormat() const
+GLenum Texture2DAttachment::getInternalFormat() const
 {
     return mTexture2D->getInternalFormat(mLevel);
 }
 
-GLenum RenderbufferTexture2D::getActualFormat() const
+GLenum Texture2DAttachment::getActualFormat() const
 {
     return mTexture2D->getActualFormat(mLevel);
 }
 
-GLsizei RenderbufferTexture2D::getSamples() const
+GLsizei Texture2DAttachment::getSamples() const
 {
     return 0;
 }
 
-unsigned int RenderbufferTexture2D::getSerial() const
+unsigned int Texture2DAttachment::getSerial() const
 {
     return mTexture2D->getRenderTargetSerial(mLevel);
 }
 
-bool RenderbufferTexture2D::isTexture() const
+bool Texture2DAttachment::isTexture() const
 {
     return true;
 }
 
-unsigned int RenderbufferTexture2D::getTextureSerial() const
+unsigned int Texture2DAttachment::getTextureSerial() const
 {
     return mTexture2D->getTextureSerial();
 }
 
-///// RenderbufferTextureCubeMap Implementation ////////
+///// TextureCubeMapAttachment Implementation ////////
 
-RenderbufferTextureCubeMap::RenderbufferTextureCubeMap(TextureCubeMap *texture, GLenum faceTarget, GLint level)
+TextureCubeMapAttachment::TextureCubeMapAttachment(TextureCubeMap *texture, GLenum faceTarget, GLint level)
     : mFaceTarget(faceTarget), mLevel(level)
 {
     mTextureCubeMap.set(texture);
 }
 
-RenderbufferTextureCubeMap::~RenderbufferTextureCubeMap()
+TextureCubeMapAttachment::~TextureCubeMapAttachment()
 {
     mTextureCubeMap.set(NULL);
 }
 
 // Textures need to maintain their own reference count for references via
 // Renderbuffers acting as proxies. Here, we notify the texture of a reference.
-void RenderbufferTextureCubeMap::addProxyRef(const Renderbuffer *proxy)
+void TextureCubeMapAttachment::addProxyRef(const FramebufferAttachment *proxy)
 {
     mTextureCubeMap->addProxyRef(proxy);
 }
 
-void RenderbufferTextureCubeMap::releaseProxy(const Renderbuffer *proxy)
+void TextureCubeMapAttachment::releaseProxy(const FramebufferAttachment *proxy)
 {
     mTextureCubeMap->releaseProxy(proxy);
 }
 
-rx::RenderTarget *RenderbufferTextureCubeMap::getRenderTarget()
+rx::RenderTarget *TextureCubeMapAttachment::getRenderTarget()
 {
     return mTextureCubeMap->getRenderTarget(mFaceTarget, mLevel);
 }
 
-rx::RenderTarget *RenderbufferTextureCubeMap::getDepthStencil()
+rx::RenderTarget *TextureCubeMapAttachment::getDepthStencil()
 {
     return mTextureCubeMap->getDepthStencil(mFaceTarget, mLevel);
 }
 
-rx::TextureStorage *RenderbufferTextureCubeMap::getTextureStorage()
+rx::TextureStorage *TextureCubeMapAttachment::getTextureStorage()
 {
     return mTextureCubeMap->getNativeTexture()->getStorageInstance();
 }
 
-GLsizei RenderbufferTextureCubeMap::getWidth() const
+GLsizei TextureCubeMapAttachment::getWidth() const
 {
     return mTextureCubeMap->getWidth(mFaceTarget, mLevel);
 }
 
-GLsizei RenderbufferTextureCubeMap::getHeight() const
+GLsizei TextureCubeMapAttachment::getHeight() const
 {
     return mTextureCubeMap->getHeight(mFaceTarget, mLevel);
 }
 
-GLenum RenderbufferTextureCubeMap::getInternalFormat() const
+GLenum TextureCubeMapAttachment::getInternalFormat() const
 {
     return mTextureCubeMap->getInternalFormat(mFaceTarget, mLevel);
 }
 
-GLenum RenderbufferTextureCubeMap::getActualFormat() const
+GLenum TextureCubeMapAttachment::getActualFormat() const
 {
     return mTextureCubeMap->getActualFormat(mFaceTarget, mLevel);
 }
 
-GLsizei RenderbufferTextureCubeMap::getSamples() const
+GLsizei TextureCubeMapAttachment::getSamples() const
 {
     return 0;
 }
 
-unsigned int RenderbufferTextureCubeMap::getSerial() const
+unsigned int TextureCubeMapAttachment::getSerial() const
 {
     return mTextureCubeMap->getRenderTargetSerial(mFaceTarget, mLevel);
 }
 
-bool RenderbufferTextureCubeMap::isTexture() const
+bool TextureCubeMapAttachment::isTexture() const
 {
     return true;
 }
 
-unsigned int RenderbufferTextureCubeMap::getTextureSerial() const
+unsigned int TextureCubeMapAttachment::getTextureSerial() const
 {
     return mTextureCubeMap->getTextureSerial();
 }
 
-///// RenderbufferTexture3DLayer Implementation ////////
+///// Texture3DAttachment Implementation ////////
 
-RenderbufferTexture3DLayer::RenderbufferTexture3DLayer(Texture3D *texture, GLint level, GLint layer)
+Texture3DAttachment::Texture3DAttachment(Texture3D *texture, GLint level, GLint layer)
     : mLevel(level), mLayer(layer)
 {
     mTexture3D.set(texture);
 }
 
-RenderbufferTexture3DLayer::~RenderbufferTexture3DLayer()
+Texture3DAttachment::~Texture3DAttachment()
 {
     mTexture3D.set(NULL);
 }
 
 // Textures need to maintain their own reference count for references via
 // Renderbuffers acting as proxies. Here, we notify the texture of a reference.
-void RenderbufferTexture3DLayer::addProxyRef(const Renderbuffer *proxy)
+void Texture3DAttachment::addProxyRef(const FramebufferAttachment *proxy)
 {
     mTexture3D->addProxyRef(proxy);
 }
 
-void RenderbufferTexture3DLayer::releaseProxy(const Renderbuffer *proxy)
+void Texture3DAttachment::releaseProxy(const FramebufferAttachment *proxy)
 {
     mTexture3D->releaseProxy(proxy);
 }
 
-rx::RenderTarget *RenderbufferTexture3DLayer::getRenderTarget()
+rx::RenderTarget *Texture3DAttachment::getRenderTarget()
 {
     return mTexture3D->getRenderTarget(mLevel, mLayer);
 }
 
-rx::RenderTarget *RenderbufferTexture3DLayer::getDepthStencil()
+rx::RenderTarget *Texture3DAttachment::getDepthStencil()
 {
     return mTexture3D->getDepthStencil(mLevel, mLayer);
 }
 
-rx::TextureStorage *RenderbufferTexture3DLayer::getTextureStorage()
+rx::TextureStorage *Texture3DAttachment::getTextureStorage()
 {
     return mTexture3D->getNativeTexture()->getStorageInstance();
 }
 
-GLsizei RenderbufferTexture3DLayer::getWidth() const
+GLsizei Texture3DAttachment::getWidth() const
 {
     return mTexture3D->getWidth(mLevel);
 }
 
-GLsizei RenderbufferTexture3DLayer::getHeight() const
+GLsizei Texture3DAttachment::getHeight() const
 {
     return mTexture3D->getHeight(mLevel);
 }
 
-GLenum RenderbufferTexture3DLayer::getInternalFormat() const
+GLenum Texture3DAttachment::getInternalFormat() const
 {
     return mTexture3D->getInternalFormat(mLevel);
 }
 
-GLenum RenderbufferTexture3DLayer::getActualFormat() const
+GLenum Texture3DAttachment::getActualFormat() const
 {
     return mTexture3D->getActualFormat(mLevel);
 }
 
-GLsizei RenderbufferTexture3DLayer::getSamples() const
+GLsizei Texture3DAttachment::getSamples() const
 {
     return 0;
 }
 
-unsigned int RenderbufferTexture3DLayer::getSerial() const
+unsigned int Texture3DAttachment::getSerial() const
 {
     return mTexture3D->getRenderTargetSerial(mLevel, mLayer);
 }
 
-bool RenderbufferTexture3DLayer::isTexture() const
+bool Texture3DAttachment::isTexture() const
 {
     return true;
 }
 
-unsigned int RenderbufferTexture3DLayer::getTextureSerial() const
+unsigned int Texture3DAttachment::getTextureSerial() const
 {
     return mTexture3D->getTextureSerial();
 }
 
-////// RenderbufferTexture2DArrayLayer Implementation //////
+////// Texture2DArrayAttachment Implementation //////
 
-RenderbufferTexture2DArrayLayer::RenderbufferTexture2DArrayLayer(Texture2DArray *texture, GLint level, GLint layer)
+Texture2DArrayAttachment::Texture2DArrayAttachment(Texture2DArray *texture, GLint level, GLint layer)
     : mLevel(level), mLayer(layer)
 {
     mTexture2DArray.set(texture);
 }
 
-RenderbufferTexture2DArrayLayer::~RenderbufferTexture2DArrayLayer()
+Texture2DArrayAttachment::~Texture2DArrayAttachment()
 {
     mTexture2DArray.set(NULL);
 }
 
-void RenderbufferTexture2DArrayLayer::addProxyRef(const Renderbuffer *proxy)
+void Texture2DArrayAttachment::addProxyRef(const FramebufferAttachment *proxy)
 {
     mTexture2DArray->addProxyRef(proxy);
 }
 
-void RenderbufferTexture2DArrayLayer::releaseProxy(const Renderbuffer *proxy)
+void Texture2DArrayAttachment::releaseProxy(const FramebufferAttachment *proxy)
 {
     mTexture2DArray->releaseProxy(proxy);
 }
 
-rx::RenderTarget *RenderbufferTexture2DArrayLayer::getRenderTarget()
+rx::RenderTarget *Texture2DArrayAttachment::getRenderTarget()
 {
     return mTexture2DArray->getRenderTarget(mLevel, mLayer);
 }
 
-rx::RenderTarget *RenderbufferTexture2DArrayLayer::getDepthStencil()
+rx::RenderTarget *Texture2DArrayAttachment::getDepthStencil()
 {
     return mTexture2DArray->getDepthStencil(mLevel, mLayer);
 }
 
-rx::TextureStorage *RenderbufferTexture2DArrayLayer::getTextureStorage()
+rx::TextureStorage *Texture2DArrayAttachment::getTextureStorage()
 {
     return mTexture2DArray->getNativeTexture()->getStorageInstance();
 }
 
-GLsizei RenderbufferTexture2DArrayLayer::getWidth() const
+GLsizei Texture2DArrayAttachment::getWidth() const
 {
     return mTexture2DArray->getWidth(mLevel);
 }
 
-GLsizei RenderbufferTexture2DArrayLayer::getHeight() const
+GLsizei Texture2DArrayAttachment::getHeight() const
 {
     return mTexture2DArray->getHeight(mLevel);
 }
 
-GLenum RenderbufferTexture2DArrayLayer::getInternalFormat() const
+GLenum Texture2DArrayAttachment::getInternalFormat() const
 {
     return mTexture2DArray->getInternalFormat(mLevel);
 }
 
-GLenum RenderbufferTexture2DArrayLayer::getActualFormat() const
+GLenum Texture2DArrayAttachment::getActualFormat() const
 {
     return mTexture2DArray->getActualFormat(mLevel);
 }
 
-GLsizei RenderbufferTexture2DArrayLayer::getSamples() const
+GLsizei Texture2DArrayAttachment::getSamples() const
 {
     return 0;
 }
 
-unsigned int RenderbufferTexture2DArrayLayer::getSerial() const
+unsigned int Texture2DArrayAttachment::getSerial() const
 {
     return mTexture2DArray->getRenderTargetSerial(mLevel, mLayer);
 }
 
-bool RenderbufferTexture2DArrayLayer::isTexture() const
+bool Texture2DArrayAttachment::isTexture() const
 {
     return true;
 }
 
-unsigned int RenderbufferTexture2DArrayLayer::getTextureSerial() const
+unsigned int Texture2DArrayAttachment::getTextureSerial() const
 {
     return mTexture2DArray->getTextureSerial();
 }
 
-////// Renderbuffer Implementation //////
+////// FramebufferAttachment Implementation //////
 
-Renderbuffer::Renderbuffer(rx::Renderer *renderer, GLuint id, RenderbufferInterface *instance) : RefCountObject(id)
+FramebufferAttachment::FramebufferAttachment(rx::Renderer *renderer, GLuint id, FramebufferAttachmentInterface *instance) : RefCountObject(id)
 {
     ASSERT(instance != NULL);
     mInstance = instance;
@@ -365,123 +365,123 @@
     mRenderer = renderer;
 }
 
-Renderbuffer::~Renderbuffer()
+FramebufferAttachment::~FramebufferAttachment()
 {
     delete mInstance;
 }
 
-// The RenderbufferInterface contained in this Renderbuffer may need to maintain
+// The FramebufferAttachmentInterface contained in this FramebufferAttachment may need to maintain
 // its own reference count, so we pass it on here.
-void Renderbuffer::addRef() const
+void FramebufferAttachment::addRef() const
 {
     mInstance->addProxyRef(this);
 
     RefCountObject::addRef();
 }
 
-void Renderbuffer::release() const
+void FramebufferAttachment::release() const
 {
     mInstance->releaseProxy(this);
 
     RefCountObject::release();
 }
 
-rx::RenderTarget *Renderbuffer::getRenderTarget()
+rx::RenderTarget *FramebufferAttachment::getRenderTarget()
 {
     return mInstance->getRenderTarget();
 }
 
-rx::RenderTarget *Renderbuffer::getDepthStencil()
+rx::RenderTarget *FramebufferAttachment::getDepthStencil()
 {
     return mInstance->getDepthStencil();
 }
 
-rx::TextureStorage *Renderbuffer::getTextureStorage()
+rx::TextureStorage *FramebufferAttachment::getTextureStorage()
 {
     return mInstance->getTextureStorage();
 }
 
-GLsizei Renderbuffer::getWidth() const
+GLsizei FramebufferAttachment::getWidth() const
 {
     return mInstance->getWidth();
 }
 
-GLsizei Renderbuffer::getHeight() const
+GLsizei FramebufferAttachment::getHeight() const
 {
     return mInstance->getHeight();
 }
 
-GLenum Renderbuffer::getInternalFormat() const
+GLenum FramebufferAttachment::getInternalFormat() const
 {
     return mInstance->getInternalFormat();
 }
 
-GLenum Renderbuffer::getActualFormat() const
+GLenum FramebufferAttachment::getActualFormat() const
 {
     return mInstance->getActualFormat();
 }
 
-GLuint Renderbuffer::getRedSize() const
+GLuint FramebufferAttachment::getRedSize() const
 {
     return gl::GetRedBits(getActualFormat(), mRenderer->getCurrentClientVersion());
 }
 
-GLuint Renderbuffer::getGreenSize() const
+GLuint FramebufferAttachment::getGreenSize() const
 {
     return gl::GetGreenBits(getActualFormat(), mRenderer->getCurrentClientVersion());
 }
 
-GLuint Renderbuffer::getBlueSize() const
+GLuint FramebufferAttachment::getBlueSize() const
 {
     return gl::GetBlueBits(getActualFormat(), mRenderer->getCurrentClientVersion());
 }
 
-GLuint Renderbuffer::getAlphaSize() const
+GLuint FramebufferAttachment::getAlphaSize() const
 {
     return gl::GetAlphaBits(getActualFormat(), mRenderer->getCurrentClientVersion());
 }
 
-GLuint Renderbuffer::getDepthSize() const
+GLuint FramebufferAttachment::getDepthSize() const
 {
     return gl::GetDepthBits(getActualFormat(), mRenderer->getCurrentClientVersion());
 }
 
-GLuint Renderbuffer::getStencilSize() const
+GLuint FramebufferAttachment::getStencilSize() const
 {
     return gl::GetStencilBits(getActualFormat(), mRenderer->getCurrentClientVersion());
 }
 
-GLenum Renderbuffer::getComponentType() const
+GLenum FramebufferAttachment::getComponentType() const
 {
     return gl::GetComponentType(getActualFormat(), mRenderer->getCurrentClientVersion());
 }
 
-GLenum Renderbuffer::getColorEncoding() const
+GLenum FramebufferAttachment::getColorEncoding() const
 {
     return gl::GetColorEncoding(getActualFormat(), mRenderer->getCurrentClientVersion());
 }
 
-GLsizei Renderbuffer::getSamples() const
+GLsizei FramebufferAttachment::getSamples() const
 {
     return mInstance->getSamples();
 }
 
-unsigned int Renderbuffer::getSerial() const
+unsigned int FramebufferAttachment::getSerial() const
 {
     return mInstance->getSerial();
 }
 
-bool Renderbuffer::isTexture() const
+bool FramebufferAttachment::isTexture() const
 {
     return mInstance->isTexture();
 }
 
-unsigned int Renderbuffer::getTextureSerial() const
+unsigned int FramebufferAttachment::getTextureSerial() const
 {
     return mInstance->getTextureSerial();
 }
 
-void Renderbuffer::setStorage(RenderbufferStorage *newStorage)
+void FramebufferAttachment::setStorage(RenderbufferStorage *newStorage)
 {
     ASSERT(newStorage != NULL);
 
diff --git a/src/libGLESv2/Renderbuffer.h b/src/libGLESv2/Renderbuffer.h
index 969232b..820175d 100644
--- a/src/libGLESv2/Renderbuffer.h
+++ b/src/libGLESv2/Renderbuffer.h
@@ -32,19 +32,19 @@
 class TextureCubeMap;
 class Texture3D;
 class Texture2DArray;
-class Renderbuffer;
+class FramebufferAttachment;
 class Colorbuffer;
 class DepthStencilbuffer;
 
-class RenderbufferInterface
+class FramebufferAttachmentInterface
 {
   public:
-    RenderbufferInterface();
+    FramebufferAttachmentInterface();
 
-    virtual ~RenderbufferInterface() {};
+    virtual ~FramebufferAttachmentInterface() {};
 
-    virtual void addProxyRef(const Renderbuffer *proxy);
-    virtual void releaseProxy(const Renderbuffer *proxy);
+    virtual void addProxyRef(const FramebufferAttachment *proxy);
+    virtual void releaseProxy(const FramebufferAttachment *proxy);
 
     virtual rx::RenderTarget *getRenderTarget() = 0;
     virtual rx::RenderTarget *getDepthStencil() = 0;
@@ -62,18 +62,18 @@
     virtual unsigned int getTextureSerial() const = 0;
 
   private:
-    DISALLOW_COPY_AND_ASSIGN(RenderbufferInterface);
+    DISALLOW_COPY_AND_ASSIGN(FramebufferAttachmentInterface);
 };
 
-class RenderbufferTexture2D : public RenderbufferInterface
+class Texture2DAttachment : public FramebufferAttachmentInterface
 {
   public:
-    RenderbufferTexture2D(Texture2D *texture, GLint level);
+    Texture2DAttachment(Texture2D *texture, GLint level);
 
-    virtual ~RenderbufferTexture2D();
+    virtual ~Texture2DAttachment();
 
-    void addProxyRef(const Renderbuffer *proxy);
-    void releaseProxy(const Renderbuffer *proxy);
+    void addProxyRef(const FramebufferAttachment *proxy);
+    void releaseProxy(const FramebufferAttachment *proxy);
 
     rx::RenderTarget *getRenderTarget();
     rx::RenderTarget *getDepthStencil();
@@ -91,21 +91,21 @@
     virtual unsigned int getTextureSerial() const;
 
   private:
-    DISALLOW_COPY_AND_ASSIGN(RenderbufferTexture2D);
+    DISALLOW_COPY_AND_ASSIGN(Texture2DAttachment);
 
     BindingPointer <Texture2D> mTexture2D;
     const GLint mLevel;
 };
 
-class RenderbufferTextureCubeMap : public RenderbufferInterface
+class TextureCubeMapAttachment : public FramebufferAttachmentInterface
 {
   public:
-    RenderbufferTextureCubeMap(TextureCubeMap *texture, GLenum faceTarget, GLint level);
+    TextureCubeMapAttachment(TextureCubeMap *texture, GLenum faceTarget, GLint level);
 
-    virtual ~RenderbufferTextureCubeMap();
+    virtual ~TextureCubeMapAttachment();
 
-    void addProxyRef(const Renderbuffer *proxy);
-    void releaseProxy(const Renderbuffer *proxy);
+    void addProxyRef(const FramebufferAttachment *proxy);
+    void releaseProxy(const FramebufferAttachment *proxy);
 
     rx::RenderTarget *getRenderTarget();
     rx::RenderTarget *getDepthStencil();
@@ -123,22 +123,22 @@
     virtual unsigned int getTextureSerial() const;
 
   private:
-    DISALLOW_COPY_AND_ASSIGN(RenderbufferTextureCubeMap);
+    DISALLOW_COPY_AND_ASSIGN(TextureCubeMapAttachment);
 
     BindingPointer <TextureCubeMap> mTextureCubeMap;
     const GLint mLevel;
     const GLenum mFaceTarget;
 };
 
-class RenderbufferTexture3DLayer : public RenderbufferInterface
+class Texture3DAttachment : public FramebufferAttachmentInterface
 {
 public:
-    RenderbufferTexture3DLayer(Texture3D *texture, GLint level, GLint layer);
+    Texture3DAttachment(Texture3D *texture, GLint level, GLint layer);
 
-    virtual ~RenderbufferTexture3DLayer();
+    virtual ~Texture3DAttachment();
 
-    void addProxyRef(const Renderbuffer *proxy);
-    void releaseProxy(const Renderbuffer *proxy);
+    void addProxyRef(const FramebufferAttachment *proxy);
+    void releaseProxy(const FramebufferAttachment *proxy);
 
     rx::RenderTarget *getRenderTarget();
     rx::RenderTarget *getDepthStencil();
@@ -156,22 +156,22 @@
     virtual unsigned int getTextureSerial() const;
 
 private:
-    DISALLOW_COPY_AND_ASSIGN(RenderbufferTexture3DLayer);
+    DISALLOW_COPY_AND_ASSIGN(Texture3DAttachment);
 
     BindingPointer<Texture3D> mTexture3D;
     const GLint mLevel;
     const GLint mLayer;
 };
 
-class RenderbufferTexture2DArrayLayer : public RenderbufferInterface
+class Texture2DArrayAttachment : public FramebufferAttachmentInterface
 {
 public:
-    RenderbufferTexture2DArrayLayer(Texture2DArray *texture, GLint level, GLint layer);
+    Texture2DArrayAttachment(Texture2DArray *texture, GLint level, GLint layer);
 
-    virtual ~RenderbufferTexture2DArrayLayer();
+    virtual ~Texture2DArrayAttachment();
 
-    void addProxyRef(const Renderbuffer *proxy);
-    void releaseProxy(const Renderbuffer *proxy);
+    void addProxyRef(const FramebufferAttachment *proxy);
+    void releaseProxy(const FramebufferAttachment *proxy);
 
     rx::RenderTarget *getRenderTarget();
     rx::RenderTarget *getDepthStencil();
@@ -189,7 +189,7 @@
     virtual unsigned int getTextureSerial() const;
 
 private:
-    DISALLOW_COPY_AND_ASSIGN(RenderbufferTexture2DArrayLayer);
+    DISALLOW_COPY_AND_ASSIGN(Texture2DArrayAttachment);
 
     BindingPointer<Texture2DArray> mTexture2DArray;
     const GLint mLevel;
@@ -199,7 +199,7 @@
 // A class derived from RenderbufferStorage is created whenever glRenderbufferStorage
 // is called. The specific concrete type depends on whether the internal format is
 // colour depth, stencil or packed depth/stencil.
-class RenderbufferStorage : public RenderbufferInterface
+class RenderbufferStorage : public FramebufferAttachmentInterface
 {
   public:
     RenderbufferStorage();
@@ -238,20 +238,20 @@
     static unsigned int mCurrentSerial;
 };
 
-// Renderbuffer implements the GL renderbuffer object.
-// It's only a proxy for a RenderbufferInterface instance; the internal object
+// FramebufferAttachment implements the GL renderbuffer object.
+// It's only a proxy for a FramebufferAttachmentInterface instance; the internal object
 // can change whenever glRenderbufferStorage is called.
-class Renderbuffer : public RefCountObject
+class FramebufferAttachment : public RefCountObject
 {
   public:
-    Renderbuffer(rx::Renderer *renderer, GLuint id, RenderbufferInterface *storage);
+    FramebufferAttachment(rx::Renderer *renderer, GLuint id, FramebufferAttachmentInterface *storage);
 
-    virtual ~Renderbuffer();
+    virtual ~FramebufferAttachment();
 
     // These functions from RefCountObject are overloaded here because
     // Textures need to maintain their own count of references to them via
     // Renderbuffers/RenderbufferTextures. These functions invoke those
-    // reference counting functions on the RenderbufferInterface.
+    // reference counting functions on the FramebufferAttachmentInterface.
     void addRef() const;
     void release() const;
 
@@ -281,10 +281,10 @@
     void setStorage(RenderbufferStorage *newStorage);
 
   private:
-    DISALLOW_COPY_AND_ASSIGN(Renderbuffer);
+    DISALLOW_COPY_AND_ASSIGN(FramebufferAttachment);
 
     rx::Renderer const *mRenderer;
-    RenderbufferInterface *mInstance;
+    FramebufferAttachmentInterface *mInstance;
 };
 
 class Colorbuffer : public RenderbufferStorage
diff --git a/src/libGLESv2/RenderbufferProxySet.cpp b/src/libGLESv2/RenderbufferProxySet.cpp
index 009c7a6..f4fbe51 100644
--- a/src/libGLESv2/RenderbufferProxySet.cpp
+++ b/src/libGLESv2/RenderbufferProxySet.cpp
@@ -14,7 +14,7 @@
 namespace gl
 {
 
-void RenderbufferProxySet::addRef(const Renderbuffer *proxy)
+void RenderbufferProxySet::addRef(const FramebufferAttachment *proxy)
 {
     RefCountMap::iterator i = mRefCountMap.find(proxy);
     if (i != mRefCountMap.end())
@@ -23,7 +23,7 @@
     }
 }
 
-void RenderbufferProxySet::release(const Renderbuffer *proxy)
+void RenderbufferProxySet::release(const FramebufferAttachment *proxy)
 {
     RefCountMap::iterator i = mRefCountMap.find(proxy);
     if (i != mRefCountMap.end())
@@ -35,7 +35,7 @@
 
         if (i->second == 0)
         {
-            // Clear the buffer map of references to this Renderbuffer
+            // Clear the buffer map of references to this FramebufferAttachment
             BufferMap::iterator j = mBufferMap.begin();
             while (j != mBufferMap.end())
             {
@@ -54,7 +54,7 @@
     }
 }
 
-void RenderbufferProxySet::add(unsigned int mipLevel, unsigned int layer, Renderbuffer *renderBuffer)
+void RenderbufferProxySet::add(unsigned int mipLevel, unsigned int layer, FramebufferAttachment *renderBuffer)
 {
     if (mRefCountMap.find(renderBuffer) == mRefCountMap.end())
     {
@@ -70,7 +70,7 @@
     }
 }
 
-Renderbuffer *RenderbufferProxySet::get(unsigned int mipLevel, unsigned int layer) const
+FramebufferAttachment *RenderbufferProxySet::get(unsigned int mipLevel, unsigned int layer) const
 {
     RenderbufferKey key;
     key.mipLevel = mipLevel;
diff --git a/src/libGLESv2/RenderbufferProxySet.h b/src/libGLESv2/RenderbufferProxySet.h
index ae5bf94..f151151 100644
--- a/src/libGLESv2/RenderbufferProxySet.h
+++ b/src/libGLESv2/RenderbufferProxySet.h
@@ -14,16 +14,16 @@
 
 namespace gl
 {
-class Renderbuffer;
+class FramebufferAttachment;
 
 class RenderbufferProxySet
 {
   public:
-    void addRef(const Renderbuffer *proxy);
-    void release(const Renderbuffer *proxy);
+    void addRef(const FramebufferAttachment *proxy);
+    void release(const FramebufferAttachment *proxy);
 
-    void add(unsigned int mipLevel, unsigned int layer, Renderbuffer *renderBuffer);
-    Renderbuffer *get(unsigned int mipLevel, unsigned int layer) const;
+    void add(unsigned int mipLevel, unsigned int layer, FramebufferAttachment *renderBuffer);
+    FramebufferAttachment *get(unsigned int mipLevel, unsigned int layer) const;
 
   private:
     struct RenderbufferKey
@@ -34,10 +34,10 @@
         bool operator<(const RenderbufferKey &other) const;
     };
 
-    typedef std::map<RenderbufferKey, Renderbuffer*> BufferMap;
+    typedef std::map<RenderbufferKey, FramebufferAttachment*> BufferMap;
     BufferMap mBufferMap;
 
-    typedef std::map<const Renderbuffer*, unsigned int> RefCountMap;
+    typedef std::map<const FramebufferAttachment*, unsigned int> RefCountMap;
     RefCountMap mRefCountMap;
 };
 
diff --git a/src/libGLESv2/ResourceManager.cpp b/src/libGLESv2/ResourceManager.cpp
index 97c28cb..cf0812d 100644
--- a/src/libGLESv2/ResourceManager.cpp
+++ b/src/libGLESv2/ResourceManager.cpp
@@ -311,7 +311,7 @@
     }
 }
 
-Renderbuffer *ResourceManager::getRenderbuffer(unsigned int handle)
+FramebufferAttachment *ResourceManager::getRenderbuffer(unsigned int handle)
 {
     RenderbufferMap::iterator renderbuffer = mRenderbufferMap.find(handle);
 
@@ -353,7 +353,7 @@
     }
 }
 
-void ResourceManager::setRenderbuffer(GLuint handle, Renderbuffer *buffer)
+void ResourceManager::setRenderbuffer(GLuint handle, FramebufferAttachment *buffer)
 {
     mRenderbufferMap[handle] = buffer;
 }
@@ -405,7 +405,7 @@
 {
     if (renderbuffer != 0 && !getRenderbuffer(renderbuffer))
     {
-        Renderbuffer *renderbufferObject = new Renderbuffer(mRenderer, renderbuffer, new Colorbuffer(mRenderer, 0, 0, GL_RGBA4, 0));
+        FramebufferAttachment *renderbufferObject = new FramebufferAttachment(mRenderer, renderbuffer, new Colorbuffer(mRenderer, 0, 0, GL_RGBA4, 0));
         mRenderbufferMap[renderbuffer] = renderbufferObject;
         renderbufferObject->addRef();
     }
diff --git a/src/libGLESv2/ResourceManager.h b/src/libGLESv2/ResourceManager.h
index 85e6b4b..a08a6aa 100644
--- a/src/libGLESv2/ResourceManager.h
+++ b/src/libGLESv2/ResourceManager.h
@@ -30,7 +30,7 @@
 class Shader;
 class Program;
 class Texture;
-class Renderbuffer;
+class FramebufferAttachment;
 class Sampler;
 class FenceSync;
 
@@ -63,11 +63,11 @@
     Shader *getShader(GLuint handle);
     Program *getProgram(GLuint handle);
     Texture *getTexture(GLuint handle);
-    Renderbuffer *getRenderbuffer(GLuint handle);
+    FramebufferAttachment *getRenderbuffer(GLuint handle);
     Sampler *getSampler(GLuint handle);
     FenceSync *getFenceSync(GLuint handle);
     
-    void setRenderbuffer(GLuint handle, Renderbuffer *renderbuffer);
+    void setRenderbuffer(GLuint handle, FramebufferAttachment *renderbuffer);
 
     void checkBufferAllocation(unsigned int buffer);
     void checkTextureAllocation(GLuint texture, TextureType type);
@@ -97,7 +97,7 @@
     TextureMap mTextureMap;
     HandleAllocator mTextureHandleAllocator;
 
-    typedef std::unordered_map<GLuint, Renderbuffer*> RenderbufferMap;
+    typedef std::unordered_map<GLuint, FramebufferAttachment*> RenderbufferMap;
     RenderbufferMap mRenderbufferMap;
     HandleAllocator mRenderbufferHandleAllocator;
 
diff --git a/src/libGLESv2/Texture.cpp b/src/libGLESv2/Texture.cpp
index 52348cb..baa5bc6 100644
--- a/src/libGLESv2/Texture.cpp
+++ b/src/libGLESv2/Texture.cpp
@@ -87,12 +87,12 @@
     return mTarget;
 }
 
-void Texture::addProxyRef(const Renderbuffer *proxy)
+void Texture::addProxyRef(const FramebufferAttachment *proxy)
 {
     mRenderbufferProxies.addRef(proxy);
 }
 
-void Texture::releaseProxy(const Renderbuffer *proxy)
+void Texture::releaseProxy(const FramebufferAttachment *proxy)
 {
     mRenderbufferProxies.release(proxy);
 }
@@ -1027,16 +1027,16 @@
     return mTexStorage;
 }
 
-Renderbuffer *Texture2D::getRenderbuffer(GLint level)
+FramebufferAttachment *Texture2D::getAttachment(GLint level)
 {
-    Renderbuffer *renderBuffer = mRenderbufferProxies.get(level, 0);
-    if (!renderBuffer)
+    FramebufferAttachment *attachment = mRenderbufferProxies.get(level, 0);
+    if (!attachment)
     {
-        renderBuffer = new Renderbuffer(mRenderer, id(), new RenderbufferTexture2D(this, level));
-        mRenderbufferProxies.add(level, 0, renderBuffer);
+        attachment = new FramebufferAttachment(mRenderer, id(), new Texture2DAttachment(this, level));
+        mRenderbufferProxies.add(level, 0, attachment);
     }
 
-    return renderBuffer;
+    return attachment;
 }
 
 unsigned int Texture2D::getRenderTargetSerial(GLint level)
@@ -1662,19 +1662,19 @@
     return mTexStorage;
 }
 
-Renderbuffer *TextureCubeMap::getRenderbuffer(GLenum target, GLint level)
+FramebufferAttachment *TextureCubeMap::getAttachment(GLenum target, GLint level)
 {
     ASSERT(!IsCubemapTextureTarget(target));
     int faceIndex = targetToIndex(target);
 
-    Renderbuffer *renderBuffer = mRenderbufferProxies.get(level, faceIndex);
-    if (!renderBuffer)
+    FramebufferAttachment *attachment = mRenderbufferProxies.get(level, faceIndex);
+    if (!attachment)
     {
-        renderBuffer = new Renderbuffer(mRenderer, id(), new RenderbufferTextureCubeMap(this, target, level));
-        mRenderbufferProxies.add(level, faceIndex, renderBuffer);
+        attachment = new FramebufferAttachment(mRenderer, id(), new TextureCubeMapAttachment(this, target, level));
+        mRenderbufferProxies.add(level, faceIndex, attachment);
     }
 
-    return renderBuffer;
+    return attachment;
 }
 
 unsigned int TextureCubeMap::getRenderTargetSerial(GLenum target, GLint level)
@@ -2042,16 +2042,16 @@
     return true;
 }
 
-Renderbuffer *Texture3D::getRenderbuffer(GLint level, GLint layer)
+FramebufferAttachment *Texture3D::getAttachment(GLint level, GLint layer)
 {
-    Renderbuffer *renderBuffer = mRenderbufferProxies.get(level, layer);
-    if (!renderBuffer)
+    FramebufferAttachment *attachment = mRenderbufferProxies.get(level, layer);
+    if (!attachment)
     {
-        renderBuffer = new Renderbuffer(mRenderer, id(), new RenderbufferTexture3DLayer(this, level, layer));
-        mRenderbufferProxies.add(level, 0, renderBuffer);
+        attachment = new FramebufferAttachment(mRenderer, id(), new Texture3DAttachment(this, level, layer));
+        mRenderbufferProxies.add(level, 0, attachment);
     }
 
-    return renderBuffer;
+    return attachment;
 }
 
 unsigned int Texture3D::getRenderTargetSerial(GLint level, GLint layer)
@@ -2593,16 +2593,16 @@
     return true;
 }
 
-Renderbuffer *Texture2DArray::getRenderbuffer(GLint level, GLint layer)
+FramebufferAttachment *Texture2DArray::getAttachment(GLint level, GLint layer)
 {
-    Renderbuffer *renderBuffer = mRenderbufferProxies.get(level, layer);
-    if (!renderBuffer)
+    FramebufferAttachment *attachment = mRenderbufferProxies.get(level, layer);
+    if (!attachment)
     {
-        renderBuffer = new Renderbuffer(mRenderer, id(), new RenderbufferTexture2DArrayLayer(this, level, layer));
-        mRenderbufferProxies.add(level, 0, renderBuffer);
+        attachment = new FramebufferAttachment(mRenderer, id(), new Texture2DArrayAttachment(this, level, layer));
+        mRenderbufferProxies.add(level, 0, attachment);
     }
 
-    return renderBuffer;
+    return attachment;
 }
 
 unsigned int Texture2DArray::getRenderTargetSerial(GLint level, GLint layer)
diff --git a/src/libGLESv2/Texture.h b/src/libGLESv2/Texture.h
index a44a701..84ca289 100644
--- a/src/libGLESv2/Texture.h
+++ b/src/libGLESv2/Texture.h
@@ -41,7 +41,7 @@
 namespace gl
 {
 class Framebuffer;
-class Renderbuffer;
+class FramebufferAttachment;
 
 enum
 {
@@ -65,8 +65,8 @@
 
     virtual ~Texture();
 
-    void addProxyRef(const Renderbuffer *proxy);
-    void releaseProxy(const Renderbuffer *proxy);
+    void addProxyRef(const FramebufferAttachment *proxy);
+    void releaseProxy(const FramebufferAttachment *proxy);
 
     GLenum getTarget() const;
 
@@ -161,7 +161,7 @@
     // because, as the renderbuffer acting as proxy will maintain a binding pointer
     // back to this texture, there would be a circular reference if we used a binding
     // pointer here. This reference count will cause the pointer to be set to NULL if
-    // the count drops to zero, but will not cause deletion of the Renderbuffer.
+    // the count drops to zero, but will not cause deletion of the FramebufferAttachment.
     RenderbufferProxySet mRenderbufferProxies;
 
   private:
@@ -199,11 +199,11 @@
 
     virtual void generateMipmaps();
 
-    Renderbuffer *getRenderbuffer(GLint level);
+    FramebufferAttachment *getAttachment(GLint level);
     unsigned int getRenderTargetSerial(GLint level);
 
   protected:
-    friend class RenderbufferTexture2D;
+    friend class Texture2DAttachment;
     rx::RenderTarget *getRenderTarget(GLint level);
     rx::RenderTarget *getDepthSencil(GLint level);
 
@@ -267,13 +267,13 @@
 
     virtual void generateMipmaps();
 
-    Renderbuffer *getRenderbuffer(GLenum target, GLint level);
+    FramebufferAttachment *getAttachment(GLenum target, GLint level);
     unsigned int getRenderTargetSerial(GLenum target, GLint level);
 
     static int targetToIndex(GLenum target);
 
   protected:
-    friend class RenderbufferTextureCubeMap;
+    friend class TextureCubeMapAttachment;
     rx::RenderTarget *getRenderTarget(GLenum target, GLint level);
     rx::RenderTarget *getDepthStencil(GLenum target, GLint level);
 
@@ -330,11 +330,11 @@
     virtual bool isSamplerComplete(const SamplerState &samplerState) const;
     virtual bool isMipmapComplete() const;
 
-    Renderbuffer *getRenderbuffer(GLint level, GLint layer);
+    FramebufferAttachment *getAttachment(GLint level, GLint layer);
     unsigned int getRenderTargetSerial(GLint level, GLint layer);
 
   protected:
-    friend class RenderbufferTexture3DLayer;
+    friend class Texture3DAttachment;
     rx::RenderTarget *getRenderTarget(GLint level);
     rx::RenderTarget *getRenderTarget(GLint level, GLint layer);
     rx::RenderTarget *getDepthStencil(GLint level, GLint layer);
@@ -391,11 +391,11 @@
     virtual bool isSamplerComplete(const SamplerState &samplerState) const;
     virtual bool isMipmapComplete() const;
 
-    Renderbuffer *getRenderbuffer(GLint level, GLint layer);
+    FramebufferAttachment *getAttachment(GLint level, GLint layer);
     unsigned int getRenderTargetSerial(GLint level, GLint layer);
 
   protected:
-    friend class RenderbufferTexture2DArrayLayer;
+    friend class Texture2DArrayAttachment;
     rx::RenderTarget *getRenderTarget(GLint level, GLint layer);
     rx::RenderTarget *getDepthStencil(GLint level, GLint layer);
 
diff --git a/src/libGLESv2/libGLESv2.cpp b/src/libGLESv2/libGLESv2.cpp
index 0645250..bf3cd0f 100644
--- a/src/libGLESv2/libGLESv2.cpp
+++ b/src/libGLESv2/libGLESv2.cpp
@@ -2692,11 +2692,11 @@
             GLuint attachmentHandle;
             GLuint attachmentLevel;
             GLuint attachmentLayer;
-            gl::Renderbuffer *renderbuffer;
+            gl::FramebufferAttachment *attachmentObject;
 
-            if(framebufferHandle == 0)
+            if (framebufferHandle == 0)
             {
-                if(context->getClientVersion() < 3)
+                if (context->getClientVersion() < 3)
                 {
                     return gl::error(GL_INVALID_OPERATION);
                 }
@@ -2708,21 +2708,21 @@
                     attachmentHandle = framebuffer->getColorbufferHandle(0);
                     attachmentLevel = framebuffer->getColorbufferMipLevel(0);
                     attachmentLayer = framebuffer->getColorbufferLayer(0);
-                    renderbuffer = framebuffer->getColorbuffer(0);
+                    attachmentObject = framebuffer->getColorbuffer(0);
                     break;
                   case GL_DEPTH:
                     attachmentType = framebuffer->getDepthbufferType();
                     attachmentHandle = framebuffer->getDepthbufferHandle();
                     attachmentLevel = framebuffer->getDepthbufferMipLevel();
                     attachmentLayer = framebuffer->getDepthbufferLayer();
-                    renderbuffer = framebuffer->getDepthbuffer();
+                    attachmentObject = framebuffer->getDepthbuffer();
                     break;
                   case GL_STENCIL:
                     attachmentType = framebuffer->getStencilbufferType();
                     attachmentHandle = framebuffer->getStencilbufferHandle();
                     attachmentLevel = framebuffer->getStencilbufferMipLevel();
                     attachmentLayer = framebuffer->getStencilbufferLayer();
-                    renderbuffer = framebuffer->getStencilbuffer();
+                    attachmentObject = framebuffer->getStencilbuffer();
                     break;
                   default:
                     return gl::error(GL_INVALID_OPERATION);
@@ -2737,7 +2737,7 @@
                     attachmentHandle = framebuffer->getColorbufferHandle(colorAttachment);
                     attachmentLevel = framebuffer->getColorbufferMipLevel(colorAttachment);
                     attachmentLayer = framebuffer->getColorbufferLayer(colorAttachment);
-                    renderbuffer = framebuffer->getColorbuffer(colorAttachment);
+                    attachmentObject = framebuffer->getColorbuffer(colorAttachment);
                 }
                 else
                 {
@@ -2748,14 +2748,14 @@
                         attachmentHandle = framebuffer->getDepthbufferHandle();
                         attachmentLevel = framebuffer->getDepthbufferMipLevel();
                         attachmentLayer = framebuffer->getDepthbufferLayer();
-                        renderbuffer = framebuffer->getDepthbuffer();
+                        attachmentObject = framebuffer->getDepthbuffer();
                         break;
                       case GL_STENCIL_ATTACHMENT:
                         attachmentType = framebuffer->getStencilbufferType();
                         attachmentHandle = framebuffer->getStencilbufferHandle();
                         attachmentLevel = framebuffer->getStencilbufferMipLevel();
                         attachmentLayer = framebuffer->getStencilbufferLayer();
-                        renderbuffer = framebuffer->getStencilbuffer();
+                        attachmentObject = framebuffer->getStencilbuffer();
                         break;
                       case GL_DEPTH_STENCIL_ATTACHMENT:
                         if (framebuffer->getDepthbufferHandle() != framebuffer->getStencilbufferHandle())
@@ -2766,7 +2766,7 @@
                         attachmentHandle = framebuffer->getDepthStencilbufferHandle();
                         attachmentLevel = framebuffer->getDepthStencilbufferMipLevel();
                         attachmentLayer = framebuffer->getDepthStencilbufferLayer();
-                        renderbuffer = framebuffer->getDepthStencilBuffer();
+                        attachmentObject = framebuffer->getDepthStencilBuffer();
                         break;
                       default:
                         return gl::error(GL_INVALID_OPERATION);
@@ -2831,7 +2831,7 @@
             {
                 ASSERT(attachmentObjectType == GL_RENDERBUFFER || attachmentObjectType == GL_TEXTURE ||
                        attachmentObjectType == GL_FRAMEBUFFER_DEFAULT);
-                ASSERT(renderbuffer != NULL);
+                ASSERT(attachmentObject != NULL);
 
                 switch (pname)
                 {
@@ -2864,27 +2864,27 @@
                     break;
 
                   case GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE:
-                    *params = renderbuffer->getRedSize();
+                    *params = attachmentObject->getRedSize();
                     break;
 
                   case GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE:
-                    *params = renderbuffer->getGreenSize();
+                    *params = attachmentObject->getGreenSize();
                     break;
 
                   case GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE:
-                    *params = renderbuffer->getBlueSize();
+                    *params = attachmentObject->getBlueSize();
                     break;
 
                   case GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE:
-                    *params = renderbuffer->getAlphaSize();
+                    *params = attachmentObject->getAlphaSize();
                     break;
 
                   case GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE:
-                    *params = renderbuffer->getDepthSize();
+                    *params = attachmentObject->getDepthSize();
                     break;
 
                   case GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE:
-                    *params = renderbuffer->getStencilSize();
+                    *params = attachmentObject->getStencilSize();
                     break;
 
                   case GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE:
@@ -2892,11 +2892,11 @@
                     {
                         gl::error(GL_INVALID_OPERATION);
                     }
-                    *params = renderbuffer->getComponentType();
+                    *params = attachmentObject->getComponentType();
                     break;
 
                   case GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING:
-                    *params = renderbuffer->getColorEncoding();
+                    *params = attachmentObject->getColorEncoding();
                     break;
 
                   case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER:
@@ -3188,23 +3188,23 @@
                 return gl::error(GL_INVALID_OPERATION);
             }
 
-            gl::Renderbuffer *renderbuffer = context->getRenderbuffer(context->getRenderbufferHandle());
+            gl::FramebufferAttachment *attachment = context->getRenderbuffer(context->getRenderbufferHandle());
 
             switch (pname)
             {
-              case GL_RENDERBUFFER_WIDTH:           *params = renderbuffer->getWidth();          break;
-              case GL_RENDERBUFFER_HEIGHT:          *params = renderbuffer->getHeight();         break;
-              case GL_RENDERBUFFER_INTERNAL_FORMAT: *params = renderbuffer->getInternalFormat(); break;
-              case GL_RENDERBUFFER_RED_SIZE:        *params = renderbuffer->getRedSize();        break;
-              case GL_RENDERBUFFER_GREEN_SIZE:      *params = renderbuffer->getGreenSize();      break;
-              case GL_RENDERBUFFER_BLUE_SIZE:       *params = renderbuffer->getBlueSize();       break;
-              case GL_RENDERBUFFER_ALPHA_SIZE:      *params = renderbuffer->getAlphaSize();      break;
-              case GL_RENDERBUFFER_DEPTH_SIZE:      *params = renderbuffer->getDepthSize();      break;
-              case GL_RENDERBUFFER_STENCIL_SIZE:    *params = renderbuffer->getStencilSize();    break;
+              case GL_RENDERBUFFER_WIDTH:           *params = attachment->getWidth();          break;
+              case GL_RENDERBUFFER_HEIGHT:          *params = attachment->getHeight();         break;
+              case GL_RENDERBUFFER_INTERNAL_FORMAT: *params = attachment->getInternalFormat(); break;
+              case GL_RENDERBUFFER_RED_SIZE:        *params = attachment->getRedSize();        break;
+              case GL_RENDERBUFFER_GREEN_SIZE:      *params = attachment->getGreenSize();      break;
+              case GL_RENDERBUFFER_BLUE_SIZE:       *params = attachment->getBlueSize();       break;
+              case GL_RENDERBUFFER_ALPHA_SIZE:      *params = attachment->getAlphaSize();      break;
+              case GL_RENDERBUFFER_DEPTH_SIZE:      *params = attachment->getDepthSize();      break;
+              case GL_RENDERBUFFER_STENCIL_SIZE:    *params = attachment->getStencilSize();    break;
               case GL_RENDERBUFFER_SAMPLES_ANGLE:
                 if (context->getMaxSupportedSamples() != 0)
                 {
-                    *params = renderbuffer->getSamples();
+                    *params = attachment->getSamples();
                 }
                 else
                 {
@@ -4237,7 +4237,7 @@
 
         if (context && renderbuffer)
         {
-            gl::Renderbuffer *renderbufferObject = context->getRenderbuffer(renderbuffer);
+            gl::FramebufferAttachment *renderbufferObject = context->getRenderbuffer(renderbuffer);
 
             if (renderbufferObject)
             {
diff --git a/src/libGLESv2/renderer/d3d11/Clear11.cpp b/src/libGLESv2/renderer/d3d11/Clear11.cpp
index c02cd9e..bb73241 100644
--- a/src/libGLESv2/renderer/d3d11/Clear11.cpp
+++ b/src/libGLESv2/renderer/d3d11/Clear11.cpp
@@ -169,16 +169,16 @@
     gl::Extents framebufferSize;
     if (frameBuffer->getFirstColorbuffer() != NULL)
     {
-        gl::Renderbuffer *renderBuffer = frameBuffer->getFirstColorbuffer();
-        framebufferSize.width = renderBuffer->getWidth();
-        framebufferSize.height = renderBuffer->getHeight();
+        gl::FramebufferAttachment *attachment = frameBuffer->getFirstColorbuffer();
+        framebufferSize.width = attachment->getWidth();
+        framebufferSize.height = attachment->getHeight();
         framebufferSize.depth = 1;
     }
     else if (frameBuffer->getDepthOrStencilbuffer() != NULL)
     {
-        gl::Renderbuffer *renderBuffer = frameBuffer->getDepthOrStencilbuffer();
-        framebufferSize.width = renderBuffer->getWidth();
-        framebufferSize.height = renderBuffer->getHeight();
+        gl::FramebufferAttachment *attachment = frameBuffer->getDepthOrStencilbuffer();
+        framebufferSize.width = attachment->getWidth();
+        framebufferSize.height = attachment->getHeight();
         framebufferSize.depth = 1;
     }
     else
@@ -211,18 +211,18 @@
     {
         if (clearParams.clearColor[colorAttachment] && frameBuffer->isEnabledColorAttachment(colorAttachment))
         {
-            gl::Renderbuffer *renderbuffer = frameBuffer->getColorbuffer(colorAttachment);
-            if (renderbuffer)
+            gl::FramebufferAttachment *attachment = frameBuffer->getColorbuffer(colorAttachment);
+            if (attachment)
             {
-                RenderTarget11 *renderTarget = RenderTarget11::makeRenderTarget11(renderbuffer->getRenderTarget());
+                RenderTarget11 *renderTarget = RenderTarget11::makeRenderTarget11(attachment->getRenderTarget());
                 if (!renderTarget)
                 {
                     ERR("Render target pointer unexpectedly null.");
                     return;
                 }
 
-                GLenum internalFormat = renderbuffer->getInternalFormat();
-                GLenum actualFormat = renderbuffer->getActualFormat();
+                GLenum internalFormat = attachment->getInternalFormat();
+                GLenum actualFormat = attachment->getActualFormat();
                 GLenum componentType = gl::GetComponentType(internalFormat, clientVersion);
                 if (clearParams.colorClearType == GL_FLOAT &&
                     !(componentType == GL_FLOAT || componentType == GL_UNSIGNED_NORMALIZED || componentType == GL_SIGNED_NORMALIZED))
@@ -287,17 +287,17 @@
 
     if (clearParams.clearDepth || clearParams.clearStencil)
     {
-        gl::Renderbuffer *renderbuffer = frameBuffer->getDepthOrStencilbuffer();
-        if (renderbuffer)
+        gl::FramebufferAttachment *attachment = frameBuffer->getDepthOrStencilbuffer();
+        if (attachment)
         {
-            RenderTarget11 *renderTarget = RenderTarget11::makeRenderTarget11(renderbuffer->getDepthStencil());
+            RenderTarget11 *renderTarget = RenderTarget11::makeRenderTarget11(attachment->getDepthStencil());
             if (!renderTarget)
             {
                 ERR("Depth stencil render target pointer unexpectedly null.");
                 return;
             }
 
-            GLenum actualFormat = renderbuffer->getActualFormat();
+            GLenum actualFormat = attachment->getActualFormat();
 
             unsigned int stencilUnmasked = frameBuffer->hasStencil() ? (1 << gl::GetStencilBits(actualFormat, clientVersion)) - 1 : 0;
             bool needMaskedStencilClear = clearParams.clearStencil && (clearParams.stencilWriteMask & stencilUnmasked) != stencilUnmasked;
diff --git a/src/libGLESv2/renderer/d3d11/Image11.cpp b/src/libGLESv2/renderer/d3d11/Image11.cpp
index 85484f9..aa9260d 100644
--- a/src/libGLESv2/renderer/d3d11/Image11.cpp
+++ b/src/libGLESv2/renderer/d3d11/Image11.cpp
@@ -213,7 +213,7 @@
 
 void Image11::copy(GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height, gl::Framebuffer *source)
 {
-    gl::Renderbuffer *colorbuffer = source->getReadColorbuffer();
+    gl::FramebufferAttachment *colorbuffer = source->getReadColorbuffer();
 
     if (colorbuffer && colorbuffer->getActualFormat() == mActualFormat)
     {
diff --git a/src/libGLESv2/renderer/d3d11/RenderStateCache.cpp b/src/libGLESv2/renderer/d3d11/RenderStateCache.cpp
index d0bfd6c..b58569a 100644
--- a/src/libGLESv2/renderer/d3d11/RenderStateCache.cpp
+++ b/src/libGLESv2/renderer/d3d11/RenderStateCache.cpp
@@ -93,18 +93,18 @@
     key.blendState = blendState;
     for (unsigned int i = 0; i < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; i++)
     {
-        gl::Renderbuffer *renderBuffer = framebuffer->getColorbuffer(i);
-        if (renderBuffer)
+        gl::FramebufferAttachment *attachment = framebuffer->getColorbuffer(i);
+        if (attachment)
         {
             if (i > 0)
             {
                 mrt = true;
             }
 
-            key.rtChannels[i][0] = renderBuffer->getRedSize()   > 0;
-            key.rtChannels[i][1] = renderBuffer->getGreenSize() > 0;
-            key.rtChannels[i][2] = renderBuffer->getBlueSize()  > 0;
-            key.rtChannels[i][3] = renderBuffer->getAlphaSize() > 0;
+            key.rtChannels[i][0] = attachment->getRedSize()   > 0;
+            key.rtChannels[i][1] = attachment->getGreenSize() > 0;
+            key.rtChannels[i][2] = attachment->getBlueSize()  > 0;
+            key.rtChannels[i][3] = attachment->getAlphaSize() > 0;
         }
         else
         {
diff --git a/src/libGLESv2/renderer/d3d11/Renderer11.cpp b/src/libGLESv2/renderer/d3d11/Renderer11.cpp
index 143799a..c0ad111 100644
--- a/src/libGLESv2/renderer/d3d11/Renderer11.cpp
+++ b/src/libGLESv2/renderer/d3d11/Renderer11.cpp
@@ -979,7 +979,7 @@
             // the draw buffer must be either "none", "back" for the default buffer or the same index as this color (in order)
             ASSERT(drawBufferState == GL_BACK || drawBufferState == (GL_COLOR_ATTACHMENT0_EXT + colorAttachment));
 
-            gl::Renderbuffer *colorbuffer = framebuffer->getColorbuffer(colorAttachment);
+            gl::FramebufferAttachment *colorbuffer = framebuffer->getColorbuffer(colorAttachment);
 
             if (!colorbuffer)
             {
@@ -1026,7 +1026,7 @@
     }
 
     // Get the depth stencil render buffer and serials
-    gl::Renderbuffer *depthStencil = NULL;
+    gl::FramebufferAttachment *depthStencil = NULL;
     unsigned int depthbufferSerial = 0;
     unsigned int stencilbufferSerial = 0;
     if (framebuffer->getDepthbufferType() != GL_NONE)
@@ -2634,7 +2634,7 @@
 bool Renderer11::copyImage(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
                            GLint xoffset, GLint yoffset, TextureStorageInterface2D *storage, GLint level)
 {
-    gl::Renderbuffer *colorbuffer = framebuffer->getReadColorbuffer();
+    gl::FramebufferAttachment *colorbuffer = framebuffer->getReadColorbuffer();
     if (!colorbuffer)
     {
         ERR("Failed to retrieve the color buffer from the frame buffer.");
@@ -2695,7 +2695,7 @@
 bool Renderer11::copyImage(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
                            GLint xoffset, GLint yoffset, TextureStorageInterfaceCube *storage, GLenum target, GLint level)
 {
-    gl::Renderbuffer *colorbuffer = framebuffer->getReadColorbuffer();
+    gl::FramebufferAttachment *colorbuffer = framebuffer->getReadColorbuffer();
     if (!colorbuffer)
     {
         ERR("Failed to retrieve the color buffer from the frame buffer.");
@@ -2756,7 +2756,7 @@
 bool Renderer11::copyImage(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
                            GLint xoffset, GLint yoffset, GLint zOffset, TextureStorageInterface3D *storage, GLint level)
 {
-    gl::Renderbuffer *colorbuffer = framebuffer->getReadColorbuffer();
+    gl::FramebufferAttachment *colorbuffer = framebuffer->getReadColorbuffer();
     if (!colorbuffer)
     {
         ERR("Failed to retrieve the color buffer from the frame buffer.");
@@ -2817,7 +2817,7 @@
 bool Renderer11::copyImage(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
                            GLint xoffset, GLint yoffset, GLint zOffset, TextureStorageInterface2DArray *storage, GLint level)
 {
-    gl::Renderbuffer *colorbuffer = framebuffer->getReadColorbuffer();
+    gl::FramebufferAttachment *colorbuffer = framebuffer->getReadColorbuffer();
     if (!colorbuffer)
     {
         ERR("Failed to retrieve the color buffer from the frame buffer.");
@@ -3169,7 +3169,7 @@
     return mPixelTransfer->copyBufferToTexture(unpack, offset, destRenderTarget, destinationFormat, sourcePixelsType, destArea);
 }
 
-bool Renderer11::getRenderTargetResource(gl::Renderbuffer *colorbuffer, unsigned int *subresourceIndex, ID3D11Texture2D **resource)
+bool Renderer11::getRenderTargetResource(gl::FramebufferAttachment *colorbuffer, unsigned int *subresourceIndex, ID3D11Texture2D **resource)
 {
     ASSERT(colorbuffer != NULL);
 
@@ -3210,7 +3210,7 @@
 {
     if (blitRenderTarget)
     {
-        gl::Renderbuffer *readBuffer = readTarget->getReadColorbuffer();
+        gl::FramebufferAttachment *readBuffer = readTarget->getReadColorbuffer();
 
         if (!readBuffer)
         {
@@ -3224,7 +3224,7 @@
         {
             if (drawTarget->isEnabledColorAttachment(colorAttachment))
             {
-                gl::Renderbuffer *drawBuffer = drawTarget->getColorbuffer(colorAttachment);
+                gl::FramebufferAttachment *drawBuffer = drawTarget->getColorbuffer(colorAttachment);
 
                 if (!drawBuffer)
                 {
@@ -3245,8 +3245,8 @@
 
     if (blitDepth || blitStencil)
     {
-        gl::Renderbuffer *readBuffer = readTarget->getDepthOrStencilbuffer();
-        gl::Renderbuffer *drawBuffer = drawTarget->getDepthOrStencilbuffer();
+        gl::FramebufferAttachment *readBuffer = readTarget->getDepthOrStencilbuffer();
+        gl::FramebufferAttachment *drawBuffer = drawTarget->getDepthOrStencilbuffer();
 
         if (!readBuffer)
         {
@@ -3281,7 +3281,7 @@
     ID3D11Texture2D *colorBufferTexture = NULL;
     unsigned int subresourceIndex = 0;
 
-    gl::Renderbuffer *colorbuffer = framebuffer->getReadColorbuffer();
+    gl::FramebufferAttachment *colorbuffer = framebuffer->getReadColorbuffer();
 
     if (colorbuffer && getRenderTargetResource(colorbuffer, &subresourceIndex, &colorBufferTexture))
     {
@@ -3749,9 +3749,10 @@
     }
 }
 
-void Renderer11::invalidateRenderbufferSwizzles(gl::Renderbuffer *renderBuffer, int mipLevel)
+void Renderer11::invalidateFBOAttachmentSwizzles(gl::FramebufferAttachment *attachment, int mipLevel)
 {
-    TextureStorage *texStorage = renderBuffer->getTextureStorage();
+    ASSERT(attachment->isTexture());
+    TextureStorage *texStorage = attachment->getTextureStorage();
     if (texStorage)
     {
         TextureStorage11 *texStorage11 = TextureStorage11::makeTextureStorage11(texStorage);
@@ -3769,23 +3770,23 @@
 {
     for (unsigned int colorAttachment = 0; colorAttachment < gl::IMPLEMENTATION_MAX_DRAW_BUFFERS; colorAttachment++)
     {
-        gl::Renderbuffer *colorbuffer = framebuffer->getColorbuffer(colorAttachment);
-        if (colorbuffer)
+        gl::FramebufferAttachment *attachment = framebuffer->getColorbuffer(colorAttachment);
+        if (attachment && attachment->isTexture())
         {
-            invalidateRenderbufferSwizzles(colorbuffer, framebuffer->getColorbufferMipLevel(colorAttachment));
+            invalidateFBOAttachmentSwizzles(attachment, framebuffer->getColorbufferMipLevel(colorAttachment));
         }
     }
 
-    gl::Renderbuffer *depthBuffer = framebuffer->getDepthbuffer();
-    if (depthBuffer)
+    gl::FramebufferAttachment *depthAttachment = framebuffer->getDepthbuffer();
+    if (depthAttachment && depthAttachment->isTexture())
     {
-        invalidateRenderbufferSwizzles(depthBuffer, framebuffer->getDepthbufferMipLevel());
+        invalidateFBOAttachmentSwizzles(depthAttachment, framebuffer->getDepthbufferMipLevel());
     }
 
-    gl::Renderbuffer *stencilBuffer = framebuffer->getStencilbuffer();
-    if (stencilBuffer)
+    gl::FramebufferAttachment *stencilAttachment = framebuffer->getStencilbuffer();
+    if (stencilAttachment && stencilAttachment->isTexture())
     {
-        invalidateRenderbufferSwizzles(stencilBuffer, framebuffer->getStencilbufferMipLevel());
+        invalidateFBOAttachmentSwizzles(stencilAttachment, framebuffer->getStencilbufferMipLevel());
     }
 }
 
diff --git a/src/libGLESv2/renderer/d3d11/Renderer11.h b/src/libGLESv2/renderer/d3d11/Renderer11.h
index 3e6a54a..bbd0de4 100644
--- a/src/libGLESv2/renderer/d3d11/Renderer11.h
+++ b/src/libGLESv2/renderer/d3d11/Renderer11.h
@@ -21,7 +21,7 @@
 
 namespace gl
 {
-class Renderbuffer;
+class FramebufferAttachment;
 }
 
 namespace rx
@@ -229,7 +229,7 @@
     virtual bool fastCopyBufferToTexture(const gl::PixelUnpackState &unpack, unsigned int offset, RenderTarget *destRenderTarget,
                                          GLenum destinationFormat, GLenum sourcePixelsType, const gl::Box &destArea);
 
-    bool getRenderTargetResource(gl::Renderbuffer *colorbuffer, unsigned int *subresourceIndex, ID3D11Texture2D **resource);
+    bool getRenderTargetResource(gl::FramebufferAttachment *colorbuffer, unsigned int *subresourceIndex, ID3D11Texture2D **resource);
     void unapplyRenderTargets();
     void setOneTimeRenderTarget(ID3D11RenderTargetView *renderTargetView);
     void packPixels(ID3D11Texture2D *readTexture, const PackPixelsParams &params, void *pixelsOut);
@@ -255,7 +255,7 @@
                               bool colorBlit, bool depthBlit, bool stencilBlit);
     ID3D11Texture2D *resolveMultisampledTexture(ID3D11Texture2D *source, unsigned int subresource);
 
-    static void invalidateRenderbufferSwizzles(gl::Renderbuffer *renderBuffer, int mipLevel);
+    static void invalidateFBOAttachmentSwizzles(gl::FramebufferAttachment *attachment, int mipLevel);
     static void invalidateFramebufferSwizzles(gl::Framebuffer *framebuffer);
 
     HMODULE mD3d11Module;
diff --git a/src/libGLESv2/renderer/d3d9/Blit9.cpp b/src/libGLESv2/renderer/d3d9/Blit9.cpp
index a8485bd..80a4375 100644
--- a/src/libGLESv2/renderer/d3d9/Blit9.cpp
+++ b/src/libGLESv2/renderer/d3d9/Blit9.cpp
@@ -213,7 +213,7 @@
 {
     RenderTarget9 *renderTarget = NULL;
     IDirect3DSurface9 *source = NULL;
-    gl::Renderbuffer *colorbuffer = framebuffer->getColorbuffer(0);
+    gl::FramebufferAttachment *colorbuffer = framebuffer->getColorbuffer(0);
 
     if (colorbuffer)
     {
@@ -249,7 +249,7 @@
 {
     RenderTarget9 *renderTarget = NULL;
     IDirect3DSurface9 *source = NULL;
-    gl::Renderbuffer *colorbuffer = framebuffer->getColorbuffer(0);
+    gl::FramebufferAttachment *colorbuffer = framebuffer->getColorbuffer(0);
 
     if (colorbuffer)
     {
diff --git a/src/libGLESv2/renderer/d3d9/Image9.cpp b/src/libGLESv2/renderer/d3d9/Image9.cpp
index 7ddf957..001858e 100644
--- a/src/libGLESv2/renderer/d3d9/Image9.cpp
+++ b/src/libGLESv2/renderer/d3d9/Image9.cpp
@@ -452,7 +452,7 @@
 
     RenderTarget9 *renderTarget = NULL;
     IDirect3DSurface9 *surface = NULL;
-    gl::Renderbuffer *colorbuffer = source->getColorbuffer(0);
+    gl::FramebufferAttachment *colorbuffer = source->getColorbuffer(0);
 
     if (colorbuffer)
     {
diff --git a/src/libGLESv2/renderer/d3d9/Renderer9.cpp b/src/libGLESv2/renderer/d3d9/Renderer9.cpp
index 76fdfdc..7d6dd7a 100644
--- a/src/libGLESv2/renderer/d3d9/Renderer9.cpp
+++ b/src/libGLESv2/renderer/d3d9/Renderer9.cpp
@@ -930,8 +930,8 @@
             FIXME("Sample alpha to coverage is unimplemented.");
         }
 
-        gl::Renderbuffer *renderBuffer = framebuffer->getFirstColorbuffer();
-        GLenum internalFormat = renderBuffer ? renderBuffer->getInternalFormat() : GL_NONE;
+        gl::FramebufferAttachment *attachment = framebuffer->getFirstColorbuffer();
+        GLenum internalFormat = attachment ? attachment->getInternalFormat() : GL_NONE;
         GLuint clientVersion = getCurrentClientVersion();
 
         // Set the color mask
@@ -1225,7 +1225,7 @@
 }
 
 
-gl::Renderbuffer *Renderer9::getNullColorbuffer(gl::Renderbuffer *depthbuffer)
+gl::FramebufferAttachment *Renderer9::getNullColorbuffer(gl::FramebufferAttachment *depthbuffer)
 {
     if (!depthbuffer)
     {
@@ -1248,7 +1248,7 @@
         }
     }
 
-    gl::Renderbuffer *nullbuffer = new gl::Renderbuffer(this, 0, new gl::Colorbuffer(this, width, height, GL_NONE, 0));
+    gl::FramebufferAttachment *nullbuffer = new gl::FramebufferAttachment(this, 0, new gl::Colorbuffer(this, width, height, GL_NONE, 0));
 
     // add nullbuffer to the cache
     NullColorbufferCacheEntry *oldest = &mNullColorbufferCache[0];
@@ -1273,7 +1273,7 @@
 {
     // if there is no color attachment we must synthesize a NULL colorattachment
     // to keep the D3D runtime happy.  This should only be possible if depth texturing.
-    gl::Renderbuffer *renderbufferObject = NULL;
+    gl::FramebufferAttachment *renderbufferObject = NULL;
     if (framebuffer->getColorbufferType(0) != GL_NONE)
     {
         renderbufferObject = framebuffer->getColorbuffer(0);
@@ -1314,7 +1314,7 @@
         renderTargetChanged = true;
     }
 
-    gl::Renderbuffer *depthStencil = NULL;
+    gl::FramebufferAttachment *depthStencil = NULL;
     unsigned int depthbufferSerial = 0;
     unsigned int stencilbufferSerial = 0;
     if (framebuffer->getDepthbufferType() != GL_NONE)
@@ -1902,9 +1902,9 @@
     D3DCOLOR color = D3DCOLOR_ARGB(255, 0, 0, 0);
     if (clearColor)
     {
-        gl::Renderbuffer *renderbuffer = frameBuffer->getFirstColorbuffer();
-        GLenum internalFormat = renderbuffer->getInternalFormat();
-        GLenum actualFormat = renderbuffer->getActualFormat();
+        gl::FramebufferAttachment *attachment = frameBuffer->getFirstColorbuffer();
+        GLenum internalFormat = attachment->getInternalFormat();
+        GLenum actualFormat = attachment->getActualFormat();
 
         GLuint clientVersion = getCurrentClientVersion();
         GLuint internalRedBits = gl::GetRedBits(internalFormat, clientVersion);
@@ -2935,8 +2935,8 @@
 
     if (blitRenderTarget)
     {
-        gl::Renderbuffer *readBuffer = readFramebuffer->getColorbuffer(0);
-        gl::Renderbuffer *drawBuffer = drawFramebuffer->getColorbuffer(0);
+        gl::FramebufferAttachment *readBuffer = readFramebuffer->getColorbuffer(0);
+        gl::FramebufferAttachment *drawBuffer = drawFramebuffer->getColorbuffer(0);
         RenderTarget9 *readRenderTarget = NULL;
         RenderTarget9 *drawRenderTarget = NULL;
         IDirect3DSurface9* readSurface = NULL;
@@ -3064,8 +3064,8 @@
 
     if (blitDepth || blitStencil)
     {
-        gl::Renderbuffer *readBuffer = readFramebuffer->getDepthOrStencilbuffer();
-        gl::Renderbuffer *drawBuffer = drawFramebuffer->getDepthOrStencilbuffer();
+        gl::FramebufferAttachment *readBuffer = readFramebuffer->getDepthOrStencilbuffer();
+        gl::FramebufferAttachment *drawBuffer = drawFramebuffer->getDepthOrStencilbuffer();
         RenderTarget9 *readDepthStencil = NULL;
         RenderTarget9 *drawDepthStencil = NULL;
         IDirect3DSurface9* readSurface = NULL;
@@ -3117,7 +3117,7 @@
 
     RenderTarget9 *renderTarget = NULL;
     IDirect3DSurface9 *surface = NULL;
-    gl::Renderbuffer *colorbuffer = framebuffer->getColorbuffer(0);
+    gl::FramebufferAttachment *colorbuffer = framebuffer->getColorbuffer(0);
 
     if (colorbuffer)
     {
diff --git a/src/libGLESv2/renderer/d3d9/Renderer9.h b/src/libGLESv2/renderer/d3d9/Renderer9.h
index 8f723e3..d3ea314 100644
--- a/src/libGLESv2/renderer/d3d9/Renderer9.h
+++ b/src/libGLESv2/renderer/d3d9/Renderer9.h
@@ -19,7 +19,7 @@
 
 namespace gl
 {
-class Renderbuffer;
+class FramebufferAttachment;
 }
 
 namespace rx
@@ -249,7 +249,7 @@
     void drawIndexedPoints(GLsizei count, GLenum type, const GLvoid *indices, int minIndex, gl::Buffer *elementArrayBuffer);
 
     bool copyToRenderTarget(IDirect3DSurface9 *dest, IDirect3DSurface9 *source, bool fromManaged);
-    gl::Renderbuffer *getNullColorbuffer(gl::Renderbuffer *depthbuffer);
+    gl::FramebufferAttachment *getNullColorbuffer(gl::FramebufferAttachment *depthbuffer);
 
     D3DPOOL getBufferPool(DWORD usage) const;
 
@@ -401,7 +401,7 @@
         UINT lruCount;
         int width;
         int height;
-        gl::Renderbuffer *buffer;
+        gl::FramebufferAttachment *buffer;
     } mNullColorbufferCache[NUM_NULL_COLORBUFFER_CACHE_ENTRIES];
     UINT mMaxNullColorbufferLRU;
 
diff --git a/src/libGLESv2/validationES.cpp b/src/libGLESv2/validationES.cpp
index 86d518d7..e44a0f7 100644
--- a/src/libGLESv2/validationES.cpp
+++ b/src/libGLESv2/validationES.cpp
@@ -375,7 +375,7 @@
     return true;
 }
 
-static bool IsPartialBlit(gl::Context *context, gl::Renderbuffer *readBuffer, gl::Renderbuffer *writeBuffer,
+static bool IsPartialBlit(gl::Context *context, gl::FramebufferAttachment *readBuffer, gl::FramebufferAttachment *writeBuffer,
                           GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
                           GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1)
 {
@@ -472,8 +472,8 @@
 
     if (mask & GL_COLOR_BUFFER_BIT)
     {
-        gl::Renderbuffer *readColorBuffer = readFramebuffer->getReadColorbuffer();
-        gl::Renderbuffer *drawColorBuffer = drawFramebuffer->getFirstColorbuffer();
+        gl::FramebufferAttachment *readColorBuffer = readFramebuffer->getReadColorbuffer();
+        gl::FramebufferAttachment *drawColorBuffer = drawFramebuffer->getFirstColorbuffer();
 
         if (readColorBuffer && drawColorBuffer)
         {
@@ -555,8 +555,8 @@
 
     if (mask & GL_DEPTH_BUFFER_BIT)
     {
-        gl::Renderbuffer *readDepthBuffer = readFramebuffer->getDepthbuffer();
-        gl::Renderbuffer *drawDepthBuffer = drawFramebuffer->getDepthbuffer();
+        gl::FramebufferAttachment *readDepthBuffer = readFramebuffer->getDepthbuffer();
+        gl::FramebufferAttachment *drawDepthBuffer = drawFramebuffer->getDepthbuffer();
 
         if (readDepthBuffer && drawDepthBuffer)
         {
@@ -589,8 +589,8 @@
 
     if (mask & GL_STENCIL_BUFFER_BIT)
     {
-        gl::Renderbuffer *readStencilBuffer = readFramebuffer->getStencilbuffer();
-        gl::Renderbuffer *drawStencilBuffer = drawFramebuffer->getStencilbuffer();
+        gl::FramebufferAttachment *readStencilBuffer = readFramebuffer->getStencilbuffer();
+        gl::FramebufferAttachment *drawStencilBuffer = drawFramebuffer->getStencilbuffer();
 
         if (readStencilBuffer && drawStencilBuffer)
         {
@@ -1078,8 +1078,8 @@
                 return gl::error(GL_INVALID_OPERATION, false);
             }
 
-            Renderbuffer *renderbuffer = framebuffer->getReadColorbuffer();
-            if (!renderbuffer)
+            FramebufferAttachment *attachment = framebuffer->getReadColorbuffer();
+            if (!attachment)
             {
                 return gl::error(GL_INVALID_OPERATION, false);
             }
diff --git a/src/libGLESv2/validationES3.cpp b/src/libGLESv2/validationES3.cpp
index 555c5e3..a45a5a3 100644
--- a/src/libGLESv2/validationES3.cpp
+++ b/src/libGLESv2/validationES3.cpp
@@ -316,7 +316,18 @@
     }
 
     gl::Framebuffer *framebuffer = context->getReadFramebuffer();
-    gl::Renderbuffer *source = framebuffer->getReadColorbuffer();
+
+    if (framebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE)
+    {
+        return gl::error(GL_INVALID_FRAMEBUFFER_OPERATION, false);
+    }
+
+    if (context->getReadFramebufferHandle() != 0 && framebuffer->getSamples() != 0)
+    {
+        return gl::error(GL_INVALID_OPERATION, false);
+    }
+
+    gl::FramebufferAttachment *source = framebuffer->getReadColorbuffer();
     GLenum colorbufferInternalFormat = source->getInternalFormat();
 
     if (isSubImage)