Remove rx::TextureStorageInterface entirely.

This class provides no added benefit now that we've scrapped the
type-specialized classes. We can squash it's functionality into
TextureStorage instead.

BUG=angle:741

Change-Id: I04984806719a01f299986265fe09b3cccf04dca5
Reviewed-on: https://chromium-review.googlesource.com/218316
Tested-by: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Geoff Lang <geofflang@chromium.org>

22 files changed, 209 insertions, 271 deletions

diff --git a/src/libGLESv2/Texture.cpp b/src/libGLESv2/Texture.cpp
index 826002df..3ec492de 100644
--- a/src/libGLESv2/Texture.cpp
+++ b/src/libGLESv2/Texture.cpp
@@ -77,7 +77,7 @@ void Texture::getSamplerStateWithNativeOffset(SamplerState *sampler)
     *sampler = mSamplerState;
 
     // Offset the effective base level by the texture storage's top level
-    rx::TextureStorageInterface *texture = getNativeTexture();
+    rx::TextureStorage *texture = getNativeTexture();
     int topLevel = texture ? texture->getTopLevel() : 0;
     sampler->baseLevel = topLevel + mSamplerState.baseLevel;
 }
@@ -138,7 +138,7 @@ GLenum Texture::getActualFormat(const ImageIndex &index) const
     return image->getActualFormat();
 }
 
-rx::TextureStorageInterface *Texture::getNativeTexture()
+rx::TextureStorage *Texture::getNativeTexture()
 {
     return getImplementation()->getNativeTexture();
 }
@@ -155,7 +155,7 @@ void Texture::copySubImage(GLenum target, GLint level, GLint xoffset, GLint yoff
 
 unsigned int Texture::getTextureSerial()
 {
-    rx::TextureStorageInterface *texture = getNativeTexture();
+    rx::TextureStorage *texture = getNativeTexture();
     return texture ? texture->getTextureSerial() : 0;
 }
 
@@ -166,7 +166,7 @@ bool Texture::isImmutable() const
 
 int Texture::immutableLevelCount()
 {
-    return (mImmutable ? getNativeTexture()->getStorageInstance()->getLevelCount() : 0);
+    return (mImmutable ? getNativeTexture()->getLevelCount() : 0);
 }
 
 int Texture::mipLevels() const
diff --git a/src/libGLESv2/Texture.h b/src/libGLESv2/Texture.h
index 94dd3bc9..ca5686fd 100644
--- a/src/libGLESv2/Texture.h
+++ b/src/libGLESv2/Texture.h
@@ -69,7 +69,7 @@ class Texture : public RefCountObject
 
     virtual bool isSamplerComplete(const SamplerState &samplerState, const TextureCapsMap &textureCaps, const Extensions &extensions, int clientVersion) const = 0;
 
-    rx::TextureStorageInterface *getNativeTexture();
+    rx::TextureStorage *getNativeTexture();
 
     virtual void generateMipmaps();
     virtual void copySubImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height, Framebuffer *source);
diff --git a/src/libGLESv2/renderer/Renderer.h b/src/libGLESv2/renderer/Renderer.h
index 742c8f6c..f104a951 100644
--- a/src/libGLESv2/renderer/Renderer.h
+++ b/src/libGLESv2/renderer/Renderer.h
@@ -44,7 +44,7 @@ struct VertexAttribCurrentValueData;
 
 namespace rx
 {
-class TextureStorageInterface;
+class TextureStorage;
 class VertexBuffer;
 class IndexBuffer;
 class QueryImpl;
@@ -170,19 +170,19 @@ class Renderer
     virtual int getMaxSwapInterval() const = 0;
 
     // Pixel operations
-    virtual bool copyToRenderTarget2D(TextureStorageInterface *dest, TextureStorageInterface *source) = 0;
-    virtual bool copyToRenderTargetCube(TextureStorageInterface *dest, TextureStorageInterface *source) = 0;
-    virtual bool copyToRenderTarget3D(TextureStorageInterface *dest, TextureStorageInterface *source) = 0;
-    virtual bool copyToRenderTarget2DArray(TextureStorageInterface *dest, TextureStorageInterface *source) = 0;
+    virtual bool copyToRenderTarget2D(TextureStorage *dest, TextureStorage *source) = 0;
+    virtual bool copyToRenderTargetCube(TextureStorage *dest, TextureStorage *source) = 0;
+    virtual bool copyToRenderTarget3D(TextureStorage *dest, TextureStorage *source) = 0;
+    virtual bool copyToRenderTarget2DArray(TextureStorage *dest, TextureStorage *source) = 0;
 
     virtual bool copyImage2D(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
-                             GLint xoffset, GLint yoffset, TextureStorageInterface *storage, GLint level) = 0;
+                             GLint xoffset, GLint yoffset, TextureStorage *storage, GLint level) = 0;
     virtual bool copyImageCube(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
-                               GLint xoffset, GLint yoffset, TextureStorageInterface *storage, GLenum target, GLint level) = 0;
+                               GLint xoffset, GLint yoffset, TextureStorage *storage, GLenum target, GLint level) = 0;
     virtual bool copyImage3D(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
-                             GLint xoffset, GLint yoffset, GLint zOffset, TextureStorageInterface *storage, GLint level) = 0;
+                             GLint xoffset, GLint yoffset, GLint zOffset, TextureStorage *storage, GLint level) = 0;
     virtual bool copyImage2DArray(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
-                                  GLint xoffset, GLint yoffset, GLint zOffset, TextureStorageInterface *storage, GLint level) = 0;
+                                  GLint xoffset, GLint yoffset, GLint zOffset, TextureStorage *storage, GLint level) = 0;
 
     virtual bool blitRect(gl::Framebuffer *readTarget, const gl::Rectangle &readRect, gl::Framebuffer *drawTarget, const gl::Rectangle &drawRect,
                           const gl::Rectangle *scissor, bool blitRenderTarget, bool blitDepth, bool blitStencil, GLenum filter) = 0;
diff --git a/src/libGLESv2/renderer/TextureImpl.h b/src/libGLESv2/renderer/TextureImpl.h
index da561bdc..e3cc50d6 100644
--- a/src/libGLESv2/renderer/TextureImpl.h
+++ b/src/libGLESv2/renderer/TextureImpl.h
@@ -32,7 +32,7 @@ namespace rx
 
 class Image;
 class Renderer;
-class TextureStorageInterface;
+class TextureStorage;
 
 class TextureImpl
 {
@@ -42,7 +42,7 @@ class TextureImpl
     // TODO: If this methods could go away that would be ideal;
     // TextureStorage should only be necessary for the D3D backend, and as such
     // higher level code should not rely on it.
-    virtual TextureStorageInterface *getNativeTexture() = 0;
+    virtual TextureStorage *getNativeTexture() = 0;
 
     // Deprecated in favour of the ImageIndex method
     virtual Image *getImage(int level, int layer) const = 0;
diff --git a/src/libGLESv2/renderer/d3d/ImageD3D.h b/src/libGLESv2/renderer/d3d/ImageD3D.h
index ac2da19e..60a6ffdf 100644
--- a/src/libGLESv2/renderer/d3d/ImageD3D.h
+++ b/src/libGLESv2/renderer/d3d/ImageD3D.h
@@ -21,7 +21,7 @@ class Framebuffer;
 
 namespace rx
 {
-class TextureStorageInterface;
+class TextureStorage;
 
 class ImageD3D : public Image
 {
@@ -33,14 +33,14 @@ class ImageD3D : public Image
 
     virtual bool isDirty() const = 0;
 
-    virtual void setManagedSurface2D(TextureStorageInterface *storage, int level) {};
-    virtual void setManagedSurfaceCube(TextureStorageInterface *storage, int face, int level) {};
-    virtual void setManagedSurface3D(TextureStorageInterface *storage, int level) {};
-    virtual void setManagedSurface2DArray(TextureStorageInterface *storage, int layer, int level) {};
-    virtual bool copyToStorage2D(TextureStorageInterface *storage, int level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height) = 0;
-    virtual bool copyToStorageCube(TextureStorageInterface *storage, int face, int level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height) = 0;
-    virtual bool copyToStorage3D(TextureStorageInterface *storage, int level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth) = 0;
-    virtual bool copyToStorage2DArray(TextureStorageInterface *storage, int level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height) = 0;
+    virtual void setManagedSurface2D(TextureStorage *storage, int level) {};
+    virtual void setManagedSurfaceCube(TextureStorage *storage, int face, int level) {};
+    virtual void setManagedSurface3D(TextureStorage *storage, int level) {};
+    virtual void setManagedSurface2DArray(TextureStorage *storage, int layer, int level) {};
+    virtual bool copyToStorage2D(TextureStorage *storage, int level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height) = 0;
+    virtual bool copyToStorageCube(TextureStorage *storage, int face, int level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height) = 0;
+    virtual bool copyToStorage3D(TextureStorage *storage, int level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth) = 0;
+    virtual bool copyToStorage2DArray(TextureStorage *storage, int level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height) = 0;
 
   private:
     DISALLOW_COPY_AND_ASSIGN(ImageD3D);
diff --git a/src/libGLESv2/renderer/d3d/TextureD3D.cpp b/src/libGLESv2/renderer/d3d/TextureD3D.cpp
index b68c7fad..2650913b 100644
--- a/src/libGLESv2/renderer/d3d/TextureD3D.cpp
+++ b/src/libGLESv2/renderer/d3d/TextureD3D.cpp
@@ -49,12 +49,12 @@ TextureD3D *TextureD3D::makeTextureD3D(TextureImpl *texture)
     return static_cast<TextureD3D*>(texture);
 }
 
-TextureStorageInterface *TextureD3D::getNativeTexture()
+TextureStorage *TextureD3D::getNativeTexture()
 {
     // ensure the underlying texture is created
     initializeStorage(false);
 
-    TextureStorageInterface *storage = getBaseLevelStorage();
+    TextureStorage *storage = getBaseLevelStorage();
     if (storage)
     {
         updateStorage();
@@ -457,7 +457,7 @@ void TextureD3D_2D::storage(GLenum target, GLsizei levels, GLenum internalformat
 
     bool renderTarget = IsRenderTargetUsage(mUsage);
     TextureStorage *storage = mRenderer->createTextureStorage2D(internalformat, renderTarget, width, height, levels);
-    setCompleteTexStorage(new TextureStorageInterface(storage, 1));
+    setCompleteTexStorage(storage);
 }
 
 void TextureD3D_2D::bindTexImage(egl::Surface *surface)
@@ -470,8 +470,8 @@ void TextureD3D_2D::bindTexImage(egl::Surface *surface)
     {
         SafeDelete(mTexStorage);
     }
-    TextureStorage *storage = mRenderer->createTextureStorage2D(surface->getSwapChain());
-    mTexStorage = new TextureStorageInterface(storage, 1);
+
+    mTexStorage = mRenderer->createTextureStorage2D(surface->getSwapChain());
 
     mDirtyImages = true;
 }
@@ -502,7 +502,7 @@ void TextureD3D_2D::generateMipmaps()
 
     if (mTexStorage && mTexStorage->isRenderTarget())
     {
-        mTexStorage->getStorageInstance()->generateMipmaps();
+        mTexStorage->generateMipmaps();
         for (int level = 1; level < levelCount; level++)
         {
             mImageArray[level]->markClean();
@@ -534,7 +534,7 @@ RenderTarget *TextureD3D_2D::getRenderTarget(const gl::ImageIndex &index)
     }
 
     updateStorageLevel(index.mipIndex);
-    return mTexStorage->getStorageInstance()->getRenderTarget(index);
+    return mTexStorage->getRenderTarget(index);
 }
 
 bool TextureD3D_2D::isValidLevel(int level) const
@@ -610,7 +610,7 @@ void TextureD3D_2D::initializeStorage(bool renderTarget)
     updateStorage();
 }
 
-TextureStorageInterface *TextureD3D_2D::createCompleteStorage(bool renderTarget) const
+TextureStorage *TextureD3D_2D::createCompleteStorage(bool renderTarget) const
 {
     GLsizei width = getBaseLevelWidth();
     GLsizei height = getBaseLevelHeight();
@@ -621,11 +621,10 @@ TextureStorageInterface *TextureD3D_2D::createCompleteStorage(bool renderTarget)
     // use existing storage level count, when previously specified by TexStorage*D
     GLint levels = (mTexStorage ? mTexStorage->getLevelCount() : creationLevels(width, height, 1));
 
-    TextureStorage *storageInstance = mRenderer->createTextureStorage2D(internalFormat, renderTarget, width, height, levels);
-    return new TextureStorageInterface(storageInstance, 1);
+    return mRenderer->createTextureStorage2D(internalFormat, renderTarget, width, height, levels);
 }
 
-void TextureD3D_2D::setCompleteTexStorage(TextureStorageInterface *newCompleteTexStorage)
+void TextureD3D_2D::setCompleteTexStorage(TextureStorage *newCompleteTexStorage)
 {
     SafeDelete(mTexStorage);
     mTexStorage = newCompleteTexStorage;
@@ -663,7 +662,7 @@ bool TextureD3D_2D::ensureRenderTarget()
         ASSERT(mTexStorage);
         if (!mTexStorage->isRenderTarget())
         {
-            TextureStorageInterface *newRenderTargetStorage = createCompleteStorage(true);
+            TextureStorage *newRenderTargetStorage = createCompleteStorage(true);
 
             if (!mRenderer->copyToRenderTarget2D(newRenderTargetStorage, mTexStorage))
             {
@@ -678,7 +677,7 @@ bool TextureD3D_2D::ensureRenderTarget()
     return (mTexStorage && mTexStorage->isRenderTarget());
 }
 
-TextureStorageInterface *TextureD3D_2D::getBaseLevelStorage()
+TextureStorage *TextureD3D_2D::getBaseLevelStorage()
 {
     return mTexStorage;
 }
@@ -943,8 +942,8 @@ void TextureD3D_Cube::storage(GLenum target, GLsizei levels, GLenum internalform
     mImmutable = true;
 
     bool renderTarget = IsRenderTargetUsage(mUsage);
-    TextureStorage *storageInstance = mRenderer->createTextureStorageCube(internalformat, renderTarget, width, levels);
-    setCompleteTexStorage(new TextureStorageInterface(storageInstance, 6));
+    TextureStorage *storage = mRenderer->createTextureStorageCube(internalformat, renderTarget, width, levels);
+    setCompleteTexStorage(storage);
 }
 
 // Tests for cube texture completeness. [OpenGL ES 2.0.24] section 3.7.10 page 81.
@@ -1000,7 +999,7 @@ void TextureD3D_Cube::generateMipmaps()
 
     if (mTexStorage && mTexStorage->isRenderTarget())
     {
-        mTexStorage->getStorageInstance()->generateMipmaps();
+        mTexStorage->generateMipmaps();
 
         for (int faceIndex = 0; faceIndex < 6; faceIndex++)
         {
@@ -1038,7 +1037,7 @@ RenderTarget *TextureD3D_Cube::getRenderTarget(const gl::ImageIndex &index)
     }
 
     updateStorageFaceLevel(index.layerIndex, index.mipIndex);
-    return mTexStorage->getStorageInstance()->getRenderTarget(index);
+    return mTexStorage->getRenderTarget(index);
 }
 
 void TextureD3D_Cube::initializeStorage(bool renderTarget)
@@ -1064,7 +1063,7 @@ void TextureD3D_Cube::initializeStorage(bool renderTarget)
     updateStorage();
 }
 
-TextureStorageInterface *TextureD3D_Cube::createCompleteStorage(bool renderTarget) const
+TextureStorage *TextureD3D_Cube::createCompleteStorage(bool renderTarget) const
 {
     GLsizei size = getBaseLevelWidth();
 
@@ -1073,11 +1072,10 @@ TextureStorageInterface *TextureD3D_Cube::createCompleteStorage(bool renderTarge
     // use existing storage level count, when previously specified by TexStorage*D
     GLint levels = (mTexStorage ? mTexStorage->getLevelCount() : creationLevels(size, size, 1));
 
-    TextureStorage *storage = mRenderer->createTextureStorageCube(getBaseLevelInternalFormat(), renderTarget, size, levels);
-    return new TextureStorageInterface(storage, 6);
+    return mRenderer->createTextureStorageCube(getBaseLevelInternalFormat(), renderTarget, size, levels);
 }
 
-void TextureD3D_Cube::setCompleteTexStorage(TextureStorageInterface *newCompleteTexStorage)
+void TextureD3D_Cube::setCompleteTexStorage(TextureStorage *newCompleteTexStorage)
 {
     SafeDelete(mTexStorage);
     mTexStorage = newCompleteTexStorage;
@@ -1121,7 +1119,7 @@ bool TextureD3D_Cube::ensureRenderTarget()
         ASSERT(mTexStorage);
         if (!mTexStorage->isRenderTarget())
         {
-            TextureStorageInterface *newRenderTargetStorage = createCompleteStorage(true);
+            TextureStorage *newRenderTargetStorage = createCompleteStorage(true);
 
             if (!mRenderer->copyToRenderTargetCube(newRenderTargetStorage, mTexStorage))
             {
@@ -1136,7 +1134,7 @@ bool TextureD3D_Cube::ensureRenderTarget()
     return (mTexStorage && mTexStorage->isRenderTarget());
 }
 
-TextureStorageInterface *TextureD3D_Cube::getBaseLevelStorage()
+TextureStorage *TextureD3D_Cube::getBaseLevelStorage()
 {
     return mTexStorage;
 }
@@ -1470,7 +1468,7 @@ void TextureD3D_3D::storage(GLenum target, GLsizei levels, GLenum internalformat
 
     bool renderTarget = IsRenderTargetUsage(mUsage);
     TextureStorage *storage = mRenderer->createTextureStorage3D(internalformat, renderTarget, width, height, depth, levels);
-    setCompleteTexStorage(new TextureStorageInterface(storage, depth));
+    setCompleteTexStorage(storage);
 }
 
 void TextureD3D_3D::bindTexImage(egl::Surface *surface)
@@ -1498,7 +1496,7 @@ void TextureD3D_3D::generateMipmaps()
 
     if (mTexStorage && mTexStorage->isRenderTarget())
     {
-        mTexStorage->getStorageInstance()->generateMipmaps();
+        mTexStorage->generateMipmaps();
 
         for (int level = 1; level < levelCount; level++)
         {
@@ -1536,7 +1534,7 @@ RenderTarget *TextureD3D_3D::getRenderTarget(const gl::ImageIndex &index)
         updateStorageLevel(index.mipIndex);
     }
 
-    return mTexStorage->getStorageInstance()->getRenderTarget(index);
+    return mTexStorage->getRenderTarget(index);
 }
 
 void TextureD3D_3D::initializeStorage(bool renderTarget)
@@ -1562,7 +1560,7 @@ void TextureD3D_3D::initializeStorage(bool renderTarget)
     updateStorage();
 }
 
-TextureStorageInterface *TextureD3D_3D::createCompleteStorage(bool renderTarget) const
+TextureStorage *TextureD3D_3D::createCompleteStorage(bool renderTarget) const
 {
     GLsizei width = getBaseLevelWidth();
     GLsizei height = getBaseLevelHeight();
@@ -1574,11 +1572,10 @@ TextureStorageInterface *TextureD3D_3D::createCompleteStorage(bool renderTarget)
     // use existing storage level count, when previously specified by TexStorage*D
     GLint levels = (mTexStorage ? mTexStorage->getLevelCount() : creationLevels(width, height, depth));
 
-    TextureStorage *storage = mRenderer->createTextureStorage3D(internalFormat, renderTarget, width, height, depth, levels);
-    return new TextureStorageInterface(storage, depth);
+    return mRenderer->createTextureStorage3D(internalFormat, renderTarget, width, height, depth, levels);
 }
 
-void TextureD3D_3D::setCompleteTexStorage(TextureStorageInterface *newCompleteTexStorage)
+void TextureD3D_3D::setCompleteTexStorage(TextureStorage *newCompleteTexStorage)
 {
     SafeDelete(mTexStorage);
     mTexStorage = newCompleteTexStorage;
@@ -1610,7 +1607,7 @@ bool TextureD3D_3D::ensureRenderTarget()
         ASSERT(mTexStorage);
         if (!mTexStorage->isRenderTarget())
         {
-            TextureStorageInterface *newRenderTargetStorage = createCompleteStorage(true);
+            TextureStorage *newRenderTargetStorage = createCompleteStorage(true);
 
             if (!mRenderer->copyToRenderTarget3D(newRenderTargetStorage, mTexStorage))
             {
@@ -1625,7 +1622,7 @@ bool TextureD3D_3D::ensureRenderTarget()
     return (mTexStorage && mTexStorage->isRenderTarget());
 }
 
-TextureStorageInterface *TextureD3D_3D::getBaseLevelStorage()
+TextureStorage *TextureD3D_3D::getBaseLevelStorage()
 {
     return mTexStorage;
 }
@@ -1952,7 +1949,7 @@ void TextureD3D_2DArray::storage(GLenum target, GLsizei levels, GLenum internalf
 
     bool renderTarget = IsRenderTargetUsage(mUsage);
     TextureStorage *storage = mRenderer->createTextureStorage2DArray(internalformat, renderTarget, width, height, depth, levels);
-    setCompleteTexStorage(new TextureStorageInterface(storage, depth));
+    setCompleteTexStorage(storage);
 }
 
 void TextureD3D_2DArray::bindTexImage(egl::Surface *surface)
@@ -1982,7 +1979,7 @@ void TextureD3D_2DArray::generateMipmaps()
 
     if (mTexStorage && mTexStorage->isRenderTarget())
     {
-        mTexStorage->getStorageInstance()->generateMipmaps();
+        mTexStorage->generateMipmaps();
 
         for (int level = 1; level < levelCount; level++)
         {
@@ -2018,7 +2015,7 @@ RenderTarget *TextureD3D_2DArray::getRenderTarget(const gl::ImageIndex &index)
     }
 
     updateStorageLevel(index.mipIndex);
-    return mTexStorage->getStorageInstance()->getRenderTarget(index);
+    return mTexStorage->getRenderTarget(index);
 }
 
 void TextureD3D_2DArray::initializeStorage(bool renderTarget)
@@ -2044,7 +2041,7 @@ void TextureD3D_2DArray::initializeStorage(bool renderTarget)
     updateStorage();
 }
 
-TextureStorageInterface *TextureD3D_2DArray::createCompleteStorage(bool renderTarget) const
+TextureStorage *TextureD3D_2DArray::createCompleteStorage(bool renderTarget) const
 {
     GLsizei width = getBaseLevelWidth();
     GLsizei height = getBaseLevelHeight();
@@ -2056,11 +2053,10 @@ TextureStorageInterface *TextureD3D_2DArray::createCompleteStorage(bool renderTa
     // use existing storage level count, when previously specified by TexStorage*D
     GLint levels = (mTexStorage ? mTexStorage->getLevelCount() : creationLevels(width, height, 1));
 
-    TextureStorage *storage = mRenderer->createTextureStorage2DArray(internalFormat, renderTarget, width, height, depth, levels);
-    return new TextureStorageInterface(storage, depth);
+    return mRenderer->createTextureStorage2DArray(internalFormat, renderTarget, width, height, depth, levels);
 }
 
-void TextureD3D_2DArray::setCompleteTexStorage(TextureStorageInterface *newCompleteTexStorage)
+void TextureD3D_2DArray::setCompleteTexStorage(TextureStorage *newCompleteTexStorage)
 {
     SafeDelete(mTexStorage);
     mTexStorage = newCompleteTexStorage;
@@ -2092,7 +2088,7 @@ bool TextureD3D_2DArray::ensureRenderTarget()
         ASSERT(mTexStorage);
         if (!mTexStorage->isRenderTarget())
         {
-            TextureStorageInterface *newRenderTargetStorage = createCompleteStorage(true);
+            TextureStorage *newRenderTargetStorage = createCompleteStorage(true);
 
             if (!mRenderer->copyToRenderTarget2DArray(newRenderTargetStorage, mTexStorage))
             {
@@ -2112,7 +2108,7 @@ const ImageD3D *TextureD3D_2DArray::getBaseLevelImage() const
     return (mLayerCounts[0] > 0 ? mImageArray[0][0] : NULL);
 }
 
-TextureStorageInterface *TextureD3D_2DArray::getBaseLevelStorage()
+TextureStorage *TextureD3D_2DArray::getBaseLevelStorage()
 {
     return mTexStorage;
 }
diff --git a/src/libGLESv2/renderer/d3d/TextureD3D.h b/src/libGLESv2/renderer/d3d/TextureD3D.h
index 227ad891..41c73180 100644
--- a/src/libGLESv2/renderer/d3d/TextureD3D.h
+++ b/src/libGLESv2/renderer/d3d/TextureD3D.h
@@ -25,7 +25,7 @@ class Image;
 class ImageD3D;
 class Renderer;
 class RenderTarget;
-class TextureStorageInterface;
+class TextureStorage;
 
 class TextureD3D : public TextureImpl
 {
@@ -35,7 +35,7 @@ class TextureD3D : public TextureImpl
 
     static TextureD3D *makeTextureD3D(TextureImpl *texture);
 
-    virtual TextureStorageInterface *getNativeTexture();
+    virtual TextureStorage *getNativeTexture();
 
     virtual void setUsage(GLenum usage) { mUsage = usage; }
     bool hasDirtyImages() const { return mDirtyImages; }
@@ -60,7 +60,7 @@ class TextureD3D : public TextureImpl
                             GLenum format, GLsizei imageSize, const void *pixels, Image *image);
     bool isFastUnpackable(const gl::PixelUnpackState &unpack, GLenum sizedInternalFormat);
     bool fastUnpackPixels(const gl::PixelUnpackState &unpack, const void *pixels, const gl::Box &destArea,
-                                  GLenum sizedInternalFormat, GLenum type, RenderTarget *destRenderTarget);
+                          GLenum sizedInternalFormat, GLenum type, RenderTarget *destRenderTarget);
 
     GLint creationLevels(GLsizei width, GLsizei height, GLsizei depth) const;
     int mipLevels() const;
@@ -79,7 +79,7 @@ class TextureD3D : public TextureImpl
     virtual void initializeStorage(bool renderTarget) = 0;
 
     virtual void updateStorage() = 0;
-    virtual TextureStorageInterface *getBaseLevelStorage() = 0;
+    virtual TextureStorage *getBaseLevelStorage() = 0;
     virtual const ImageD3D *getBaseLevelImage() const = 0;
 };
 
@@ -119,12 +119,12 @@ class TextureD3D_2D : public TextureD3D
     DISALLOW_COPY_AND_ASSIGN(TextureD3D_2D);
 
     virtual void initializeStorage(bool renderTarget);
-    TextureStorageInterface *createCompleteStorage(bool renderTarget) const;
-    void setCompleteTexStorage(TextureStorageInterface *newCompleteTexStorage);
+    TextureStorage *createCompleteStorage(bool renderTarget) const;
+    void setCompleteTexStorage(TextureStorage *newCompleteTexStorage);
 
     virtual void updateStorage();
     bool ensureRenderTarget();
-    virtual TextureStorageInterface *getBaseLevelStorage();
+    virtual TextureStorage *getBaseLevelStorage();
     virtual const ImageD3D *getBaseLevelImage() const;
 
     bool isValidLevel(int level) const;
@@ -135,7 +135,7 @@ class TextureD3D_2D : public TextureD3D
     void redefineImage(GLint level, GLenum internalformat, GLsizei width, GLsizei height);
     void commitRect(GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height);
 
-    TextureStorageInterface *mTexStorage;
+    TextureStorage *mTexStorage;
     ImageD3D *mImageArray[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
 };
 
@@ -176,12 +176,12 @@ class TextureD3D_Cube : public TextureD3D
     DISALLOW_COPY_AND_ASSIGN(TextureD3D_Cube);
 
     virtual void initializeStorage(bool renderTarget);
-    TextureStorageInterface *createCompleteStorage(bool renderTarget) const;
-    void setCompleteTexStorage(TextureStorageInterface *newCompleteTexStorage);
+    TextureStorage *createCompleteStorage(bool renderTarget) const;
+    void setCompleteTexStorage(TextureStorage *newCompleteTexStorage);
 
     virtual void updateStorage();
     bool ensureRenderTarget();
-    virtual TextureStorageInterface *getBaseLevelStorage();
+    virtual TextureStorage *getBaseLevelStorage();
     virtual const ImageD3D *getBaseLevelImage() const;
 
     bool isValidFaceLevel(int faceIndex, int level) const;
@@ -194,7 +194,7 @@ class TextureD3D_Cube : public TextureD3D
 
     ImageD3D *mImageArray[6][gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
 
-    TextureStorageInterface *mTexStorage;
+    TextureStorage *mTexStorage;
 };
 
 class TextureD3D_3D : public TextureD3D
@@ -233,12 +233,12 @@ class TextureD3D_3D : public TextureD3D
     DISALLOW_COPY_AND_ASSIGN(TextureD3D_3D);
 
     virtual void initializeStorage(bool renderTarget);
-    TextureStorageInterface *createCompleteStorage(bool renderTarget) const;
-    void setCompleteTexStorage(TextureStorageInterface *newCompleteTexStorage);
+    TextureStorage *createCompleteStorage(bool renderTarget) const;
+    void setCompleteTexStorage(TextureStorage *newCompleteTexStorage);
 
     virtual void updateStorage();
     bool ensureRenderTarget();
-    virtual TextureStorageInterface *getBaseLevelStorage();
+    virtual TextureStorage *getBaseLevelStorage();
     virtual const ImageD3D *getBaseLevelImage() const;
 
     bool isValidLevel(int level) const;
@@ -250,7 +250,7 @@ class TextureD3D_3D : public TextureD3D
 
     ImageD3D *mImageArray[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
 
-    TextureStorageInterface *mTexStorage;
+    TextureStorage *mTexStorage;
 };
 
 class TextureD3D_2DArray : public TextureD3D
@@ -289,12 +289,12 @@ class TextureD3D_2DArray : public TextureD3D
     DISALLOW_COPY_AND_ASSIGN(TextureD3D_2DArray);
 
     virtual void initializeStorage(bool renderTarget);
-    TextureStorageInterface *createCompleteStorage(bool renderTarget) const;
-    void setCompleteTexStorage(TextureStorageInterface *newCompleteTexStorage);
+    TextureStorage *createCompleteStorage(bool renderTarget) const;
+    void setCompleteTexStorage(TextureStorage *newCompleteTexStorage);
 
     virtual void updateStorage();
     bool ensureRenderTarget();
-    virtual TextureStorageInterface *getBaseLevelStorage();
+    virtual TextureStorage *getBaseLevelStorage();
     virtual const ImageD3D *getBaseLevelImage() const;
 
     bool isValidLevel(int level) const;
@@ -312,7 +312,7 @@ class TextureD3D_2DArray : public TextureD3D
     GLsizei mLayerCounts[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
     ImageD3D **mImageArray[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
 
-    TextureStorageInterface *mTexStorage;
+    TextureStorage *mTexStorage;
 };
 
 }
diff --git a/src/libGLESv2/renderer/d3d/TextureStorage.cpp b/src/libGLESv2/renderer/d3d/TextureStorage.cpp
index b46db145..dedd266c 100644
--- a/src/libGLESv2/renderer/d3d/TextureStorage.cpp
+++ b/src/libGLESv2/renderer/d3d/TextureStorage.cpp
@@ -17,54 +17,35 @@
 
 namespace rx
 {
-unsigned int TextureStorageInterface::mCurrentTextureSerial = 1;
 
-TextureStorageInterface::TextureStorageInterface(TextureStorage *textureStorage, unsigned int rtSerialLayerStride)
+unsigned int TextureStorage::mCurrentTextureSerial = 1;
+
+TextureStorage::TextureStorage()
     : mTextureSerial(issueTextureSerial()),
-      mInstance(textureStorage),
-      mFirstRenderTargetSerial(gl::RenderbufferStorage::issueSerials(static_cast<unsigned int>(textureStorage->getLevelCount()) * rtSerialLayerStride)),
-      mRenderTargetSerialsLayerStride(rtSerialLayerStride)
+      mFirstRenderTargetSerial(0),
+      mRenderTargetSerialsLayerStride(0)
 {}
 
-TextureStorageInterface::~TextureStorageInterface()
+void TextureStorage::initializeSerials(unsigned int rtSerialsToReserve, unsigned int rtSerialsLayerStride)
 {
-    delete mInstance;
+    mFirstRenderTargetSerial = gl::RenderbufferStorage::issueSerials(rtSerialsToReserve);
+    mRenderTargetSerialsLayerStride = rtSerialsLayerStride;
 }
 
-bool TextureStorageInterface::isRenderTarget() const
+unsigned int TextureStorage::getRenderTargetSerial(const gl::ImageIndex &index) const
 {
-    return mInstance->isRenderTarget();
-}
-
-bool TextureStorageInterface::isManaged() const
-{
-    return mInstance->isManaged();
+    unsigned int layerOffset = (index.hasLayer() ? (static_cast<unsigned int>(index.layerIndex) * mRenderTargetSerialsLayerStride) : 0);
+    return mFirstRenderTargetSerial + static_cast<unsigned int>(index.mipIndex) + layerOffset;
 }
 
-unsigned int TextureStorageInterface::getTextureSerial() const
+unsigned int TextureStorage::getTextureSerial() const
 {
     return mTextureSerial;
 }
 
-unsigned int TextureStorageInterface::issueTextureSerial()
+unsigned int TextureStorage::issueTextureSerial()
 {
     return mCurrentTextureSerial++;
 }
 
-int TextureStorageInterface::getTopLevel() const
-{
-    return mInstance->getTopLevel();
-}
-
-int TextureStorageInterface::getLevelCount() const
-{
-    return mInstance->getLevelCount();
-}
-
-unsigned int TextureStorageInterface::getRenderTargetSerial(const gl::ImageIndex &index) const
-{
-    unsigned int layerOffset = (index.hasLayer() ? (static_cast<unsigned int>(index.layerIndex) * mRenderTargetSerialsLayerStride) : 0);
-    return mFirstRenderTargetSerial + static_cast<unsigned int>(index.mipIndex) + layerOffset;
-}
-
 }
diff --git a/src/libGLESv2/renderer/d3d/TextureStorage.h b/src/libGLESv2/renderer/d3d/TextureStorage.h
index ae00f892..9cc2c297 100644
--- a/src/libGLESv2/renderer/d3d/TextureStorage.h
+++ b/src/libGLESv2/renderer/d3d/TextureStorage.h
@@ -27,7 +27,7 @@ class RenderTarget;
 class TextureStorage
 {
   public:
-    TextureStorage() {};
+    TextureStorage();
     virtual ~TextureStorage() {};
 
     virtual int getTopLevel() const = 0;
@@ -38,33 +38,14 @@ class TextureStorage
     virtual RenderTarget *getRenderTarget(const gl::ImageIndex &index) = 0;
     virtual void generateMipmaps() = 0;
 
-  private:
-    DISALLOW_COPY_AND_ASSIGN(TextureStorage);
-
-};
-
-class TextureStorageInterface
-{
-  public:
-    TextureStorageInterface(TextureStorage *storageInstance, unsigned int rtSerialLayerStride);
-    virtual ~TextureStorageInterface();
-
-    TextureStorage *getStorageInstance() { return mInstance; }
-
-    unsigned int getTextureSerial() const;
-
-    virtual int getTopLevel() const;
-    virtual bool isRenderTarget() const;
-    virtual bool isManaged() const;
-    virtual int getLevelCount() const;
-
     unsigned int getRenderTargetSerial(const gl::ImageIndex &index) const;
+    unsigned int getTextureSerial() const;
 
   protected:
-    TextureStorage *mInstance;
+    void initializeSerials(unsigned int rtSerialsToReserve, unsigned int rtSerialsLayerStride);
 
   private:
-    DISALLOW_COPY_AND_ASSIGN(TextureStorageInterface);
+    DISALLOW_COPY_AND_ASSIGN(TextureStorage);
 
     const unsigned int mTextureSerial;
     static unsigned int issueTextureSerial();
diff --git a/src/libGLESv2/renderer/d3d/d3d11/Image11.cpp b/src/libGLESv2/renderer/d3d/d3d11/Image11.cpp
index d448f732..7536713a 100644
--- a/src/libGLESv2/renderer/d3d/d3d11/Image11.cpp
+++ b/src/libGLESv2/renderer/d3d/d3d11/Image11.cpp
@@ -99,27 +99,27 @@ bool Image11::isDirty() const
     return mDirty;
 }
 
-bool Image11::copyToStorage2D(TextureStorageInterface *storage, int level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height)
+bool Image11::copyToStorage2D(TextureStorage *storage, int level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height)
 {
-    TextureStorage11_2D *storage11 = TextureStorage11_2D::makeTextureStorage11_2D(storage->getStorageInstance());
+    TextureStorage11_2D *storage11 = TextureStorage11_2D::makeTextureStorage11_2D(storage);
     return copyToStorageImpl(storage11, level, 0, xoffset, yoffset, width, height);
 }
 
-bool Image11::copyToStorageCube(TextureStorageInterface *storage, int face, int level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height)
+bool Image11::copyToStorageCube(TextureStorage *storage, int face, int level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height)
 {
-    TextureStorage11_Cube *storage11 = TextureStorage11_Cube::makeTextureStorage11_Cube(storage->getStorageInstance());
+    TextureStorage11_Cube *storage11 = TextureStorage11_Cube::makeTextureStorage11_Cube(storage);
     return copyToStorageImpl(storage11, level, face, xoffset, yoffset, width, height);
 }
 
-bool Image11::copyToStorage3D(TextureStorageInterface *storage, int level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth)
+bool Image11::copyToStorage3D(TextureStorage *storage, int level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth)
 {
-    TextureStorage11_3D *storage11 = TextureStorage11_3D::makeTextureStorage11_3D(storage->getStorageInstance());
+    TextureStorage11_3D *storage11 = TextureStorage11_3D::makeTextureStorage11_3D(storage);
     return copyToStorageImpl(storage11, level, 0, xoffset, yoffset, width, height);
 }
 
-bool Image11::copyToStorage2DArray(TextureStorageInterface *storage, int level, GLint xoffset, GLint yoffset, GLint arrayLayer, GLsizei width, GLsizei height)
+bool Image11::copyToStorage2DArray(TextureStorage *storage, int level, GLint xoffset, GLint yoffset, GLint arrayLayer, GLsizei width, GLsizei height)
 {
-    TextureStorage11_2DArray *storage11 = TextureStorage11_2DArray::makeTextureStorage11_2DArray(storage->getStorageInstance());
+    TextureStorage11_2DArray *storage11 = TextureStorage11_2DArray::makeTextureStorage11_2DArray(storage);
     return copyToStorageImpl(storage11, level, arrayLayer, xoffset, yoffset, width, height);
 }
 
diff --git a/src/libGLESv2/renderer/d3d/d3d11/Image11.h b/src/libGLESv2/renderer/d3d/d3d11/Image11.h
index 80909d2c..a76a61f0 100644
--- a/src/libGLESv2/renderer/d3d/d3d11/Image11.h
+++ b/src/libGLESv2/renderer/d3d/d3d11/Image11.h
@@ -23,7 +23,6 @@ namespace rx
 {
 class Renderer;
 class Renderer11;
-class TextureStorageInterface;
 class TextureStorage11;
 
 class Image11 : public ImageD3D
@@ -38,10 +37,10 @@ class Image11 : public ImageD3D
 
     virtual bool isDirty() const;
 
-    virtual bool copyToStorage2D(TextureStorageInterface *storage, int level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height);
-    virtual bool copyToStorageCube(TextureStorageInterface *storage, int face, int level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height);
-    virtual bool copyToStorage3D(TextureStorageInterface *storage, int level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth);
-    virtual bool copyToStorage2DArray(TextureStorageInterface *storage, int level, GLint xoffset, GLint yoffset, GLint arrayLayer, GLsizei width, GLsizei height);
+    virtual bool copyToStorage2D(TextureStorage *storage, int level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height);
+    virtual bool copyToStorageCube(TextureStorage *storage, int face, int level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height);
+    virtual bool copyToStorage3D(TextureStorage *storage, int level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth);
+    virtual bool copyToStorage2DArray(TextureStorage *storage, int level, GLint xoffset, GLint yoffset, GLint arrayLayer, GLsizei width, GLsizei height);
 
     virtual bool redefine(Renderer *renderer, GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, bool forceRelease);
 
diff --git a/src/libGLESv2/renderer/d3d/d3d11/Renderer11.cpp b/src/libGLESv2/renderer/d3d/d3d11/Renderer11.cpp
index 651e83ff..c93def8b 100644
--- a/src/libGLESv2/renderer/d3d/d3d11/Renderer11.cpp
+++ b/src/libGLESv2/renderer/d3d/d3d11/Renderer11.cpp
@@ -417,10 +417,10 @@ void Renderer11::generateSwizzle(gl::Texture *texture)
 {
     if (texture)
     {
-        TextureStorageInterface *texStorage = texture->getNativeTexture();
+        TextureStorage *texStorage = texture->getNativeTexture();
         if (texStorage)
         {
-            TextureStorage11 *storage11 = TextureStorage11::makeTextureStorage11(texStorage->getStorageInstance());
+            TextureStorage11 *storage11 = TextureStorage11::makeTextureStorage11(texStorage);
 
             storage11->generateSwizzles(texture->getSamplerState().swizzleRed,
                                         texture->getSamplerState().swizzleGreen,
@@ -488,10 +488,10 @@ void Renderer11::setTexture(gl::SamplerType type, int index, gl::Texture *textur
     {
         TextureD3D* textureImpl = TextureD3D::makeTextureD3D(texture->getImplementation());
 
-        TextureStorageInterface *texStorage = textureImpl->getNativeTexture();
+        TextureStorage *texStorage = textureImpl->getNativeTexture();
         if (texStorage)
         {
-            TextureStorage11 *storage11 = TextureStorage11::makeTextureStorage11(texStorage->getStorageInstance());
+            TextureStorage11 *storage11 = TextureStorage11::makeTextureStorage11(texStorage);
             gl::SamplerState samplerState;
             texture->getSamplerStateWithNativeOffset(&samplerState);
             textureSRV = storage11->getSRV(samplerState);
@@ -1873,12 +1873,12 @@ int Renderer11::getMaxSwapInterval() const
     return 4;
 }
 
-bool Renderer11::copyToRenderTarget2D(TextureStorageInterface *dest, TextureStorageInterface *source)
+bool Renderer11::copyToRenderTarget2D(TextureStorage *dest, TextureStorage *source)
 {
     if (source && dest)
     {
-        TextureStorage11_2D *source11 = TextureStorage11_2D::makeTextureStorage11_2D(source->getStorageInstance());
-        TextureStorage11_2D *dest11 = TextureStorage11_2D::makeTextureStorage11_2D(dest->getStorageInstance());
+        TextureStorage11_2D *source11 = TextureStorage11_2D::makeTextureStorage11_2D(source);
+        TextureStorage11_2D *dest11 = TextureStorage11_2D::makeTextureStorage11_2D(dest);
 
         mDeviceContext->CopyResource(dest11->getResource(), source11->getResource());
 
@@ -1890,12 +1890,12 @@ bool Renderer11::copyToRenderTarget2D(TextureStorageInterface *dest, TextureStor
     return false;
 }
 
-bool Renderer11::copyToRenderTargetCube(TextureStorageInterface *dest, TextureStorageInterface *source)
+bool Renderer11::copyToRenderTargetCube(TextureStorage *dest, TextureStorage *source)
 {
     if (source && dest)
     {
-        TextureStorage11_Cube *source11 = TextureStorage11_Cube::makeTextureStorage11_Cube(source->getStorageInstance());
-        TextureStorage11_Cube *dest11 = TextureStorage11_Cube::makeTextureStorage11_Cube(dest->getStorageInstance());
+        TextureStorage11_Cube *source11 = TextureStorage11_Cube::makeTextureStorage11_Cube(source);
+        TextureStorage11_Cube *dest11 = TextureStorage11_Cube::makeTextureStorage11_Cube(dest);
 
         mDeviceContext->CopyResource(dest11->getResource(), source11->getResource());
 
@@ -1907,12 +1907,12 @@ bool Renderer11::copyToRenderTargetCube(TextureStorageInterface *dest, TextureSt
     return false;
 }
 
-bool Renderer11::copyToRenderTarget3D(TextureStorageInterface *dest, TextureStorageInterface *source)
+bool Renderer11::copyToRenderTarget3D(TextureStorage *dest, TextureStorage *source)
 {
     if (source && dest)
     {
-        TextureStorage11_3D *source11 = TextureStorage11_3D::makeTextureStorage11_3D(source->getStorageInstance());
-        TextureStorage11_3D *dest11 = TextureStorage11_3D::makeTextureStorage11_3D(dest->getStorageInstance());
+        TextureStorage11_3D *source11 = TextureStorage11_3D::makeTextureStorage11_3D(source);
+        TextureStorage11_3D *dest11 = TextureStorage11_3D::makeTextureStorage11_3D(dest);
 
         mDeviceContext->CopyResource(dest11->getResource(), source11->getResource());
 
@@ -1924,12 +1924,12 @@ bool Renderer11::copyToRenderTarget3D(TextureStorageInterface *dest, TextureStor
     return false;
 }
 
-bool Renderer11::copyToRenderTarget2DArray(TextureStorageInterface *dest, TextureStorageInterface *source)
+bool Renderer11::copyToRenderTarget2DArray(TextureStorage *dest, TextureStorage *source)
 {
     if (source && dest)
     {
-        TextureStorage11_2DArray *source11 = TextureStorage11_2DArray::makeTextureStorage11_2DArray(source->getStorageInstance());
-        TextureStorage11_2DArray *dest11 = TextureStorage11_2DArray::makeTextureStorage11_2DArray(dest->getStorageInstance());
+        TextureStorage11_2DArray *source11 = TextureStorage11_2DArray::makeTextureStorage11_2DArray(source);
+        TextureStorage11_2DArray *dest11 = TextureStorage11_2DArray::makeTextureStorage11_2DArray(dest);
 
         mDeviceContext->CopyResource(dest11->getResource(), source11->getResource());
 
@@ -1942,7 +1942,7 @@ bool Renderer11::copyToRenderTarget2DArray(TextureStorageInterface *dest, Textur
 }
 
 bool Renderer11::copyImage2D(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
-                             GLint xoffset, GLint yoffset, TextureStorageInterface *storage, GLint level)
+                             GLint xoffset, GLint yoffset, TextureStorage *storage, GLint level)
 {
     gl::FramebufferAttachment *colorbuffer = framebuffer->getReadColorbuffer();
     if (!colorbuffer)
@@ -1965,7 +1965,7 @@ bool Renderer11::copyImage2D(gl::Framebuffer *framebuffer, const gl::Rectangle &
         return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
-    TextureStorage11_2D *storage11 = TextureStorage11_2D::makeTextureStorage11_2D(storage->getStorageInstance());
+    TextureStorage11_2D *storage11 = TextureStorage11_2D::makeTextureStorage11_2D(storage);
     if (!storage11)
     {
         ERR("Failed to retrieve the texture storage from the destination.");
@@ -2004,7 +2004,7 @@ bool Renderer11::copyImage2D(gl::Framebuffer *framebuffer, const gl::Rectangle &
 }
 
 bool Renderer11::copyImageCube(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
-                               GLint xoffset, GLint yoffset, TextureStorageInterface *storage, GLenum target, GLint level)
+                               GLint xoffset, GLint yoffset, TextureStorage *storage, GLenum target, GLint level)
 {
     gl::FramebufferAttachment *colorbuffer = framebuffer->getReadColorbuffer();
     if (!colorbuffer)
@@ -2027,7 +2027,7 @@ bool Renderer11::copyImageCube(gl::Framebuffer *framebuffer, const gl::Rectangle
         return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
-    TextureStorage11_Cube *storage11 = TextureStorage11_Cube::makeTextureStorage11_Cube(storage->getStorageInstance());
+    TextureStorage11_Cube *storage11 = TextureStorage11_Cube::makeTextureStorage11_Cube(storage);
     if (!storage11)
     {
         ERR("Failed to retrieve the texture storage from the destination.");
@@ -2066,7 +2066,7 @@ bool Renderer11::copyImageCube(gl::Framebuffer *framebuffer, const gl::Rectangle
 }
 
 bool Renderer11::copyImage3D(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
-                             GLint xoffset, GLint yoffset, GLint zOffset, TextureStorageInterface *storage, GLint level)
+                             GLint xoffset, GLint yoffset, GLint zOffset, TextureStorage *storage, GLint level)
 {
     gl::FramebufferAttachment *colorbuffer = framebuffer->getReadColorbuffer();
     if (!colorbuffer)
@@ -2089,7 +2089,7 @@ bool Renderer11::copyImage3D(gl::Framebuffer *framebuffer, const gl::Rectangle &
         return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
-    TextureStorage11_3D *storage11 = TextureStorage11_3D::makeTextureStorage11_3D(storage->getStorageInstance());
+    TextureStorage11_3D *storage11 = TextureStorage11_3D::makeTextureStorage11_3D(storage);
     if (!storage11)
     {
         ERR("Failed to retrieve the texture storage from the destination.");
@@ -2128,7 +2128,7 @@ bool Renderer11::copyImage3D(gl::Framebuffer *framebuffer, const gl::Rectangle &
 }
 
 bool Renderer11::copyImage2DArray(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
-                                  GLint xoffset, GLint yoffset, GLint zOffset, TextureStorageInterface *storage, GLint level)
+                                  GLint xoffset, GLint yoffset, GLint zOffset, TextureStorage *storage, GLint level)
 {
     gl::FramebufferAttachment *colorbuffer = framebuffer->getReadColorbuffer();
     if (!colorbuffer)
@@ -2151,7 +2151,7 @@ bool Renderer11::copyImage2DArray(gl::Framebuffer *framebuffer, const gl::Rectan
         return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
-    TextureStorage11_2DArray *storage11 = TextureStorage11_2DArray::makeTextureStorage11_2DArray(storage->getStorageInstance());
+    TextureStorage11_2DArray *storage11 = TextureStorage11_2DArray::makeTextureStorage11_2DArray(storage);
     if (!storage11)
     {
         SafeRelease(source);
@@ -3115,7 +3115,7 @@ void Renderer11::invalidateFBOAttachmentSwizzles(gl::FramebufferAttachment *atta
     ASSERT(attachment->isTexture());
     gl::Texture *texture = attachment->getTexture();
 
-    TextureStorage *texStorage = texture->getNativeTexture()->getStorageInstance();
+    TextureStorage *texStorage = texture->getNativeTexture();
     if (texStorage)
     {
         TextureStorage11 *texStorage11 = TextureStorage11::makeTextureStorage11(texStorage);
diff --git a/src/libGLESv2/renderer/d3d/d3d11/Renderer11.h b/src/libGLESv2/renderer/d3d/d3d11/Renderer11.h
index d23b71d0..19e27477 100644
--- a/src/libGLESv2/renderer/d3d/d3d11/Renderer11.h
+++ b/src/libGLESv2/renderer/d3d/d3d11/Renderer11.h
@@ -115,19 +115,19 @@ class Renderer11 : public Renderer
     virtual int getMaxSwapInterval() const;
 
     // Pixel operations
-    virtual bool copyToRenderTarget2D(TextureStorageInterface *dest, TextureStorageInterface *source);
-    virtual bool copyToRenderTargetCube(TextureStorageInterface *dest, TextureStorageInterface *source);
-    virtual bool copyToRenderTarget3D(TextureStorageInterface *dest, TextureStorageInterface *source);
-    virtual bool copyToRenderTarget2DArray(TextureStorageInterface *dest, TextureStorageInterface *source);
+    virtual bool copyToRenderTarget2D(TextureStorage *dest, TextureStorage *source);
+    virtual bool copyToRenderTargetCube(TextureStorage *dest, TextureStorage *source);
+    virtual bool copyToRenderTarget3D(TextureStorage *dest, TextureStorage *source);
+    virtual bool copyToRenderTarget2DArray(TextureStorage *dest, TextureStorage *source);
 
     virtual bool copyImage2D(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
-                             GLint xoffset, GLint yoffset, TextureStorageInterface *storage, GLint level);
+                             GLint xoffset, GLint yoffset, TextureStorage *storage, GLint level);
     virtual bool copyImageCube(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
-                               GLint xoffset, GLint yoffset, TextureStorageInterface *storage, GLenum target, GLint level);
+                               GLint xoffset, GLint yoffset, TextureStorage *storage, GLenum target, GLint level);
     virtual bool copyImage3D(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
-                             GLint xoffset, GLint yoffset, GLint zOffset, TextureStorageInterface *storage, GLint level);
+                             GLint xoffset, GLint yoffset, GLint zOffset, TextureStorage *storage, GLint level);
     virtual bool copyImage2DArray(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
-                                  GLint xoffset, GLint yoffset, GLint zOffset, TextureStorageInterface *storage, GLint level);
+                                  GLint xoffset, GLint yoffset, GLint zOffset, TextureStorage *storage, GLint level);
 
     virtual bool blitRect(gl::Framebuffer *readTarget, const gl::Rectangle &readRect, gl::Framebuffer *drawTarget, const gl::Rectangle &drawRect,
                           const gl::Rectangle *scissor, bool blitRenderTarget, bool blitDepth, bool blitStencil, GLenum filter);
diff --git a/src/libGLESv2/renderer/d3d/d3d11/TextureStorage11.cpp b/src/libGLESv2/renderer/d3d/d3d11/TextureStorage11.cpp
index 55366019..c012637b 100644
--- a/src/libGLESv2/renderer/d3d/d3d11/TextureStorage11.cpp
+++ b/src/libGLESv2/renderer/d3d/d3d11/TextureStorage11.cpp
@@ -396,11 +396,11 @@ void TextureStorage11::verifySwizzleExists(GLenum swizzleRed, GLenum swizzleGree
 }
 
 TextureStorage11_2D::TextureStorage11_2D(Renderer *renderer, SwapChain11 *swapchain)
-    : TextureStorage11(renderer, D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE)
+    : TextureStorage11(renderer, D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE),
+      mTexture(swapchain->getOffscreenTexture()),
+      mSwizzleTexture(NULL)
 {
-    mTexture = swapchain->getOffscreenTexture();
     mTexture->AddRef();
-    mSwizzleTexture = NULL;
 
     for (unsigned int i = 0; i < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; i++)
     {
@@ -434,14 +434,15 @@ TextureStorage11_2D::TextureStorage11_2D(Renderer *renderer, SwapChain11 *swapch
     mSwizzleRenderTargetFormat = formatInfo.swizzleRTVFormat;
 
     mDepthStencilFormat = DXGI_FORMAT_UNKNOWN;
+
+    initializeSerials(1, 1);
 }
 
 TextureStorage11_2D::TextureStorage11_2D(Renderer *renderer, GLenum internalformat, bool renderTarget, GLsizei width, GLsizei height, int levels)
-    : TextureStorage11(renderer, GetTextureBindFlags(internalformat, renderTarget))
+    : TextureStorage11(renderer, GetTextureBindFlags(internalformat, renderTarget)),
+      mTexture(NULL),
+      mSwizzleTexture(NULL)
 {
-    mTexture = NULL;
-    mSwizzleTexture = NULL;
-
     for (unsigned int i = 0; i < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; i++)
     {
         mAssociatedImages[i] = NULL;
@@ -503,6 +504,8 @@ TextureStorage11_2D::TextureStorage11_2D(Renderer *renderer, GLenum internalform
             mTextureDepth = 1;
         }
     }
+
+    initializeSerials(getLevelCount(), 1);
 }
 
 TextureStorage11_2D::~TextureStorage11_2D()
@@ -790,11 +793,6 @@ ID3D11RenderTargetView *TextureStorage11_2D::getSwizzleRenderTarget(int mipLevel
     }
 }
 
-unsigned int TextureStorage11_2D::getTextureLevelDepth(int mipLevel) const
-{
-    return 1;
-}
-
 TextureStorage11_Cube::TextureStorage11_Cube(Renderer *renderer, GLenum internalformat, bool renderTarget, int size, int levels)
     : TextureStorage11(renderer, GetTextureBindFlags(internalformat, renderTarget))
 {
@@ -860,8 +858,11 @@ TextureStorage11_Cube::TextureStorage11_Cube(Renderer *renderer, GLenum internal
             mTextureDepth = 1;
         }
     }
+
+    initializeSerials(getLevelCount() * 6, 6);
 }
 
+
 TextureStorage11_Cube::~TextureStorage11_Cube()
 {
     for (unsigned int level = 0; level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; level++)
@@ -1204,11 +1205,6 @@ ID3D11RenderTargetView *TextureStorage11_Cube::getSwizzleRenderTarget(int mipLev
     }
 }
 
-unsigned int TextureStorage11_Cube::getTextureLevelDepth(int mipLevel) const
-{
-    return 6;
-}
-
 TextureStorage11_3D::TextureStorage11_3D(Renderer *renderer, GLenum internalformat, bool renderTarget,
                                          GLsizei width, GLsizei height, GLsizei depth, int levels)
     : TextureStorage11(renderer, GetTextureBindFlags(internalformat, renderTarget))
@@ -1275,6 +1271,8 @@ TextureStorage11_3D::TextureStorage11_3D(Renderer *renderer, GLenum internalform
             mTextureDepth = desc.Depth;
         }
     }
+
+    initializeSerials(getLevelCount() * depth, depth);
 }
 
 TextureStorage11_3D::~TextureStorage11_3D()
@@ -1580,12 +1578,6 @@ ID3D11RenderTargetView *TextureStorage11_3D::getSwizzleRenderTarget(int mipLevel
     }
 }
 
-unsigned int TextureStorage11_3D::getTextureLevelDepth(int mipLevel) const
-{
-    return std::max(mTextureDepth >> mipLevel, 1U);
-}
-
-
 TextureStorage11_2DArray::TextureStorage11_2DArray(Renderer *renderer, GLenum internalformat, bool renderTarget,
                                                    GLsizei width, GLsizei height, GLsizei depth, int levels)
     : TextureStorage11(renderer, GetTextureBindFlags(internalformat, renderTarget))
@@ -1652,6 +1644,8 @@ TextureStorage11_2DArray::TextureStorage11_2DArray(Renderer *renderer, GLenum in
             mTextureDepth = desc.ArraySize;
         }
     }
+
+    initializeSerials(getLevelCount() * depth, depth);
 }
 
 TextureStorage11_2DArray::~TextureStorage11_2DArray()
@@ -1939,9 +1933,4 @@ ID3D11RenderTargetView *TextureStorage11_2DArray::getSwizzleRenderTarget(int mip
     }
 }
 
-unsigned int TextureStorage11_2DArray::getTextureLevelDepth(int mipLevel) const
-{
-    return mTextureDepth;
-}
-
 }
diff --git a/src/libGLESv2/renderer/d3d/d3d11/TextureStorage11.h b/src/libGLESv2/renderer/d3d/d3d11/TextureStorage11.h
index 913ffb2d..da06aa6f 100644
--- a/src/libGLESv2/renderer/d3d/d3d11/TextureStorage11.h
+++ b/src/libGLESv2/renderer/d3d/d3d11/TextureStorage11.h
@@ -84,8 +84,6 @@ class TextureStorage11 : public TextureStorage
 
     void verifySwizzleExists(GLenum swizzleRed, GLenum swizzleGreen, GLenum swizzleBlue, GLenum swizzleAlpha);
 
-    virtual unsigned int getTextureLevelDepth(int mipLevel) const = 0;
-
     Renderer11 *mRenderer;
     int mTopLevel;
     unsigned int mMipLevels;
@@ -175,8 +173,6 @@ class TextureStorage11_2D : public TextureStorage11
     virtual ID3D11Resource *getSwizzleTexture();
     virtual ID3D11RenderTargetView *getSwizzleRenderTarget(int mipLevel);
 
-    virtual unsigned int getTextureLevelDepth(int mipLevel) const;
-
   private:
     DISALLOW_COPY_AND_ASSIGN(TextureStorage11_2D);
 
@@ -213,8 +209,6 @@ class TextureStorage11_Cube : public TextureStorage11
     virtual ID3D11Resource *getSwizzleTexture();
     virtual ID3D11RenderTargetView *getSwizzleRenderTarget(int mipLevel);
 
-    virtual unsigned int getTextureLevelDepth(int mipLevel) const;
-
   private:
     DISALLOW_COPY_AND_ASSIGN(TextureStorage11_Cube);
 
@@ -254,8 +248,6 @@ class TextureStorage11_3D : public TextureStorage11
     virtual ID3D11Resource *getSwizzleTexture();
     virtual ID3D11RenderTargetView *getSwizzleRenderTarget(int mipLevel);
 
-    virtual unsigned int getTextureLevelDepth(int mipLevel) const;
-
   private:
     DISALLOW_COPY_AND_ASSIGN(TextureStorage11_3D);
 
@@ -297,8 +289,6 @@ class TextureStorage11_2DArray : public TextureStorage11
     virtual ID3D11Resource *getSwizzleTexture();
     virtual ID3D11RenderTargetView *getSwizzleRenderTarget(int mipLevel);
 
-    virtual unsigned int getTextureLevelDepth(int mipLevel) const;
-
   private:
     DISALLOW_COPY_AND_ASSIGN(TextureStorage11_2DArray);
 
diff --git a/src/libGLESv2/renderer/d3d/d3d9/Blit9.cpp b/src/libGLESv2/renderer/d3d/d3d9/Blit9.cpp
index 9730f9d8..80503d53 100644
--- a/src/libGLESv2/renderer/d3d/d3d9/Blit9.cpp
+++ b/src/libGLESv2/renderer/d3d/d3d9/Blit9.cpp
@@ -208,7 +208,7 @@ bool Blit9::boxFilter(IDirect3DSurface9 *source, IDirect3DSurface9 *dest)
     return true;
 }
 
-bool Blit9::copy2D(gl::Framebuffer *framebuffer, const RECT &sourceRect, GLenum destFormat, GLint xoffset, GLint yoffset, TextureStorageInterface *storage, GLint level)
+bool Blit9::copy2D(gl::Framebuffer *framebuffer, const RECT &sourceRect, GLenum destFormat, GLint xoffset, GLint yoffset, TextureStorage *storage, GLint level)
 {
     RenderTarget9 *renderTarget = NULL;
     IDirect3DSurface9 *source = NULL;
@@ -230,7 +230,7 @@ bool Blit9::copy2D(gl::Framebuffer *framebuffer, const RECT &sourceRect, GLenum
         return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
-    TextureStorage9_2D *storage9 = TextureStorage9_2D::makeTextureStorage9_2D(storage->getStorageInstance());
+    TextureStorage9_2D *storage9 = TextureStorage9_2D::makeTextureStorage9_2D(storage);
     IDirect3DSurface9 *destSurface = storage9->getSurfaceLevel(level, true);
     bool result = false;
 
@@ -244,7 +244,7 @@ bool Blit9::copy2D(gl::Framebuffer *framebuffer, const RECT &sourceRect, GLenum
     return result;
 }
 
-bool Blit9::copyCube(gl::Framebuffer *framebuffer, const RECT &sourceRect, GLenum destFormat, GLint xoffset, GLint yoffset, TextureStorageInterface *storage, GLenum target, GLint level)
+bool Blit9::copyCube(gl::Framebuffer *framebuffer, const RECT &sourceRect, GLenum destFormat, GLint xoffset, GLint yoffset, TextureStorage *storage, GLenum target, GLint level)
 {
     RenderTarget9 *renderTarget = NULL;
     IDirect3DSurface9 *source = NULL;
@@ -266,7 +266,7 @@ bool Blit9::copyCube(gl::Framebuffer *framebuffer, const RECT &sourceRect, GLenu
         return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
-    TextureStorage9_Cube *storage9 = TextureStorage9_Cube::makeTextureStorage9_Cube(storage->getStorageInstance());
+    TextureStorage9_Cube *storage9 = TextureStorage9_Cube::makeTextureStorage9_Cube(storage);
     IDirect3DSurface9 *destSurface = storage9->getCubeMapSurface(target, level, true);
     bool result = false;
 
diff --git a/src/libGLESv2/renderer/d3d/d3d9/Blit9.h b/src/libGLESv2/renderer/d3d/d3d9/Blit9.h
index 2f4f8f1a..46a3ee1c 100644
--- a/src/libGLESv2/renderer/d3d/d3d9/Blit9.h
+++ b/src/libGLESv2/renderer/d3d/d3d9/Blit9.h
@@ -21,7 +21,7 @@ class Framebuffer;
 namespace rx
 {
 class Renderer9;
-class TextureStorageInterface;
+class TextureStorage;
 
 class Blit9
 {
@@ -31,8 +31,8 @@ class Blit9
 
     // Copy from source surface to dest surface.
     // sourceRect, xoffset, yoffset are in D3D coordinates (0,0 in upper-left)
-    bool copy2D(gl::Framebuffer *framebuffer, const RECT &sourceRect, GLenum destFormat, GLint xoffset, GLint yoffset, TextureStorageInterface *storage, GLint level);
-    bool copyCube(gl::Framebuffer *framebuffer, const RECT &sourceRect, GLenum destFormat, GLint xoffset, GLint yoffset, TextureStorageInterface *storage, GLenum target, GLint level);
+    bool copy2D(gl::Framebuffer *framebuffer, const RECT &sourceRect, GLenum destFormat, GLint xoffset, GLint yoffset, TextureStorage *storage, GLint level);
+    bool copyCube(gl::Framebuffer *framebuffer, const RECT &sourceRect, GLenum destFormat, GLint xoffset, GLint yoffset, TextureStorage *storage, GLenum target, GLint level);
 
     // Copy from source surface to dest surface.
     // sourceRect, xoffset, yoffset are in D3D coordinates (0,0 in upper-left)
diff --git a/src/libGLESv2/renderer/d3d/d3d9/Image9.cpp b/src/libGLESv2/renderer/d3d/d3d9/Image9.cpp
index c332305b..18383fba 100644
--- a/src/libGLESv2/renderer/d3d/d3d9/Image9.cpp
+++ b/src/libGLESv2/renderer/d3d/d3d9/Image9.cpp
@@ -270,15 +270,15 @@ IDirect3DSurface9 *Image9::getSurface()
     return mSurface;
 }
 
-void Image9::setManagedSurface2D(TextureStorageInterface *storage, int level)
+void Image9::setManagedSurface2D(TextureStorage *storage, int level)
 {
-    TextureStorage9_2D *storage9 = TextureStorage9_2D::makeTextureStorage9_2D(storage->getStorageInstance());
+    TextureStorage9_2D *storage9 = TextureStorage9_2D::makeTextureStorage9_2D(storage);
     setManagedSurface(storage9->getSurfaceLevel(level, false));
 }
 
-void Image9::setManagedSurfaceCube(TextureStorageInterface *storage, int face, int level)
+void Image9::setManagedSurfaceCube(TextureStorage *storage, int face, int level)
 {
-    TextureStorage9_Cube *storage9 = TextureStorage9_Cube::makeTextureStorage9_Cube(storage->getStorageInstance());
+    TextureStorage9_Cube *storage9 = TextureStorage9_Cube::makeTextureStorage9_Cube(storage);
     setManagedSurface(storage9->getCubeMapSurface(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, level, false));
 }
 
@@ -301,28 +301,28 @@ void Image9::setManagedSurface(IDirect3DSurface9 *surface)
     }
 }
 
-bool Image9::copyToStorage2D(TextureStorageInterface *storage, int level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height)
+bool Image9::copyToStorage2D(TextureStorage *storage, int level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height)
 {
     ASSERT(getSurface() != NULL);
-    TextureStorage9_2D *storage9 = TextureStorage9_2D::makeTextureStorage9_2D(storage->getStorageInstance());
+    TextureStorage9_2D *storage9 = TextureStorage9_2D::makeTextureStorage9_2D(storage);
     return copyToSurface(storage9->getSurfaceLevel(level, true), xoffset, yoffset, width, height);
 }
 
-bool Image9::copyToStorageCube(TextureStorageInterface *storage, int face, int level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height)
+bool Image9::copyToStorageCube(TextureStorage *storage, int face, int level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height)
 {
     ASSERT(getSurface() != NULL);
-    TextureStorage9_Cube *storage9 = TextureStorage9_Cube::makeTextureStorage9_Cube(storage->getStorageInstance());
+    TextureStorage9_Cube *storage9 = TextureStorage9_Cube::makeTextureStorage9_Cube(storage);
     return copyToSurface(storage9->getCubeMapSurface(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, level, true), xoffset, yoffset, width, height);
 }
 
-bool Image9::copyToStorage3D(TextureStorageInterface *storage, int level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth)
+bool Image9::copyToStorage3D(TextureStorage *storage, int level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth)
 {
     // 3D textures are not supported by the D3D9 backend.
     UNREACHABLE();
     return false;
 }
 
-bool Image9::copyToStorage2DArray(TextureStorageInterface *storage, int level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height)
+bool Image9::copyToStorage2DArray(TextureStorage *storage, int level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height)
 {
     // 2D array textures are not supported by the D3D9 backend.
     UNREACHABLE();
diff --git a/src/libGLESv2/renderer/d3d/d3d9/Image9.h b/src/libGLESv2/renderer/d3d/d3d9/Image9.h
index c170b0af..08d8ee35 100644
--- a/src/libGLESv2/renderer/d3d/d3d9/Image9.h
+++ b/src/libGLESv2/renderer/d3d/d3d9/Image9.h
@@ -22,7 +22,6 @@ namespace rx
 {
 class Renderer;
 class Renderer9;
-class TextureStorageInterface;
 
 class Image9 : public ImageD3D
 {
@@ -43,12 +42,12 @@ class Image9 : public ImageD3D
     virtual bool isDirty() const;
     IDirect3DSurface9 *getSurface();
 
-    virtual void setManagedSurface2D(TextureStorageInterface *storage, int level);
-    virtual void setManagedSurfaceCube(TextureStorageInterface *storage, int face, int level);
-    virtual bool copyToStorage2D(TextureStorageInterface *storage, int level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height);
-    virtual bool copyToStorageCube(TextureStorageInterface *storage, int face, int level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height);
-    virtual bool copyToStorage3D(TextureStorageInterface *storage, int level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth);
-    virtual bool copyToStorage2DArray(TextureStorageInterface *storage, int level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height);
+    virtual void setManagedSurface2D(TextureStorage *storage, int level);
+    virtual void setManagedSurfaceCube(TextureStorage *storage, int face, int level);
+    virtual bool copyToStorage2D(TextureStorage *storage, int level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height);
+    virtual bool copyToStorageCube(TextureStorage *storage, int face, int level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height);
+    virtual bool copyToStorage3D(TextureStorage *storage, int level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth);
+    virtual bool copyToStorage2DArray(TextureStorage *storage, int level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height);
 
     virtual void loadData(GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
                           GLint unpackAlignment, GLenum type, const void *input);
diff --git a/src/libGLESv2/renderer/d3d/d3d9/Renderer9.cpp b/src/libGLESv2/renderer/d3d/d3d9/Renderer9.cpp
index 6f61fb99..dd750483 100644
--- a/src/libGLESv2/renderer/d3d/d3d9/Renderer9.cpp
+++ b/src/libGLESv2/renderer/d3d/d3d9/Renderer9.cpp
@@ -685,10 +685,10 @@ void Renderer9::setTexture(gl::SamplerType type, int index, gl::Texture *texture
     {
         TextureD3D* textureImpl = TextureD3D::makeTextureD3D(texture->getImplementation());
 
-        TextureStorageInterface *texStorage = textureImpl->getNativeTexture();
+        TextureStorage *texStorage = textureImpl->getNativeTexture();
         if (texStorage)
         {
-            TextureStorage9 *storage9 = TextureStorage9::makeTextureStorage9(texStorage->getStorageInstance());
+            TextureStorage9 *storage9 = TextureStorage9::makeTextureStorage9(texStorage);
             d3dTexture = storage9->getBaseTexture();
         }
         // If we get NULL back from getBaseTexture here, something went wrong
@@ -2335,14 +2335,14 @@ int Renderer9::getMaxSwapInterval() const
     return mMaxSwapInterval;
 }
 
-bool Renderer9::copyToRenderTarget2D(TextureStorageInterface *dest, TextureStorageInterface *source)
+bool Renderer9::copyToRenderTarget2D(TextureStorage *dest, TextureStorage *source)
 {
     bool result = false;
 
     if (source && dest)
     {
-        TextureStorage9_2D *source9 = TextureStorage9_2D::makeTextureStorage9_2D(source->getStorageInstance());
-        TextureStorage9_2D *dest9 = TextureStorage9_2D::makeTextureStorage9_2D(dest->getStorageInstance());
+        TextureStorage9_2D *source9 = TextureStorage9_2D::makeTextureStorage9_2D(source);
+        TextureStorage9_2D *dest9 = TextureStorage9_2D::makeTextureStorage9_2D(dest);
 
         int levels = source9->getLevelCount();
         for (int i = 0; i < levels; ++i)
@@ -2365,14 +2365,14 @@ bool Renderer9::copyToRenderTarget2D(TextureStorageInterface *dest, TextureStora
     return result;
 }
 
-bool Renderer9::copyToRenderTargetCube(TextureStorageInterface *dest, TextureStorageInterface *source)
+bool Renderer9::copyToRenderTargetCube(TextureStorage *dest, TextureStorage *source)
 {
     bool result = false;
 
     if (source && dest)
     {
-        TextureStorage9_Cube *source9 = TextureStorage9_Cube::makeTextureStorage9_Cube(source->getStorageInstance());
-        TextureStorage9_Cube *dest9 = TextureStorage9_Cube::makeTextureStorage9_Cube(dest->getStorageInstance());
+        TextureStorage9_Cube *source9 = TextureStorage9_Cube::makeTextureStorage9_Cube(source);
+        TextureStorage9_Cube *dest9 = TextureStorage9_Cube::makeTextureStorage9_Cube(dest);
         int levels = source9->getLevelCount();
         for (int f = 0; f < 6; f++)
         {
@@ -2397,14 +2397,14 @@ bool Renderer9::copyToRenderTargetCube(TextureStorageInterface *dest, TextureSto
     return result;
 }
 
-bool Renderer9::copyToRenderTarget3D(TextureStorageInterface *dest, TextureStorageInterface *source)
+bool Renderer9::copyToRenderTarget3D(TextureStorage *dest, TextureStorage *source)
 {
     // 3D textures are not available in the D3D9 backend.
     UNREACHABLE();
     return false;
 }
 
-bool Renderer9::copyToRenderTarget2DArray(TextureStorageInterface *dest, TextureStorageInterface *source)
+bool Renderer9::copyToRenderTarget2DArray(TextureStorage *dest, TextureStorage *source)
 {
     // 2D array textures are not supported by the D3D9 backend.
     UNREACHABLE();
@@ -2429,7 +2429,7 @@ D3DPOOL Renderer9::getBufferPool(DWORD usage) const
 }
 
 bool Renderer9::copyImage2D(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
-                            GLint xoffset, GLint yoffset, TextureStorageInterface *storage, GLint level)
+                            GLint xoffset, GLint yoffset, TextureStorage *storage, GLint level)
 {
     RECT rect;
     rect.left = sourceRect.x;
@@ -2441,7 +2441,7 @@ bool Renderer9::copyImage2D(gl::Framebuffer *framebuffer, const gl::Rectangle &s
 }
 
 bool Renderer9::copyImageCube(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
-                              GLint xoffset, GLint yoffset, TextureStorageInterface *storage, GLenum target, GLint level)
+                              GLint xoffset, GLint yoffset, TextureStorage *storage, GLenum target, GLint level)
 {
     RECT rect;
     rect.left = sourceRect.x;
@@ -2453,7 +2453,7 @@ bool Renderer9::copyImageCube(gl::Framebuffer *framebuffer, const gl::Rectangle
 }
 
 bool Renderer9::copyImage3D(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
-                            GLint xoffset, GLint yoffset, GLint zOffset, TextureStorageInterface *storage, GLint level)
+                            GLint xoffset, GLint yoffset, GLint zOffset, TextureStorage *storage, GLint level)
 {
     // 3D textures are not available in the D3D9 backend.
     UNREACHABLE();
@@ -2461,7 +2461,7 @@ bool Renderer9::copyImage3D(gl::Framebuffer *framebuffer, const gl::Rectangle &s
 }
 
 bool Renderer9::copyImage2DArray(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
-                                 GLint xoffset, GLint yoffset, GLint zOffset, TextureStorageInterface *storage, GLint level)
+                                 GLint xoffset, GLint yoffset, GLint zOffset, TextureStorage *storage, GLint level)
 {
     // 2D array textures are not available in the D3D9 backend.
     UNREACHABLE();
diff --git a/src/libGLESv2/renderer/d3d/d3d9/Renderer9.h b/src/libGLESv2/renderer/d3d/d3d9/Renderer9.h
index ca1d1723..87a33231 100644
--- a/src/libGLESv2/renderer/d3d/d3d9/Renderer9.h
+++ b/src/libGLESv2/renderer/d3d/d3d9/Renderer9.h
@@ -119,19 +119,19 @@ class Renderer9 : public Renderer
     virtual int getMaxSwapInterval() const;
 
     // Pixel operations
-    virtual bool copyToRenderTarget2D(TextureStorageInterface *dest, TextureStorageInterface *source);
-    virtual bool copyToRenderTargetCube(TextureStorageInterface *dest, TextureStorageInterface *source);
-    virtual bool copyToRenderTarget3D(TextureStorageInterface *dest, TextureStorageInterface *source);
-    virtual bool copyToRenderTarget2DArray(TextureStorageInterface *dest, TextureStorageInterface *source);
+    virtual bool copyToRenderTarget2D(TextureStorage *dest, TextureStorage *source);
+    virtual bool copyToRenderTargetCube(TextureStorage *dest, TextureStorage *source);
+    virtual bool copyToRenderTarget3D(TextureStorage *dest, TextureStorage *source);
+    virtual bool copyToRenderTarget2DArray(TextureStorage *dest, TextureStorage *source);
 
     virtual bool copyImage2D(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
-                             GLint xoffset, GLint yoffset, TextureStorageInterface *storage, GLint level);
+                             GLint xoffset, GLint yoffset, TextureStorage *storage, GLint level);
     virtual bool copyImageCube(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
-                               GLint xoffset, GLint yoffset, TextureStorageInterface *storage, GLenum target, GLint level);
+                               GLint xoffset, GLint yoffset, TextureStorage *storage, GLenum target, GLint level);
     virtual bool copyImage3D(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
-                             GLint xoffset, GLint yoffset, GLint zOffset, TextureStorageInterface *storage, GLint level);
+                             GLint xoffset, GLint yoffset, GLint zOffset, TextureStorage *storage, GLint level);
     virtual bool copyImage2DArray(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
-                                  GLint xoffset, GLint yoffset, GLint zOffset, TextureStorageInterface *storage, GLint level);
+                                  GLint xoffset, GLint yoffset, GLint zOffset, TextureStorage *storage, GLint level);
 
     virtual bool blitRect(gl::Framebuffer *readTarget, const gl::Rectangle &readRect, gl::Framebuffer *drawTarget, const gl::Rectangle &drawRect,
                           const gl::Rectangle *scissor, bool blitRenderTarget, bool blitDepth, bool blitStencil, GLenum filter);
diff --git a/src/libGLESv2/renderer/d3d/d3d9/TextureStorage9.cpp b/src/libGLESv2/renderer/d3d/d3d9/TextureStorage9.cpp
index f18544c5..f44e33db 100644
--- a/src/libGLESv2/renderer/d3d/d3d9/TextureStorage9.cpp
+++ b/src/libGLESv2/renderer/d3d/d3d9/TextureStorage9.cpp
@@ -95,6 +95,7 @@ TextureStorage9_2D::TextureStorage9_2D(Renderer *renderer, SwapChain9 *swapchain
     mRenderTarget = NULL;
 
     initializeRenderTarget();
+    initializeSerials(1, 1);
 }
 
 TextureStorage9_2D::TextureStorage9_2D(Renderer *renderer, GLenum internalformat, bool renderTarget, GLsizei width, GLsizei height, int levels)
@@ -121,6 +122,7 @@ TextureStorage9_2D::TextureStorage9_2D(Renderer *renderer, GLenum internalformat
     }
 
     initializeRenderTarget();
+    initializeSerials(getLevelCount(), 1);
 }
 
 TextureStorage9_2D::~TextureStorage9_2D()
@@ -227,6 +229,7 @@ TextureStorage9_Cube::TextureStorage9_Cube(Renderer *renderer, GLenum internalfo
     }
 
     initializeRenderTarget();
+    initializeSerials(getLevelCount() * 6, 6);
 }
 
 TextureStorage9_Cube::~TextureStorage9_Cube()