Bug 858914 - Mark all TextureHost and TextureClient classes deprecated. r=mattwoodrow
authorNicolas Silva <nical@mozilla.com>
Mon, 08 Jul 2013 23:30:44 +0200
changeset 138101 26f83c4cb81e5ff3f80675cc739603d901bcc322
parent 138100 f1088655c731d338805556c181beac905005d1b2
child 138102 ebdf97f9ec5251696f54f076327cd88a9ed18b61
push id270
push userpvanderbeken@mozilla.com
push dateThu, 06 Mar 2014 09:24:21 +0000
reviewersmattwoodrow
bugs858914
milestone25.0a1
Bug 858914 - Mark all TextureHost and TextureClient classes deprecated. r=mattwoodrow
gfx/layers/Compositor.h
gfx/layers/CompositorTypes.h
gfx/layers/Effects.h
gfx/layers/ThebesLayerBuffer.h
gfx/layers/basic/BasicCompositor.cpp
gfx/layers/client/CanvasClient.cpp
gfx/layers/client/CanvasClient.h
gfx/layers/client/CompositableClient.cpp
gfx/layers/client/CompositableClient.h
gfx/layers/client/ContentClient.cpp
gfx/layers/client/ContentClient.h
gfx/layers/client/ImageClient.cpp
gfx/layers/client/ImageClient.h
gfx/layers/client/TextureClient.cpp
gfx/layers/client/TextureClient.h
gfx/layers/client/TiledContentClient.cpp
gfx/layers/client/TiledContentClient.h
gfx/layers/composite/CompositableHost.cpp
gfx/layers/composite/CompositableHost.h
gfx/layers/composite/ContentHost.cpp
gfx/layers/composite/ContentHost.h
gfx/layers/composite/ImageHost.cpp
gfx/layers/composite/ImageHost.h
gfx/layers/composite/ImageLayerComposite.cpp
gfx/layers/composite/TextureHost.cpp
gfx/layers/composite/TextureHost.h
gfx/layers/composite/TiledContentHost.cpp
gfx/layers/composite/TiledContentHost.h
gfx/layers/d3d11/TextureD3D11.cpp
gfx/layers/d3d11/TextureD3D11.h
gfx/layers/ipc/CompositableForwarder.h
gfx/layers/ipc/CompositableTransactionParent.cpp
gfx/layers/ipc/ISurfaceAllocator.h
gfx/layers/ipc/ShadowLayerUtilsGralloc.cpp
gfx/layers/ipc/ShadowLayerUtilsGralloc.h
gfx/layers/ipc/ShadowLayers.h
gfx/layers/opengl/TextureClientOGL.cpp
gfx/layers/opengl/TextureClientOGL.h
gfx/layers/opengl/TextureHostOGL.cpp
gfx/layers/opengl/TextureHostOGL.h
ipc/glue/IPCMessageUtils.h
--- a/gfx/layers/Compositor.h
+++ b/gfx/layers/Compositor.h
@@ -89,17 +89,17 @@
  *
  *
  * # Backend implementations
  *
  * Compositor backends like OpenGL or flavours of D3D live in their own directory
  * under gfx/layers/. To add a new backend, implement at least the following
  * interfaces:
  * - Compositor (ex. CompositorOGL)
- * - TextureHost (ex. TextureImageTextureHost)
+ * - TextureHost (ex. SharedTextureHostOGL)
  * Depending on the type of data that needs to be serialized, you may need to
  * add specific TextureClient implementations.
  */
 
 class gfxContext;
 class nsIWidget;
 
 namespace mozilla {
--- a/gfx/layers/CompositorTypes.h
+++ b/gfx/layers/CompositorTypes.h
@@ -40,17 +40,17 @@ const TextureFlags ComponentAlpha     = 
 const TextureFlags OwnByClient        = 0x80;
 
 
 /**
  * The kind of memory held by the texture client/host pair. This will
  * determine how the texture client is drawn into and how the memory
  * is shared between client and host.
  */
-enum TextureClientType
+enum DeprecatedTextureClientType
 {
   TEXTURE_CONTENT,            // dynamically drawn content
   TEXTURE_SHMEM,              // shared memory
   TEXTURE_YCBCR,              // YCbCr in a shmem
   TEXTURE_SHARED_GL,          // GLContext::SharedTextureHandle
   TEXTURE_SHARED_GL_EXTERNAL, // GLContext::SharedTextureHandle, the ownership of
                               // the SurfaceDescriptor passed to the texture
                               // remains with whoever passed it.
@@ -72,17 +72,17 @@ enum CompositableType
                           // updates to a texture on the compositor side.
   BUFFER_TILED,           // tiled thebes layer
   BUFFER_COUNT
 };
 
 /**
  * How the texture host is used for composition,
  */
-enum TextureHostFlags
+enum DeprecatedTextureHostFlags
 {
   TEXTURE_HOST_DEFAULT = 0,       // The default texture host for the given
                                   // SurfaceDescriptor
   TEXTURE_HOST_TILED = 1 << 0,    // A texture host that supports tiling
   TEXTURE_HOST_COPY_PREVIOUS = 1 << 1 // Texture contents should be initialized
                                       // from the previous texture.
 };
 
@@ -121,35 +121,35 @@ const TextureIdentifier TextureOnWhiteBa
 
 /**
  * Information required by the compositor from the content-side for creating or
  * using compositables and textures.
  */
 struct TextureInfo
 {
   CompositableType mCompositableType;
-  uint32_t mTextureHostFlags;
+  uint32_t mDeprecatedTextureHostFlags;
   uint32_t mTextureFlags;
 
   TextureInfo()
     : mCompositableType(BUFFER_UNKNOWN)
-    , mTextureHostFlags(0)
+    , mDeprecatedTextureHostFlags(0)
     , mTextureFlags(0)
   {}
 
   TextureInfo(CompositableType aType)
     : mCompositableType(aType)
-    , mTextureHostFlags(0)
+    , mDeprecatedTextureHostFlags(0)
     , mTextureFlags(0)
   {}
 
   bool operator==(const TextureInfo& aOther) const
   {
     return mCompositableType == aOther.mCompositableType &&
-           mTextureHostFlags == aOther.mTextureHostFlags &&
+           mDeprecatedTextureHostFlags == aOther.mDeprecatedTextureHostFlags &&
            mTextureFlags == aOther.mTextureFlags;
   }
 };
 
 /**
  * How a SurfaceDescriptor will be opened.
  *
  * See ShadowLayerForwarder::OpenDescriptor for example.
--- a/gfx/layers/Effects.h
+++ b/gfx/layers/Effects.h
@@ -220,56 +220,56 @@ struct EffectSolidColor : public Effect
 
 struct EffectChain
 {
   RefPtr<Effect> mPrimaryEffect;
   RefPtr<Effect> mSecondaryEffects[EFFECT_MAX_SECONDARY];
 };
 
 inline TemporaryRef<TexturedEffect>
-CreateTexturedEffect(TextureHost *aTextureHost,
-                     TextureHost *aTextureHostOnWhite,
+CreateTexturedEffect(DeprecatedTextureHost *aDeprecatedTextureHost,
+                     DeprecatedTextureHost *aDeprecatedTextureHostOnWhite,
                      const gfx::Filter& aFilter)
 {
-  if (aTextureHostOnWhite) {
-    MOZ_ASSERT(aTextureHost->GetFormat() == gfx::FORMAT_R8G8B8X8 ||
-               aTextureHost->GetFormat() == gfx::FORMAT_B8G8R8X8);
-    return new EffectComponentAlpha(aTextureHost, aTextureHostOnWhite, aFilter);
+  if (aDeprecatedTextureHostOnWhite) {
+    MOZ_ASSERT(aDeprecatedTextureHost->GetFormat() == gfx::FORMAT_R8G8B8X8 ||
+               aDeprecatedTextureHost->GetFormat() == gfx::FORMAT_B8G8R8X8);
+    return new EffectComponentAlpha(aDeprecatedTextureHost, aDeprecatedTextureHostOnWhite, aFilter);
   }
 
   RefPtr<TexturedEffect> result;
-  switch (aTextureHost->GetFormat()) {
+  switch (aDeprecatedTextureHost->GetFormat()) {
   case gfx::FORMAT_B8G8R8A8:
-    result = new EffectBGRA(aTextureHost, true, aFilter);
+    result = new EffectBGRA(aDeprecatedTextureHost, true, aFilter);
     break;
   case gfx::FORMAT_B8G8R8X8:
-    result = new EffectBGRX(aTextureHost, true, aFilter);
+    result = new EffectBGRX(aDeprecatedTextureHost, true, aFilter);
     break;
   case gfx::FORMAT_R8G8B8X8:
-    result = new EffectRGBX(aTextureHost, true, aFilter);
+    result = new EffectRGBX(aDeprecatedTextureHost, true, aFilter);
     break;
   case gfx::FORMAT_R5G6B5:
-    result = new EffectRGBX(aTextureHost, true, aFilter);
+    result = new EffectRGBX(aDeprecatedTextureHost, true, aFilter);
     break;
   case gfx::FORMAT_R8G8B8A8:
-    result = new EffectRGBA(aTextureHost, true, aFilter);
+    result = new EffectRGBA(aDeprecatedTextureHost, true, aFilter);
     break;
   case gfx::FORMAT_YUV:
-    result = new EffectYCbCr(aTextureHost, aFilter);
+    result = new EffectYCbCr(aDeprecatedTextureHost, aFilter);
     break;
   default:
     MOZ_CRASH("unhandled program type");
   }
 
   return result;
 }
 
 inline TemporaryRef<TexturedEffect>
-CreateTexturedEffect(TextureHost *aTextureHost,
+CreateTexturedEffect(DeprecatedTextureHost *aDeprecatedTextureHost,
                      const gfx::Filter& aFilter)
 {
-  return CreateTexturedEffect(aTextureHost, nullptr, aFilter);
+  return CreateTexturedEffect(aDeprecatedTextureHost, nullptr, aFilter);
 }
 
 } // namespace layers
 } // namespace mozilla
 
 #endif
--- a/gfx/layers/ThebesLayerBuffer.h
+++ b/gfx/layers/ThebesLayerBuffer.h
@@ -281,30 +281,30 @@ protected:
    * demand in this code.
    *
    * It's the caller's responsibility to ensure |aClient| is valid
    * for the duration of operations it requests of this
    * ThebesLayerBuffer.  It's also the caller's responsibility to
    * unset the provider when inactive, by calling
    * SetBufferProvider(nullptr).
    */
-  void SetBufferProvider(TextureClient* aClient)
+  void SetBufferProvider(DeprecatedTextureClient* aClient)
   {
     // Only this buffer provider can give us a buffer.  If we
     // already have one, something has gone wrong.
     MOZ_ASSERT(!aClient || (!mBuffer && !mDTBuffer));
 
     mBufferProvider = aClient;
     if (!mBufferProvider) {
       mBuffer = nullptr;
       mDTBuffer = nullptr;
     } 
   }
   
-  void SetBufferProviderOnWhite(TextureClient* aClient)
+  void SetBufferProviderOnWhite(DeprecatedTextureClient* aClient)
   {
     // Only this buffer provider can give us a buffer.  If we
     // already have one, something has gone wrong.
     MOZ_ASSERT(!aClient || (!mBufferOnWhite && !mDTBufferOnWhite));
 
     mBufferProviderOnWhite = aClient;
     if (!mBufferProviderOnWhite) {
       mBufferOnWhite = nullptr;
@@ -345,18 +345,18 @@ protected:
   virtual bool HaveBuffer() const;
   virtual bool HaveBufferOnWhite() const;
 
   /**
    * These members are only set transiently.  They're used to map mBuffer
    * when we're using surfaces that require explicit map/unmap. Only one
    * may be used at a time.
    */
-  TextureClient* mBufferProvider;
-  TextureClient* mBufferProviderOnWhite;
+  DeprecatedTextureClient* mBufferProvider;
+  DeprecatedTextureClient* mBufferProviderOnWhite;
 
   BufferSizePolicy      mBufferSizePolicy;
 };
 
 }
 }
 
 #endif /* THEBESLAYERBUFFER_H_ */
--- a/gfx/layers/basic/BasicCompositor.cpp
+++ b/gfx/layers/basic/BasicCompositor.cpp
@@ -25,32 +25,32 @@ class TextureSourceBasic
 public:
   virtual ~TextureSourceBasic() {}
   virtual gfx::SourceSurface* GetSurface() = 0;
 };
 
 /**
  * Texture source and host implementaion for software compositing.
  */
-class TextureHostBasic : public TextureHost
-                             , public TextureSourceBasic
+class DeprecatedTextureHostBasic : public DeprecatedTextureHost
+                                 , public TextureSourceBasic
 {
 public:
   virtual IntSize GetSize() const MOZ_OVERRIDE { return mSize; }
 
   virtual TextureSourceBasic* AsSourceBasic() MOZ_OVERRIDE { return this; }
 
   SourceSurface *GetSurface() { return mSurface; }
 
   virtual void SetCompositor(Compositor* aCompositor)
   {
     mCompositor = static_cast<BasicCompositor*>(aCompositor);
   }
 
-  virtual const char *Name() { return "TextureHostBasic"; }
+  virtual const char *Name() { return "DeprecatedTextureHostBasic"; }
 
 protected:
   virtual void UpdateImpl(const SurfaceDescriptor& aImage,
                           nsIntRegion *aRegion,
                           nsIntPoint*) MOZ_OVERRIDE
   {
     AutoOpenSurface surf(OPEN_READ_ONLY, aImage);
     mFormat =
@@ -100,17 +100,17 @@ DeserializerToPlanarYCbCrImageData(YCbCr
   aData.mYSize = aDeserializer.GetYSize();
   aData.mCbChannel = aDeserializer.GetCbData();
   aData.mCrChannel = aDeserializer.GetCrData();
   aData.mCbCrStride = aDeserializer.GetCbCrStride();
   aData.mCbCrSize = aDeserializer.GetCbCrSize();
   aData.mPicSize = aDeserializer.GetYSize();
 }
 
-class YCbCrTextureHostBasic : public TextureHostBasic
+class YCbCrDeprecatedTextureHostBasic : public DeprecatedTextureHostBasic
 {
 public:
   virtual void UpdateImpl(const SurfaceDescriptor& aImage,
                           nsIntRegion *aRegion,
                           nsIntPoint*) MOZ_OVERRIDE
   {
     MOZ_ASSERT(aImage.type() == SurfaceDescriptor::TYCbCrImage);
     mSurface = nullptr;
@@ -157,29 +157,29 @@ public:
     mSize = IntSize(size.width, size.height);
     mFormat =
       (format == gfxASurface::ImageFormatARGB32) ? FORMAT_B8G8R8A8 :
                                                    FORMAT_B8G8R8X8;
   }
 
 };
 
-TemporaryRef<TextureHost>
-CreateBasicTextureHost(SurfaceDescriptorType aDescriptorType,
-                       uint32_t aTextureHostFlags,
-                       uint32_t aTextureFlags)
+TemporaryRef<DeprecatedTextureHost>
+CreateBasicDeprecatedTextureHost(SurfaceDescriptorType aDescriptorType,
+                             uint32_t aTextureHostFlags,
+                             uint32_t aTextureFlags)
 {
   if (aDescriptorType == SurfaceDescriptor::TYCbCrImage) {
-    return new YCbCrTextureHostBasic();
+    return new YCbCrDeprecatedTextureHostBasic();
   }
 
   MOZ_ASSERT(aDescriptorType == SurfaceDescriptor::TShmem ||
              aDescriptorType == SurfaceDescriptor::TMemoryImage,
              "We can only support Shmem currently");
-  return new TextureHostBasic();
+  return new DeprecatedTextureHostBasic();
 }
 
 BasicCompositor::BasicCompositor(nsIWidget *aWidget)
   : mWidget(aWidget)
   , mWidgetSize(-1, -1)
 {
   MOZ_COUNT_CTOR(BasicCompositor);
   sBackend = LAYERS_BASIC;
--- a/gfx/layers/client/CanvasClient.cpp
+++ b/gfx/layers/client/CanvasClient.cpp
@@ -36,72 +36,72 @@ CanvasClient::CreateCanvasClient(Composi
     return new CanvasClient2D(aForwarder, aFlags);
   }
   return nullptr;
 }
 
 void
 CanvasClient::Updated()
 {
-  mForwarder->UpdateTexture(this, 1, mTextureClient->GetDescriptor());
+  mForwarder->UpdateTexture(this, 1, mDeprecatedTextureClient->GetDescriptor());
 }
 
 
 CanvasClient2D::CanvasClient2D(CompositableForwarder* aFwd,
                                TextureFlags aFlags)
 : CanvasClient(aFwd, aFlags)
 {
   mTextureInfo.mCompositableType = BUFFER_IMAGE_SINGLE;
 }
 
 void
 CanvasClient2D::Update(gfx::IntSize aSize, ClientCanvasLayer* aLayer)
 {
-  if (!mTextureClient) {
-    mTextureClient = CreateTextureClient(TEXTURE_CONTENT);
-    MOZ_ASSERT(mTextureClient, "Failed to create texture client");
+  if (!mDeprecatedTextureClient) {
+    mDeprecatedTextureClient = CreateDeprecatedTextureClient(TEXTURE_CONTENT);
+    MOZ_ASSERT(mDeprecatedTextureClient, "Failed to create texture client");
   }
 
   bool isOpaque = (aLayer->GetContentFlags() & Layer::CONTENT_OPAQUE);
   gfxASurface::gfxContentType contentType = isOpaque
                                               ? gfxASurface::CONTENT_COLOR
                                               : gfxASurface::CONTENT_COLOR_ALPHA;
-  mTextureClient->EnsureAllocated(aSize, contentType);
+  mDeprecatedTextureClient->EnsureAllocated(aSize, contentType);
 
-  gfxASurface* surface = mTextureClient->LockSurface();
+  gfxASurface* surface = mDeprecatedTextureClient->LockSurface();
   aLayer->UpdateSurface(surface);
-  mTextureClient->Unlock();
+  mDeprecatedTextureClient->Unlock();
 }
 
 void
 CanvasClientWebGL::Updated()
 {
-  mForwarder->UpdateTextureNoSwap(this, 1, mTextureClient->GetDescriptor());
+  mForwarder->UpdateTextureNoSwap(this, 1, mDeprecatedTextureClient->GetDescriptor());
 }
 
 
 CanvasClientWebGL::CanvasClientWebGL(CompositableForwarder* aFwd,
                                      TextureFlags aFlags)
 : CanvasClient(aFwd, aFlags)
 {
   mTextureInfo.mCompositableType = BUFFER_IMAGE_BUFFERED;
 }
 
 void
 CanvasClientWebGL::Update(gfx::IntSize aSize, ClientCanvasLayer* aLayer)
 {
-  if (!mTextureClient) {
-    mTextureClient = CreateTextureClient(TEXTURE_STREAM_GL);
-    MOZ_ASSERT(mTextureClient, "Failed to create texture client");
+  if (!mDeprecatedTextureClient) {
+    mDeprecatedTextureClient = CreateDeprecatedTextureClient(TEXTURE_STREAM_GL);
+    MOZ_ASSERT(mDeprecatedTextureClient, "Failed to create texture client");
   }
 
   NS_ASSERTION(aLayer->mGLContext, "CanvasClientWebGL should only be used with GL canvases");
 
   // the content type won't be used
-  mTextureClient->EnsureAllocated(aSize, gfxASurface::CONTENT_COLOR);
+  mDeprecatedTextureClient->EnsureAllocated(aSize, gfxASurface::CONTENT_COLOR);
 
   GLScreenBuffer* screen = aLayer->mGLContext->Screen();
   SurfaceStream* stream = screen->Stream();
 
   bool isCrossProcess = !(XRE_GetProcessType() == GeckoProcessType_Default);
   if (isCrossProcess) {
     // swap staging -> consumer so we can send it to the compositor
     SharedSurface* surf = stream->SwapConsumer();
@@ -112,23 +112,23 @@ CanvasClientWebGL::Update(gfx::IntSize a
 
 #ifdef MOZ_WIDGET_GONK
     if (surf->Type() != SharedSurfaceType::Gralloc) {
       printf_stderr("Unexpected non-Gralloc SharedSurface in IPC path!");
       return;
     }
 
     SharedSurface_Gralloc* grallocSurf = SharedSurface_Gralloc::Cast(surf);
-    mTextureClient->SetDescriptor(grallocSurf->GetDescriptor());
+    mDeprecatedTextureClient->SetDescriptor(grallocSurf->GetDescriptor());
 #else
     printf_stderr("isCrossProcess, but not MOZ_WIDGET_GONK! Someone needs to write some code!");
     MOZ_ASSERT(false);
 #endif
   } else {
     SurfaceStreamHandle handle = stream->GetShareHandle();
-    mTextureClient->SetDescriptor(SurfaceStreamDescriptor(handle, false));
+    mDeprecatedTextureClient->SetDescriptor(SurfaceStreamDescriptor(handle, false));
   }
 
   aLayer->Painted();
 }
 
 }
 }
--- a/gfx/layers/client/CanvasClient.h
+++ b/gfx/layers/client/CanvasClient.h
@@ -40,20 +40,20 @@ public:
 
   virtual void Update(gfx::IntSize aSize, ClientCanvasLayer* aLayer) = 0;
 
   virtual void Updated();
 
   virtual void SetDescriptorFromReply(TextureIdentifier aTextureId,
                                       const SurfaceDescriptor& aDescriptor) MOZ_OVERRIDE
   {
-    mTextureClient->SetDescriptorFromReply(aDescriptor);
+    mDeprecatedTextureClient->SetDescriptorFromReply(aDescriptor);
   }
 protected:
-  RefPtr<TextureClient> mTextureClient;
+  RefPtr<DeprecatedTextureClient> mDeprecatedTextureClient;
   TextureInfo mTextureInfo;
 };
 
 // Used for 2D canvases and WebGL canvas on non-GL systems where readback is requried.
 class CanvasClient2D : public CanvasClient
 {
 public:
   CanvasClient2D(CompositableForwarder* aLayerForwarder,
--- a/gfx/layers/client/CompositableClient.cpp
+++ b/gfx/layers/client/CompositableClient.cpp
@@ -71,69 +71,69 @@ CompositableClient::GetAsyncID() const
 
 
 void
 CompositableChild::Destroy()
 {
   Send__delete__(this);
 }
 
-TemporaryRef<TextureClient>
-CompositableClient::CreateTextureClient(TextureClientType aTextureClientType)
+TemporaryRef<DeprecatedTextureClient>
+CompositableClient::CreateDeprecatedTextureClient(DeprecatedTextureClientType aDeprecatedTextureClientType)
 {
   MOZ_ASSERT(GetForwarder(), "Can't create a texture client if the compositable is not connected to the compositor.");
   LayersBackend parentBackend = GetForwarder()->GetCompositorBackendType();
-  RefPtr<TextureClient> result;
+  RefPtr<DeprecatedTextureClient> result;
 
-  switch (aTextureClientType) {
+  switch (aDeprecatedTextureClientType) {
   case TEXTURE_SHARED_GL:
     if (parentBackend == LAYERS_OPENGL) {
-      result = new TextureClientSharedOGL(GetForwarder(), GetTextureInfo());
+      result = new DeprecatedTextureClientSharedOGL(GetForwarder(), GetTextureInfo());
     }
      break;
   case TEXTURE_SHARED_GL_EXTERNAL:
     if (parentBackend == LAYERS_OPENGL) {
-      result = new TextureClientSharedOGLExternal(GetForwarder(), GetTextureInfo());
+      result = new DeprecatedTextureClientSharedOGLExternal(GetForwarder(), GetTextureInfo());
     }
     break;
   case TEXTURE_STREAM_GL:
     if (parentBackend == LAYERS_OPENGL) {
-      result = new TextureClientStreamOGL(GetForwarder(), GetTextureInfo());
+      result = new DeprecatedTextureClientStreamOGL(GetForwarder(), GetTextureInfo());
     }
     break;
   case TEXTURE_YCBCR:
     if (parentBackend == LAYERS_OPENGL ||
         parentBackend == LAYERS_D3D11 ||
         parentBackend == LAYERS_BASIC) {
-      result = new TextureClientShmemYCbCr(GetForwarder(), GetTextureInfo());
+      result = new DeprecatedTextureClientShmemYCbCr(GetForwarder(), GetTextureInfo());
     }
     break;
   case TEXTURE_CONTENT:
 #ifdef XP_WIN
     if (parentBackend == LAYERS_D3D11 && gfxWindowsPlatform::GetPlatform()->GetD2DDevice()) {
-      result = new TextureClientD3D11(GetForwarder(), GetTextureInfo());
+      result = new DeprecatedTextureClientD3D11(GetForwarder(), GetTextureInfo());
       break;
     }
 #endif
      // fall through to TEXTURE_SHMEM
   case TEXTURE_SHMEM:
-    result = new TextureClientShmem(GetForwarder(), GetTextureInfo());
+    result = new DeprecatedTextureClientShmem(GetForwarder(), GetTextureInfo());
     break;
   default:
     MOZ_ASSERT(false, "Unhandled texture client type");
   }
 
   // If we couldn't create an appropriate texture client,
   // then return nullptr so the caller can chose another
   // type.
   if (!result) {
     return nullptr;
   }
 
-  MOZ_ASSERT(result->SupportsType(aTextureClientType),
+  MOZ_ASSERT(result->SupportsType(aDeprecatedTextureClientType),
              "Created the wrong texture client?");
   result->SetFlags(GetTextureInfo().mTextureFlags);
 
   return result.forget();
 }
 
 } // namespace layers
 } // namespace mozilla
--- a/gfx/layers/client/CompositableClient.h
+++ b/gfx/layers/client/CompositableClient.h
@@ -10,17 +10,17 @@
 #include "mozilla/layers/LayersTypes.h"
 #include "mozilla/RefPtr.h"
 
 namespace mozilla {
 namespace layers {
 
 class CompositableChild;
 class CompositableClient;
-class TextureClient;
+class DeprecatedTextureClient;
 class ImageBridgeChild;
 class ShadowableLayer;
 class CompositableForwarder;
 class CompositableChild;
 class SurfaceDescriptor;
 
 /**
  * CompositableClient manages the texture-specific logic for composite layers,
@@ -73,18 +73,18 @@ public:
 
   virtual TextureInfo GetTextureInfo() const
   {
     MOZ_CRASH("This method should be overridden");
   }
 
   LayersBackend GetCompositorBackendType() const;
 
-  TemporaryRef<TextureClient>
-  CreateTextureClient(TextureClientType aTextureClientType);
+  TemporaryRef<DeprecatedTextureClient>
+  CreateDeprecatedTextureClient(DeprecatedTextureClientType aDeprecatedTextureClientType);
 
   virtual void SetDescriptorFromReply(TextureIdentifier aTextureId,
                                       const SurfaceDescriptor& aDescriptor)
   {
     MOZ_CRASH("If you want to call this, you should have implemented it");
   }
 
   /**
--- a/gfx/layers/client/ContentClient.cpp
+++ b/gfx/layers/client/ContentClient.cpp
@@ -90,120 +90,120 @@ ContentClientBasic::CreateDTBuffer(Conte
   NS_RUNTIMEABORT("ContentClientBasic does not support Moz2D drawing yet!");
   // TODO[Bas] - Implement me!?
   return nullptr;
 }
 
 void
 ContentClientRemoteBuffer::DestroyBuffers()
 {
-  if (!mTextureClient) {
+  if (!mDeprecatedTextureClient) {
     return;
   }
 
-  MOZ_ASSERT(mTextureClient->GetAccessMode() == TextureClient::ACCESS_READ_WRITE);
-  mTextureClient = nullptr;
-  mTextureClientOnWhite = nullptr;
+  MOZ_ASSERT(mDeprecatedTextureClient->GetAccessMode() == DeprecatedTextureClient::ACCESS_READ_WRITE);
+  mDeprecatedTextureClient = nullptr;
+  mDeprecatedTextureClientOnWhite = nullptr;
 
   DestroyFrontBuffer();
 
   mForwarder->DestroyThebesBuffer(this);
 }
 
 void
 ContentClientRemoteBuffer::BeginPaint()
 {
-  // XXX: So we might not have a TextureClient yet.. because it will
+  // XXX: So we might not have a DeprecatedTextureClient yet.. because it will
   // only be created by CreateBuffer.. which will deliver a locked surface!.
-  if (mTextureClient) {
-    SetBufferProvider(mTextureClient);
+  if (mDeprecatedTextureClient) {
+    SetBufferProvider(mDeprecatedTextureClient);
   }
-  if (mTextureClientOnWhite) {
-    SetBufferProviderOnWhite(mTextureClientOnWhite);
+  if (mDeprecatedTextureClientOnWhite) {
+    SetBufferProviderOnWhite(mDeprecatedTextureClientOnWhite);
   }
 }
 
 void
 ContentClientRemoteBuffer::EndPaint()
 {
   // XXX: We might still not have a texture client if PaintThebes
   // decided we didn't need one yet because the region to draw was empty.
   SetBufferProvider(nullptr);
   SetBufferProviderOnWhite(nullptr);
   mOldTextures.Clear();
 
-  if (mTextureClient) {
-    mTextureClient->Unlock();
+  if (mDeprecatedTextureClient) {
+    mDeprecatedTextureClient->Unlock();
   }
-  if (mTextureClientOnWhite) {
-    mTextureClientOnWhite->Unlock();
+  if (mDeprecatedTextureClientOnWhite) {
+    mDeprecatedTextureClientOnWhite->Unlock();
   }
 }
 
 void
-ContentClientRemoteBuffer::BuildTextureClients(ContentType aType,
+ContentClientRemoteBuffer::BuildDeprecatedTextureClients(ContentType aType,
                                                const nsIntRect& aRect,
                                                uint32_t aFlags)
 {
   NS_ABORT_IF_FALSE(!mIsNewBuffer,
                     "Bad! Did we create a buffer twice without painting?");
 
   mIsNewBuffer = true;
 
-  if (mTextureClient) {
-    mOldTextures.AppendElement(mTextureClient);
-    if (mTextureClientOnWhite) {
-      mOldTextures.AppendElement(mTextureClientOnWhite);
+  if (mDeprecatedTextureClient) {
+    mOldTextures.AppendElement(mDeprecatedTextureClient);
+    if (mDeprecatedTextureClientOnWhite) {
+      mOldTextures.AppendElement(mDeprecatedTextureClientOnWhite);
     }
     DestroyBuffers();
   }
   mTextureInfo.mTextureFlags = aFlags | HostRelease;
-  mTextureClient = CreateTextureClient(TEXTURE_CONTENT);
-  MOZ_ASSERT(mTextureClient, "Failed to create texture client");
+  mDeprecatedTextureClient = CreateDeprecatedTextureClient(TEXTURE_CONTENT);
+  MOZ_ASSERT(mDeprecatedTextureClient, "Failed to create texture client");
   if (aFlags & BUFFER_COMPONENT_ALPHA) {
-    mTextureClientOnWhite = CreateTextureClient(TEXTURE_CONTENT);
-    MOZ_ASSERT(mTextureClientOnWhite, "Failed to create texture client");
+    mDeprecatedTextureClientOnWhite = CreateDeprecatedTextureClient(TEXTURE_CONTENT);
+    MOZ_ASSERT(mDeprecatedTextureClientOnWhite, "Failed to create texture client");
     mTextureInfo.mTextureFlags |= ComponentAlpha;
   }
 
   mContentType = aType;
   mSize = gfx::IntSize(aRect.width, aRect.height);
-  mTextureClient->EnsureAllocated(mSize, mContentType);
-  MOZ_ASSERT(IsSurfaceDescriptorValid(*mTextureClient->GetDescriptor()));
-  if (mTextureClientOnWhite) {
-    mTextureClientOnWhite->EnsureAllocated(mSize, mContentType);
-    MOZ_ASSERT(IsSurfaceDescriptorValid(*mTextureClientOnWhite->GetDescriptor()));
+  mDeprecatedTextureClient->EnsureAllocated(mSize, mContentType);
+  MOZ_ASSERT(IsSurfaceDescriptorValid(*mDeprecatedTextureClient->GetDescriptor()));
+  if (mDeprecatedTextureClientOnWhite) {
+    mDeprecatedTextureClientOnWhite->EnsureAllocated(mSize, mContentType);
+    MOZ_ASSERT(IsSurfaceDescriptorValid(*mDeprecatedTextureClientOnWhite->GetDescriptor()));
   }
 
   CreateFrontBufferAndNotify(aRect);
 }
 
 TemporaryRef<DrawTarget>
 ContentClientRemoteBuffer::CreateDTBuffer(ContentType aType,
                                           const nsIntRect& aRect,
                                           uint32_t aFlags)
 {
   MOZ_ASSERT(!(aFlags & BUFFER_COMPONENT_ALPHA), "We don't support component alpha here!");
-  BuildTextureClients(aType, aRect, aFlags);
+  BuildDeprecatedTextureClients(aType, aRect, aFlags);
 
-  RefPtr<DrawTarget> ret = mTextureClient->LockDrawTarget();
+  RefPtr<DrawTarget> ret = mDeprecatedTextureClient->LockDrawTarget();
   return ret.forget();
 }
 
 already_AddRefed<gfxASurface>
 ContentClientRemoteBuffer::CreateBuffer(ContentType aType,
                                         const nsIntRect& aRect,
                                         uint32_t aFlags,
                                         gfxASurface** aWhiteSurface)
 {
-  BuildTextureClients(aType, aRect, aFlags);
+  BuildDeprecatedTextureClients(aType, aRect, aFlags);
 
-  nsRefPtr<gfxASurface> ret = mTextureClient->LockSurface();
+  nsRefPtr<gfxASurface> ret = mDeprecatedTextureClient->LockSurface();
   if (aFlags & BUFFER_COMPONENT_ALPHA) {
-    nsRefPtr<gfxASurface> retWhite = mTextureClientOnWhite->LockSurface();
+    nsRefPtr<gfxASurface> retWhite = mDeprecatedTextureClientOnWhite->LockSurface();
     *aWhiteSurface = retWhite.forget().get();
   }
   return ret.forget();
 }
 
 nsIntRegion
 ContentClientRemoteBuffer::GetUpdatedRegion(const nsIntRegion& aRegionToDraw,
                                             const nsIntRegion& aVisibleRegion,
@@ -221,186 +221,186 @@ ContentClientRemoteBuffer::GetUpdatedReg
     updatedRegion = aVisibleRegion;
     mIsNewBuffer = false;
   } else {
     updatedRegion = aRegionToDraw;
   }
 
   NS_ASSERTION(BufferRect().Contains(aRegionToDraw.GetBounds()),
                "Update outside of buffer rect!");
-  NS_ABORT_IF_FALSE(mTextureClient, "should have a back buffer by now");
+  NS_ABORT_IF_FALSE(mDeprecatedTextureClient, "should have a back buffer by now");
 
   return updatedRegion;
 }
 
 void
 ContentClientRemoteBuffer::Updated(const nsIntRegion& aRegionToDraw,
                                    const nsIntRegion& aVisibleRegion,
                                    bool aDidSelfCopy)
 {
   nsIntRegion updatedRegion = GetUpdatedRegion(aRegionToDraw,
                                                aVisibleRegion,
                                                aDidSelfCopy);
 
-  MOZ_ASSERT(mTextureClient);
-  mTextureClient->SetAccessMode(TextureClient::ACCESS_NONE);
-  if (mTextureClientOnWhite) {
-    mTextureClientOnWhite->SetAccessMode(TextureClient::ACCESS_NONE);
+  MOZ_ASSERT(mDeprecatedTextureClient);
+  mDeprecatedTextureClient->SetAccessMode(DeprecatedTextureClient::ACCESS_NONE);
+  if (mDeprecatedTextureClientOnWhite) {
+    mDeprecatedTextureClientOnWhite->SetAccessMode(DeprecatedTextureClient::ACCESS_NONE);
   }
   LockFrontBuffer();
   mForwarder->UpdateTextureRegion(this,
                                   ThebesBufferData(BufferRect(),
                                                    BufferRotation()),
                                   updatedRegion);
 }
 
 void
 ContentClientRemoteBuffer::SwapBuffers(const nsIntRegion& aFrontUpdatedRegion)
 {
-  MOZ_ASSERT(mTextureClient->GetAccessMode() == TextureClient::ACCESS_NONE);
-  MOZ_ASSERT(!mTextureClientOnWhite || mTextureClientOnWhite->GetAccessMode() == TextureClient::ACCESS_NONE);
-  MOZ_ASSERT(mTextureClient);
+  MOZ_ASSERT(mDeprecatedTextureClient->GetAccessMode() == DeprecatedTextureClient::ACCESS_NONE);
+  MOZ_ASSERT(!mDeprecatedTextureClientOnWhite || mDeprecatedTextureClientOnWhite->GetAccessMode() == DeprecatedTextureClient::ACCESS_NONE);
+  MOZ_ASSERT(mDeprecatedTextureClient);
 
   mFrontAndBackBufferDiffer = true;
-  mTextureClient->SetAccessMode(TextureClient::ACCESS_READ_WRITE);
-  if (mTextureClientOnWhite) {
-    mTextureClientOnWhite->SetAccessMode(TextureClient::ACCESS_READ_WRITE);
+  mDeprecatedTextureClient->SetAccessMode(DeprecatedTextureClient::ACCESS_READ_WRITE);
+  if (mDeprecatedTextureClientOnWhite) {
+    mDeprecatedTextureClientOnWhite->SetAccessMode(DeprecatedTextureClient::ACCESS_READ_WRITE);
   }
 }
 
 ContentClientDoubleBuffered::~ContentClientDoubleBuffered()
 {
-  if (mTextureClient) {
+  if (mDeprecatedTextureClient) {
     MOZ_ASSERT(mFrontClient);
-    mTextureClient->SetDescriptor(SurfaceDescriptor());
+    mDeprecatedTextureClient->SetDescriptor(SurfaceDescriptor());
     mFrontClient->SetDescriptor(SurfaceDescriptor());
   }
-  if (mTextureClientOnWhite) {
+  if (mDeprecatedTextureClientOnWhite) {
     MOZ_ASSERT(mFrontClientOnWhite);
-    mTextureClientOnWhite->SetDescriptor(SurfaceDescriptor());
+    mDeprecatedTextureClientOnWhite->SetDescriptor(SurfaceDescriptor());
     mFrontClientOnWhite->SetDescriptor(SurfaceDescriptor());
   }
 }
 
 void
 ContentClientDoubleBuffered::CreateFrontBufferAndNotify(const nsIntRect& aBufferRect)
 {
-  mFrontClient = CreateTextureClient(TEXTURE_CONTENT);
+  mFrontClient = CreateDeprecatedTextureClient(TEXTURE_CONTENT);
   MOZ_ASSERT(mFrontClient, "Failed to create texture client");
   mFrontClient->EnsureAllocated(mSize, mContentType);
 
   mFrontBufferRect = aBufferRect;
   mFrontBufferRotation = nsIntPoint();
 
   if (mTextureInfo.mTextureFlags & ComponentAlpha) {
-    mFrontClientOnWhite = CreateTextureClient(TEXTURE_CONTENT);
+    mFrontClientOnWhite = CreateDeprecatedTextureClient(TEXTURE_CONTENT);
     MOZ_ASSERT(mFrontClientOnWhite, "Failed to create texture client");
     mFrontClientOnWhite->EnsureAllocated(mSize, mContentType);
   }
   
   mForwarder->CreatedDoubleBuffer(this,
                                   *mFrontClient->GetDescriptor(),
-                                  *mTextureClient->GetDescriptor(),
+                                  *mDeprecatedTextureClient->GetDescriptor(),
                                   mTextureInfo,
                                   mFrontClientOnWhite ? mFrontClientOnWhite->GetDescriptor() : nullptr,
-                                  mTextureClientOnWhite ? mTextureClientOnWhite->GetDescriptor() : nullptr);
+                                  mDeprecatedTextureClientOnWhite ? mDeprecatedTextureClientOnWhite->GetDescriptor() : nullptr);
 }
 
 void
 ContentClientDoubleBuffered::DestroyFrontBuffer()
 {
   MOZ_ASSERT(mFrontClient);
-  MOZ_ASSERT(mFrontClient->GetAccessMode() != TextureClient::ACCESS_NONE);
+  MOZ_ASSERT(mFrontClient->GetAccessMode() != DeprecatedTextureClient::ACCESS_NONE);
 
   mFrontClient = nullptr;
   mFrontClientOnWhite = nullptr;
 }
 
 void
 ContentClientDoubleBuffered::LockFrontBuffer()
 {
   MOZ_ASSERT(mFrontClient);
-  mFrontClient->SetAccessMode(TextureClient::ACCESS_NONE);
+  mFrontClient->SetAccessMode(DeprecatedTextureClient::ACCESS_NONE);
   if (mFrontClientOnWhite) {
-    mFrontClientOnWhite->SetAccessMode(TextureClient::ACCESS_NONE);
+    mFrontClientOnWhite->SetAccessMode(DeprecatedTextureClient::ACCESS_NONE);
   }
 }
 
 void
 ContentClientDoubleBuffered::SwapBuffers(const nsIntRegion& aFrontUpdatedRegion)
 {
   mFrontUpdatedRegion = aFrontUpdatedRegion;
 
-  RefPtr<TextureClient> oldBack = mTextureClient;
-  mTextureClient = mFrontClient;
+  RefPtr<DeprecatedTextureClient> oldBack = mDeprecatedTextureClient;
+  mDeprecatedTextureClient = mFrontClient;
   mFrontClient = oldBack;
 
-  oldBack = mTextureClientOnWhite;
-  mTextureClientOnWhite = mFrontClientOnWhite;
+  oldBack = mDeprecatedTextureClientOnWhite;
+  mDeprecatedTextureClientOnWhite = mFrontClientOnWhite;
   mFrontClientOnWhite = oldBack;
 
   nsIntRect oldBufferRect = mBufferRect;
   mBufferRect = mFrontBufferRect;
   mFrontBufferRect = oldBufferRect;
 
   nsIntPoint oldBufferRotation = mBufferRotation;
   mBufferRotation = mFrontBufferRotation;
   mFrontBufferRotation = oldBufferRotation;
 
   MOZ_ASSERT(mFrontClient);
-  mFrontClient->SetAccessMode(TextureClient::ACCESS_READ_ONLY);
+  mFrontClient->SetAccessMode(DeprecatedTextureClient::ACCESS_READ_ONLY);
   if (mFrontClientOnWhite) {
-    mFrontClientOnWhite->SetAccessMode(TextureClient::ACCESS_READ_ONLY);
+    mFrontClientOnWhite->SetAccessMode(DeprecatedTextureClient::ACCESS_READ_ONLY);
   }
 
   ContentClientRemoteBuffer::SwapBuffers(aFrontUpdatedRegion);
 }
 
-struct AutoTextureClient {
-  AutoTextureClient()
+struct AutoDeprecatedTextureClient {
+  AutoDeprecatedTextureClient()
     : mTexture(nullptr)
   {}
-  ~AutoTextureClient()
+  ~AutoDeprecatedTextureClient()
   {
     if (mTexture) {
       mTexture->Unlock();
     }
   }
-  gfxASurface* GetSurface(TextureClient* aTexture)
+  gfxASurface* GetSurface(DeprecatedTextureClient* aTexture)
   {
     MOZ_ASSERT(!mTexture);
     mTexture = aTexture;
     if (mTexture) {
       return mTexture->LockSurface();
     }
     return nullptr;
   }
-  DrawTarget* GetDrawTarget(TextureClient* aTexture)
+  DrawTarget* GetDrawTarget(DeprecatedTextureClient* aTexture)
   {
     MOZ_ASSERT(!mTexture);
     mTexture = aTexture;
     if (mTexture) {
       return mTexture->LockDrawTarget();
     }
     return nullptr;
   }
 private:
-  TextureClient* mTexture;
+  DeprecatedTextureClient* mTexture;
 };
 
 void
 ContentClientDoubleBuffered::SyncFrontBufferToBackBuffer()
 {
   if (!mFrontAndBackBufferDiffer) {
     return;
   }
   MOZ_ASSERT(mFrontClient);
-  MOZ_ASSERT(mFrontClient->GetAccessMode() == TextureClient::ACCESS_READ_ONLY);
+  MOZ_ASSERT(mFrontClient->GetAccessMode() == DeprecatedTextureClient::ACCESS_READ_ONLY);
   MOZ_ASSERT(!mFrontClientOnWhite ||
-             mFrontClientOnWhite->GetAccessMode() == TextureClient::ACCESS_READ_ONLY);
+             mFrontClientOnWhite->GetAccessMode() == DeprecatedTextureClient::ACCESS_READ_ONLY);
 
   MOZ_LAYERS_LOG(("BasicShadowableThebes(%p): reading back <x=%d,y=%d,w=%d,h=%d>",
                   this,
                   mFrontUpdatedRegion.GetBounds().x,
                   mFrontUpdatedRegion.GetBounds().y,
                   mFrontUpdatedRegion.GetBounds().width,
                   mFrontUpdatedRegion.GetBounds().height));
 
@@ -428,18 +428,18 @@ ContentClientDoubleBuffered::SyncFrontBu
     mBufferRect.MoveTo(mFrontBufferRect.TopLeft());
     mBufferRotation = nsIntPoint();
     updateRegion = mBufferRect;
   } else {
     mBufferRect = mFrontBufferRect;
     mBufferRotation = mFrontBufferRotation;
   }
  
-  AutoTextureClient autoTextureFront;
-  AutoTextureClient autoTextureFrontOnWhite;
+  AutoDeprecatedTextureClient autoTextureFront;
+  AutoDeprecatedTextureClient autoTextureFrontOnWhite;
   if (gfxPlatform::GetPlatform()->SupportsAzureContent()) {
     RotatedBuffer frontBuffer(autoTextureFront.GetDrawTarget(mFrontClient),
                               autoTextureFrontOnWhite.GetDrawTarget(mFrontClientOnWhite),
                               mFrontBufferRect,
                               mFrontBufferRotation);
     UpdateDestinationFrom(frontBuffer, updateRegion);
   } else {
     RotatedBuffer frontBuffer(autoTextureFront.GetSurface(mFrontClient),
@@ -498,53 +498,53 @@ ContentClientDoubleBuffered::UpdateDesti
     } else {
       aSource.DrawBufferWithRotation(destCtx, BUFFER_WHITE);
     }
   }
 }
 
 ContentClientSingleBuffered::~ContentClientSingleBuffered()
 {
-  if (mTextureClient) {
-    mTextureClient->SetDescriptor(SurfaceDescriptor());
+  if (mDeprecatedTextureClient) {
+    mDeprecatedTextureClient->SetDescriptor(SurfaceDescriptor());
   }
-  if (mTextureClientOnWhite) {
-    mTextureClientOnWhite->SetDescriptor(SurfaceDescriptor());
+  if (mDeprecatedTextureClientOnWhite) {
+    mDeprecatedTextureClientOnWhite->SetDescriptor(SurfaceDescriptor());
   }
 }
 
 void
 ContentClientSingleBuffered::CreateFrontBufferAndNotify(const nsIntRect& aBufferRect)
 {
   mForwarder->CreatedSingleBuffer(this,
-                                  *mTextureClient->GetDescriptor(),
+                                  *mDeprecatedTextureClient->GetDescriptor(),
                                   mTextureInfo,
-                                  mTextureClientOnWhite ? mTextureClientOnWhite->GetDescriptor() : nullptr);
+                                  mDeprecatedTextureClientOnWhite ? mDeprecatedTextureClientOnWhite->GetDescriptor() : nullptr);
 }
 
 void
 ContentClientSingleBuffered::SyncFrontBufferToBackBuffer()
 {
   if (!mFrontAndBackBufferDiffer) {
     return;
   }
 
   gfxASurface* backBuffer = GetBuffer();
-  if (!backBuffer && mTextureClient) {
-    backBuffer = mTextureClient->LockSurface();
+  if (!backBuffer && mDeprecatedTextureClient) {
+    backBuffer = mDeprecatedTextureClient->LockSurface();
   }
 
   nsRefPtr<gfxASurface> oldBuffer;
   oldBuffer = SetBuffer(backBuffer,
                         mBufferRect,
                         mBufferRotation);
 
   backBuffer = GetBufferOnWhite();
-  if (!backBuffer && mTextureClientOnWhite) {
-    backBuffer = mTextureClientOnWhite->LockSurface();
+  if (!backBuffer && mDeprecatedTextureClientOnWhite) {
+    backBuffer = mDeprecatedTextureClientOnWhite->LockSurface();
   }
 
   oldBuffer = SetBufferOnWhite(backBuffer);
 
   mIsNewBuffer = false;
   mFrontAndBackBufferDiffer = false;
 }
 
@@ -569,17 +569,17 @@ FillSurface(gfxASurface* aSurface, const
   ctx->Paint();
 }
 
 ThebesLayerBuffer::PaintState
 ContentClientIncremental::BeginPaintBuffer(ThebesLayer* aLayer,
                                            ThebesLayerBuffer::ContentType aContentType,
                                            uint32_t aFlags)
 {
-  mTextureInfo.mTextureHostFlags = 0;
+  mTextureInfo.mDeprecatedTextureHostFlags = 0;
   PaintState result;
   // We need to disable rotation if we're going to be resampled when
   // drawing, because we might sample across the rotation boundary.
   bool canHaveRotation =  !(aFlags & ThebesLayerBuffer::PAINT_WILL_RESAMPLE);
 
   nsIntRegion validRegion = aLayer->GetValidRegion();
 
   Layer::SurfaceMode mode;
@@ -732,17 +732,17 @@ ContentClientIncremental::BeginPaintBuff
 
   if (!createdBuffer && !mHasBuffer) {
     return result;
   }
 
   if (createdBuffer) {
     if (mHasBuffer &&
         (mode != Layer::SURFACE_COMPONENT_ALPHA || mHasBufferOnWhite)) {
-      mTextureInfo.mTextureHostFlags = TEXTURE_HOST_COPY_PREVIOUS;
+      mTextureInfo.mDeprecatedTextureHostFlags = TEXTURE_HOST_COPY_PREVIOUS;
     }
 
     mHasBuffer = true;
     if (mode == Layer::SURFACE_COMPONENT_ALPHA) {
       mHasBufferOnWhite = true;
     }
     mBufferRect = destBufferRect;
     mBufferRotation = nsIntPoint(0,0);
--- a/gfx/layers/client/ContentClient.h
+++ b/gfx/layers/client/ContentClient.h
@@ -167,17 +167,17 @@ class ContentClientRemoteBuffer : public
                                 , protected ThebesLayerBuffer
 {
   using ThebesLayerBuffer::BufferRect;
   using ThebesLayerBuffer::BufferRotation;
 public:
   ContentClientRemoteBuffer(CompositableForwarder* aForwarder)
     : ContentClientRemote(aForwarder)
     , ThebesLayerBuffer(ContainsVisibleBounds)
-    , mTextureClient(nullptr)
+    , mDeprecatedTextureClient(nullptr)
     , mIsNewBuffer(false)
     , mFrontAndBackBufferDiffer(false)
     , mContentType(gfxASurface::CONTENT_COLOR_ALPHA)
   {}
 
   typedef ThebesLayerBuffer::PaintState PaintState;
   typedef ThebesLayerBuffer::ContentType ContentType;
 
@@ -235,47 +235,47 @@ public:
     return mTextureInfo;
   }
 
 protected:
   virtual nsIntRegion GetUpdatedRegion(const nsIntRegion& aRegionToDraw,
                                        const nsIntRegion& aVisibleRegion,
                                        bool aDidSelfCopy);
 
-  // create and configure mTextureClient
-  void BuildTextureClients(ContentType aType,
-                           const nsIntRect& aRect,
-                           uint32_t aFlags);
+  // create and configure mDeprecatedTextureClient
+  void BuildDeprecatedTextureClients(ContentType aType,
+                                     const nsIntRect& aRect,
+                                     uint32_t aFlags);
 
   // Create the front buffer for the ContentClient/Host pair if necessary
   // and notify the compositor that we have created the buffer(s).
   virtual void CreateFrontBufferAndNotify(const nsIntRect& aBufferRect) = 0;
   virtual void DestroyFrontBuffer() {}
   // We're about to hand off to the compositor, if you've got a back buffer,
   // lock it now.
   virtual void LockFrontBuffer() {}
 
-  RefPtr<TextureClient> mTextureClient;
-  RefPtr<TextureClient> mTextureClientOnWhite;
+  RefPtr<DeprecatedTextureClient> mDeprecatedTextureClient;
+  RefPtr<DeprecatedTextureClient> mDeprecatedTextureClientOnWhite;
   // keep a record of texture clients we have created and need to keep
   // around, then unlock when we are done painting
-  nsTArray<RefPtr<TextureClient> > mOldTextures;
+  nsTArray<RefPtr<DeprecatedTextureClient> > mOldTextures;
 
   TextureInfo mTextureInfo;
   bool mIsNewBuffer;
   bool mFrontAndBackBufferDiffer;
   gfx::IntSize mSize;
   ContentType mContentType;
 };
 
 /**
- * A double buffered ContentClient. mTextureClient is the back buffer, which
+ * A double buffered ContentClient. mDeprecatedTextureClient is the back buffer, which
  * we draw into. mFrontClient is the front buffer which we may read from, but
  * not write to, when the compositor does not have the 'soft' lock. We can write
- * into mTextureClient at any time.
+ * into mDeprecatedTextureClient at any time.
  *
  * The ContentHost keeps a reference to both corresponding texture hosts, in
  * response to our UpdateTextureRegion message, the compositor swaps its
  * references. In response to the compositor's reply we swap our references
  * (in SwapBuffers).
  */
 class ContentClientDoubleBuffered : public ContentClientRemoteBuffer
 {
@@ -295,18 +295,18 @@ protected:
   virtual void CreateFrontBufferAndNotify(const nsIntRect& aBufferRect) MOZ_OVERRIDE;
   virtual void DestroyFrontBuffer() MOZ_OVERRIDE;
   virtual void LockFrontBuffer() MOZ_OVERRIDE;
 
 private:
   void UpdateDestinationFrom(const RotatedBuffer& aSource,
                              const nsIntRegion& aUpdateRegion);
 
-  RefPtr<TextureClient> mFrontClient;
-  RefPtr<TextureClient> mFrontClientOnWhite;
+  RefPtr<DeprecatedTextureClient> mFrontClient;
+  RefPtr<DeprecatedTextureClient> mFrontClientOnWhite;
   nsIntRegion mFrontUpdatedRegion;
   nsIntRect mFrontBufferRect;
   nsIntPoint mFrontBufferRotation;
 };
 
 /**
  * A single buffered ContentClient. We have a single TextureClient/Host
  * which we update and then send a message to the compositor that we are
--- a/gfx/layers/client/ImageClient.cpp
+++ b/gfx/layers/client/ImageClient.cpp
@@ -72,25 +72,25 @@ ImageClientSingle::ImageClientSingle(Com
                                      CompositableType aType)
   : ImageClient(aFwd, aType)
   , mTextureInfo(aType)
 {
   mTextureInfo.mTextureFlags = aFlags;
 }
 
 bool
-ImageClientSingle::EnsureTextureClient(TextureClientType aType)
+ImageClientSingle::EnsureDeprecatedTextureClient(DeprecatedTextureClientType aType)
 {
   // We should not call this method if using ImageBridge or tiled texture
   // clients since SupportsType always fails
-  if (mTextureClient && mTextureClient->SupportsType(aType)) {
+  if (mDeprecatedTextureClient && mDeprecatedTextureClient->SupportsType(aType)) {
     return true;
   }
-  mTextureClient = CreateTextureClient(aType);
-  return !!mTextureClient;
+  mDeprecatedTextureClient = CreateDeprecatedTextureClient(aType);
+  return !!mDeprecatedTextureClient;
 }
 
 bool
 ImageClientSingle::UpdateImage(ImageContainer* aContainer,
                                uint32_t aContentFlags)
 {
   AutoLockImage autoLock(aContainer);
 
@@ -99,108 +99,108 @@ ImageClientSingle::UpdateImage(ImageCont
     return false;
   }
 
   if (mLastPaintedImageSerial == image->GetSerial()) {
     return true;
   }
 
   if (image->GetFormat() == PLANAR_YCBCR &&
-      EnsureTextureClient(TEXTURE_YCBCR)) {
+      EnsureDeprecatedTextureClient(TEXTURE_YCBCR)) {
     PlanarYCbCrImage* ycbcr = static_cast<PlanarYCbCrImage*>(image);
 
     if (ycbcr->AsSharedPlanarYCbCrImage()) {
-      AutoLockTextureClient lock(mTextureClient);
+      AutoLockDeprecatedTextureClient lock(mDeprecatedTextureClient);
 
       SurfaceDescriptor sd;
       if (!ycbcr->AsSharedPlanarYCbCrImage()->ToSurfaceDescriptor(sd)) {
         return false;
       }
 
       if (IsSurfaceDescriptorValid(*lock.GetSurfaceDescriptor())) {
         GetForwarder()->DestroySharedSurface(lock.GetSurfaceDescriptor());
       }
 
       *lock.GetSurfaceDescriptor() = sd;
     } else {
-      AutoLockYCbCrClient clientLock(mTextureClient);
+      AutoLockYCbCrClient clientLock(mDeprecatedTextureClient);
 
       if (!clientLock.Update(ycbcr)) {
-        NS_WARNING("failed to update TextureClient (YCbCr)");
+        NS_WARNING("failed to update DeprecatedTextureClient (YCbCr)");
         return false;
       }
     }
   } else if (image->GetFormat() == SHARED_TEXTURE &&
-             EnsureTextureClient(TEXTURE_SHARED_GL_EXTERNAL)) {
+             EnsureDeprecatedTextureClient(TEXTURE_SHARED_GL_EXTERNAL)) {
     SharedTextureImage* sharedImage = static_cast<SharedTextureImage*>(image);
     const SharedTextureImage::Data *data = sharedImage->GetData();
 
     SharedTextureDescriptor texture(data->mShareType,
                                     data->mHandle,
                                     data->mSize,
                                     data->mInverted);
-    mTextureClient->SetDescriptor(SurfaceDescriptor(texture));
+    mDeprecatedTextureClient->SetDescriptor(SurfaceDescriptor(texture));
   } else if (image->GetFormat() == SHARED_RGB &&
-             EnsureTextureClient(TEXTURE_SHMEM)) {
+             EnsureDeprecatedTextureClient(TEXTURE_SHMEM)) {
     nsIntRect rect(0, 0,
                    image->GetSize().width,
                    image->GetSize().height);
     UpdatePictureRect(rect);
 
-    AutoLockTextureClient lock(mTextureClient);
+    AutoLockDeprecatedTextureClient lock(mDeprecatedTextureClient);
 
     SurfaceDescriptor desc;
     if (!static_cast<SharedRGBImage*>(image)->ToSurfaceDescriptor(desc)) {
       return false;
     }
-    mTextureClient->SetDescriptor(desc);
+    mDeprecatedTextureClient->SetDescriptor(desc);
 #ifdef MOZ_WIDGET_GONK
   } else if (image->GetFormat() == GONK_IO_SURFACE &&
-             EnsureTextureClient(TEXTURE_SHARED_GL_EXTERNAL)) {
+             EnsureDeprecatedTextureClient(TEXTURE_SHARED_GL_EXTERNAL)) {
     nsIntRect rect(0, 0,
                    image->GetSize().width,
                    image->GetSize().height);
     UpdatePictureRect(rect);
 
-    AutoLockTextureClient lock(mTextureClient);
+    AutoLockDeprecatedTextureClient lock(mDeprecatedTextureClient);
 
     SurfaceDescriptor desc = static_cast<GonkIOSurfaceImage*>(image)->GetSurfaceDescriptor();
     if (!IsSurfaceDescriptorValid(desc)) {
       return false;
     }
-    mTextureClient->SetDescriptor(desc);
+    mDeprecatedTextureClient->SetDescriptor(desc);
   } else if (image->GetFormat() == GRALLOC_PLANAR_YCBCR) {
-    EnsureTextureClient(TEXTURE_SHARED_GL_EXTERNAL);
+    EnsureDeprecatedTextureClient(TEXTURE_SHARED_GL_EXTERNAL);
 
     nsIntRect rect(0, 0,
                    image->GetSize().width,
                    image->GetSize().height);
     UpdatePictureRect(rect);
 
-    AutoLockTextureClient lock(mTextureClient);
+    AutoLockDeprecatedTextureClient lock(mDeprecatedTextureClient);
 
     SurfaceDescriptor desc = static_cast<GrallocPlanarYCbCrImage*>(image)->GetSurfaceDescriptor();
     if (!IsSurfaceDescriptorValid(desc)) {
       return false;
     }
-    mTextureClient->SetDescriptor(desc);
+    mDeprecatedTextureClient->SetDescriptor(desc);
 #endif
   } else {
     nsRefPtr<gfxASurface> surface = image->GetAsSurface();
     MOZ_ASSERT(surface);
 
-    EnsureTextureClient(TEXTURE_SHMEM);
-    MOZ_ASSERT(mTextureClient, "Failed to create texture client");
+    EnsureDeprecatedTextureClient(TEXTURE_SHMEM);
+    MOZ_ASSERT(mDeprecatedTextureClient, "Failed to create texture client");
 
     nsRefPtr<gfxPattern> pattern = new gfxPattern(surface);
     pattern->SetFilter(mFilter);
 
-    AutoLockShmemClient clientLock(mTextureClient);
+    AutoLockShmemClient clientLock(mDeprecatedTextureClient);
     if (!clientLock.Update(image, aContentFlags, pattern)) {
-      NS_WARNING("failed to update TextureClient");
+      NS_WARNING("failed to update DeprecatedTextureClient");
       return false;
     }
   }
 
   Updated();
 
   if (image->GetFormat() == PLANAR_YCBCR) {
     PlanarYCbCrImage* ycbcr = static_cast<PlanarYCbCrImage*>(image);
@@ -210,17 +210,17 @@ ImageClientSingle::UpdateImage(ImageCont
   mLastPaintedImageSerial = image->GetSerial();
   aContainer->NotifyPaintedImage(image);
   return true;
 }
 
 void
 ImageClientSingle::Updated()
 {
-  mForwarder->UpdateTexture(this, 1, mTextureClient->GetDescriptor());
+  mForwarder->UpdateTexture(this, 1, mDeprecatedTextureClient->GetDescriptor());
 }
 
 ImageClientBridge::ImageClientBridge(CompositableForwarder* aFwd,
                                      TextureFlags aFlags)
 : ImageClient(aFwd, BUFFER_BRIDGE)
 , mAsyncContainerID(0)
 , mLayer(nullptr)
 {
--- a/gfx/layers/client/ImageClient.h
+++ b/gfx/layers/client/ImageClient.h
@@ -82,40 +82,40 @@ public:
 
   virtual bool UpdateImage(ImageContainer* aContainer, uint32_t aContentFlags);
 
   /**
    * Creates a texture client of the requested type.
    * Returns true if the texture client was created succesfully,
    * false otherwise.
    */
-  bool EnsureTextureClient(TextureClientType aType);
+  bool EnsureDeprecatedTextureClient(DeprecatedTextureClientType aType);
 
   virtual void Updated();
 
   virtual void SetDescriptorFromReply(TextureIdentifier aTextureId,
                                       const SurfaceDescriptor& aDescriptor) MOZ_OVERRIDE
   {
-    mTextureClient->SetDescriptorFromReply(aDescriptor);
+    mDeprecatedTextureClient->SetDescriptorFromReply(aDescriptor);
   }
 
   virtual TextureInfo GetTextureInfo() const MOZ_OVERRIDE
   {
     return mTextureInfo;
   }
 
 private:
-  RefPtr<TextureClient> mTextureClient;
+  RefPtr<DeprecatedTextureClient> mDeprecatedTextureClient;
   TextureInfo mTextureInfo;
 };
 
 /**
  * Image class to be used for async image uploads using the image bridge
  * protocol.
- * We store the ImageBridge id in the TextureClientIdentifier.
+ * We store the ImageBridge id in the DeprecatedTextureClientIdentifier.
  */
 class ImageClientBridge : public ImageClient
 {
 public:
   ImageClientBridge(CompositableForwarder* aFwd,
                     TextureFlags aFlags);
 
   virtual bool UpdateImage(ImageContainer* aContainer, uint32_t aContentFlags);
--- a/gfx/layers/client/TextureClient.cpp
+++ b/gfx/layers/client/TextureClient.cpp
@@ -18,41 +18,41 @@
 #include "gfxPlatform.h"
 #include "mozilla/StandardInteger.h"
 
 using namespace mozilla::gl;
 
 namespace mozilla {
 namespace layers {
 
-TextureClient::TextureClient(CompositableForwarder* aForwarder,
+DeprecatedTextureClient::DeprecatedTextureClient(CompositableForwarder* aForwarder,
                              const TextureInfo& aTextureInfo)
   : mForwarder(aForwarder)
   , mTextureInfo(aTextureInfo)
   , mAccessMode(ACCESS_READ_WRITE)
 {
-  MOZ_COUNT_CTOR(TextureClient);
+  MOZ_COUNT_CTOR(DeprecatedTextureClient);
 }
 
-TextureClient::~TextureClient()
+DeprecatedTextureClient::~DeprecatedTextureClient()
 {
-  MOZ_COUNT_DTOR(TextureClient);
+  MOZ_COUNT_DTOR(DeprecatedTextureClient);
   MOZ_ASSERT(mDescriptor.type() == SurfaceDescriptor::T__None, "Need to release surface!");
 }
 
-TextureClientShmem::TextureClientShmem(CompositableForwarder* aForwarder,
+DeprecatedTextureClientShmem::DeprecatedTextureClientShmem(CompositableForwarder* aForwarder,
                                        const TextureInfo& aTextureInfo)
-  : TextureClient(aForwarder, aTextureInfo)
+  : DeprecatedTextureClient(aForwarder, aTextureInfo)
   , mSurface(nullptr)
   , mSurfaceAsImage(nullptr)
 {
 }
 
 void
-TextureClientShmem::ReleaseResources()
+DeprecatedTextureClientShmem::ReleaseResources()
 {
   if (mSurface) {
     mSurface = nullptr;
     ShadowLayerForwarder::CloseDescriptor(mDescriptor);
   }
 
   if (mTextureInfo.mTextureFlags & HostRelease) {
     mDescriptor = SurfaceDescriptor();
@@ -61,17 +61,17 @@ TextureClientShmem::ReleaseResources()
 
   if (IsSurfaceDescriptorValid(mDescriptor)) {
     mForwarder->DestroySharedSurface(&mDescriptor);
     mDescriptor = SurfaceDescriptor();
   }
 }
 
 void
-TextureClientShmem::EnsureAllocated(gfx::IntSize aSize,
+DeprecatedTextureClientShmem::EnsureAllocated(gfx::IntSize aSize,
                                     gfxASurface::gfxContentType aContentType)
 {
   if (aSize != mSize ||
       aContentType != mContentType ||
       !IsSurfaceDescriptorValid(mDescriptor)) {
     ReleaseResources();
 
     mContentType = aContentType;
@@ -80,17 +80,17 @@ TextureClientShmem::EnsureAllocated(gfx:
     if (!mForwarder->AllocSurfaceDescriptor(gfxIntSize(mSize.width, mSize.height),
                                             mContentType, &mDescriptor)) {
       NS_WARNING("creating SurfaceDescriptor failed!");
     }
   }
 }
 
 void
-TextureClientShmem::SetDescriptor(const SurfaceDescriptor& aDescriptor)
+DeprecatedTextureClientShmem::SetDescriptor(const SurfaceDescriptor& aDescriptor)
 {
   if (IsSurfaceDescriptorValid(aDescriptor)) {
     ReleaseResources();
     mDescriptor = aDescriptor;
   } else {
     EnsureAllocated(mSize, mContentType);
   }
 
@@ -99,121 +99,121 @@ TextureClientShmem::SetDescriptor(const 
   NS_ASSERTION(mDescriptor.type() == SurfaceDescriptor::TSurfaceDescriptorGralloc ||
                mDescriptor.type() == SurfaceDescriptor::TShmem ||
                mDescriptor.type() == SurfaceDescriptor::TMemoryImage ||
                mDescriptor.type() == SurfaceDescriptor::TRGBImage,
                "Invalid surface descriptor");
 }
 
 gfxASurface*
-TextureClientShmem::GetSurface()
+DeprecatedTextureClientShmem::GetSurface()
 {
   if (!mSurface) {
     if (!IsSurfaceDescriptorValid(mDescriptor)) {
       return nullptr;
     }
     MOZ_ASSERT(mAccessMode == ACCESS_READ_WRITE || mAccessMode == ACCESS_READ_ONLY);
     OpenMode mode = mAccessMode == ACCESS_READ_WRITE
                     ? OPEN_READ_WRITE
                     : OPEN_READ_ONLY;
     mSurface = ShadowLayerForwarder::OpenDescriptor(mode, mDescriptor);
   }
 
   return mSurface.get();
 }
 
 void
-TextureClientShmem::Unlock()
+DeprecatedTextureClientShmem::Unlock()
 {
   mSurface = nullptr;
   mSurfaceAsImage = nullptr;
 
   ShadowLayerForwarder::CloseDescriptor(mDescriptor);
 }
 
 gfxImageSurface*
-TextureClientShmem::LockImageSurface()
+DeprecatedTextureClientShmem::LockImageSurface()
 {
   if (!mSurfaceAsImage) {
     mSurfaceAsImage = GetSurface()->GetAsImageSurface();
   }
 
   return mSurfaceAsImage.get();
 }
 
 void
-TextureClientShmemYCbCr::ReleaseResources()
+DeprecatedTextureClientShmemYCbCr::ReleaseResources()
 {
   GetForwarder()->DestroySharedSurface(&mDescriptor);
 }
 
 void
-TextureClientShmemYCbCr::SetDescriptor(const SurfaceDescriptor& aDescriptor)
+DeprecatedTextureClientShmemYCbCr::SetDescriptor(const SurfaceDescriptor& aDescriptor)
 {
   MOZ_ASSERT(aDescriptor.type() == SurfaceDescriptor::TYCbCrImage);
 
   if (IsSurfaceDescriptorValid(mDescriptor)) {
     GetForwarder()->DestroySharedSurface(&mDescriptor);
   }
   mDescriptor = aDescriptor;
   MOZ_ASSERT(IsSurfaceDescriptorValid(mDescriptor));
 }
 
 void
-TextureClientShmemYCbCr::SetDescriptorFromReply(const SurfaceDescriptor& aDescriptor)
+DeprecatedTextureClientShmemYCbCr::SetDescriptorFromReply(const SurfaceDescriptor& aDescriptor)
 {
   MOZ_ASSERT(aDescriptor.type() == SurfaceDescriptor::TYCbCrImage);
   SharedPlanarYCbCrImage* shYCbCr = SharedPlanarYCbCrImage::FromSurfaceDescriptor(aDescriptor);
   if (shYCbCr) {
     shYCbCr->Release();
     mDescriptor = SurfaceDescriptor();
   } else {
     SetDescriptor(aDescriptor);
   }
 }
 
 void
-TextureClientShmemYCbCr::EnsureAllocated(gfx::IntSize aSize,
+DeprecatedTextureClientShmemYCbCr::EnsureAllocated(gfx::IntSize aSize,
                                          gfxASurface::gfxContentType aType)
 {
   NS_RUNTIMEABORT("not enough arguments to do this (need both Y and CbCr sizes)");
 }
 
 
-TextureClientTile::TextureClientTile(const TextureClientTile& aOther)
-  : TextureClient(aOther.mForwarder, aOther.mTextureInfo)
+DeprecatedTextureClientTile::DeprecatedTextureClientTile(const DeprecatedTextureClientTile& aOther)
+  : DeprecatedTextureClient(aOther.mForwarder, aOther.mTextureInfo)
   , mSurface(aOther.mSurface)
 {}
 
-TextureClientTile::~TextureClientTile()
+DeprecatedTextureClientTile::~DeprecatedTextureClientTile()
 {}
 
-TextureClientTile::TextureClientTile(CompositableForwarder* aForwarder,
+DeprecatedTextureClientTile::DeprecatedTextureClientTile(CompositableForwarder* aForwarder,
                                      const TextureInfo& aTextureInfo)
-  : TextureClient(aForwarder, aTextureInfo)
+  : DeprecatedTextureClient(aForwarder, aTextureInfo)
   , mSurface(nullptr)
 {
-  mTextureInfo.mTextureHostFlags = TEXTURE_HOST_TILED;
+  mTextureInfo.mDeprecatedTextureHostFlags = TEXTURE_HOST_TILED;
 }
 
 void
-TextureClientTile::EnsureAllocated(gfx::IntSize aSize, gfxASurface::gfxContentType aType)
+DeprecatedTextureClientTile::EnsureAllocated(gfx::IntSize aSize, gfxASurface::gfxContentType aType)
 {
   if (!mSurface ||
       mSurface->Format() != gfxPlatform::GetPlatform()->OptimalFormatForContent(aType)) {
     gfxImageSurface* tmpTile = new gfxImageSurface(gfxIntSize(aSize.width, aSize.height),
                                                    gfxPlatform::GetPlatform()->OptimalFormatForContent(aType),
                                                    aType != gfxASurface::CONTENT_COLOR);
     mSurface = new gfxReusableSurfaceWrapper(tmpTile);
     mContentType = aType;
   }
 }
 
 gfxImageSurface*
-TextureClientTile::LockImageSurface()
+DeprecatedTextureClientTile::LockImageSurface()
 {
   // Use the gfxReusableSurfaceWrapper, which will reuse the surface
   // if the compositor no longer has a read lock, otherwise the surface
   // will be copied into a new writable surface.
   gfxImageSurface* writableSurface = nullptr;
   mSurface = mSurface->GetWritable(&writableSurface);
   return writableSurface;
 }
@@ -235,24 +235,24 @@ bool AutoLockShmemClient::Update(Image* 
   bool isOpaque = (aContentFlags & Layer::CONTENT_OPAQUE);
   if (surface) {
     contentType = surface->GetContentType();
   }
   if (contentType != gfxASurface::CONTENT_ALPHA &&
       isOpaque) {
     contentType = gfxASurface::CONTENT_COLOR;
   }
-  mTextureClient->EnsureAllocated(gfx::IntSize(size.width, size.height), contentType);
+  mDeprecatedTextureClient->EnsureAllocated(gfx::IntSize(size.width, size.height), contentType);
 
-  OpenMode mode = mTextureClient->GetAccessMode() == TextureClient::ACCESS_READ_WRITE
+  OpenMode mode = mDeprecatedTextureClient->GetAccessMode() == DeprecatedTextureClient::ACCESS_READ_WRITE
                   ? OPEN_READ_WRITE
                   : OPEN_READ_ONLY;
   nsRefPtr<gfxASurface> tmpASurface =
     ShadowLayerForwarder::OpenDescriptor(mode,
-                                         *mTextureClient->LockSurfaceDescriptor());
+                                         *mDeprecatedTextureClient->LockSurfaceDescriptor());
   if (!tmpASurface) {
     return false;
   }
   nsRefPtr<gfxContext> tmpCtx = new gfxContext(tmpASurface.get());
   tmpCtx->SetOperator(gfxContext::OPERATOR_SOURCE);
   PaintContext(pat,
                nsIntRegion(nsIntRect(0, 0, size.width, size.height)),
                1.0, tmpCtx, nullptr);
@@ -267,34 +267,34 @@ AutoLockYCbCrClient::Update(PlanarYCbCrI
   MOZ_ASSERT(mDescriptor);
 
   const PlanarYCbCrImage::Data *data = aImage->GetData();
   NS_ASSERTION(data, "Must be able to retrieve yuv data from image!");
   if (!data) {
     return false;
   }
 
-  if (!EnsureTextureClient(aImage)) {
+  if (!EnsureDeprecatedTextureClient(aImage)) {
     return false;
   }
 
   ipc::Shmem& shmem = mDescriptor->get_YCbCrImage().data();
 
   YCbCrImageDataSerializer serializer(shmem.get<uint8_t>());
   if (!serializer.CopyData(data->mYChannel, data->mCbChannel, data->mCrChannel,
                            data->mYSize, data->mYStride,
                            data->mCbCrSize, data->mCbCrStride,
                            data->mYSkip, data->mCbSkip)) {
     NS_WARNING("Failed to copy image data!");
     return false;
   }
   return true;
 }
 
-bool AutoLockYCbCrClient::EnsureTextureClient(PlanarYCbCrImage* aImage)
+bool AutoLockYCbCrClient::EnsureDeprecatedTextureClient(PlanarYCbCrImage* aImage)
 {
   MOZ_ASSERT(aImage);
   if (!aImage) {
     return false;
   }
 
   const PlanarYCbCrImage::Data *data = aImage->GetData();
   NS_ASSERTION(data, "Must be able to retrieve yuv data from image!");
@@ -313,23 +313,23 @@ bool AutoLockYCbCrClient::EnsureTextureC
       needsAllocation = true;
     }
   }
 
   if (!needsAllocation) {
     return true;
   }
 
-  mTextureClient->ReleaseResources();
+  mDeprecatedTextureClient->ReleaseResources();
 
   ipc::SharedMemory::SharedMemoryType shmType = OptimalShmemType();
   size_t size = YCbCrImageDataSerializer::ComputeMinBufferSize(data->mYSize,
                                                                data->mCbCrSize);
   ipc::Shmem shmem;
-  if (!mTextureClient->GetForwarder()->AllocUnsafeShmem(size, shmType, &shmem)) {
+  if (!mDeprecatedTextureClient->GetForwarder()->AllocUnsafeShmem(size, shmType, &shmem)) {
     return false;
   }
 
   YCbCrImageDataSerializer serializer(shmem.get<uint8_t>());
   serializer.InitializeBufferInfo(data->mYSize,
                                   data->mCbCrSize);
 
   *mDescriptor = YCbCrImage(shmem, 0);
--- a/gfx/layers/client/TextureClient.h
+++ b/gfx/layers/client/TextureClient.h
@@ -22,59 +22,61 @@ class GLContext;
 namespace layers {
 
 class ContentClient;
 class PlanarYCbCrImage;
 class Image;
 class CompositableForwarder;
 
 /**
+ * XXX - This class is deprecated, will be removed soon.
+ *
  * This class allows texture clients to draw into textures through Azure or
  * thebes and applies locking semantics to allow GPU or CPU level
  * synchronization.
- * TextureClient's purpose is for the texture data to be
+ * DeprecatedTextureClient's purpose is for the texture data to be
  * forwarded to the right place on the compositor side and with correct locking
  * semantics.
  *
- * When modifying a TextureClient's data, first call LockDescriptor, modify the
+ * When modifying a DeprecatedTextureClient's data, first call LockDescriptor, modify the
  * data in the descriptor, and then call Unlock. This makes sure that if the
  * data is shared with the compositor, the later will not try to read while the
- * data is being modified (on the other side, TextureHost also has Lock/Unlock
+ * data is being modified (on the other side, DeprecatedTextureHost also has Lock/Unlock
  * semantics).
  * After unlocking, call Updated in order to add the modification to the current
  * layer transaction.
  * Depending on whether the data is shared or copied, Lock/Unlock and Updated
  * can be no-ops. What's important is that the Client/Host pair implement the
  * same semantics.
  *
- * Ownership of the surface descriptor depends on how the TextureClient/Host is
+ * Ownership of the surface descriptor depends on how the DeprecatedTextureClient/Host is
  * used by the CompositableClient/Host.
  */
-class TextureClient : public RefCounted<TextureClient>
+class DeprecatedTextureClient : public RefCounted<DeprecatedTextureClient>
 {
 public:
   typedef gl::SharedTextureHandle SharedTextureHandle;
   typedef gl::GLContext GLContext;
   typedef gl::TextureImage TextureImage;
 
-  virtual ~TextureClient();
+  virtual ~DeprecatedTextureClient();
 
   /* This will return an identifier that can be sent accross a process or
-   * thread boundary and used to construct a TextureHost object
+   * thread boundary and used to construct a DeprecatedTextureHost object
    * which can then be used as a texture for rendering by a compatible
    * compositor. This texture should have been created with the
-   * TextureHostIdentifier specified by the compositor that this identifier
+   * DeprecatedTextureHostIdentifier specified by the compositor that this identifier
    * is to be used with.
    */
   virtual const TextureInfo& GetTextureInfo() const
   {
     return mTextureInfo;
   }
 
-  virtual bool SupportsType(TextureClientType aType) { return false; }
+  virtual bool SupportsType(DeprecatedTextureClientType aType) { return false; }
 
   /**
    * The Lock* methods lock the texture client for drawing into, providing some
    * object that can be used for drawing to. Once the user is finished
    * with the object it should call Unlock.
    */
   virtual gfxImageSurface* LockImageSurface() { return nullptr; }
   virtual gfxASurface* LockSurface() { return nullptr; }
@@ -135,34 +137,34 @@ public:
   AccessMode GetAccessMode() const
   {
     return mAccessMode;
   }
 
   virtual gfxASurface::gfxContentType GetContentType() = 0;
 
 protected:
-  TextureClient(CompositableForwarder* aForwarder,
+  DeprecatedTextureClient(CompositableForwarder* aForwarder,
                 const TextureInfo& aTextureInfo);
 
   CompositableForwarder* mForwarder;
-  // So far all TextureClients use a SurfaceDescriptor, so it makes sense to
+  // So far all DeprecatedTextureClients use a SurfaceDescriptor, so it makes sense to
   // keep the reference here.
   SurfaceDescriptor mDescriptor;
   TextureInfo mTextureInfo;
   AccessMode mAccessMode;
 };
 
-class TextureClientShmem : public TextureClient
+class DeprecatedTextureClientShmem : public DeprecatedTextureClient
 {
 public:
-  TextureClientShmem(CompositableForwarder* aForwarder, const TextureInfo& aTextureInfo);
-  ~TextureClientShmem() { ReleaseResources(); }
+  DeprecatedTextureClientShmem(CompositableForwarder* aForwarder, const TextureInfo& aTextureInfo);
+  ~DeprecatedTextureClientShmem() { ReleaseResources(); }
 
-  virtual bool SupportsType(TextureClientType aType) MOZ_OVERRIDE
+  virtual bool SupportsType(DeprecatedTextureClientType aType) MOZ_OVERRIDE
   {
     return aType == TEXTURE_SHMEM || aType == TEXTURE_CONTENT;
   }
   virtual gfxImageSurface* LockImageSurface() MOZ_OVERRIDE;
   virtual gfxASurface* LockSurface() MOZ_OVERRIDE { return GetSurface(); }
   virtual void Unlock() MOZ_OVERRIDE;
   virtual void EnsureAllocated(gfx::IntSize aSize, gfxASurface::gfxContentType aType) MOZ_OVERRIDE;
 
@@ -176,39 +178,39 @@ private:
   nsRefPtr<gfxImageSurface> mSurfaceAsImage;
 
   gfxASurface::gfxContentType mContentType;
   gfx::IntSize mSize;
 
   friend class CompositingFactory;
 };
 
-class TextureClientShmemYCbCr : public TextureClient
+class DeprecatedTextureClientShmemYCbCr : public DeprecatedTextureClient
 {
 public:
-  TextureClientShmemYCbCr(CompositableForwarder* aForwarder, const TextureInfo& aTextureInfo)
-    : TextureClient(aForwarder, aTextureInfo)
+  DeprecatedTextureClientShmemYCbCr(CompositableForwarder* aForwarder, const TextureInfo& aTextureInfo)
+    : DeprecatedTextureClient(aForwarder, aTextureInfo)
   { }
-  ~TextureClientShmemYCbCr() { ReleaseResources(); }
+  ~DeprecatedTextureClientShmemYCbCr() { ReleaseResources(); }
 
-  virtual bool SupportsType(TextureClientType aType) MOZ_OVERRIDE { return aType == TEXTURE_YCBCR; }
+  virtual bool SupportsType(DeprecatedTextureClientType aType) MOZ_OVERRIDE { return aType == TEXTURE_YCBCR; }
   void EnsureAllocated(gfx::IntSize aSize, gfxASurface::gfxContentType aType) MOZ_OVERRIDE;
   virtual void SetDescriptorFromReply(const SurfaceDescriptor& aDescriptor) MOZ_OVERRIDE;
   virtual void SetDescriptor(const SurfaceDescriptor& aDescriptor) MOZ_OVERRIDE;
   virtual void ReleaseResources();
   virtual gfxASurface::gfxContentType GetContentType() MOZ_OVERRIDE { return gfxASurface::CONTENT_COLOR_ALPHA; }
 };
 
-class TextureClientTile : public TextureClient
+class DeprecatedTextureClientTile : public DeprecatedTextureClient
 {
 public:
-  TextureClientTile(const TextureClientTile& aOther);
-  TextureClientTile(CompositableForwarder* aForwarder,
+  DeprecatedTextureClientTile(const DeprecatedTextureClientTile& aOther);
+  DeprecatedTextureClientTile(CompositableForwarder* aForwarder,
                     const TextureInfo& aTextureInfo);
-  ~TextureClientTile();
+  ~DeprecatedTextureClientTile();
 
   virtual void EnsureAllocated(gfx::IntSize aSize,
                                gfxASurface::gfxContentType aType) MOZ_OVERRIDE;
 
   virtual gfxImageSurface* LockImageSurface() MOZ_OVERRIDE;
 
   gfxReusableSurfaceWrapper* GetReusableSurfaceWrapper()
   {
@@ -225,69 +227,60 @@ public:
 
 private:
   gfxASurface::gfxContentType mContentType;
   nsRefPtr<gfxReusableSurfaceWrapper> mSurface;
 
   friend class CompositingFactory;
 };
 
-/*
- * The logic of converting input image data into a Surface descriptor should be
- * outside of TextureClient. For Image layers we implement them in the AutoLock*
- * idiom so that the states need for the purpose of convertion only exist within
- * the conversion operation, and to avoid adding special interfaces in
- * TextureClient tht are only used in one place and not implemented everywhere.
- * We should do this for all the input data type.
- */
-
 /**
  * Base class for AutoLock*Client.
  * handles lock/unlock
  */
-class AutoLockTextureClient
+class AutoLockDeprecatedTextureClient
 {
 public:
-  AutoLockTextureClient(TextureClient* aTexture)
+  AutoLockDeprecatedTextureClient(DeprecatedTextureClient* aTexture)
   {
-    mTextureClient = aTexture;
+    mDeprecatedTextureClient = aTexture;
     mDescriptor = aTexture->LockSurfaceDescriptor();
   }
 
   SurfaceDescriptor* GetSurfaceDescriptor()
   {
     return mDescriptor;
   }
 
-  virtual ~AutoLockTextureClient()
+  virtual ~AutoLockDeprecatedTextureClient()
   {
-    mTextureClient->Unlock();
+    mDeprecatedTextureClient->Unlock();
   }
 protected:
-  TextureClient* mTextureClient;
+  DeprecatedTextureClient* mDeprecatedTextureClient;
   SurfaceDescriptor* mDescriptor;
 };
 
 /**
  * Writes the content of a PlanarYCbCrImage into a SurfaceDescriptor.
  */
-class AutoLockYCbCrClient : public AutoLockTextureClient
+class AutoLockYCbCrClient : public AutoLockDeprecatedTextureClient
 {
 public:
-  AutoLockYCbCrClient(TextureClient* aTexture) : AutoLockTextureClient(aTexture) {}
+  AutoLockYCbCrClient(DeprecatedTextureClient* aTexture) : AutoLockDeprecatedTextureClient(aTexture) {}
   bool Update(PlanarYCbCrImage* aImage);
 protected:
-  bool EnsureTextureClient(PlanarYCbCrImage* aImage);
+  bool EnsureDeprecatedTextureClient(PlanarYCbCrImage* aImage);
 };
 
 /**
  * Writes the content of a gfxASurface into a SurfaceDescriptor.
  */
-class AutoLockShmemClient : public AutoLockTextureClient
+class AutoLockShmemClient : public AutoLockDeprecatedTextureClient
 {
 public:
-  AutoLockShmemClient(TextureClient* aTexture) : AutoLockTextureClient(aTexture) {}
+  AutoLockShmemClient(DeprecatedTextureClient* aTexture) : AutoLockDeprecatedTextureClient(aTexture) {}
   bool Update(Image* aImage, uint32_t aContentFlags, gfxPattern* pat);
 };
 
 }
 }
 #endif
--- a/gfx/layers/client/TiledContentClient.cpp
+++ b/gfx/layers/client/TiledContentClient.cpp
@@ -200,22 +200,22 @@ BasicTiledLayerBuffer::PaintThebes(const
 }
 
 BasicTiledLayerTile
 BasicTiledLayerBuffer::ValidateTileInternal(BasicTiledLayerTile aTile,
                                             const nsIntPoint& aTileOrigin,
                                             const nsIntRect& aDirtyRect)
 {
   if (aTile.IsPlaceholderTile()) {
-    RefPtr<TextureClient> textureClient =
-      new TextureClientTile(mManager, TextureInfo(BUFFER_TILED));
-    aTile.mTextureClient = static_cast<TextureClientTile*>(textureClient.get());
+    RefPtr<DeprecatedTextureClient> textureClient =
+      new DeprecatedTextureClientTile(mManager, TextureInfo(BUFFER_TILED));
+    aTile.mDeprecatedTextureClient = static_cast<DeprecatedTextureClientTile*>(textureClient.get());
   }
-  aTile.mTextureClient->EnsureAllocated(gfx::IntSize(GetTileLength(), GetTileLength()), GetContentType());
-  gfxASurface* writableSurface = aTile.mTextureClient->LockImageSurface();
+  aTile.mDeprecatedTextureClient->EnsureAllocated(gfx::IntSize(GetTileLength(), GetTileLength()), GetContentType());
+  gfxASurface* writableSurface = aTile.mDeprecatedTextureClient->LockImageSurface();
   // Bug 742100, this gfxContext really should live on the stack.
   nsRefPtr<gfxContext> ctxt = new gfxContext(writableSurface);
 
   if (mSinglePaintBuffer) {
     gfxRect drawRect(aDirtyRect.x - aTileOrigin.x, aDirtyRect.y - aTileOrigin.y,
                      aDirtyRect.width, aDirtyRect.height);
 
     ctxt->SetOperator(gfxContext::OPERATOR_SOURCE);
@@ -466,17 +466,17 @@ BasicTiledLayerBuffer::ProgressiveUpdate
 BasicTiledLayerBuffer
 BasicTiledLayerBuffer::DeepCopy() const
 {
   BasicTiledLayerBuffer result = *this;
 
   for (size_t i = 0; i < result.mRetainedTiles.Length(); i++) {
     if (result.mRetainedTiles[i].IsPlaceholderTile()) continue;
 
-    result.mRetainedTiles[i].mTextureClient =
-      new TextureClientTile(*result.mRetainedTiles[i].mTextureClient);
+    result.mRetainedTiles[i].mDeprecatedTextureClient =
+      new DeprecatedTextureClientTile(*result.mRetainedTiles[i].mDeprecatedTextureClient);
   }
 
   return result;
 }
 
 }
 }
--- a/gfx/layers/client/TiledContentClient.h
+++ b/gfx/layers/client/TiledContentClient.h
@@ -18,58 +18,58 @@ namespace layers {
  * each tile keeps a reference to a texture client. The texture client
  * is backed by a gfxReusableSurfaceWrapper that implements a
  * copy-on-write mechanism while locked. The tile should be
  * locked before being sent to the compositor and unlocked
  * as soon as it is uploaded to prevent a copy.
  * Ideal place to store per tile debug information.
  */
 struct BasicTiledLayerTile {
-  RefPtr<TextureClientTile> mTextureClient;
+  RefPtr<DeprecatedTextureClientTile> mDeprecatedTextureClient;
 #ifdef GFX_TILEDLAYER_DEBUG_OVERLAY
   TimeStamp        mLastUpdate;
 #endif
 
   // Placeholder
   BasicTiledLayerTile()
-    : mTextureClient(nullptr)
+    : mDeprecatedTextureClient(nullptr)
   {}
 
   BasicTiledLayerTile(const BasicTiledLayerTile& o) {
-    mTextureClient = o.mTextureClient;
+    mDeprecatedTextureClient = o.mDeprecatedTextureClient;
 #ifdef GFX_TILEDLAYER_DEBUG_OVERLAY
     mLastUpdate = o.mLastUpdate;
 #endif
   }
   BasicTiledLayerTile& operator=(const BasicTiledLayerTile& o) {
     if (this == &o) return *this;
-    mTextureClient = o.mTextureClient;
+    mDeprecatedTextureClient = o.mDeprecatedTextureClient;
 #ifdef GFX_TILEDLAYER_DEBUG_OVERLAY
     mLastUpdate = o.mLastUpdate;
 #endif
     return *this;
   }
   bool operator== (const BasicTiledLayerTile& o) const {
-    return mTextureClient == o.mTextureClient;
+    return mDeprecatedTextureClient == o.mDeprecatedTextureClient;
   }
   bool operator!= (const BasicTiledLayerTile& o) const {
-    return mTextureClient != o.mTextureClient;
+    return mDeprecatedTextureClient != o.mDeprecatedTextureClient;
   }
 
-  bool IsPlaceholderTile() { return mTextureClient == nullptr; }
+  bool IsPlaceholderTile() { return mDeprecatedTextureClient == nullptr; }
 
   void ReadUnlock() {
     GetSurface()->ReadUnlock();
   }
   void ReadLock() {
     GetSurface()->ReadLock();
   }
 
   gfxReusableSurfaceWrapper* GetSurface() {
-    return mTextureClient->GetReusableSurfaceWrapper();
+    return mDeprecatedTextureClient->GetReusableSurfaceWrapper();
   }
 };
 
 /**
  * This struct stores all the data necessary to perform a paint so that it
  * doesn't need to be recalculated on every repeated transaction.
  */
 struct BasicTiledLayerPaintData {
--- a/gfx/layers/composite/CompositableHost.cpp
+++ b/gfx/layers/composite/CompositableHost.cpp
@@ -12,33 +12,33 @@
 
 namespace mozilla {
 namespace layers {
 
 bool
 CompositableHost::Update(const SurfaceDescriptor& aImage,
                          SurfaceDescriptor* aResult)
 {
-  if (!GetTextureHost()) {
+  if (!GetDeprecatedTextureHost()) {
     *aResult = aImage;
     return false;
   }
-  MOZ_ASSERT(!GetTextureHost()->GetBuffer(),
+  MOZ_ASSERT(!GetDeprecatedTextureHost()->GetBuffer(),
              "This path not suitable for texture-level double buffering.");
-  GetTextureHost()->Update(aImage);
+  GetDeprecatedTextureHost()->Update(aImage);
   *aResult = aImage;
-  return GetTextureHost()->IsValid();
+  return GetDeprecatedTextureHost()->IsValid();
 }
 
 bool
 CompositableHost::AddMaskEffect(EffectChain& aEffects,
                                 const gfx::Matrix4x4& aTransform,
                                 bool aIs3D)
 {
-  RefPtr<TextureSource> source = GetTextureHost();
+  RefPtr<TextureSource> source = GetDeprecatedTextureHost();
 
   if (!source) {
     NS_WARNING("Using compositable with no texture host as mask layer");
     return false;
   }
 
   RefPtr<EffectMask> effect = new EffectMask(source,
                                              source->GetSize(),
@@ -72,17 +72,17 @@ CompositableHost::Create(const TextureIn
     result = new ContentHostIncremental(aTextureInfo);
     return result;
   default:
     MOZ_CRASH("Unknown CompositableType");
   }
 }
 
 void
-CompositableHost::DumpTextureHost(FILE* aFile, TextureHost* aTexture)
+CompositableHost::DumpDeprecatedTextureHost(FILE* aFile, DeprecatedTextureHost* aTexture)
 {
   if (!aTexture) {
     return;
   }
   nsRefPtr<gfxImageSurface> surf = aTexture->GetAsSurface();
   if (!surf) {
     return;
   }
--- a/gfx/layers/composite/CompositableHost.h
+++ b/gfx/layers/composite/CompositableHost.h
@@ -23,17 +23,17 @@ struct TiledLayerProperties
   nsIntRegion mValidRegion;
   gfxRect mDisplayPort;
   gfxSize mEffectiveResolution;
   gfxRect mCompositionBounds;
   bool mRetainTiles;
 };
 
 class Layer;
-class TextureHost;
+class DeprecatedTextureHost;
 class SurfaceDescriptor;
 
 /**
  * The compositor-side counterpart to CompositableClient. Responsible for
  * updating textures and data about textures from IPC and how textures are
  * composited (tiling, double buffering, etc.).
  *
  * Update (for images/canvases) and UpdateThebes (for Thebes) are called during
@@ -131,38 +131,38 @@ public:
    * host and will vary between types of compositable.
    * aSurface - the new or existing texture host should support surface
    * descriptors of the same type and, if necessary, this specific surface
    * descriptor. Whether it is necessary or not depends on the protocol between
    * the compositable client and host.
    * aAllocator - the allocator used to allocate and de-allocate resources.
    * aTextureInfo - contains flags for the texture.
    */
-  virtual void EnsureTextureHost(TextureIdentifier aTextureId,
+  virtual void EnsureDeprecatedTextureHost(TextureIdentifier aTextureId,
                                  const SurfaceDescriptor& aSurface,
                                  ISurfaceAllocator* aAllocator,
                                  const TextureInfo& aTextureInfo) = 0;
 
   /**
    * Ensure that a suitable texture host exists in this compsitable.
    *
    * Only used with ContentHostIncremental.
    *
    * No SurfaceDescriptor or TextureIdentifier is provider as we
    * don't have a single surface for the texture contents, and we
    * need to allocate our own one to be updated later.
    */
-  virtual void EnsureTextureHostIncremental(ISurfaceAllocator* aAllocator,
+  virtual void EnsureDeprecatedTextureHostIncremental(ISurfaceAllocator* aAllocator,
                                             const TextureInfo& aTextureInfo,
                                             const nsIntRect& aBufferRect)
   {
     MOZ_ASSERT(false, "should be implemented or not used");
   }
 
-  virtual TextureHost* GetTextureHost() { return nullptr; }
+  virtual DeprecatedTextureHost* GetDeprecatedTextureHost() { return nullptr; }
 
   virtual LayerRenderState GetRenderState() = 0;
 
   virtual void SetPictureRect(const nsIntRect& aPictureRect)
   {
     MOZ_ASSERT(false, "Should have been overridden");
   }
 
@@ -193,17 +193,17 @@ public:
   void Detach() {
     SetLayer(nullptr);
     SetCompositor(nullptr);
   }
 
   virtual void Dump(FILE* aFile=NULL,
                     const char* aPrefix="",
                     bool aDumpHtml=false) { }
-  static void DumpTextureHost(FILE* aFile, TextureHost* aTexture);
+  static void DumpDeprecatedTextureHost(FILE* aFile, DeprecatedTextureHost* aTexture);
 
 #ifdef MOZ_DUMP_PAINTING
   virtual already_AddRefed<gfxImageSurface> GetAsSurface() { return nullptr; }
 #endif
 
 #ifdef MOZ_LAYERS_HAVE_LOG
   virtual void PrintInfo(nsACString& aTo, const char* aPrefix) { }
 #endif
--- a/gfx/layers/composite/ContentHost.cpp
+++ b/gfx/layers/composite/ContentHost.cpp
@@ -16,56 +16,56 @@ ContentHostBase::ContentHostBase(const T
   : ContentHost(aTextureInfo)
   , mPaintWillResample(false)
   , mInitialised(false)
 {}
 
 ContentHostBase::~ContentHostBase()
 {}
 
-TextureHost*
-ContentHostBase::GetTextureHost()
+DeprecatedTextureHost*
+ContentHostBase::GetDeprecatedTextureHost()
 {
-  return mTextureHost;
+  return mDeprecatedTextureHost;
 }
 
 void
 ContentHostBase::DestroyFrontHost()
 {
-  MOZ_ASSERT(!mTextureHost || mTextureHost->GetDeAllocator(),
+  MOZ_ASSERT(!mDeprecatedTextureHost || mDeprecatedTextureHost->GetDeAllocator(),
              "We won't be able to destroy our SurfaceDescriptor");
-  MOZ_ASSERT(!mTextureHostOnWhite || mTextureHostOnWhite->GetDeAllocator(),
+  MOZ_ASSERT(!mDeprecatedTextureHostOnWhite || mDeprecatedTextureHostOnWhite->GetDeAllocator(),
              "We won't be able to destroy our SurfaceDescriptor");
-  mTextureHost = nullptr;
-  mTextureHostOnWhite = nullptr;
+  mDeprecatedTextureHost = nullptr;
+  mDeprecatedTextureHostOnWhite = nullptr;
 }
 
 void
 ContentHostBase::Composite(EffectChain& aEffectChain,
                            float aOpacity,
                            const gfx::Matrix4x4& aTransform,
                            const Point& aOffset,
                            const Filter& aFilter,
                            const Rect& aClipRect,
                            const nsIntRegion* aVisibleRegion,
                            TiledLayerProperties* aLayerProperties)
 {
   NS_ASSERTION(aVisibleRegion, "Requires a visible region");
 
-  AutoLockTextureHost lock(mTextureHost);
-  AutoLockTextureHost lockOnWhite(mTextureHostOnWhite);
+  AutoLockDeprecatedTextureHost lock(mDeprecatedTextureHost);
+  AutoLockDeprecatedTextureHost lockOnWhite(mDeprecatedTextureHostOnWhite);
 
-  if (!mTextureHost ||
+  if (!mDeprecatedTextureHost ||
       !lock.IsValid() ||
       !lockOnWhite.IsValid()) {
     return;
   }
 
   RefPtr<TexturedEffect> effect =
-    CreateTexturedEffect(mTextureHost, mTextureHostOnWhite, aFilter);
+    CreateTexturedEffect(mDeprecatedTextureHost, mDeprecatedTextureHostOnWhite, aFilter);
 
   aEffectChain.mPrimaryEffect = effect;
 
   nsIntRegion tmpRegion;
   const nsIntRegion* renderRegion;
   if (PaintWillResample()) {
     // If we're resampling, then the texture image will contain exactly the
     // entire visible region's bounds, and we should draw it all in one quad
@@ -76,17 +76,17 @@ ContentHostBase::Composite(EffectChain& 
     renderRegion = aVisibleRegion;
   }
 
   nsIntRegion region(*renderRegion);
   nsIntPoint origin = GetOriginOffset();
   region.MoveBy(-origin);           // translate into TexImage space, buffer origin might not be at texture (0,0)
 
   // Figure out the intersecting draw region
-  TextureSource* source = mTextureHost;
+  TextureSource* source = mDeprecatedTextureHost;
   MOZ_ASSERT(source);
   gfx::IntSize texSize = source->GetSize();
   nsIntRect textureRect = nsIntRect(0, 0, texSize.width, texSize.height);
   textureRect.MoveBy(region.GetBounds().TopLeft());
   nsIntRegion subregion;
   subregion.And(region, textureRect);
   if (subregion.IsEmpty()) {
     // Region is empty, nothing to draw
@@ -108,18 +108,18 @@ ContentHostBase::Composite(EffectChain& 
   }
 
   TileIterator* tileIter = source->AsTileIterator();
   TileIterator* iterOnWhite = nullptr;
   if (tileIter) {
     tileIter->BeginTileIteration();
   }
 
-  if (mTextureHostOnWhite) {
-    iterOnWhite = mTextureHostOnWhite->AsTileIterator();
+  if (mDeprecatedTextureHostOnWhite) {
+    iterOnWhite = mDeprecatedTextureHostOnWhite->AsTileIterator();
     MOZ_ASSERT(!tileIter || tileIter->GetTileCount() == iterOnWhite->GetTileCount(),
                "Tile count mismatch on component alpha texture");
     if (iterOnWhite) {
       iterOnWhite->BeginTileIteration();
     }
   }
 
   bool usingTiles = (tileIter && tileIter->GetTileCount() > 1);
@@ -198,72 +198,72 @@ ContentHostBase::Composite(EffectChain& 
     iterOnWhite->EndTileIteration();
   }
 }
 
 void
 ContentHostBase::SetCompositor(Compositor* aCompositor)
 {
   CompositableHost::SetCompositor(aCompositor);
-  if (mTextureHost) {
-    mTextureHost->SetCompositor(aCompositor);
+  if (mDeprecatedTextureHost) {
+    mDeprecatedTextureHost->SetCompositor(aCompositor);
   }
-  if (mTextureHostOnWhite) {
-    mTextureHostOnWhite->SetCompositor(aCompositor);
+  if (mDeprecatedTextureHostOnWhite) {
+    mDeprecatedTextureHostOnWhite->SetCompositor(aCompositor);
   }
 }
 
 void
 ContentHostBase::Dump(FILE* aFile,
                       const char* aPrefix,
                       bool aDumpHtml)
 {
   if (!aFile) {
     aFile = stderr;
   }
   if (aDumpHtml) {
     fprintf(aFile, "<ul>");
   }
-  if (mTextureHost) {
+  if (mDeprecatedTextureHost) {
     fprintf(aFile, "%s", aPrefix);
     fprintf(aFile, aDumpHtml ? "<li> <a href=" : "Front buffer: ");
-    DumpTextureHost(aFile, mTextureHost);
+    DumpDeprecatedTextureHost(aFile, mDeprecatedTextureHost);
     fprintf(aFile, aDumpHtml ? "> Front buffer </a></li> " : " ");
   }
-  if (mTextureHostOnWhite) {
+  if (mDeprecatedTextureHostOnWhite) {
     fprintf(aFile, "%s", aPrefix);
-    fprintf(aFile, aDumpHtml ? "<li> <a href=" : "TextureHost on white: ");
-    DumpTextureHost(aFile, mTextureHostOnWhite);
+    fprintf(aFile, aDumpHtml ? "<li> <a href=" : "DeprecatedTextureHost on white: ");
+    DumpDeprecatedTextureHost(aFile, mDeprecatedTextureHostOnWhite);
     fprintf(aFile, aDumpHtml ? "> Front buffer on white </a> </li> " : " ");
   }
   if (aDumpHtml) {
     fprintf(aFile, "</ul>");
   }
 
 }
 
 ContentHostSingleBuffered::~ContentHostSingleBuffered()
 {
   DestroyTextures();
   DestroyFrontHost();
 }
 
 void
-ContentHostSingleBuffered::EnsureTextureHost(TextureIdentifier aTextureId,
+ContentHostSingleBuffered::EnsureDeprecatedTextureHost(TextureIdentifier aTextureId,
                                              const SurfaceDescriptor& aSurface,
                                              ISurfaceAllocator* aAllocator,
                                              const TextureInfo& aTextureInfo)
 {
   MOZ_ASSERT(aTextureId == TextureFront ||
              aTextureId == TextureOnWhiteFront);
-  RefPtr<TextureHost> *newHost =
+  RefPtr<DeprecatedTextureHost> *newHost =
     (aTextureId == TextureFront) ? &mNewFrontHost : &mNewFrontHostOnWhite;
 
-  *newHost = TextureHost::CreateTextureHost(aSurface.type(),
-                                            aTextureInfo.mTextureHostFlags,
+  *newHost = DeprecatedTextureHost::CreateDeprecatedTextureHost(aSurface.type(),
+                                            aTextureInfo.mDeprecatedTextureHostFlags,
                                             aTextureInfo.mTextureFlags);
 
   (*newHost)->SetBuffer(new SurfaceDescriptor(aSurface), aAllocator);
   Compositor* compositor = GetCompositor();
   if (compositor) {
     (*newHost)->SetCompositor(compositor);
   }
 }
@@ -273,43 +273,43 @@ ContentHostSingleBuffered::DestroyTextur
 {
   MOZ_ASSERT(!mNewFrontHost || mNewFrontHost->GetDeAllocator(),
              "We won't be able to destroy our SurfaceDescriptor");
   MOZ_ASSERT(!mNewFrontHostOnWhite || mNewFrontHostOnWhite->GetDeAllocator(),
              "We won't be able to destroy our SurfaceDescriptor");
   mNewFrontHost = nullptr;
   mNewFrontHostOnWhite = nullptr;
 
-  // don't touch mTextureHost, we might need it for compositing
+  // don't touch mDeprecatedTextureHost, we might need it for compositing
 }
 
 void
 ContentHostSingleBuffered::UpdateThebes(const ThebesBufferData& aData,
                                         const nsIntRegion& aUpdated,
                                         const nsIntRegion& aOldValidRegionBack,
                                         nsIntRegion* aUpdatedRegionBack)
 {
   aUpdatedRegionBack->SetEmpty();
 
-  if (!mTextureHost && !mNewFrontHost) {
+  if (!mDeprecatedTextureHost && !mNewFrontHost) {
     mInitialised = false;
     return;
   }
 
   if (mNewFrontHost) {
     DestroyFrontHost();
-    mTextureHost = mNewFrontHost;
+    mDeprecatedTextureHost = mNewFrontHost;
     mNewFrontHost = nullptr;
     if (mNewFrontHostOnWhite) {
-      mTextureHostOnWhite = mNewFrontHostOnWhite;
+      mDeprecatedTextureHostOnWhite = mNewFrontHostOnWhite;
       mNewFrontHostOnWhite = nullptr;
     }
   }
 
-  MOZ_ASSERT(mTextureHost);
+  MOZ_ASSERT(mDeprecatedTextureHost);
   MOZ_ASSERT(!mNewFrontHostOnWhite, "New white host without a new black?");
 
   // updated is in screen coordinates. Convert it to buffer coordinates.
   nsIntRegion destRegion(aUpdated);
   destRegion.MoveBy(-aData.rect().TopLeft());
 
   // Correct for rotation
   destRegion.MoveBy(aData.rotation());
@@ -321,40 +321,40 @@ ContentHostSingleBuffered::UpdateThebes(
 
   // There's code to make sure that updated regions don't cross rotation
   // boundaries, so assert here that this is the case
   MOZ_ASSERT((destBounds.x % size.width) + destBounds.width <= size.width,
                "updated region lies across rotation boundaries!");
   MOZ_ASSERT((destBounds.y % size.height) + destBounds.height <= size.height,
                "updated region lies across rotation boundaries!");
 
-  mTextureHost->Update(*mTextureHost->GetBuffer(), &destRegion);
-  if (mTextureHostOnWhite) {
-    mTextureHostOnWhite->Update(*mTextureHostOnWhite->GetBuffer(), &destRegion);
+  mDeprecatedTextureHost->Update(*mDeprecatedTextureHost->GetBuffer(), &destRegion);
+  if (mDeprecatedTextureHostOnWhite) {
+    mDeprecatedTextureHostOnWhite->Update(*mDeprecatedTextureHostOnWhite->GetBuffer(), &destRegion);
   }
   mInitialised = true;
 
   mBufferRect = aData.rect();
   mBufferRotation = aData.rotation();
 }
 
 ContentHostDoubleBuffered::~ContentHostDoubleBuffered()
 {
   DestroyTextures();
   DestroyFrontHost();
 }
 
 void
-ContentHostDoubleBuffered::EnsureTextureHost(TextureIdentifier aTextureId,
+ContentHostDoubleBuffered::EnsureDeprecatedTextureHost(TextureIdentifier aTextureId,
                                              const SurfaceDescriptor& aSurface,
                                              ISurfaceAllocator* aAllocator,
                                              const TextureInfo& aTextureInfo)
 {
-  RefPtr<TextureHost> newHost = TextureHost::CreateTextureHost(aSurface.type(),
-                                                               aTextureInfo.mTextureHostFlags,
+  RefPtr<DeprecatedTextureHost> newHost = DeprecatedTextureHost::CreateDeprecatedTextureHost(aSurface.type(),
+                                                               aTextureInfo.mDeprecatedTextureHostFlags,
                                                                aTextureInfo.mTextureFlags);
 
   newHost->SetBuffer(new SurfaceDescriptor(aSurface), aAllocator);
 
   Compositor* compositor = GetCompositor();
   if (compositor) {
     newHost->SetCompositor(compositor);
   }
@@ -403,57 +403,57 @@ ContentHostDoubleBuffered::DestroyTextur
   }
 
   if (mBackHostOnWhite) {
     MOZ_ASSERT(mBackHostOnWhite->GetDeAllocator(),
                "We won't be able to destroy our SurfaceDescriptor");
     mBackHostOnWhite = nullptr;
   }
 
-  // don't touch mTextureHost, we might need it for compositing
+  // don't touch mDeprecatedTextureHost, we might need it for compositing
 }
 
 void
 ContentHostDoubleBuffered::UpdateThebes(const ThebesBufferData& aData,
                                         const nsIntRegion& aUpdated,
                                         const nsIntRegion& aOldValidRegionBack,
                                         nsIntRegion* aUpdatedRegionBack)
 {
-  if (!mTextureHost && !mNewFrontHost) {
+  if (!mDeprecatedTextureHost && !mNewFrontHost) {
     mInitialised = false;
 
     *aUpdatedRegionBack = aUpdated;
     return;
   }
 
   if (mNewFrontHost) {
     DestroyFrontHost();
-    mTextureHost = mNewFrontHost;
+    mDeprecatedTextureHost = mNewFrontHost;
     mNewFrontHost = nullptr;
     if (mNewFrontHostOnWhite) {
-      mTextureHostOnWhite = mNewFrontHostOnWhite;
+      mDeprecatedTextureHostOnWhite = mNewFrontHostOnWhite;
       mNewFrontHostOnWhite = nullptr;
     }
   }
 
-  MOZ_ASSERT(mTextureHost);
+  MOZ_ASSERT(mDeprecatedTextureHost);
   MOZ_ASSERT(!mNewFrontHostOnWhite, "New white host without a new black?");
   MOZ_ASSERT(mBackHost);
 
-  RefPtr<TextureHost> oldFront = mTextureHost;
-  mTextureHost = mBackHost;
+  RefPtr<DeprecatedTextureHost> oldFront = mDeprecatedTextureHost;
+  mDeprecatedTextureHost = mBackHost;
   mBackHost = oldFront;
 
-  oldFront = mTextureHostOnWhite;
-  mTextureHostOnWhite = mBackHostOnWhite;
+  oldFront = mDeprecatedTextureHostOnWhite;
+  mDeprecatedTextureHostOnWhite = mBackHostOnWhite;
   mBackHostOnWhite = oldFront;
 
-  mTextureHost->Update(*mTextureHost->GetBuffer());
-  if (mTextureHostOnWhite) {
-    mTextureHostOnWhite->Update(*mTextureHostOnWhite->GetBuffer());
+  mDeprecatedTextureHost->Update(*mDeprecatedTextureHost->GetBuffer());
+  if (mDeprecatedTextureHostOnWhite) {
+    mDeprecatedTextureHostOnWhite->Update(*mDeprecatedTextureHostOnWhite->GetBuffer());
   }
   mInitialised = true;
 
   mBufferRect = aData.rect();
   mBufferRotation = aData.rotation();
 
   *aUpdatedRegionBack = aUpdated;
 
@@ -463,17 +463,17 @@ ContentHostDoubleBuffered::UpdateThebes(
   //
   // NB: we rely here on the fact that mValidRegion is initialized to
   // empty, and that the first time Swap() is called we don't have a
   // valid front buffer that we're going to return to content.
   mValidRegionForNextBackBuffer = aOldValidRegionBack;
 }
 
 void
-ContentHostIncremental::EnsureTextureHostIncremental(ISurfaceAllocator* aAllocator,
+ContentHostIncremental::EnsureDeprecatedTextureHostIncremental(ISurfaceAllocator* aAllocator,
                                                      const TextureInfo& aTextureInfo,
                                                      const nsIntRect& aBufferRect)
 {
   mUpdateList.AppendElement(new TextureCreationRequest(aTextureInfo,
                                                        aBufferRect));
   mDeAllocator = aAllocator;
 }
 
@@ -499,37 +499,37 @@ ContentHostIncremental::ProcessTextureUp
     mUpdateList[i]->Execute(this);
   }
   mUpdateList.Clear();
 }
 
 void
 ContentHostIncremental::TextureCreationRequest::Execute(ContentHostIncremental* aHost)
 {
-  RefPtr<TextureHost> newHost =
-    TextureHost::CreateTextureHost(SurfaceDescriptor::TShmem,
-                                   mTextureInfo.mTextureHostFlags,
+  RefPtr<DeprecatedTextureHost> newHost =
+    DeprecatedTextureHost::CreateDeprecatedTextureHost(SurfaceDescriptor::TShmem,
+                                   mTextureInfo.mDeprecatedTextureHostFlags,
                                    mTextureInfo.mTextureFlags);
   Compositor* compositor = aHost->GetCompositor();
   if (compositor) {
     newHost->SetCompositor(compositor);
   }
-  RefPtr<TextureHost> newHostOnWhite;
+  RefPtr<DeprecatedTextureHost> newHostOnWhite;
   if (mTextureInfo.mTextureFlags & ComponentAlpha) {
     newHostOnWhite =
-      TextureHost::CreateTextureHost(SurfaceDescriptor::TShmem,
-                                     mTextureInfo.mTextureHostFlags,
+      DeprecatedTextureHost::CreateDeprecatedTextureHost(SurfaceDescriptor::TShmem,
+                                     mTextureInfo.mDeprecatedTextureHostFlags,
                                      mTextureInfo.mTextureFlags);
     Compositor* compositor = aHost->GetCompositor();
     if (compositor) {
       newHostOnWhite->SetCompositor(compositor);
     }
   }
 
-  if (mTextureInfo.mTextureHostFlags & TEXTURE_HOST_COPY_PREVIOUS) {
+  if (mTextureInfo.mDeprecatedTextureHostFlags & TEXTURE_HOST_COPY_PREVIOUS) {
     nsIntRect bufferRect = aHost->mBufferRect;
     nsIntPoint bufferRotation = aHost->mBufferRotation;
     nsIntRect overlap;
 
     // The buffer looks like:
     //  ______
     // |1  |2 |  Where the center point is offset by mBufferRotation from the top-left corner.
     // |___|__|
@@ -590,56 +590,56 @@ ContentHostIncremental::TextureCreationR
 
     // transform to destBuffer space
     dstRect              .MoveBy(-mBufferRect.TopLeft());
     dstRectDrawTopRight  .MoveBy(-mBufferRect.TopLeft());
     dstRectDrawTopLeft   .MoveBy(-mBufferRect.TopLeft());
     dstRectDrawBottomLeft.MoveBy(-mBufferRect.TopLeft());
 
     newHost->EnsureBuffer(mBufferRect.Size(),
-                          ContentForFormat(aHost->mTextureHost->GetFormat()));
+                          ContentForFormat(aHost->mDeprecatedTextureHost->GetFormat()));
 
-    aHost->mTextureHost->CopyTo(srcRect, newHost, dstRect);
+    aHost->mDeprecatedTextureHost->CopyTo(srcRect, newHost, dstRect);
     if (bufferRotation != nsIntPoint(0, 0)) {
       // Draw the remaining quadrants. We call BlitTextureImage 3 extra
       // times instead of doing a single draw call because supporting that
       // with a tiled source is quite tricky.
 
       if (!srcRectDrawTopRight.IsEmpty())
-        aHost->mTextureHost->CopyTo(srcRectDrawTopRight,
+        aHost->mDeprecatedTextureHost->CopyTo(srcRectDrawTopRight,
                                           newHost, dstRectDrawTopRight);
       if (!srcRectDrawTopLeft.IsEmpty())
-        aHost->mTextureHost->CopyTo(srcRectDrawTopLeft,
+        aHost->mDeprecatedTextureHost->CopyTo(srcRectDrawTopLeft,
                                           newHost, dstRectDrawTopLeft);
       if (!srcRectDrawBottomLeft.IsEmpty())
-        aHost->mTextureHost->CopyTo(srcRectDrawBottomLeft,
+        aHost->mDeprecatedTextureHost->CopyTo(srcRectDrawBottomLeft,
                                           newHost, dstRectDrawBottomLeft);
     }
 
     if (newHostOnWhite) {
       newHostOnWhite->EnsureBuffer(mBufferRect.Size(),
-                                   ContentForFormat(aHost->mTextureHostOnWhite->GetFormat()));
-      aHost->mTextureHostOnWhite->CopyTo(srcRect, newHostOnWhite, dstRect);
+                                   ContentForFormat(aHost->mDeprecatedTextureHostOnWhite->GetFormat()));
+      aHost->mDeprecatedTextureHostOnWhite->CopyTo(srcRect, newHostOnWhite, dstRect);
       if (bufferRotation != nsIntPoint(0, 0)) {
         // draw the remaining quadrants
         if (!srcRectDrawTopRight.IsEmpty())
-          aHost->mTextureHostOnWhite->CopyTo(srcRectDrawTopRight,
+          aHost->mDeprecatedTextureHostOnWhite->CopyTo(srcRectDrawTopRight,
                                                    newHostOnWhite, dstRectDrawTopRight);
         if (!srcRectDrawTopLeft.IsEmpty())
-          aHost->mTextureHostOnWhite->CopyTo(srcRectDrawTopLeft,
+          aHost->mDeprecatedTextureHostOnWhite->CopyTo(srcRectDrawTopLeft,
                                                    newHostOnWhite, dstRectDrawTopLeft);
         if (!srcRectDrawBottomLeft.IsEmpty())
-          aHost->mTextureHostOnWhite->CopyTo(srcRectDrawBottomLeft,
+          aHost->mDeprecatedTextureHostOnWhite->CopyTo(srcRectDrawBottomLeft,
                                                    newHostOnWhite, dstRectDrawBottomLeft);
       }
     }
   }
 
-  aHost->mTextureHost = newHost;
-  aHost->mTextureHostOnWhite = newHostOnWhite;
+  aHost->mDeprecatedTextureHost = newHost;
+  aHost->mDeprecatedTextureHostOnWhite = newHostOnWhite;
 
   aHost->mBufferRect = mBufferRect;
   aHost->mBufferRotation = nsIntPoint();
 }
 
 nsIntRect
 ContentHostIncremental::TextureUpdateRequest::GetQuadrantRectangle(XSide aXSide,
                                                                    YSide aYSide) const
@@ -668,19 +668,19 @@ ContentHostIncremental::TextureUpdateReq
   nsIntRect quadrantRect = GetQuadrantRectangle(sideX, sideY);
   NS_ASSERTION(quadrantRect.Contains(drawBounds), "Messed up quadrants");
 
   mUpdated.MoveBy(-nsIntPoint(quadrantRect.x, quadrantRect.y));
 
   nsIntPoint offset = -mUpdated.GetBounds().TopLeft();
 
   if (mTextureId == TextureFront) {
-    aHost->mTextureHost->Update(mDescriptor, &mUpdated, &offset);
+    aHost->mDeprecatedTextureHost->Update(mDescriptor, &mUpdated, &offset);
   } else {
-    aHost->mTextureHostOnWhite->Update(mDescriptor, &mUpdated, &offset);
+    aHost->mDeprecatedTextureHostOnWhite->Update(mDescriptor, &mUpdated, &offset);
   }
 }
 
 #ifdef MOZ_LAYERS_HAVE_LOG
 void
 ContentHostSingleBuffered::PrintInfo(nsACString& aTo, const char* aPrefix)
 {
   aTo += aPrefix;
@@ -690,19 +690,19 @@ ContentHostSingleBuffered::PrintInfo(nsA
   AppendToString(aTo, mBufferRotation, " [buffer-rotation=", "]");
   if (PaintWillResample()) {
     aTo += " [paint-will-resample]";
   }
 
   nsAutoCString pfx(aPrefix);
   pfx += "  ";
 
-  if (mTextureHost) {
+  if (mDeprecatedTextureHost) {
     aTo += "\n";
-    mTextureHost->PrintInfo(aTo, pfx.get());
+    mDeprecatedTextureHost->PrintInfo(aTo, pfx.get());
   }
 }
 
 void
 ContentHostDoubleBuffered::PrintInfo(nsACString& aTo, const char* aPrefix)
 {
   aTo += aPrefix;
   aTo += nsPrintfCString("ContentHostDoubleBuffered (0x%p)", this);
@@ -711,19 +711,19 @@ ContentHostDoubleBuffered::PrintInfo(nsA
   AppendToString(aTo, mBufferRotation, " [buffer-rotation=", "]");
   if (PaintWillResample()) {
     aTo += " [paint-will-resample]";
   }
 
   nsAutoCString prefix(aPrefix);
   prefix += "  ";
 
-  if (mTextureHost) {
+  if (mDeprecatedTextureHost) {
     aTo += "\n";
-    mTextureHost->PrintInfo(aTo, prefix.get());
+    mDeprecatedTextureHost->PrintInfo(aTo, prefix.get());
   }
 
   if (mBackHost) {
     aTo += "\n";
     mBackHost->PrintInfo(aTo, prefix.get());
   }
 }
 #endif
@@ -738,23 +738,23 @@ ContentHostDoubleBuffered::Dump(FILE* aF
     aFile = stderr;
   }
   if (aDumpHtml) {
     fprintf(aFile, "<ul>");
   }
   if (mBackHost) {
     fprintf(aFile, "%s", aPrefix);
     fprintf(aFile, aDumpHtml ? "<li> <a href=" : "Back buffer: ");
-    DumpTextureHost(aFile, mBackHost);
+    DumpDeprecatedTextureHost(aFile, mBackHost);
     fprintf(aFile, aDumpHtml ? " >Back buffer</a></li>" : " ");
   }
   if (mBackHostOnWhite) {
     fprintf(aFile, "%s", aPrefix);
     fprintf(aFile, aDumpHtml ? "<li> <a href=" : "Back buffer on white: ");
-    DumpTextureHost(aFile, mBackHostOnWhite);
+    DumpDeprecatedTextureHost(aFile, mBackHostOnWhite);
     fprintf(aFile, aDumpHtml ? " >Back buffer on white</a> </li>" : " ");
   }
   if (aDumpHtml) {
     fprintf(aFile, "</ul>");
   }
 
 }
 
--- a/gfx/layers/composite/ContentHost.h
+++ b/gfx/layers/composite/ContentHost.h
@@ -41,18 +41,18 @@ protected:
     : CompositableHost(aTextureInfo)
   {}
 };
 
 /**
  * Base class for non-tiled ContentHosts.
  *
  * Ownership of the SurfaceDescriptor and the resources it represents is passed
- * from the ContentClient to the ContentHost when the TextureClient/Hosts are
- * created, that is recevied here by SetTextureHosts which assigns one or two
+ * from the ContentClient to the ContentHost when the DeprecatedTextureClient/Hosts are
+ * created, that is recevied here by SetDeprecatedTextureHosts which assigns one or two
  * texture hosts (for single and double buffering) to the ContentHost.
  *
  * It is the responsibility of the ContentHost to destroy its resources when
  * they are recreated or the ContentHost dies.
  */
 class ContentHostBase : public ContentHost
 {
 public:
@@ -74,39 +74,39 @@ public:
   virtual PaintState BeginPaint(ContentType, uint32_t)
   {
     NS_RUNTIMEABORT("shouldn't BeginPaint for a shadow layer");
     return PaintState();
   }
 
   virtual LayerRenderState GetRenderState() MOZ_OVERRIDE
   {
-    LayerRenderState result = mTextureHost->GetRenderState();
+    LayerRenderState result = mDeprecatedTextureHost->GetRenderState();
 
     if (mBufferRotation != nsIntPoint()) {
       result.mFlags |= LAYER_RENDER_STATE_BUFFER_ROTATION;
     }
     result.SetOffset(GetOriginOffset());
     return result;
   }
 
   virtual void SetCompositor(Compositor* aCompositor) MOZ_OVERRIDE;
 
 #ifdef MOZ_DUMP_PAINTING
   virtual already_AddRefed<gfxImageSurface> GetAsSurface()
   {
-    return mTextureHost->GetAsSurface();
+    return mDeprecatedTextureHost->GetAsSurface();
   }
 #endif
 
   virtual void Dump(FILE* aFile=NULL,
                     const char* aPrefix="",
                     bool aDumpHtml=false) MOZ_OVERRIDE;
 
-  virtual TextureHost* GetTextureHost() MOZ_OVERRIDE;
+  virtual DeprecatedTextureHost* GetDeprecatedTextureHost() MOZ_OVERRIDE;
 
   virtual void SetPaintWillResample(bool aResample) { mPaintWillResample = aResample; }
   // The client has destroyed its texture clients and we should destroy our
   // texture hosts and SurfaceDescriptors. Note that we don't immediately
   // destroy our front buffer so that we can continue to composite.
   virtual void DestroyTextures() = 0;
 
 protected:
@@ -118,29 +118,29 @@ protected:
   bool PaintWillResample() { return mPaintWillResample; }
 
   // Destroy the front buffer's texture host. This should only happen when
   // we have a new front buffer to use or the ContentHost is going to die.
   void DestroyFrontHost();
 
   nsIntRect mBufferRect;
   nsIntPoint mBufferRotation;
-  RefPtr<TextureHost> mTextureHost;
-  RefPtr<TextureHost> mTextureHostOnWhite;
-  // When we set a new front buffer TextureHost, we don't want to stomp on
+  RefPtr<DeprecatedTextureHost> mDeprecatedTextureHost;
+  RefPtr<DeprecatedTextureHost> mDeprecatedTextureHostOnWhite;
+  // When we set a new front buffer DeprecatedTextureHost, we don't want to stomp on
   // the old one which might still be used for compositing. So we store it
-  // here and move it to mTextureHost once we do the first buffer swap.
-  RefPtr<TextureHost> mNewFrontHost;
-  RefPtr<TextureHost> mNewFrontHostOnWhite;
+  // here and move it to mDeprecatedTextureHost once we do the first buffer swap.
+  RefPtr<DeprecatedTextureHost> mNewFrontHost;
+  RefPtr<DeprecatedTextureHost> mNewFrontHostOnWhite;
   bool mPaintWillResample;
   bool mInitialised;
 };
 
 /**
- * Double buffering is implemented by swapping the front and back TextureHosts.
+ * Double buffering is implemented by swapping the front and back DeprecatedTextureHosts.
  */
 class ContentHostDoubleBuffered : public ContentHostBase
 {
 public:
   ContentHostDoubleBuffered(const TextureInfo& aTextureInfo)
     : ContentHostBase(aTextureInfo)
   {}
 
@@ -148,58 +148,58 @@ public:
 
   virtual CompositableType GetType() { return BUFFER_CONTENT_DIRECT; }
 
   virtual void UpdateThebes(const ThebesBufferData& aData,
                             const nsIntRegion& aUpdated,
                             const nsIntRegion& aOldValidRegionBack,
                             nsIntRegion* aUpdatedRegionBack);
 
-  virtual void EnsureTextureHost(TextureIdentifier aTextureId,
+  virtual void EnsureDeprecatedTextureHost(TextureIdentifier aTextureId,
                                  const SurfaceDescriptor& aSurface,
                                  ISurfaceAllocator* aAllocator,
                                  const TextureInfo& aTextureInfo) MOZ_OVERRIDE;
   virtual void DestroyTextures() MOZ_OVERRIDE;
 
   virtual void Dump(FILE* aFile=NULL,
                     const char* aPrefix="",
                     bool aDumpHtml=false) MOZ_OVERRIDE;
 
 #ifdef MOZ_LAYERS_HAVE_LOG
   virtual void PrintInfo(nsACString& aTo, const char* aPrefix);
 #endif
 protected:
   nsIntRegion mValidRegionForNextBackBuffer;
   // Texture host for the back buffer. We never read or write this buffer. We
-  // only swap it with the front buffer (mTextureHost) when we are told by the
+  // only swap it with the front buffer (mDeprecatedTextureHost) when we are told by the
   // content thread.
-  RefPtr<TextureHost> mBackHost;
-  RefPtr<TextureHost> mBackHostOnWhite;
+  RefPtr<DeprecatedTextureHost> mBackHost;
+  RefPtr<DeprecatedTextureHost> mBackHostOnWhite;
 };
 
 /**
  * Single buffered, therefore we must synchronously upload the image from the
- * TextureHost in the layers transaction (i.e., in UpdateThebes).
+ * DeprecatedTextureHost in the layers transaction (i.e., in UpdateThebes).
  */
 class ContentHostSingleBuffered : public ContentHostBase
 {
 public:
   ContentHostSingleBuffered(const TextureInfo& aTextureInfo)
     : ContentHostBase(aTextureInfo)
   {}
   virtual ~ContentHostSingleBuffered();
 
   virtual CompositableType GetType() { return BUFFER_CONTENT; }
 
   virtual void UpdateThebes(const ThebesBufferData& aData,
                             const nsIntRegion& aUpdated,
                             const nsIntRegion& aOldValidRegionBack,
                             nsIntRegion* aUpdatedRegionBack);
 
-  virtual void EnsureTextureHost(TextureIdentifier aTextureId,
+  virtual void EnsureDeprecatedTextureHost(TextureIdentifier aTextureId,
                                  const SurfaceDescriptor& aSurface,
                                  ISurfaceAllocator* aAllocator,
                                  const TextureInfo& aTextureInfo) MOZ_OVERRIDE;
   virtual void DestroyTextures() MOZ_OVERRIDE;
 
 #ifdef MOZ_LAYERS_HAVE_LOG
   virtual void PrintInfo(nsACString& aTo, const char* aPrefix);
 #endif
@@ -220,21 +220,21 @@ class ContentHostIncremental : public Co
 public:
   ContentHostIncremental(const TextureInfo& aTextureInfo)
     : ContentHostBase(aTextureInfo)
     , mDeAllocator(nullptr)
   {}
 
   virtual CompositableType GetType() { return BUFFER_CONTENT; }
 
-  virtual void EnsureTextureHostIncremental(ISurfaceAllocator* aAllocator,
+  virtual void EnsureDeprecatedTextureHostIncremental(ISurfaceAllocator* aAllocator,
                                             const TextureInfo& aTextureInfo,
                                             const nsIntRect& aBufferRect) MOZ_OVERRIDE;
 
-  virtual void EnsureTextureHost(TextureIdentifier aTextureId,
+  virtual void EnsureDeprecatedTextureHost(TextureIdentifier aTextureId,
                                  const SurfaceDescriptor& aSurface,
                                  ISurfaceAllocator* aAllocator,
                                  const TextureInfo& aTextureInfo)
   {
     NS_RUNTIMEABORT("Shouldn't call this");
   }
 
   virtual void UpdateIncremental(TextureIdentifier aTextureId,
@@ -265,18 +265,18 @@ public:
     ContentHostBase::Composite(aEffectChain, aOpacity,
                                aTransform, aOffset, aFilter,
                                aClipRect, aVisibleRegion,
                                aLayerProperties);
   }
 
   virtual void DestroyTextures()
   {
-    mTextureHost = nullptr;
-    mTextureHostOnWhite = nullptr;
+    mDeprecatedTextureHost = nullptr;
+    mDeprecatedTextureHostOnWhite = nullptr;
     mUpdateList.Clear();
   }
 
 private:
 
   void ProcessTextureUpdates();
 
   class Request
--- a/gfx/layers/composite/ImageHost.cpp
+++ b/gfx/layers/composite/ImageHost.cpp
@@ -14,188 +14,188 @@ namespace mozilla {
 
 using namespace gfx;
 
 namespace layers {
 
 void
 ImageHostSingle::SetCompositor(Compositor* aCompositor) {
   CompositableHost::SetCompositor(aCompositor);
-  if (mTextureHost) {
-    mTextureHost->SetCompositor(aCompositor);
+  if (mDeprecatedTextureHost) {
+    mDeprecatedTextureHost->SetCompositor(aCompositor);
   }
 }
 
 void
-ImageHostSingle::EnsureTextureHost(TextureIdentifier aTextureId,
+ImageHostSingle::EnsureDeprecatedTextureHost(TextureIdentifier aTextureId,
                                    const SurfaceDescriptor& aSurface,
                                    ISurfaceAllocator* aAllocator,
                                    const TextureInfo& aTextureInfo)
 {
-  if (mTextureHost &&
-      mTextureHost->GetBuffer() &&
-      mTextureHost->GetBuffer()->type() == aSurface.type()) {
+  if (mDeprecatedTextureHost &&
+      mDeprecatedTextureHost->GetBuffer() &&
+      mDeprecatedTextureHost->GetBuffer()->type() == aSurface.type()) {
     return;
   }
 
-  MakeTextureHost(aTextureId,
+  MakeDeprecatedTextureHost(aTextureId,
                   aSurface,
                   aAllocator,
                   aTextureInfo);
 }
 
 void
-ImageHostSingle::MakeTextureHost(TextureIdentifier aTextureId,
+ImageHostSingle::MakeDeprecatedTextureHost(TextureIdentifier aTextureId,
                                  const SurfaceDescriptor& aSurface,
                                  ISurfaceAllocator* aAllocator,
                                  const TextureInfo& aTextureInfo)
 {
-  mTextureHost = TextureHost::CreateTextureHost(aSurface.type(),
-                                                mTextureInfo.mTextureHostFlags,
+  mDeprecatedTextureHost = DeprecatedTextureHost::CreateDeprecatedTextureHost(aSurface.type(),
+                                                mTextureInfo.mDeprecatedTextureHostFlags,
                                                 mTextureInfo.mTextureFlags);
 
-  NS_ASSERTION(mTextureHost, "Failed to create texture host");
+  NS_ASSERTION(mDeprecatedTextureHost, "Failed to create texture host");
 
   Compositor* compositor = GetCompositor();
-  if (compositor && mTextureHost) {
-    mTextureHost->SetCompositor(compositor);
+  if (compositor && mDeprecatedTextureHost) {
+    mDeprecatedTextureHost->SetCompositor(compositor);
   }
 }
 
 void
 ImageHostSingle::Composite(EffectChain& aEffectChain,
                            float aOpacity,
                            const gfx::Matrix4x4& aTransform,
                            const gfx::Point& aOffset,
                            const gfx::Filter& aFilter,
                            const gfx::Rect& aClipRect,
                            const nsIntRegion* aVisibleRegion,
                            TiledLayerProperties* aLayerProperties)
 {
-  if (!mTextureHost) {
-    NS_WARNING("Can't composite an invalid or null TextureHost");
+  if (!mDeprecatedTextureHost) {
+    NS_WARNING("Can't composite an invalid or null DeprecatedTextureHost");
     return;
   }
 
-  if (!mTextureHost->IsValid()) {
-    NS_WARNING("Can't composite an invalid TextureHost");
+  if (!mDeprecatedTextureHost->IsValid()) {
+    NS_WARNING("Can't composite an invalid DeprecatedTextureHost");
     return;
   }
 
   if (!GetCompositor()) {
     // should only happen during tabswitch if async-video is still sending frames.
     return;
   }
 
-  if (!mTextureHost->Lock()) {
+  if (!mDeprecatedTextureHost->Lock()) {
     NS_ASSERTION(false, "failed to lock texture host");
     return;
   }
 
   RefPtr<TexturedEffect> effect =
-    CreateTexturedEffect(mTextureHost, aFilter);
+    CreateTexturedEffect(mDeprecatedTextureHost, aFilter);
 
   aEffectChain.mPrimaryEffect = effect;
 
-  TileIterator* it = mTextureHost->AsTileIterator();
+  TileIterator* it = mDeprecatedTextureHost->AsTileIterator();
   if (it) {
     it->BeginTileIteration();
     do {
       nsIntRect tileRect = it->GetTileRect();
       gfx::Rect rect(tileRect.x, tileRect.y, tileRect.width, tileRect.height);
       GetCompositor()->DrawQuad(rect, aClipRect, aEffectChain,
                                 aOpacity, aTransform, aOffset);
       GetCompositor()->DrawDiagnostics(gfx::Color(0.5,0.0,0.0,1.0),
                                        rect, aClipRect, aTransform, aOffset);
     } while (it->NextTile());
     it->EndTileIteration();
   } else {
-    IntSize textureSize = mTextureHost->GetSize();
+    IntSize textureSize = mDeprecatedTextureHost->GetSize();
     gfx::Rect rect(0, 0,
                    mPictureRect.width,
                    mPictureRect.height);
     if (mHasPictureRect) {
       effect->mTextureCoords = Rect(Float(mPictureRect.x) / textureSize.width,
                                     Float(mPictureRect.y) / textureSize.height,
                                     Float(mPictureRect.width) / textureSize.width,
                                     Float(mPictureRect.height) / textureSize.height);
     } else {
       effect->mTextureCoords = Rect(0, 0, 1, 1);
       rect = gfx::Rect(0, 0, textureSize.width, textureSize.height);
     }
 
-    if (mTextureHost->GetFlags() & NeedsYFlip) {
+    if (mDeprecatedTextureHost->GetFlags() & NeedsYFlip) {
       effect->mTextureCoords.y = effect->mTextureCoords.YMost();
       effect->mTextureCoords.height = -effect->mTextureCoords.height;
     }
 
     GetCompositor()->DrawQuad(rect, aClipRect, aEffectChain,
                               aOpacity, aTransform, aOffset);
     GetCompositor()->DrawDiagnostics(gfx::Color(1.0,0.1,0.1,1.0),
                                      rect, aClipRect, aTransform, aOffset);
   }
 
-  mTextureHost->Unlock();
+  mDeprecatedTextureHost->Unlock();
 }
 
 #ifdef MOZ_LAYERS_HAVE_LOG
 void
 ImageHostSingle::PrintInfo(nsACString& aTo, const char* aPrefix)
 {
   aTo += aPrefix;
   aTo += nsPrintfCString("ImageHostSingle (0x%p)", this);
 
   AppendToString(aTo, mPictureRect, " [picture-rect=", "]");
 
-  if (mTextureHost) {
+  if (mDeprecatedTextureHost) {
     nsAutoCString pfx(aPrefix);
     pfx += "  ";
     aTo += "\n";
-    mTextureHost->PrintInfo(aTo, pfx.get());
+    mDeprecatedTextureHost->PrintInfo(aTo, pfx.get());
   }
 }
 #endif
 
 bool
 ImageHostBuffered::Update(const SurfaceDescriptor& aImage,
                           SurfaceDescriptor* aResult) {
-  if (!GetTextureHost()) {
+  if (!GetDeprecatedTextureHost()) {
     *aResult = aImage;
     return false;
   }
-  GetTextureHost()->SwapTextures(aImage, aResult);
-  return GetTextureHost()->IsValid();
+  GetDeprecatedTextureHost()->SwapTextures(aImage, aResult);
+  return GetDeprecatedTextureHost()->IsValid();
 }
 
 void
-ImageHostBuffered::MakeTextureHost(TextureIdentifier aTextureId,
+ImageHostBuffered::MakeDeprecatedTextureHost(TextureIdentifier aTextureId,
                                    const SurfaceDescriptor& aSurface,
                                    ISurfaceAllocator* aAllocator,
                                    const TextureInfo& aTextureInfo)
 {
-  ImageHostSingle::MakeTextureHost(aTextureId,
+  ImageHostSingle::MakeDeprecatedTextureHost(aTextureId,
                                    aSurface,
                                    aAllocator,
                                    aTextureInfo);
-  if (mTextureHost) {
-    mTextureHost->SetBuffer(new SurfaceDescriptor(null_t()), aAllocator);
+  if (mDeprecatedTextureHost) {
+    mDeprecatedTextureHost->SetBuffer(new SurfaceDescriptor(null_t()), aAllocator);
   }
 }
 
 void
 ImageHostSingle::Dump(FILE* aFile,
                       const char* aPrefix,
                       bool aDumpHtml)
 {
   if (!aFile) {
     aFile = stderr;
   }
-  if (mTextureHost) {
+  if (mDeprecatedTextureHost) {
     fprintf(aFile, "%s", aPrefix);
-    fprintf(aFile, aDumpHtml ? "<ul><li>TextureHost: "
-                             : "TextureHost: ");
-    DumpTextureHost(aFile, mTextureHost);
+    fprintf(aFile, aDumpHtml ? "<ul><li>DeprecatedTextureHost: "
+                             : "DeprecatedTextureHost: ");
+    DumpDeprecatedTextureHost(aFile, mDeprecatedTextureHost);
     fprintf(aFile, aDumpHtml ? " </li></ul> " : " ");
   }
 }
 
 }
 }
--- a/gfx/layers/composite/ImageHost.h
+++ b/gfx/layers/composite/ImageHost.h
@@ -16,49 +16,49 @@ namespace layers {
  * Used for compositing Image and Canvas layers, matched on the content-side
  * by an ImageClient or CanvasClient.
  *
  * ImageHosts support Update., not UpdateThebes().
  */
 class ImageHost : public CompositableHost
 {
 public:
-  TextureHost* GetTextureHost() MOZ_OVERRIDE { return nullptr; }
+  DeprecatedTextureHost* GetDeprecatedTextureHost() MOZ_OVERRIDE { return nullptr; }
 
 protected:
   ImageHost(const TextureInfo& aTextureInfo)
   : CompositableHost(aTextureInfo)
   {
     MOZ_COUNT_CTOR(ImageHost);
   }
 
   ~ImageHost()
   {
     MOZ_COUNT_DTOR(ImageHost);
   }
 };
 
-// ImageHost with a single TextureHost
+// ImageHost with a single DeprecatedTextureHost
 class ImageHostSingle : public ImageHost
 {
 public:
   ImageHostSingle(const TextureInfo& aTextureInfo)
     : ImageHost(aTextureInfo)
-    , mTextureHost(nullptr)
+    , mDeprecatedTextureHost(nullptr)
     , mHasPictureRect(false)
   {}
 
   virtual CompositableType GetType() { return mTextureInfo.mCompositableType; }
 
-  virtual void EnsureTextureHost(TextureIdentifier aTextureId,
+  virtual void EnsureDeprecatedTextureHost(TextureIdentifier aTextureId,
                                  const SurfaceDescriptor& aSurface,
                                  ISurfaceAllocator* aAllocator,
                                  const TextureInfo& aTextureInfo) MOZ_OVERRIDE;
 
-  TextureHost* GetTextureHost() MOZ_OVERRIDE { return mTextureHost; }
+  DeprecatedTextureHost* GetDeprecatedTextureHost() MOZ_OVERRIDE { return mDeprecatedTextureHost; }
 
   virtual void Composite(EffectChain& aEffectChain,
                          float aOpacity,
                          const gfx::Matrix4x4& aTransform,
                          const gfx::Point& aOffset,
                          const gfx::Filter& aFilter,
                          const gfx::Rect& aClipRect,
                          const nsIntRegion* aVisibleRegion = nullptr,
@@ -73,18 +73,18 @@ public:
   virtual void SetPictureRect(const nsIntRect& aPictureRect) MOZ_OVERRIDE
   {
     mPictureRect = aPictureRect;
     mHasPictureRect = true;
   }
 
   virtual LayerRenderState GetRenderState() MOZ_OVERRIDE
   {
-    if (mTextureHost) {
-      return mTextureHost->GetRenderState();
+    if (mDeprecatedTextureHost) {
+      return mDeprecatedTextureHost->GetRenderState();
     }
     return LayerRenderState();
   }
 
   virtual void SetCompositor(Compositor* aCompositor) MOZ_OVERRIDE;
 
   virtual void Dump(FILE* aFile=NULL,
                     const char* aPrefix="",
@@ -92,27 +92,27 @@ public:
 
 #ifdef MOZ_LAYERS_HAVE_LOG
   virtual void PrintInfo(nsACString& aTo, const char* aPrefix);
 #endif
 
 #ifdef MOZ_DUMP_PAINTING
   virtual already_AddRefed<gfxImageSurface> GetAsSurface() MOZ_OVERRIDE
   {
-    return mTextureHost->GetAsSurface();
+    return mDeprecatedTextureHost->GetAsSurface();
   }
 #endif
 
 protected:
-  virtual void MakeTextureHost(TextureIdentifier aTextureId,
+  virtual void MakeDeprecatedTextureHost(TextureIdentifier aTextureId,
                                const SurfaceDescriptor& aSurface,
                                ISurfaceAllocator* aAllocator,
                                const TextureInfo& aTextureInfo);
 
-  RefPtr<TextureHost> mTextureHost;
+  RefPtr<DeprecatedTextureHost> mDeprecatedTextureHost;
   nsIntRect mPictureRect;
   bool mHasPictureRect;
 };
 
 // Double buffered ImageHost. We have a single TextureHost and double buffering
 // is done at the TextureHost/Client level. This is in contrast with buffered
 // ContentHosts which do their own double buffering 
 class ImageHostBuffered : public ImageHostSingle
@@ -121,17 +121,17 @@ public:
   ImageHostBuffered(const TextureInfo& aTextureInfo)
     : ImageHostSingle(aTextureInfo)
   {}
 
   virtual bool Update(const SurfaceDescriptor& aImage,
                       SurfaceDescriptor* aResult = nullptr) MOZ_OVERRIDE;
 
 protected:
-  virtual void MakeTextureHost(TextureIdentifier aTextureId,
+  virtual void MakeDeprecatedTextureHost(TextureIdentifier aTextureId,
                                const SurfaceDescriptor& aSurface,
                                ISurfaceAllocator* aAllocator,
                                const TextureInfo& aTextureInfo) MOZ_OVERRIDE;
 };
 
 }
 }
 
--- a/gfx/layers/composite/ImageLayerComposite.cpp
+++ b/gfx/layers/composite/ImageLayerComposite.cpp
@@ -100,18 +100,18 @@ ImageLayerComposite::RenderLayer(const n
 
 void 
 ImageLayerComposite::ComputeEffectiveTransforms(const gfx3DMatrix& aTransformToSurface)
 {
   gfx3DMatrix local = GetLocalTransform();
 
   // Snap image edges to pixel boundaries
   gfxRect sourceRect(0, 0, 0, 0);
-  if (mImageHost && mImageHost->GetTextureHost()) {
-    IntSize size = mImageHost->GetTextureHost()->GetSize();
+  if (mImageHost && mImageHost->GetDeprecatedTextureHost()) {
+    IntSize size = mImageHost->GetDeprecatedTextureHost()->GetSize();
     sourceRect.SizeTo(size.width, size.height);
     if (mScaleMode != SCALE_NONE &&
         sourceRect.width != 0.0 && sourceRect.height != 0.0) {
       NS_ASSERTION(mScaleMode == SCALE_STRETCH,
                    "No other scalemodes than stretch and none supported yet.");
       local.Scale(mScaleToSize.width / sourceRect.width,
                   mScaleToSize.height / sourceRect.height, 1.0);
     }
--- a/gfx/layers/composite/TextureHost.cpp
+++ b/gfx/layers/composite/TextureHost.cpp
@@ -7,104 +7,104 @@
 #include "mozilla/layers/LayersSurfaces.h"
 #include "LayersLogging.h"
 #include "nsPrintfCString.h"
 
 namespace mozilla {
 namespace layers {
 
 // implemented in TextureOGL.cpp
-TemporaryRef<TextureHost> CreateTextureHostOGL(SurfaceDescriptorType aDescriptorType,
-                                               uint32_t aTextureHostFlags,
-                                               uint32_t aTextureFlags);
+TemporaryRef<DeprecatedTextureHost> CreateDeprecatedTextureHostOGL(SurfaceDescriptorType aDescriptorType,
+                                                           uint32_t aDeprecatedTextureHostFlags,
+                                                           uint32_t aTextureFlags);
 // implemented in BasicCompositor.cpp
-TemporaryRef<TextureHost> CreateBasicTextureHost(SurfaceDescriptorType aDescriptorType,
-                                                 uint32_t aTextureHostFlags,
-                                                 uint32_t aTextureFlags);
+TemporaryRef<DeprecatedTextureHost> CreateBasicDeprecatedTextureHost(SurfaceDescriptorType aDescriptorType,
+                                                             uint32_t aDeprecatedTextureHostFlags,
+                                                             uint32_t aTextureFlags);
 
-TemporaryRef<TextureHost> CreateTextureHostD3D9(SurfaceDescriptorType aDescriptorType,
-                                                uint32_t aTextureHostFlags,
-                                                uint32_t aTextureFlags)
+TemporaryRef<DeprecatedTextureHost> CreateDeprecatedTextureHostD3D9(SurfaceDescriptorType aDescriptorType,
+                                                            uint32_t aDeprecatedTextureHostFlags,
+                                                            uint32_t aTextureFlags)
 {
   NS_RUNTIMEABORT("not implemented");
   return nullptr;
 }
 
 #ifdef XP_WIN
-TemporaryRef<TextureHost> CreateTextureHostD3D11(SurfaceDescriptorType aDescriptorType,
-                                                 uint32_t aTextureHostFlags,
-                                                 uint32_t aTextureFlags);
+TemporaryRef<DeprecatedTextureHost> CreateDeprecatedTextureHostD3D11(SurfaceDescriptorType aDescriptorType,
+                                                             uint32_t aDeprecatedTextureHostFlags,
+                                                             uint32_t aTextureFlags);
 #endif
 
-/* static */ TemporaryRef<TextureHost>
-TextureHost::CreateTextureHost(SurfaceDescriptorType aDescriptorType,
-                               uint32_t aTextureHostFlags,
-                               uint32_t aTextureFlags)
+/* static */ TemporaryRef<DeprecatedTextureHost>
+DeprecatedTextureHost::CreateDeprecatedTextureHost(SurfaceDescriptorType aDescriptorType,
+                                           uint32_t aDeprecatedTextureHostFlags,
+                                           uint32_t aTextureFlags)
 {
   switch (Compositor::GetBackend()) {
     case LAYERS_OPENGL:
-      return CreateTextureHostOGL(aDescriptorType,
-                                  aTextureHostFlags,
-                                  aTextureFlags);
+      return CreateDeprecatedTextureHostOGL(aDescriptorType,
+                                        aDeprecatedTextureHostFlags,
+                                        aTextureFlags);
     case LAYERS_D3D9:
-      return CreateTextureHostD3D9(aDescriptorType,
-                                   aTextureHostFlags,
-                                   aTextureFlags);
+      return CreateDeprecatedTextureHostD3D9(aDescriptorType,
+                                         aDeprecatedTextureHostFlags,
+                                         aTextureFlags);
 #ifdef XP_WIN
     case LAYERS_D3D11:
-      return CreateTextureHostD3D11(aDescriptorType,
-                                    aTextureHostFlags,
-                                    aTextureFlags);
+      return CreateDeprecatedTextureHostD3D11(aDescriptorType,
+                                          aDeprecatedTextureHostFlags,
+                                          aTextureFlags);
 #endif
     case LAYERS_BASIC:
-      return CreateBasicTextureHost(aDescriptorType,
-                                    aTextureHostFlags,
-                                    aTextureFlags);
+      return CreateBasicDeprecatedTextureHost(aDescriptorType,
+                                          aDeprecatedTextureHostFlags,
+                                          aTextureFlags);
     default:
       MOZ_CRASH("Couldn't create texture host");
   }
 }
 
 
-TextureHost::TextureHost()
+DeprecatedTextureHost::DeprecatedTextureHost()
   : mFlags(0)
   , mBuffer(nullptr)
   , mFormat(gfx::FORMAT_UNKNOWN)
   , mDeAllocator(nullptr)
 {
-  MOZ_COUNT_CTOR(TextureHost);
+  MOZ_COUNT_CTOR(DeprecatedTextureHost);
 }
 
-TextureHost::~TextureHost()
+DeprecatedTextureHost::~DeprecatedTextureHost()
 {
   if (mBuffer) {
     if (!(mFlags & OwnByClient)) {
       if (mDeAllocator) {
         mDeAllocator->DestroySharedSurface(mBuffer);
       } else {
         MOZ_ASSERT(mBuffer->type() == SurfaceDescriptor::Tnull_t);
       }
     }
     delete mBuffer;
   }
-  MOZ_COUNT_DTOR(TextureHost);
+  MOZ_COUNT_DTOR(DeprecatedTextureHost);
 }
 
 void
-TextureHost::Update(const SurfaceDescriptor& aImage,
-                    nsIntRegion* aRegion,
-                    nsIntPoint* aOffset)
+DeprecatedTextureHost::Update(const SurfaceDescriptor& aImage,
+                          nsIntRegion* aRegion,
+                          nsIntPoint* aOffset)
 {
   UpdateImpl(aImage, aRegion, aOffset);
 }
 
 void
-TextureHost::SwapTextures(const SurfaceDescriptor& aImage,
-                          SurfaceDescriptor* aResult,
-                          nsIntRegion* aRegion)
+DeprecatedTextureHost::SwapTextures(const SurfaceDescriptor& aImage,
+                                SurfaceDescriptor* aResult,
+                                nsIntRegion* aRegion)
 {
   SwapTexturesImpl(aImage, aRegion);
 
   MOZ_ASSERT(mBuffer, "trying to swap a non-buffered texture host?");
   if (aResult) {
     *aResult = *mBuffer;
   }
   *mBuffer = aImage;
@@ -114,17 +114,17 @@ TextureHost::SwapTextures(const SurfaceD
 void
 TextureSource::PrintInfo(nsACString& aTo, const char* aPrefix)
 {
   aTo += aPrefix;
   aTo += nsPrintfCString("UnknownTextureSource (0x%p)", this);
 }
 
 void
-TextureHost::PrintInfo(nsACString& aTo, const char* aPrefix)
+DeprecatedTextureHost::PrintInfo(nsACString& aTo, const char* aPrefix)
 {
   aTo += aPrefix;
   aTo += nsPrintfCString("%s (0x%p)", Name(), this);
   AppendToString(aTo, GetSize(), " [size=", "]");
   AppendToString(aTo, GetFormat(), " [format=", "]");
   AppendToString(aTo, mFlags, " [flags=", "]");
 }
 #endif // MOZ_LAYERS_HAVE_LOG
--- a/gfx/layers/composite/TextureHost.h
+++ b/gfx/layers/composite/TextureHost.h
@@ -25,17 +25,17 @@ class Compositor;
 class SurfaceDescriptor;
 class ISurfaceAllocator;
 class TextureSourceOGL;
 class TextureSourceD3D11;
 class TextureSourceBasic;
 class TextureParent;
 
 /**
- * A view on a TextureHost where the texture is internally represented as tiles
+ * A view on a DeprecatedTextureHost where the texture is internally represented as tiles
  * (contrast with a tiled buffer, where each texture is a tile). For iteration by
  * the texture's buffer host.
  * This is only useful when the underlying surface is too big to fit in one
  * device texture, which forces us to split it in smaller parts.
  * Tiled Compositable is a different thing.
  */
 class TileIterator
 {
@@ -98,80 +98,82 @@ public:
   virtual TileIterator* AsTileIterator() { return nullptr; }
 
 #ifdef MOZ_LAYERS_HAVE_LOG
   virtual void PrintInfo(nsACString& aTo, const char* aPrefix);
 #endif
 };
 
 /**
- * TextureHost is a thin abstraction over texture data that need to be shared
+ * XXX - This class is deprectaed, will be removed soon.
+ *
+ * DeprecatedTextureHost is a thin abstraction over texture data that need to be shared
  * or transfered from the content process to the compositor process. It is the
- * compositor-side half of a TextureClient/TextureHost pair. A corresponding
- * TextureClient lives on the client-side.
+ * compositor-side half of a DeprecatedTextureClient/DeprecatedTextureHost pair. A corresponding
+ * DeprecatedTextureClient lives on the client-side.
  *
- * TextureHost only knows how to deserialize or synchronize generic image data
+ * DeprecatedTextureHost only knows how to deserialize or synchronize generic image data
  * (SurfaceDescriptor) and provide access to one or more TextureSource objects
  * (these provide the necessary APIs for compositor backends to composite the
  * image).
  *
- * A TextureHost should mostly correspond to one or several SurfaceDescriptor
+ * A DeprecatedTextureHost should mostly correspond to one or several SurfaceDescriptor
  * types. This means that for YCbCr planes, even though they are represented as
- * 3 textures internally, use 1 TextureHost and not 3, because the 3 planes
+ * 3 textures internally, use 1 DeprecatedTextureHost and not 3, because the 3 planes
  * arrive in the same IPC message.
  *
- * The Lock/Unlock mecanism here mirrors Lock/Unlock in TextureClient. These two
+ * The Lock/Unlock mecanism here mirrors Lock/Unlock in DeprecatedTextureClient. These two
  * methods don't always have to use blocking locks, unless a resource is shared
  * between the two sides (like shared texture handles). For instance, in some
  * cases the data received in Update(...) is a copy in shared memory of the data
  * owned by the content process, in which case no blocking lock is required.
  *
- * TextureHosts can be changed at any time, for example if we receive a
+ * DeprecatedTextureHosts can be changed at any time, for example if we receive a
  * SurfaceDescriptor type that was not expected. This should be an incentive
  * to keep the ownership model simple (especially on the OpenGL case, where
  * we have additionnal constraints).
  *
  * There are two fundamental operations carried out on texture hosts - update
  * from the content thread and composition. Texture upload can occur in either
  * phase. Update happens in response to an IPDL message from content and
  * composition when the compositor 'ticks'. We may composite many times before
  * update.
  *
- * Update ends up at TextureHost::UpdateImpl. It always occurs in a layers
+ * Update ends up at DeprecatedTextureHost::UpdateImpl. It always occurs in a layers
  * transacton. (TextureParent should call EnsureTexture before updating to
- * ensure the TextureHost exists and is of the correct type).
+ * ensure the DeprecatedTextureHost exists and is of the correct type).
  *
  * CompositableHost::Composite does compositing. It should check the texture
  * host exists (and give up otherwise), then lock the texture host
- * (TextureHost::Lock). Then it passes the texture host to the Compositor in an
+ * (DeprecatedTextureHost::Lock). Then it passes the texture host to the Compositor in an
  * effect as a texture source, which does the actual composition. Finally the
- * compositable calls Unlock on the TextureHost.
+ * compositable calls Unlock on the DeprecatedTextureHost.
  *
- * The class TextureImageTextureHostOGL is a good example of a TextureHost
+ * The class TextureImageDeprecatedTextureHostOGL is a good example of a DeprecatedTextureHost
  * implementation.
  *
  * This class is used only on the compositor side.
  */
-class TextureHost : public TextureSource
+class DeprecatedTextureHost : public TextureSource
 {
 public:
   /**
    * Create a new texture host to handle surfaces of aDescriptorType
    *
    * @param aDescriptorType The SurfaceDescriptor type being passed
-   * @param aTextureHostFlags Modifier flags that specify changes in
-   * the usage of a aDescriptorType, see TextureHostFlags
-   * @param aTextureFlags Flags to pass to the new TextureHost
+   * @param aDeprecatedTextureHostFlags Modifier flags that specify changes in
+   * the usage of a aDescriptorType, see DeprecatedTextureHostFlags
+   * @param aTextureFlags Flags to pass to the new DeprecatedTextureHost
    */
-  static TemporaryRef<TextureHost> CreateTextureHost(SurfaceDescriptorType aDescriptorType,
-                                                     uint32_t aTextureHostFlags,
+  static TemporaryRef<DeprecatedTextureHost> CreateDeprecatedTextureHost(SurfaceDescriptorType aDescriptorType,
+                                                     uint32_t aDeprecatedTextureHostFlags,
                                                      uint32_t aTextureFlags);
 
-  TextureHost();
-  virtual ~TextureHost();
+  DeprecatedTextureHost();
+  virtual ~DeprecatedTextureHost();
 
   virtual gfx::SurfaceFormat GetFormat() const { return mFormat; }
 
   virtual bool IsValid() const { return true; }
 
   /**
    * Update the texture host using the data from aSurfaceDescriptor.
    *
@@ -195,50 +197,50 @@ public:
    * Update for tiled texture hosts could probably have a better signature, but we
    * will replace it with PTexture stuff anyway, so nm.
    */
   virtual void Update(gfxReusableSurfaceWrapper* aReusableSurface,
   	                  TextureFlags aFlags,
   	                  const gfx::IntSize& aSize) {}
 
   /**
-   * Lock the texture host for compositing, returns true if the TextureHost is
+   * Lock the texture host for compositing, returns true if the DeprecatedTextureHost is
    * valid for composition.
    */
   virtual bool Lock() { return IsValid(); }
 
   /**
    * Unlock the texture host after compositing.
    * Should handle the case where Lock failed without crashing.
    */
   virtual void Unlock() {}
 
   void SetFlags(TextureFlags aFlags) { mFlags = aFlags; }
   void AddFlag(TextureFlags aFlag) { mFlags |= aFlag; }
   TextureFlags GetFlags() { return mFlags; }
 
   /**
-   * Sets ths TextureHost's compositor.
-   * A TextureHost can change compositor on certain occasions, in particular if
+   * Sets ths DeprecatedTextureHost's compositor.
+   * A DeprecatedTextureHost can change compositor on certain occasions, in particular if
    * it belongs to an async Compositable.
-   * aCompositor can be null, in which case the TextureHost must cleanup  all
+   * aCompositor can be null, in which case the DeprecatedTextureHost must cleanup  all
    * of it's device textures.
    */
   virtual void SetCompositor(Compositor* aCompositor) {}
 
   ISurfaceAllocator* GetDeAllocator()
   {
     return mDeAllocator;
   }
 
-  bool operator== (const TextureHost& o) const
+  bool operator== (const DeprecatedTextureHost& o) const
   {
     return GetIdentifier() == o.GetIdentifier();
   }
-  bool operator!= (const TextureHost& o) const
+  bool operator!= (const DeprecatedTextureHost& o) const
   {
     return GetIdentifier() != o.GetIdentifier();
   }
 
   virtual LayerRenderState GetRenderState()
   {
     return LayerRenderState();
   }
@@ -253,72 +255,72 @@ public:
   /**
    * TEMPORARY.
    *
    * Ensure that a buffer of the given size/type has been allocated so that
    * we can update it using Update and/or CopyTo.
    */
   virtual void EnsureBuffer(const nsIntSize& aSize, gfxASurface::gfxContentType aType)
   {
-    NS_RUNTIMEABORT("TextureHost doesn't support EnsureBuffer");
+    NS_RUNTIMEABORT("DeprecatedTextureHost doesn't support EnsureBuffer");
   }
 
   /**
-   * Copy the contents of this TextureHost to aDest. aDest must already
+   * Copy the contents of this DeprecatedTextureHost to aDest. aDest must already
    * have a suitable buffer allocated using EnsureBuffer.
    *
    * @param aSourceRect Area of this texture host to copy.
    * @param aDest Destination texture host.
    * @param aDestRect Destination rect.
    */
   virtual void CopyTo(const nsIntRect& aSourceRect,
-                      TextureHost *aDest,
+                      DeprecatedTextureHost *aDest,
                       const nsIntRect& aDestRect)
   {
-    NS_RUNTIMEABORT("TextureHost doesn't support CopyTo");
+    NS_RUNTIMEABORT("DeprecatedTextureHost doesn't support CopyTo");
   }
 
 
   SurfaceDescriptor* GetBuffer() const { return mBuffer; }
 
   /**
    * Set a SurfaceDescriptor for this texture host. By setting a buffer and
-   * allocator/de-allocator for the TextureHost, you cause the TextureHost to
+   * allocator/de-allocator for the DeprecatedTextureHost, you cause the DeprecatedTextureHost to
    * retain a SurfaceDescriptor.
    * Ownership of the SurfaceDescriptor passes to this.
    */
-  // only made virtual to allow overriding in GrallocTextureHostOGL, for hacky fix in gecko 23 for bug 862324.
+  // only made virtual to allow overriding in GrallocDeprecatedTextureHostOGL, for hacky fix in gecko 23 for bug 862324.
   // see bug 865908 about fixing this.
   virtual void SetBuffer(SurfaceDescriptor* aBuffer, ISurfaceAllocator* aAllocator)
   {
     MOZ_ASSERT(!mBuffer, "Will leak the old mBuffer");
     mBuffer = aBuffer;
     mDeAllocator = aAllocator;
   }
 
   // used only for hacky fix in gecko 23 for bug 862324
   // see bug 865908 about fixing this.
   virtual void ForgetBuffer() {}
 
 protected:
   /**
-   * Should be implemented by the backend-specific TextureHost classes
+   * Should be implemented by the backend-specific DeprecatedTextureHost classes
    *
    * It should not take a reference to aImage, unless it knows the data
    * to be thread-safe.
    */
   virtual void UpdateImpl(const SurfaceDescriptor& aImage,
                           nsIntRegion *aRegion,
                           nsIntPoint *aOffset = nullptr)
   {
     NS_RUNTIMEABORT("Should not be reached");
   }
 
   /**
-   * Should be implemented by the backend-specific TextureHost classes.
+   * Should be implemented by the backend-specific DeprecatedTextureHost classes.
    *
    * Doesn't need to do the actual surface descriptor swap, just
    * any preparation work required to use the new descriptor.
    *
    * If the implementation doesn't define anything in particular
    * for handling swaps, then we can just do an update instead.
    */
   virtual void SwapTexturesImpl(const SurfaceDescriptor& aImage,
@@ -342,39 +344,39 @@ protected:
                               // which can go away under our feet at any time. This is the cause
                               // of bug 862324 among others. Our current understanding is that
                               // this will be gone in Gecko 24. See bug 858914.
   gfx::SurfaceFormat mFormat;
 
   ISurfaceAllocator* mDeAllocator;
 };
 
-class AutoLockTextureHost
+class AutoLockDeprecatedTextureHost
 {
 public:
-  AutoLockTextureHost(TextureHost* aHost)
-    : mTextureHost(aHost)
+  AutoLockDeprecatedTextureHost(DeprecatedTextureHost* aHost)
+    : mDeprecatedTextureHost(aHost)
     , mIsValid(true)
   {
-    if (mTextureHost) {
-      mIsValid = mTextureHost->Lock();
+    if (mDeprecatedTextureHost) {
+      mIsValid = mDeprecatedTextureHost->Lock();
     }
   }
 
-  ~AutoLockTextureHost()
+  ~AutoLockDeprecatedTextureHost()
   {
-    if (mTextureHost && mIsValid) {
-      mTextureHost->Unlock();
+    if (mDeprecatedTextureHost && mIsValid) {
+      mDeprecatedTextureHost->Unlock();
     }
   }
 
   bool IsValid() { return mIsValid; }
 
 private:
-  TextureHost *mTextureHost;
+  DeprecatedTextureHost *mDeprecatedTextureHost;
   bool mIsValid;
 };
 
 /**
  * This can be used as an offscreen rendering target by the compositor, and
  * subsequently can be used as a source by the compositor.
  */
 class CompositingRenderTarget : public TextureSource
--- a/gfx/layers/composite/TiledContentHost.cpp
+++ b/gfx/layers/composite/TiledContentHost.cpp
@@ -179,21 +179,21 @@ TiledContentHost::RenderTile(const Tiled
                              const gfx::Matrix4x4& aTransform,
                              const gfx::Point& aOffset,
                              const gfx::Filter& aFilter,
                              const gfx::Rect& aClipRect,
                              const nsIntRegion& aScreenRegion,
                              const nsIntPoint& aTextureOffset,
                              const nsIntSize& aTextureBounds)
 {
-  MOZ_ASSERT(aTile.mTextureHost, "Trying to render a placeholder tile?");
+  MOZ_ASSERT(aTile.mDeprecatedTextureHost, "Trying to render a placeholder tile?");
 
   RefPtr<TexturedEffect> effect =
-    CreateTexturedEffect(aTile.mTextureHost, aFilter);
-  if (aTile.mTextureHost->Lock()) {
+    CreateTexturedEffect(aTile.mDeprecatedTextureHost, aFilter);
+  if (aTile.mDeprecatedTextureHost->Lock()) {
     aEffectChain.mPrimaryEffect = effect;
   } else {
     return;
   }
 
   nsIntRegionRectIterator it(aScreenRegion);
   for (const nsIntRect* rect = it.Next(); rect != nullptr; rect = it.Next()) {
     Rect graphicsRect(rect->x, rect->y, rect->width, rect->height);
@@ -204,17 +204,17 @@ TiledContentHost::RenderTile(const Tiled
                                   textureRect.y / aTextureBounds.height,
                                   textureRect.width / aTextureBounds.width,
                                   textureRect.height / aTextureBounds.height);
     mCompositor->DrawQuad(graphicsRect, aClipRect, aEffectChain, aOpacity, aTransform, aOffset);
     mCompositor->DrawDiagnostics(gfx::Color(0.0,0.5,0.0,1.0),
                                  graphicsRect, aClipRect, aTransform, aOffset);
   }
 
-  aTile.mTextureHost->Unlock();
+  aTile.mDeprecatedTextureHost->Unlock();
 }
 
 void
 TiledContentHost::RenderLayerBuffer(TiledLayerBufferComposite& aLayerBuffer,
                                     const nsIntRegion& aValidRegion,
                                     EffectChain& aEffectChain,
                                     float aOpacity,
                                     const gfx::Point& aOffset,
@@ -289,26 +289,26 @@ TiledContentHost::RenderLayerBuffer(Tile
     x += w;
   }
 }
 
 void
 TiledTexture::Validate(gfxReusableSurfaceWrapper* aReusableSurface, Compositor* aCompositor, uint16_t aSize)
 {
   TextureFlags flags = 0;
-  if (!mTextureHost) {
+  if (!mDeprecatedTextureHost) {
     // convert placeholder tile to a real tile
-    mTextureHost = TextureHost::CreateTextureHost(SurfaceDescriptor::Tnull_t,
+    mDeprecatedTextureHost = DeprecatedTextureHost::CreateDeprecatedTextureHost(SurfaceDescriptor::Tnull_t,
                                                   TEXTURE_HOST_TILED,
                                                   flags);
-    mTextureHost->SetCompositor(aCompositor);
+    mDeprecatedTextureHost->SetCompositor(aCompositor);
     flags |= NewTile;
   }
 
-  mTextureHost->Update(aReusableSurface, flags, gfx::IntSize(aSize, aSize));
+  mDeprecatedTextureHost->Update(aReusableSurface, flags, gfx::IntSize(aSize, aSize));
 }
 
 #ifdef MOZ_LAYERS_HAVE_LOG
 void
 TiledContentHost::PrintInfo(nsACString& aTo, const char* aPrefix)
 {
   aTo += aPrefix;
   aTo += nsPrintfCString("TiledContentHost (0x%p)", this);
@@ -328,17 +328,17 @@ TiledContentHost::Dump(FILE* aFile,
   TiledLayerBufferComposite::Iterator it = mVideoMemoryTiledBuffer.TilesBegin();
   TiledLayerBufferComposite::Iterator stop = mVideoMemoryTiledBuffer.TilesEnd();
   if (aDumpHtml) {
     fprintf(aFile, "<ul>");
   }
   for (;it != stop; ++it) {
     fprintf(aFile, "%s", aPrefix);
     fprintf(aFile, aDumpHtml ? "<li> <a href=" : "Tile ");
-    DumpTextureHost(aFile, it->mTextureHost);
+    DumpDeprecatedTextureHost(aFile, it->mDeprecatedTextureHost);
     fprintf(aFile, aDumpHtml ? " >Tile</a></li>" : " ");
   }
     if (aDumpHtml) {
     fprintf(aFile, "</ul>");
   }
 }
 
 } // namespace
--- a/gfx/layers/composite/TiledContentHost.h
+++ b/gfx/layers/composite/TiledContentHost.h
@@ -18,51 +18,51 @@ struct TexturedEffect;
 
 class TiledTexture {
 public:
   // Constructs a placeholder TiledTexture. See the comments above
   // TiledLayerBuffer for more information on what this is used for;
   // essentially, this is a sentinel used to represent an invalid or blank
   // tile.
   TiledTexture()
-    : mTextureHost(nullptr)
+    : mDeprecatedTextureHost(nullptr)
   {}
 
-  // Constructs a TiledTexture from a TextureHost.
-  TiledTexture(TextureHost* aTextureHost)
-    : mTextureHost(aTextureHost)
+  // Constructs a TiledTexture from a DeprecatedTextureHost.
+  TiledTexture(DeprecatedTextureHost* aDeprecatedTextureHost)
+    : mDeprecatedTextureHost(aDeprecatedTextureHost)
   {}
 
   TiledTexture(const TiledTexture& o) {
-    mTextureHost = o.mTextureHost;
+    mDeprecatedTextureHost = o.mDeprecatedTextureHost;
   }
   TiledTexture& operator=(const TiledTexture& o) {
     if (this == &o) {
       return *this;
     }
-    mTextureHost = o.mTextureHost;
+    mDeprecatedTextureHost = o.mDeprecatedTextureHost;
     return *this;
   }
 
   void Validate(gfxReusableSurfaceWrapper* aReusableSurface, Compositor* aCompositor, uint16_t aSize);
 
   bool operator== (const TiledTexture& o) const {
-    if (!mTextureHost || !o.mTextureHost) {
-      return mTextureHost == o.mTextureHost;
+    if (!mDeprecatedTextureHost || !o.mDeprecatedTextureHost) {
+      return mDeprecatedTextureHost == o.mDeprecatedTextureHost;
     }
-    return *mTextureHost == *o.mTextureHost;
+    return *mDeprecatedTextureHost == *o.mDeprecatedTextureHost;
   }
   bool operator!= (const TiledTexture& o) const {
-    if (!mTextureHost || !o.mTextureHost) {
-      return mTextureHost != o.mTextureHost;
+    if (!mDeprecatedTextureHost || !o.mDeprecatedTextureHost) {
+      return mDeprecatedTextureHost != o.mDeprecatedTextureHost;
     }
-    return *mTextureHost != *o.mTextureHost;
+    return *mDeprecatedTextureHost != *o.mDeprecatedTextureHost;
   }
 
-  RefPtr<TextureHost> mTextureHost;
+  RefPtr<DeprecatedTextureHost> mDeprecatedTextureHost;
 };
 
 class TiledLayerBufferComposite
   : public TiledLayerBuffer<TiledLayerBufferComposite, TiledTexture>
 {
   friend class TiledLayerBuffer<TiledLayerBufferComposite, TiledTexture>;
 
 public:
@@ -180,17 +180,17 @@ public:
                  const gfx::Rect& aClipRect,
                  const nsIntRegion* aVisibleRegion = nullptr,
                  TiledLayerProperties* aLayerProperties = nullptr);
 
   virtual CompositableType GetType() { return BUFFER_TILED; }
 
   virtual TiledLayerComposer* AsTiledLayerComposer() MOZ_OVERRIDE { return this; }
 
-  virtual void EnsureTextureHost(TextureIdentifier aTextureId,
+  virtual void EnsureDeprecatedTextureHost(TextureIdentifier aTextureId,
                                  const SurfaceDescriptor& aSurface,
                                  ISurfaceAllocator* aAllocator,
                                  const TextureInfo& aTextureInfo) MOZ_OVERRIDE
   {
     MOZ_CRASH("Does nothing");
   }
 
   virtual void SetCompositor(Compositor* aCompositor) MOZ_OVERRIDE
--- a/gfx/layers/d3d11/TextureD3D11.cpp
+++ b/gfx/layers/d3d11/TextureD3D11.cpp
@@ -14,28 +14,28 @@
 #include "gfxD2DSurface.h"
 
 namespace mozilla {
 
 using namespace gfx;
 
 namespace layers {
 
-TemporaryRef<TextureHost>
-CreateTextureHostD3D11(SurfaceDescriptorType aDescriptorType,
-                       uint32_t aTextureHostFlags,
-                       uint32_t aTextureFlags)
+TemporaryRef<DeprecatedTextureHost>
+CreateDeprecatedTextureHostD3D11(SurfaceDescriptorType aDescriptorType,
+                             uint32_t aDeprecatedTextureHostFlags,
+                             uint32_t aTextureFlags)
 {
-  RefPtr<TextureHost> result;
+  RefPtr<DeprecatedTextureHost> result;
   if (aDescriptorType == SurfaceDescriptor::TYCbCrImage) {
-    result = new TextureHostYCbCrD3D11();
+    result = new DeprecatedTextureHostYCbCrD3D11();
   } else if (aDescriptorType == SurfaceDescriptor::TSurfaceDescriptorD3D10) {
-    result = new TextureHostDXGID3D11();
+    result = new DeprecatedTextureHostDXGID3D11();
   } else {
-    result = new TextureHostShmemD3D11();
+    result = new DeprecatedTextureHostShmemD3D11();
   }
 
   result->SetFlags(aTextureFlags);
 
   return result.forget();
 }
 
 
@@ -58,32 +58,32 @@ CompositingRenderTargetD3D11::Compositin
 }
 
 IntSize
 CompositingRenderTargetD3D11::GetSize() const
 {
   return TextureSourceD3D11::GetSize();
 }
 
-TextureClientD3D11::TextureClientD3D11(CompositableForwarder* aCompositableForwarder, const TextureInfo& aTextureInfo)
-  : TextureClient(aCompositableForwarder, aTextureInfo)
+DeprecatedTextureClientD3D11::DeprecatedTextureClientD3D11(CompositableForwarder* aCompositableForwarder, const TextureInfo& aTextureInfo)
+  : DeprecatedTextureClient(aCompositableForwarder, aTextureInfo)
   , mIsLocked(false)
 {
   mTextureInfo = aTextureInfo;
 }
 
-TextureClientD3D11::~TextureClientD3D11()
+DeprecatedTextureClientD3D11::~DeprecatedTextureClientD3D11()
 {
   mDescriptor = SurfaceDescriptor();
 
   ClearDT();
 }
 
 void
-TextureClientD3D11::EnsureAllocated(gfx::IntSize aSize, gfxASurface::gfxContentType aType)
+DeprecatedTextureClientD3D11::EnsureAllocated(gfx::IntSize aSize, gfxASurface::gfxContentType aType)
 {
   D3D10_TEXTURE2D_DESC desc;
 
   if (mTexture) {
     mTexture->GetDesc(&desc);
 
     if (desc.Width == aSize.width || desc.Height == aSize.height) {
       return;
@@ -122,43 +122,43 @@ TextureClientD3D11::EnsureAllocated(gfx:
   }
 
   mDescriptor = SurfaceDescriptorD3D10((WindowsHandle)sharedHandle, aType == gfxASurface::CONTENT_COLOR_ALPHA);
 
   mContentType = aType;
 }
 
 gfxASurface*
-TextureClientD3D11::LockSurface()
+DeprecatedTextureClientD3D11::LockSurface()
 {
   EnsureSurface();
 
   LockTexture();
   return mSurface.get();
 }
 
 DrawTarget*
-TextureClientD3D11::LockDrawTarget()
+DeprecatedTextureClientD3D11::LockDrawTarget()
 {
   EnsureDrawTarget();
 
   LockTexture();
   return mDrawTarget.get();
 }
 
 void
-TextureClientD3D11::Unlock()
+DeprecatedTextureClientD3D11::Unlock()
 {
   // TODO - Things seem to believe they can hold on to our surface... well...
   // They shouldn't!!
   ReleaseTexture();
 }
 
 void
-TextureClientD3D11::SetDescriptor(const SurfaceDescriptor& aDescriptor)
+DeprecatedTextureClientD3D11::SetDescriptor(const SurfaceDescriptor& aDescriptor)
 {
   if (aDescriptor.type() == SurfaceDescriptor::Tnull_t) {
     EnsureAllocated(mSize, mContentType);
     return;
   }
 
   mDescriptor = aDescriptor;
   mSurface = nullptr;
@@ -172,29 +172,29 @@ TextureClientD3D11::SetDescriptor(const 
   ID3D10Device *device = gfxWindowsPlatform::GetPlatform()->GetD3D10Device();
 
   device->OpenSharedResource((HANDLE)aDescriptor.get_SurfaceDescriptorD3D10().handle(),
                              __uuidof(ID3D10Texture2D),
                              (void**)(ID3D10Texture2D**)byRef(mTexture));
 }
 
 void
-TextureClientD3D11::EnsureSurface()
+DeprecatedTextureClientD3D11::EnsureSurface()
 {
   if (mSurface) {
     return;
   }
 
   LockTexture();
   mSurface = new gfxD2DSurface(mTexture, mContentType);
   ReleaseTexture();
 }
 
 void
-TextureClientD3D11::EnsureDrawTarget()
+DeprecatedTextureClientD3D11::EnsureDrawTarget()
 {
   if (mDrawTarget) {
     return;
   }
 
   LockTexture();
 
   SurfaceFormat format;
@@ -212,27 +212,27 @@ TextureClientD3D11::EnsureDrawTarget()
     format = FORMAT_B8G8R8A8;
   }
 
   mDrawTarget = Factory::CreateDrawTargetForD3D10Texture(mTexture, format);
   ReleaseTexture();
 }
 
 void
-TextureClientD3D11::LockTexture()
+DeprecatedTextureClientD3D11::LockTexture()
 {
   RefPtr<IDXGIKeyedMutex> mutex;
   mTexture->QueryInterface((IDXGIKeyedMutex**)byRef(mutex));
 
   mutex->AcquireSync(0, INFINITE);
   mIsLocked = true;
 }
 
 void
-TextureClientD3D11::ReleaseTexture()
+DeprecatedTextureClientD3D11::ReleaseTexture()
 {
   // TODO - Bas - We seem to have places that unlock without ever having locked,
   // that's kind of bad.
   if (!mIsLocked) {
     return;
   }
 
   if (mDrawTarget) {
@@ -242,65 +242,65 @@ TextureClientD3D11::ReleaseTexture()
   RefPtr<IDXGIKeyedMutex> mutex;
   mTexture->QueryInterface((IDXGIKeyedMutex**)byRef(mutex));
 
   mutex->ReleaseSync(0);
   mIsLocked = false;
 }
 
 void
-TextureClientD3D11::ClearDT()
+DeprecatedTextureClientD3D11::ClearDT()
 {
   // An Azure DrawTarget needs to be locked when it gets NULL'ed as this is
   // when it calls EndDraw. This EndDraw should not execute anything so it
   // shouldn't -really- need the lock but the debug layer chokes on this.
   //
   // Perhaps this should be debug only.
   if (mDrawTarget) {
     LockTexture();
     mDrawTarget = nullptr;
     ReleaseTexture();
   }
 }
 
 IntSize
-TextureHostShmemD3D11::GetSize() const
+DeprecatedTextureHostShmemD3D11::GetSize() const
 {
   if (mIterating) {
     gfx::IntRect rect = GetTileRect(mCurrentTile);
     return gfx::IntSize(rect.width, rect.height);
   }
   return TextureSourceD3D11::GetSize();
 }
 
 nsIntRect
-TextureHostShmemD3D11::GetTileRect()
+DeprecatedTextureHostShmemD3D11::GetTileRect()
 {
   IntRect rect = GetTileRect(mCurrentTile);
   return nsIntRect(rect.x, rect.y, rect.width, rect.height);
 }
 
 static uint32_t GetRequiredTiles(uint32_t aSize, uint32_t aMaxSize)
 {
   uint32_t requiredTiles = aSize / aMaxSize;
   if (aSize % aMaxSize) {
     requiredTiles++;
   }
   return requiredTiles;
 }
 
 void
-TextureHostShmemD3D11::SetCompositor(Compositor* aCompositor)
+DeprecatedTextureHostShmemD3D11::SetCompositor(Compositor* aCompositor)
 {
   CompositorD3D11 *d3dCompositor = static_cast<CompositorD3D11*>(aCompositor);
   mDevice = d3dCompositor ? d3dCompositor->GetDevice() : nullptr;
 }
 
 void
-TextureHostShmemD3D11::UpdateImpl(const SurfaceDescriptor& aImage,
+DeprecatedTextureHostShmemD3D11::UpdateImpl(const SurfaceDescriptor& aImage,
                                   nsIntRegion *aRegion,
                                   nsIntPoint *aOffset)
 {
   MOZ_ASSERT(aImage.type() == SurfaceDescriptor::TShmem ||
              aImage.type() == SurfaceDescriptor::TMemoryImage);
 
   AutoOpenSurface openSurf(OPEN_READ_ONLY, aImage);
 
@@ -360,107 +360,107 @@ TextureHostShmemD3D11::UpdateImpl(const 
       initData.SysMemPitch = surf->Stride();
 
       mDevice->CreateTexture2D(&desc, &initData, byRef(mTileTextures[i]));
     }
   }
 }
 
 IntRect
-TextureHostShmemD3D11::GetTileRect(uint32_t aID) const
+DeprecatedTextureHostShmemD3D11::GetTileRect(uint32_t aID) const
 {
   uint32_t maxSize = GetMaxTextureSizeForFeatureLevel(mDevice->GetFeatureLevel());
   uint32_t horizontalTiles = GetRequiredTiles(mSize.width, maxSize);
   uint32_t verticalTiles = GetRequiredTiles(mSize.height, maxSize);
 
   uint32_t verticalTile = aID / horizontalTiles;
   uint32_t horizontalTile = aID % horizontalTiles;
 
   return IntRect(horizontalTile * maxSize,
                  verticalTile * maxSize,
                  horizontalTile < (horizontalTiles - 1) ? maxSize : mSize.width % maxSize,
                  verticalTile < (verticalTiles - 1) ? maxSize : mSize.height % maxSize);
 }
 
 void
-TextureHostDXGID3D11::SetCompositor(Compositor* aCompositor)
+DeprecatedTextureHostDXGID3D11::SetCompositor(Compositor* aCompositor)
 {
   CompositorD3D11 *d3dCompositor = static_cast<CompositorD3D11*>(aCompositor);
   mDevice = d3dCompositor ? d3dCompositor->GetDevice() : nullptr;
 }
 
 IntSize
-TextureHostDXGID3D11::GetSize() const
+DeprecatedTextureHostDXGID3D11::GetSize() const
 {
   return TextureSourceD3D11::GetSize();
 }
 
 bool
-TextureHostDXGID3D11::Lock()
+DeprecatedTextureHostDXGID3D11::Lock()
 {
   LockTexture();
   return true;
 }
 
 void
-TextureHostDXGID3D11::Unlock()
+DeprecatedTextureHostDXGID3D11::Unlock()
 {
   ReleaseTexture();
 }
 
 void
-TextureHostDXGID3D11::UpdateImpl(const SurfaceDescriptor& aImage,
+DeprecatedTextureHostDXGID3D11::UpdateImpl(const SurfaceDescriptor& aImage,
                                  nsIntRegion *aRegion,
                                  nsIntPoint *aOffset)
 {
   MOZ_ASSERT(aImage.type() == SurfaceDescriptor::TSurfaceDescriptorD3D10);
 
   mDevice->OpenSharedResource((HANDLE)aImage.get_SurfaceDescriptorD3D10().handle(),
                               __uuidof(ID3D11Texture2D), (void**)(ID3D11Texture2D**)byRef(mTextures[0]));
   mFormat = aImage.get_SurfaceDescriptorD3D10().hasAlpha() ? FORMAT_B8G8R8A8 : FORMAT_B8G8R8X8;
 
   D3D11_TEXTURE2D_DESC desc;
   mTextures[0]->GetDesc(&desc);
 
   mSize = IntSize(desc.Width, desc.Height);
 }
 
 void
-TextureHostDXGID3D11::LockTexture()
+DeprecatedTextureHostDXGID3D11::LockTexture()
 {
   RefPtr<IDXGIKeyedMutex> mutex;
   mTextures[0]->QueryInterface((IDXGIKeyedMutex**)byRef(mutex));
 
   mutex->AcquireSync(0, INFINITE);
 }
 
 void
-TextureHostDXGID3D11::ReleaseTexture()
+DeprecatedTextureHostDXGID3D11::ReleaseTexture()
 {
   RefPtr<IDXGIKeyedMutex> mutex;
   mTextures[0]->QueryInterface((IDXGIKeyedMutex**)byRef(mutex));
 
   mutex->ReleaseSync(0);
 }
 
 void
-TextureHostYCbCrD3D11::SetCompositor(Compositor* aCompositor)
+DeprecatedTextureHostYCbCrD3D11::SetCompositor(Compositor* aCompositor)
 {
   CompositorD3D11 *d3dCompositor = static_cast<CompositorD3D11*>(aCompositor);
   mDevice = d3dCompositor ? d3dCompositor->GetDevice() : nullptr;
 }
 
 IntSize
-TextureHostYCbCrD3D11::GetSize() const
+DeprecatedTextureHostYCbCrD3D11::GetSize() const
 {
   return TextureSourceD3D11::GetSize();
 }
 
 void
-TextureHostYCbCrD3D11::UpdateImpl(const SurfaceDescriptor& aImage,
+DeprecatedTextureHostYCbCrD3D11::UpdateImpl(const SurfaceDescriptor& aImage,
                                   nsIntRegion *aRegion,
                                   nsIntPoint *aOffset)
 {
   MOZ_ASSERT(aImage.type() == SurfaceDescriptor::TYCbCrImage);
 
   YCbCrImageDataDeserializer yuvDeserializer(aImage.get_YCbCrImage().data().get<uint8_t>());
 
   gfxIntSize gfxCbCrSize = yuvDeserializer.GetCbCrSize();
--- a/gfx/layers/d3d11/TextureD3D11.h
+++ b/gfx/layers/d3d11/TextureD3D11.h
@@ -57,23 +57,23 @@ public:
   void SetSize(const gfx::IntSize& aSize) { mSize = aSize; }
 
 private:
   friend class CompositorD3D11;
 
   RefPtr<ID3D11RenderTargetView> mRTView;
 };
 
-class TextureClientD3D11 : public TextureClient
+class DeprecatedTextureClientD3D11 : public DeprecatedTextureClient
 {
 public:
-  TextureClientD3D11(CompositableForwarder* aCompositableForwarder, const TextureInfo& aTextureInfo);
-  ~TextureClientD3D11();
+  DeprecatedTextureClientD3D11(CompositableForwarder* aCompositableForwarder, const TextureInfo& aTextureInfo);
+  ~DeprecatedTextureClientD3D11();
 
-  virtual bool SupportsType(TextureClientType aType) MOZ_OVERRIDE { return aType == TEXTURE_CONTENT; }
+  virtual bool SupportsType(DeprecatedTextureClientType aType) MOZ_OVERRIDE { return aType == TEXTURE_CONTENT; }
 
   virtual void EnsureAllocated(gfx::IntSize aSize, gfxASurface::gfxContentType aType) MOZ_OVERRIDE;
 
   virtual gfxASurface* LockSurface() MOZ_OVERRIDE;
   virtual gfx::DrawTarget* LockDrawTarget() MOZ_OVERRIDE;
   virtual void Unlock() MOZ_OVERRIDE;
 
   virtual void SetDescriptor(const SurfaceDescriptor& aDescriptor) MOZ_OVERRIDE;
@@ -90,22 +90,22 @@ private:
   RefPtr<ID3D10Texture2D> mTexture;
   nsRefPtr<gfxD2DSurface> mSurface;
   RefPtr<gfx::DrawTarget> mDrawTarget;
   gfx::IntSize mSize;
   bool mIsLocked;
   gfxContentType mContentType;
 };
 
-class TextureHostShmemD3D11 : public TextureHost
+class DeprecatedTextureHostShmemD3D11 : public DeprecatedTextureHost
                             , public TextureSourceD3D11
                             , public TileIterator
 {
 public:
-  TextureHostShmemD3D11()
+  DeprecatedTextureHostShmemD3D11()
     : mDevice(nullptr)
     , mIsTiled(false)
     , mCurrentTile(0)
     , mIterating(false)
   {
   }
 
   virtual void SetCompositor(Compositor* aCompositor) MOZ_OVERRIDE;
@@ -123,17 +123,17 @@ public:
   virtual bool Lock() MOZ_OVERRIDE { return true; }
 
   virtual already_AddRefed<gfxImageSurface> GetAsSurface() MOZ_OVERRIDE
   {
     return nullptr; // TODO: cf bug 872568
   }
 
 #ifdef MOZ_LAYERS_HAVE_LOG
-  virtual const char* Name() { return "TextureHostShmemD3D11"; }
+  virtual const char* Name() { return "DeprecatedTextureHostShmemD3D11"; }
 #endif
 
   virtual void BeginTileIteration() MOZ_OVERRIDE {
     mIterating = true;
     mCurrentTile = 0;
   }
   virtual void EndTileIteration() MOZ_OVERRIDE {
     mIterating = false;
@@ -157,21 +157,21 @@ private:
 
   RefPtr<ID3D11Device> mDevice;
   bool mIsTiled;
   std::vector< RefPtr<ID3D11Texture2D> > mTileTextures;
   uint32_t mCurrentTile;
   bool mIterating;
 };
 
-class TextureHostDXGID3D11 : public TextureHost
+class DeprecatedTextureHostDXGID3D11 : public DeprecatedTextureHost
                            , public TextureSourceD3D11
 {
 public:
-  TextureHostDXGID3D11()
+  DeprecatedTextureHostDXGID3D11()
     : mDevice(nullptr)
   {
   }
 
   virtual void SetCompositor(Compositor* aCompositor) MOZ_OVERRIDE;
 
   virtual TextureSourceD3D11* AsSourceD3D11() MOZ_OVERRIDE { return this; }
 
@@ -181,37 +181,37 @@ public:
   virtual void Unlock() MOZ_OVERRIDE;
 
   virtual already_AddRefed<gfxImageSurface> GetAsSurface() MOZ_OVERRIDE
   {
     return nullptr; // TODO: cf bug 872568
   }
 
 #ifdef MOZ_LAYERS_HAVE_LOG
-  virtual const char* Name() { return "TextureHostDXGID3D11"; }
+  virtual const char* Name() { return "DeprecatedTextureHostDXGID3D11"; }
 #endif
 
 protected:
   virtual void UpdateImpl(const SurfaceDescriptor& aSurface,
                           nsIntRegion* aRegion,
                           nsIntPoint* aOffset = nullptr) MOZ_OVERRIDE;
 private:
   void LockTexture();
   void ReleaseTexture();
 
   gfx::IntRect GetTileRect(uint32_t aID) const; // TODO[Bas] not defined anywhere?
 
   RefPtr<ID3D11Device> mDevice;
 };
 
-class TextureHostYCbCrD3D11 : public TextureHost
+class DeprecatedTextureHostYCbCrD3D11 : public DeprecatedTextureHost
                             , public TextureSourceD3D11
 {
 public:
-  TextureHostYCbCrD3D11()
+  DeprecatedTextureHostYCbCrD3D11()
     : mDevice(nullptr)
   {
     mFormat = gfx::FORMAT_YUV;
   }
 
   virtual void SetCompositor(Compositor* aCompositor) MOZ_OVERRIDE;
 
   virtual TextureSourceD3D11* AsSourceD3D11() MOZ_OVERRIDE { return this; }
@@ -221,17 +221,17 @@ public:
   virtual bool IsYCbCrSource() const MOZ_OVERRIDE { return true; }
 
   virtual already_AddRefed<gfxImageSurface> GetAsSurface() MOZ_OVERRIDE
   {
     return nullptr; // TODO: cf bug 872568
   }
 
 #ifdef MOZ_LAYERS_HAVE_LOG
-  virtual const char* Name() MOZ_OVERRIDE { return "TextureImageTextureHostD3D11"; }
+  virtual const char* Name() MOZ_OVERRIDE { return "TextureImageDeprecatedTextureHostD3D11"; }
 #endif
 
 protected:
   virtual void UpdateImpl(const SurfaceDescriptor& aSurface,
                           nsIntRegion* aRegion,
                           nsIntPoint* aOffset = nullptr) MOZ_OVERRIDE;
 
 private:
--- a/gfx/layers/ipc/CompositableForwarder.h
+++ b/gfx/layers/ipc/CompositableForwarder.h
@@ -14,33 +14,33 @@
 
 namespace mozilla {
 namespace layers {
 
 class CompositableClient;
 class TextureFactoryIdentifier;
 class SurfaceDescriptor;
 class ThebesBufferData;
-class TextureClient;
+class DeprecatedTextureClient;
 class BasicTiledLayerBuffer;
 
 /**
  * A transaction is a set of changes that happenned on the content side, that
  * should be sent to the compositor side.
  * CompositableForwarder is an interface to manage a transaction of
  * compositable objetcs.
  *
  * ShadowLayerForwarder is an example of a CompositableForwarder (that can
  * additionally forward modifications of the Layer tree).
  * ImageBridgeChild is another CompositableForwarder.
  */
 class CompositableForwarder : public ISurfaceAllocator
 {
   friend class AutoOpenSurface;
-  friend class TextureClientShmem;
+  friend class DeprecatedTextureClientShmem;
 public:
   typedef gfxASurface::gfxContentType gfxContentType;
 
   CompositableForwarder()
   : mMaxTextureSize(0)
   , mCompositorBackend(layers::LAYERS_NONE)
   , mSupportsTextureBlitting(false)
   , mSupportsPartialUploads(false)
--- a/gfx/layers/ipc/CompositableTransactionParent.cpp
+++ b/gfx/layers/ipc/CompositableTransactionParent.cpp
@@ -27,31 +27,31 @@ CompositableParentManager::ReceiveCompos
   switch (aEdit.type()) {
     case CompositableOperation::TOpCreatedTexture: {
       MOZ_LAYERS_LOG(("[ParentSide] Created texture"));
       const OpCreatedTexture& op = aEdit.get_OpCreatedTexture();
       CompositableParent* compositableParent =
         static_cast<CompositableParent*>(op.compositableParent());
       CompositableHost* compositable = compositableParent->GetCompositableHost();
 
-      compositable->EnsureTextureHost(op.textureId(), op.descriptor(),
+      compositable->EnsureDeprecatedTextureHost(op.textureId(), op.descriptor(),
                                       compositableParent->GetCompositableManager(),
                                       op.textureInfo());
 
       break;
     }
     case CompositableOperation::TOpCreatedIncrementalTexture: {
       MOZ_LAYERS_LOG(("[ParentSide] Created texture"));
       const OpCreatedIncrementalTexture& op = aEdit.get_OpCreatedIncrementalTexture();
 
       CompositableParent* compositableParent =
         static_cast<CompositableParent*>(op.compositableParent());
       CompositableHost* compositable = compositableParent->GetCompositableHost();
 
-      compositable->EnsureTextureHostIncremental(compositableParent->GetCompositableManager(),
+      compositable->EnsureDeprecatedTextureHostIncremental(compositableParent->GetCompositableManager(),
                                                  op.textureInfo(),
                                                  op.bufferRect());
       break;
     }
     case CompositableOperation::TOpDestroyThebesBuffer: {
       MOZ_LAYERS_LOG(("[ParentSide] Created double buffer"));
       const OpDestroyThebesBuffer& op = aEdit.get_OpDestroyThebesBuffer();
       CompositableParent* compositableParent = static_cast<CompositableParent*>(op.compositableParent());
@@ -83,21 +83,21 @@ CompositableParentManager::ReceiveCompos
       }
 
       if (layer) {
         RenderTraceInvalidateStart(layer, "FF00FF", layer->GetVisibleRegion().GetBounds());
       }
 
       if (compositable) {
         const SurfaceDescriptor& descriptor = op.image();
-        compositable->EnsureTextureHost(op.textureId(),
+        compositable->EnsureDeprecatedTextureHost(op.textureId(),
                                         descriptor,
                                         compositableParent->GetCompositableManager(),
                                         TextureInfo());
-        MOZ_ASSERT(compositable->GetTextureHost());
+        MOZ_ASSERT(compositable->GetDeprecatedTextureHost());
 
         SurfaceDescriptor newBack;
         bool shouldRecomposite = compositable->Update(descriptor, &newBack);
         if (IsSurfaceDescriptorValid(newBack)) {
           replyv.push_back(OpTextureSwap(compositableParent, nullptr,
                                          op.textureId(), newBack));
         }
 
--- a/gfx/layers/ipc/ISurfaceAllocator.h
+++ b/gfx/layers/ipc/ISurfaceAllocator.h
@@ -106,17 +106,17 @@ ISurfaceAllocator() {}
                                               gfxASurface::gfxContentType aContent,
                                               uint32_t aCaps,
                                               SurfaceDescriptor* aBuffer);
 
   virtual void DestroySharedSurface(SurfaceDescriptor* aSurface);
 
 protected:
   // this method is needed for a temporary fix, will be removed after
-  // TextureClient/Host rework.
+  // DeprecatedTextureClient/Host rework.
   virtual bool IsOnCompositorSide() const = 0;
   static bool PlatformDestroySharedSurface(SurfaceDescriptor* aSurface);
   virtual bool PlatformAllocSurfaceDescriptor(const gfxIntSize& aSize,
                                               gfxASurface::gfxContentType aContent,
                                               uint32_t aCaps,
                                               SurfaceDescriptor* aBuffer);
 
   // method that does the actual allocation work
--- a/gfx/layers/ipc/ShadowLayerUtilsGralloc.cpp
+++ b/gfx/layers/ipc/ShadowLayerUtilsGralloc.cpp
@@ -194,17 +194,17 @@ NS_MEMORY_REPORTER_IMPLEMENT(GrallocBuff
   "Special RAM that can be shared between processes and directly "
   "accessed by both the CPU and GPU.  Gralloc memory is usually a "
   "relatively precious resource, with much less available than generic "
   "RAM.  When it's exhausted, graphics performance can suffer. "
   "This value can be incorrect because of race conditions.");
 
 GrallocBufferActor::GrallocBufferActor()
 : mAllocBytes(0)
-, mTextureHost(nullptr)
+, mDeprecatedTextureHost(nullptr)
 {
   static bool registered;
   if (!registered) {
     // We want to be sure that the first call here will always run on
     // the main thread.
     NS_ASSERTION(NS_IsMainThread(), "Should be on main thread.");
 
     NS_RegisterMemoryReporter(new NS_MEMORY_REPORTER_NAME(GrallocBufferActor));
@@ -248,25 +248,25 @@ GrallocBufferActor::Create(const gfxIntS
   *aOutHandle = MagicGrallocBufferHandle(buffer);
 
   return actor;
 }
 
 // used only for hacky fix in gecko 23 for bug 862324
 void GrallocBufferActor::ActorDestroy(ActorDestroyReason)
 {
-  if (mTextureHost) {
-    mTextureHost->ForgetBuffer();
+  if (mDeprecatedTextureHost) {
+    mDeprecatedTextureHost->ForgetBuffer();
   }
 }
 
 // used only for hacky fix in gecko 23 for bug 862324
-void GrallocBufferActor::SetTextureHost(TextureHost* aTextureHost)
+void GrallocBufferActor::SetDeprecatedTextureHost(DeprecatedTextureHost* aDeprecatedTextureHost)
 {
-  mTextureHost = aTextureHost;
+  mDeprecatedTextureHost = aDeprecatedTextureHost;
 }
 
 /*static*/ already_AddRefed<TextureImage>
 LayerManagerComposite::OpenDescriptorForDirectTexturing(GLContext* aGL,
                                                         const SurfaceDescriptor& aDescriptor,
                                                         GLenum aWrapMode)
 {
   PROFILER_LABEL("LayerManagerComposite", "OpenDescriptorForDirectTexturing");
--- a/gfx/layers/ipc/ShadowLayerUtilsGralloc.h
+++ b/gfx/layers/ipc/ShadowLayerUtilsGralloc.h
@@ -82,32 +82,32 @@ public:
   GetFrom(const SurfaceDescriptorGralloc& aDescriptor);
 
   // used only for hacky fix in gecko 23 for bug 862324
   // see bug 865908 about fixing this.
   void ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE;
 
   // used only for hacky fix in gecko 23 for bug 862324
   // see bug 865908 about fixing this.
-  void SetTextureHost(TextureHost* aTextureHost);
+  void SetDeprecatedTextureHost(DeprecatedTextureHost* aDeprecatedTextureHost);
 
 private:
   GrallocBufferActor();
 
   void InitFromHandle(const MagicGrallocBufferHandle& aHandle);
 
   android::sp<GraphicBuffer> mGraphicBuffer;
 
   // This value stores the number of bytes allocated in this
   // BufferActor. This will be used for the memory reporter.
   size_t mAllocBytes;
 
   // used only for hacky fix in gecko 23 for bug 862324
   // see bug 865908 about fixing this.
-  TextureHost* mTextureHost;
+  DeprecatedTextureHost* mDeprecatedTextureHost;
 
   friend class ISurfaceAllocator;
 };
 
 } // namespace layers
 } // namespace mozilla
 
 namespace IPC {
--- a/gfx/layers/ipc/ShadowLayers.h
+++ b/gfx/layers/ipc/ShadowLayers.h
@@ -46,17 +46,17 @@ class ColorLayerComposite;
 class CanvasLayerComposite;
 class RefLayerComposite;
 class SurfaceDescriptor;
 class ThebesBuffer;
 class TiledLayerComposer;
 class Transaction;
 class SurfaceDescriptor;
 class CanvasSurface;
-class TextureClientShmem;
+class DeprecatedTextureClientShmem;
 class ContentClientRemote;
 class CompositableChild;
 class ImageClient;
 class CanvasClient;
 class ContentClient;
 
 
 /**
@@ -130,17 +130,17 @@ class ContentClient;
  * Compositable transactions are subset of a layer transaction with which only
  * compositables and textures can be manipulated, and does not always originate
  * from the content thread. (See CompositableForwarder.h and ImageBridgeChild.h)
  */
 
 class ShadowLayerForwarder : public CompositableForwarder
 {
   friend class AutoOpenSurface;
-  friend class TextureClientShmem;
+  friend class DeprecatedTextureClientShmem;
   friend class ContentClientIncremental;
 
 public:
   virtual ~ShadowLayerForwarder();
 
   /**
    * Setup the IPDL actor for aCompositable to be part of layers
    * transactions.
--- a/gfx/layers/opengl/TextureClientOGL.cpp
+++ b/gfx/layers/opengl/TextureClientOGL.cpp
@@ -6,37 +6,37 @@
 #include "mozilla/layers/TextureClientOGL.h"
 #include "GLContext.h"
 
 using namespace mozilla::gl;
 
 namespace mozilla {
 namespace layers {
 
-TextureClientSharedOGL::TextureClientSharedOGL(CompositableForwarder* aForwarder,
+DeprecatedTextureClientSharedOGL::DeprecatedTextureClientSharedOGL(CompositableForwarder* aForwarder,
                                                const TextureInfo& aTextureInfo)
-  : TextureClient(aForwarder, aTextureInfo)
+  : DeprecatedTextureClient(aForwarder, aTextureInfo)
   , mGL(nullptr)
 {
 }
 
 void
-TextureClientSharedOGL::ReleaseResources()
+DeprecatedTextureClientSharedOGL::ReleaseResources()
 {
   if (!IsSurfaceDescriptorValid(mDescriptor)) {
     return;
   }
   MOZ_ASSERT(mDescriptor.type() == SurfaceDescriptor::TSharedTextureDescriptor);
   mDescriptor = SurfaceDescriptor();
-  // It's important our handle gets released! SharedTextureHostOGL will take
+  // It's important our handle gets released! SharedDeprecatedTextureHostOGL will take
   // care of this for us though.
 }
 
 void
-TextureClientSharedOGL::EnsureAllocated(gfx::IntSize aSize,
+DeprecatedTextureClientSharedOGL::EnsureAllocated(gfx::IntSize aSize,
                                         gfxASurface::gfxContentType aContentType)
 {
   mSize = aSize;
 }
 
 
 } // namespace
 } // namespace
--- a/gfx/layers/opengl/TextureClientOGL.h
+++ b/gfx/layers/opengl/TextureClientOGL.h
@@ -7,55 +7,55 @@
 #define MOZILLA_GFX_TEXTURECLIENTOGL_H
 
 #include "mozilla/layers/TextureClient.h"
 #include "ISurfaceAllocator.h" // For IsSurfaceDescriptorValid
 
 namespace mozilla {
 namespace layers {
 
-class TextureClientSharedOGL : public TextureClient
+class DeprecatedTextureClientSharedOGL : public DeprecatedTextureClient
 {
 public:
-  TextureClientSharedOGL(CompositableForwarder* aForwarder, const TextureInfo& aTextureInfo);
-  ~TextureClientSharedOGL() { ReleaseResources(); }
+  DeprecatedTextureClientSharedOGL(CompositableForwarder* aForwarder, const TextureInfo& aTextureInfo);
+  ~DeprecatedTextureClientSharedOGL() { ReleaseResources(); }
 
-  virtual bool SupportsType(TextureClientType aType) MOZ_OVERRIDE { return aType == TEXTURE_SHARED_GL; }
+  virtual bool SupportsType(DeprecatedTextureClientType aType) MOZ_OVERRIDE { return aType == TEXTURE_SHARED_GL; }
   virtual void EnsureAllocated(gfx::IntSize aSize, gfxASurface::gfxContentType aType);
   virtual void ReleaseResources();
   virtual gfxASurface::gfxContentType GetContentType() MOZ_OVERRIDE { return gfxASurface::CONTENT_COLOR_ALPHA; }
 
 protected:
   gl::GLContext* mGL;
   gfx::IntSize mSize;
 
   friend class CompositingFactory;
 };
 
 // Doesn't own the surface descriptor, so we shouldn't delete it
-class TextureClientSharedOGLExternal : public TextureClientSharedOGL
+class DeprecatedTextureClientSharedOGLExternal : public DeprecatedTextureClientSharedOGL
 {
 public:
-  TextureClientSharedOGLExternal(CompositableForwarder* aForwarder, const TextureInfo& aTextureInfo)
-    : TextureClientSharedOGL(aForwarder, aTextureInfo)
+  DeprecatedTextureClientSharedOGLExternal(CompositableForwarder* aForwarder, const TextureInfo& aTextureInfo)
+    : DeprecatedTextureClientSharedOGL(aForwarder, aTextureInfo)
   {}
 
-  virtual bool SupportsType(TextureClientType aType) MOZ_OVERRIDE { return aType == TEXTURE_SHARED_GL_EXTERNAL; }
+  virtual bool SupportsType(DeprecatedTextureClientType aType) MOZ_OVERRIDE { return aType == TEXTURE_SHARED_GL_EXTERNAL; }
   virtual void ReleaseResources() {}
 };
 
-class TextureClientStreamOGL : public TextureClient
+class DeprecatedTextureClientStreamOGL : public DeprecatedTextureClient
 {
 public:
-  TextureClientStreamOGL(CompositableForwarder* aForwarder, const TextureInfo& aTextureInfo)
-    : TextureClient(aForwarder, aTextureInfo)
+  DeprecatedTextureClientStreamOGL(CompositableForwarder* aForwarder, const TextureInfo& aTextureInfo)
+    : DeprecatedTextureClient(aForwarder, aTextureInfo)
   {}
-  ~TextureClientStreamOGL() { ReleaseResources(); }
+  ~DeprecatedTextureClientStreamOGL() { ReleaseResources(); }
 
-  virtual bool SupportsType(TextureClientType aType) MOZ_OVERRIDE { return aType == TEXTURE_STREAM_GL; }
+  virtual bool SupportsType(DeprecatedTextureClientType aType) MOZ_OVERRIDE { return aType == TEXTURE_STREAM_GL; }
   virtual void EnsureAllocated(gfx::IntSize aSize, gfxASurface::gfxContentType aType) { }
   virtual void ReleaseResources() { mDescriptor = SurfaceDescriptor(); }
   virtual gfxASurface::gfxContentType GetContentType() MOZ_OVERRIDE { return gfxASurface::CONTENT_COLOR_ALPHA; }
 };
 
 } // namespace
 } // namespace
 
--- a/gfx/layers/opengl/TextureHostOGL.cpp
+++ b/gfx/layers/opengl/TextureHostOGL.cpp
@@ -16,37 +16,37 @@
 #include "mozilla/layers/CompositorOGL.h"
 
 using namespace mozilla::gl;
 using namespace mozilla::gfx;
 
 namespace mozilla {
 namespace layers {
 
-TemporaryRef<TextureHost>
-CreateTextureHostOGL(SurfaceDescriptorType aDescriptorType,
-                     uint32_t aTextureHostFlags,
+TemporaryRef<DeprecatedTextureHost>
+CreateDeprecatedTextureHostOGL(SurfaceDescriptorType aDescriptorType,
+                     uint32_t aDeprecatedTextureHostFlags,
                      uint32_t aTextureFlags)
 {
-  RefPtr<TextureHost> result = nullptr;
+  RefPtr<DeprecatedTextureHost> result = nullptr;
 
   if (aDescriptorType == SurfaceDescriptor::TYCbCrImage) {
-    result = new YCbCrTextureHostOGL();
+    result = new YCbCrDeprecatedTextureHostOGL();
   } else if (aDescriptorType == SurfaceDescriptor::TSurfaceStreamDescriptor) {
     result = new SurfaceStreamHostOGL();
   } else if (aDescriptorType == SurfaceDescriptor::TSharedTextureDescriptor) {
-    result = new SharedTextureHostOGL();
+    result = new SharedDeprecatedTextureHostOGL();
 #ifdef MOZ_WIDGET_GONK
   } else if (aDescriptorType == SurfaceDescriptor::TSurfaceDescriptorGralloc) {
-    result = new GrallocTextureHostOGL();
+    result = new GrallocDeprecatedTextureHostOGL();
 #endif
-  } else if (aTextureHostFlags & TEXTURE_HOST_TILED) {
-    result = new TiledTextureHostOGL();
+  } else if (aDeprecatedTextureHostFlags & TEXTURE_HOST_TILED) {
+    result = new TiledDeprecatedTextureHostOGL();
   } else {
-    result = new TextureImageTextureHostOGL();
+    result = new TextureImageDeprecatedTextureHostOGL();
   }
 
   NS_ASSERTION(result, "Result should have been created.");
 
   result->SetFlags(aTextureFlags);
   return result.forget();
 }
 
@@ -94,91 +94,91 @@ WrapMode(gl::GLContext *aGl, bool aAllow
   if (aAllowRepeat &&
       (aGl->IsExtensionSupported(GLContext::ARB_texture_non_power_of_two) ||
        aGl->IsExtensionSupported(GLContext::OES_texture_npot))) {
     return LOCAL_GL_REPEAT;
   }
   return LOCAL_GL_CLAMP_TO_EDGE;
 }
 
-TextureImageTextureHostOGL::~TextureImageTextureHostOGL()
+TextureImageDeprecatedTextureHostOGL::~TextureImageDeprecatedTextureHostOGL()
 {
-  MOZ_COUNT_DTOR(TextureImageTextureHostOGL);
+  MOZ_COUNT_DTOR(TextureImageDeprecatedTextureHostOGL);
   if (mTexture && mTexture->InUpdate()) {
     mTexture->EndUpdate();
   }
 }
 
 gfx::IntSize
-TextureImageTextureHostOGL::GetSize() const
+TextureImageDeprecatedTextureHostOGL::GetSize() const
 {
   if (mTexture) {
     if (mIterating) {
       nsIntRect rect = mTexture->GetTileRect();
       return gfx::IntSize(rect.width, rect.height);
     }
     return gfx::IntSize(mTexture->GetSize().width, mTexture->GetSize().height);
   }
   return gfx::IntSize(0, 0);
 }
 
 void
-TextureImageTextureHostOGL::SetCompositor(Compositor* aCompositor)
+TextureImageDeprecatedTextureHostOGL::SetCompositor(Compositor* aCompositor)
 {
   CompositorOGL* glCompositor = static_cast<CompositorOGL*>(aCompositor);
   GLContext* newGL = glCompositor ? glCompositor->gl() : nullptr;
   if (mGL != newGL) {
     mGL = newGL;
     mTexture = nullptr;
     // if we have a buffer we reupload it with the new gl context
-    // Post landing TODO: the new TextureClient/Host model will make this
+    // Post landing TODO: the new DeprecatedTextureClient/Host model will make this
     // go away.
     if (newGL && mBuffer && IsSurfaceDescriptorValid(*mBuffer)) {
       UpdateImpl(*mBuffer);
     }
   }
 }
 
 void
-TextureImageTextureHostOGL::EnsureBuffer(const nsIntSize& aSize,
+TextureImageDeprecatedTextureHostOGL::EnsureBuffer(const nsIntSize& aSize,
                                          gfxContentType aContentType)
 {
   if (!mTexture ||
       mTexture->GetSize() != aSize ||
       mTexture->GetContentType() != aContentType) {
     mTexture = mGL->CreateTextureImage(aSize,
                                        aContentType,
                                        WrapMode(mGL, mFlags & AllowRepeat),
                                        FlagsToGLFlags(mFlags));
   }
   mTexture->Resize(aSize);
 }
 
 void
-TextureImageTextureHostOGL::CopyTo(const nsIntRect& aSourceRect,
-                                   TextureHost *aDest,
+TextureImageDeprecatedTextureHostOGL::CopyTo(const nsIntRect& aSourceRect,
+                                   DeprecatedTextureHost *aDest,
                                    const nsIntRect& aDestRect)
 {
   MOZ_ASSERT(aDest->AsSourceOGL(), "Incompatible destination type!");
-  TextureImageTextureHostOGL *dest =
-    aDest->AsSourceOGL()->AsTextureImageTextureHost();
+  TextureImageDeprecatedTextureHostOGL *dest =
+    aDest->AsSourceOGL()->AsTextureImageDeprecatedTextureHost();
   MOZ_ASSERT(dest, "Incompatible destination type!");
 
   mGL->BlitTextureImage(mTexture, aSourceRect,
                         dest->mTexture, aDestRect);
   dest->mTexture->MarkValid();
 }
 
 void
-TextureImageTextureHostOGL::UpdateImpl(const SurfaceDescriptor& aImage,
+TextureImageDeprecatedTextureHostOGL::UpdateImpl(const SurfaceDescriptor& aImage,
                                        nsIntRegion* aRegion,
                                        nsIntPoint* aOffset)
 {
   if (!mGL) {
-    NS_WARNING("trying to update TextureImageTextureHostOGL without a compositor?");
+    NS_WARNING("trying to update TextureImageDeprecatedTextureHostOGL without a compositor?");
     return;
   }
   AutoOpenSurface surf(OPEN_READ_ONLY, aImage);
   nsIntSize size = surf.Size();
 
   if (!mTexture ||
       (mTexture->GetSize() != size && !aOffset) ||
       mTexture->GetContentType() != surf.ContentType()) {
@@ -204,66 +204,66 @@ TextureImageTextureHostOGL::UpdateImpl(c
   mFormat = mTexture->GetTextureFormat();
 
   if (mTexture->InUpdate()) {
     mTexture->EndUpdate();
   }
 }
 
 bool
-TextureImageTextureHostOGL::Lock()
+TextureImageDeprecatedTextureHostOGL::Lock()
 {
   if (!mTexture) {
-    NS_WARNING("TextureImageTextureHost to be composited without texture");
+    NS_WARNING("TextureImageDeprecatedTextureHost to be composited without texture");
     return false;
   }
 
   NS_ASSERTION(mTexture->GetContentType() != gfxASurface::CONTENT_ALPHA,
                 "Image layer has alpha image");
 
   mFormat = mTexture->GetTextureFormat();
 
   return true;
 }
 
 void
-SharedTextureHostOGL::SetCompositor(Compositor* aCompositor)
+SharedDeprecatedTextureHostOGL::SetCompositor(Compositor* aCompositor)
 {
   CompositorOGL* glCompositor = static_cast<CompositorOGL*>(aCompositor);
   if (mGL && !glCompositor) {
     DeleteTextures();
   }
   mGL = glCompositor ? glCompositor->gl() : nullptr;
 }
 
 void
-SharedTextureHostOGL::DeleteTextures()
+SharedDeprecatedTextureHostOGL::DeleteTextures()
 {
   MOZ_ASSERT(mGL);
   mGL->MakeCurrent();
   if (mSharedHandle) {
     mGL->ReleaseSharedHandle(mShareType, mSharedHandle);
     mSharedHandle = 0;
   }
   if (mTextureHandle) {
     mGL->fDeleteTextures(1, &mTextureHandle);
     mTextureHandle = 0;
   }
 }
 
 void
-SharedTextureHostOGL::UpdateImpl(const SurfaceDescriptor& aImage,
+SharedDeprecatedTextureHostOGL::UpdateImpl(const SurfaceDescriptor& aImage,
                                  nsIntRegion* aRegion,
                                  nsIntPoint* aOffset)
 {
   SwapTexturesImpl(aImage, aRegion);
 }
 
 void
-SharedTextureHostOGL::SwapTexturesImpl(const SurfaceDescriptor& aImage,
+SharedDeprecatedTextureHostOGL::SwapTexturesImpl(const SurfaceDescriptor& aImage,
                                        nsIntRegion* aRegion)
 {
   NS_ASSERTION(aImage.type() == SurfaceDescriptor::TSharedTextureDescriptor,
               "Invalid descriptor");
 
   SharedTextureDescriptor texture = aImage.get_SharedTextureDescriptor();
 
   SharedTextureHandle newHandle = texture.handle();
@@ -283,40 +283,40 @@ SharedTextureHostOGL::SwapTexturesImpl(c
   GLContext::SharedHandleDetails handleDetails;
   if (mSharedHandle && mGL->GetSharedHandleDetails(mShareType, mSharedHandle, handleDetails)) {
     mTextureTarget = handleDetails.mTarget;
     mFormat = handleDetails.mTextureFormat;
   }
 }
 
 bool
-SharedTextureHostOGL::Lock()
+SharedDeprecatedTextureHostOGL::Lock()
 {
   MakeTextureIfNeeded(mGL, mTextureTarget, mTextureHandle);
 
   mGL->fActiveTexture(LOCAL_GL_TEXTURE0);
   mGL->fBindTexture(mTextureTarget, mTextureHandle);
   if (!mGL->AttachSharedHandle(mShareType, mSharedHandle)) {
     NS_ERROR("Failed to bind shared texture handle");
     return false;
   }
 
   return true;
 }
 
 void
-SharedTextureHostOGL::Unlock()
+SharedDeprecatedTextureHostOGL::Unlock()
 {
   mGL->DetachSharedHandle(mShareType, mSharedHandle);
   mGL->fBindTexture(LOCAL_GL_TEXTURE_2D, 0);
 }
 
 
 gfx3DMatrix
-SharedTextureHostOGL::GetTextureTransform()
+SharedDeprecatedTextureHostOGL::GetTextureTransform()
 {
   GLContext::SharedHandleDetails handleDetails;
   // GetSharedHandleDetails can call into Java which we'd
   // rather not do from the compositor
   if (mSharedHandle) {
     mGL->GetSharedHandleDetails(mShareType, mSharedHandle, handleDetails);
   }
   return handleDetails.mTextureTransform;
@@ -436,34 +436,34 @@ SurfaceStreamHostOGL::Lock()
   mGL->fTexParameteri(LOCAL_GL_TEXTURE_2D,
                       LOCAL_GL_TEXTURE_WRAP_T,
                       LOCAL_GL_CLAMP_TO_EDGE);
   return true;
 }
 
 
 void
-YCbCrTextureHostOGL::SetCompositor(Compositor* aCompositor)
+YCbCrDeprecatedTextureHostOGL::SetCompositor(Compositor* aCompositor)
 {
   CompositorOGL* glCompositor = static_cast<CompositorOGL*>(aCompositor);
   GLContext* newGL = glCompositor ? glCompositor->gl() : nullptr;
   if (mGL != newGL) {
     mGL = newGL;
     mYTexture->mTexImage = nullptr;
     mCbTexture->mTexImage = nullptr;
     mCrTexture->mTexImage = nullptr;
     // if we have a buffer we reupload it with the new gl context
     if (newGL && mBuffer && mBuffer->type() == SurfaceDescriptor::TYCbCrImage) {
       UpdateImpl(*mBuffer);
     }
   }
 }
 
 void
-YCbCrTextureHostOGL::UpdateImpl(const SurfaceDescriptor& aImage,
+YCbCrDeprecatedTextureHostOGL::UpdateImpl(const SurfaceDescriptor& aImage,
                                 nsIntRegion* aRegion,
                                 nsIntPoint* aOffset)
 {
   if (!mGL) {
     return;
   }
   NS_ASSERTION(aImage.type() == SurfaceDescriptor::TYCbCrImage, "SurfaceDescriptor mismatch");
 
@@ -508,22 +508,22 @@ YCbCrTextureHostOGL::UpdateImpl(const Su
   nsIntRegion cbCrRegion(nsIntRect(0, 0, gfxCbCrSize.width, gfxCbCrSize.height));
 
   mYTexture->mTexImage->DirectUpdate(tempY, yRegion);
   mCbTexture->mTexImage->DirectUpdate(tempCb, cbCrRegion);
   mCrTexture->mTexImage->DirectUpdate(tempCr, cbCrRegion);
 }
 
 bool
-YCbCrTextureHostOGL::Lock()
+YCbCrDeprecatedTextureHostOGL::Lock()
 {
   return true;
 }
 
-TiledTextureHostOGL::~TiledTextureHostOGL()
+TiledDeprecatedTextureHostOGL::~TiledDeprecatedTextureHostOGL()
 {
   DeleteTextures();
 }
 
 static void
 GetFormatAndTileForImageFormat(gfxASurface::gfxImageFormat aFormat,
                                GLenum& aOutFormat,
                                GLenum& aOutType)
@@ -533,40 +533,40 @@ GetFormatAndTileForImageFormat(gfxASurfa
     aOutType = LOCAL_GL_UNSIGNED_SHORT_5_6_5;
   } else {
     aOutFormat = LOCAL_GL_RGBA;
     aOutType = LOCAL_GL_UNSIGNED_BYTE;
   }
 }
 
 void
-TiledTextureHostOGL::SetCompositor(Compositor* aCompositor)
+TiledDeprecatedTextureHostOGL::SetCompositor(Compositor* aCompositor)
 {
   CompositorOGL* glCompositor = static_cast<CompositorOGL*>(aCompositor);
   if (mGL && !glCompositor) {
     DeleteTextures();
   }
   mGL = glCompositor ? glCompositor->gl() : nullptr;
 }
 
 void
-TiledTextureHostOGL::DeleteTextures()
+TiledDeprecatedTextureHostOGL::DeleteTextures()
 {
   if (mTextureHandle) {
     mGL->MakeCurrent();
     mGL->fDeleteTextures(1, &mTextureHandle);
 
     gl::GLContext::UpdateTextureMemoryUsage(gl::GLContext::MemoryFreed, mGLFormat,
                                             GetTileType(), TILEDLAYERBUFFER_TILE_SIZE);
     mTextureHandle = 0;
   }
 }
 
 void
-TiledTextureHostOGL::Update(gfxReusableSurfaceWrapper* aReusableSurface, TextureFlags aFlags, const gfx::IntSize& aSize)
+TiledDeprecatedTextureHostOGL::Update(gfxReusableSurfaceWrapper* aReusableSurface, TextureFlags aFlags, const gfx::IntSize& aSize)
 {
   mSize = aSize;
   mGL->MakeCurrent();
   if (aFlags & NewTile) {
     SetFlags(aFlags);
     mGL->fGenTextures(1, &mTextureHandle);
     mGL->fBindTexture(LOCAL_GL_TEXTURE_2D, mTextureHandle);
     mGL->fTexParameteri(LOCAL_GL_TEXTURE_2D, LOCAL_GL_TEXTURE_MIN_FILTER, LOCAL_GL_LINEAR);
@@ -595,20 +595,20 @@ TiledTextureHostOGL::Update(gfxReusableS
   if (mGLFormat == LOCAL_GL_RGB) {
     mFormat = FORMAT_R8G8B8X8;
   } else {
     mFormat = FORMAT_B8G8R8A8;
   }
 }
 
 bool
-TiledTextureHostOGL::Lock()
+TiledDeprecatedTextureHostOGL::Lock()
 {
   if (!mTextureHandle) {
-    NS_WARNING("TiledTextureHostOGL not ready to be composited");
+    NS_WARNING("TiledDeprecatedTextureHostOGL not ready to be composited");
     return false;
   }
 
   mGL->MakeCurrent();
   mGL->fActiveTexture(LOCAL_GL_TEXTURE0);
 
   return true;
 }
@@ -675,95 +675,95 @@ TextureTargetForAndroidPixelFormat(andro
       // we'll take down the compositor process and thus the phone. This seems
       // like undesirable behaviour. We'd rather have a subtle artifact.
       MOZ_ASSERT(false, "Unknown Android pixel format.");
       return LOCAL_GL_TEXTURE_EXTERNAL;
     }
   }
 }
 
-GrallocTextureHostOGL::GrallocTextureHostOGL()
+GrallocDeprecatedTextureHostOGL::GrallocDeprecatedTextureHostOGL()
 : mCompositor(nullptr)
 , mTextureTarget(0)
 , mEGLImage(0)
 , mIsRBSwapped(false)
 {
 }
 
-void GrallocTextureHostOGL::SetCompositor(Compositor* aCompositor)
+void GrallocDeprecatedTextureHostOGL::SetCompositor(Compositor* aCompositor)
 {
   CompositorOGL* glCompositor = static_cast<CompositorOGL*>(aCompositor);
   if (mCompositor && !glCompositor) {
     DeleteTextures();
   }
   mCompositor = glCompositor;
 }
 
 void
-GrallocTextureHostOGL::DeleteTextures()
+GrallocDeprecatedTextureHostOGL::DeleteTextures()
 {
   if (mEGLImage) {
     gl()->MakeCurrent();
     gl()->DestroyEGLImage(mEGLImage);
     mEGLImage = 0;
   }
 }
 
 // only used for hacky fix in gecko 23 for bug 862324
 static void
-RegisterTextureHostAtGrallocBufferActor(TextureHost* aTextureHost, const SurfaceDescriptor& aSurfaceDescriptor)
+RegisterDeprecatedTextureHostAtGrallocBufferActor(DeprecatedTextureHost* aDeprecatedTextureHost, const SurfaceDescriptor& aSurfaceDescriptor)
 {
   if (IsSurfaceDescriptorValid(aSurfaceDescriptor)) {
     GrallocBufferActor* actor = static_cast<GrallocBufferActor*>(aSurfaceDescriptor.get_SurfaceDescriptorGralloc().bufferParent());
-    actor->SetTextureHost(aTextureHost);
+    actor->SetDeprecatedTextureHost(aDeprecatedTextureHost);
   }
 }
 
 void
-GrallocTextureHostOGL::UpdateImpl(const SurfaceDescriptor& aImage,
+GrallocDeprecatedTextureHostOGL::UpdateImpl(const SurfaceDescriptor& aImage,
                                  nsIntRegion* aRegion,
                                  nsIntPoint* aOffset)
 {
   SwapTexturesImpl(aImage, aRegion);
 }
 
 void
-GrallocTextureHostOGL::SwapTexturesImpl(const SurfaceDescriptor& aImage,
+GrallocDeprecatedTextureHostOGL::SwapTexturesImpl(const SurfaceDescriptor& aImage,
                                         nsIntRegion*)
 {
   MOZ_ASSERT(aImage.type() == SurfaceDescriptor::TSurfaceDescriptorGralloc);
 
   if (mBuffer) {
     // only done for hacky fix in gecko 23 for bug 862324.
-    RegisterTextureHostAtGrallocBufferActor(nullptr, *mBuffer);
+    RegisterDeprecatedTextureHostAtGrallocBufferActor(nullptr, *mBuffer);
   }
 
   const SurfaceDescriptorGralloc& desc = aImage.get_SurfaceDescriptorGralloc();
   mGraphicBuffer = GrallocBufferActor::GetFrom(desc);
   mIsRBSwapped = desc.isRBSwapped();
   mFormat = SurfaceFormatForAndroidPixelFormat(mGraphicBuffer->getPixelFormat(),
                                                mIsRBSwapped);
 
   mTextureTarget = TextureTargetForAndroidPixelFormat(mGraphicBuffer->getPixelFormat());
 
   DeleteTextures();
 
   // only done for hacky fix in gecko 23 for bug 862324.
   // Doing this in SetBuffer is not enough, as ImageHostBuffered::SwapTextures can
   // change the value of *mBuffer without calling SetBuffer again.
-  RegisterTextureHostAtGrallocBufferActor(this, aImage);
+  RegisterDeprecatedTextureHostAtGrallocBufferActor(this, aImage);
 }
 
 gl::GLContext*
-GrallocTextureHostOGL::gl() const
+GrallocDeprecatedTextureHostOGL::gl() const
 {
   return mCompositor ? mCompositor->gl() : nullptr;
 }
 
-void GrallocTextureHostOGL::BindTexture(GLenum aTextureUnit)
+void GrallocDeprecatedTextureHostOGL::BindTexture(GLenum aTextureUnit)
 {
   /*
    * The job of this function is to ensure that the texture is tied to the
    * android::GraphicBuffer, so that texturing will source the GraphicBuffer.
    *
    * To this effect we create an EGLImage wrapping this GraphicBuffer,
    * using CreateEGLImageForNativeBuffer, and then we tie this EGLImage to our
    * texture using fEGLImageTargetTexture2D.
@@ -781,66 +781,66 @@ void GrallocTextureHostOGL::BindTexture(
   if (!mEGLImage) {
     mEGLImage = gl()->CreateEGLImageForNativeBuffer(mGraphicBuffer->getNativeBuffer());
   }
   gl()->fEGLImageTargetTexture2D(mTextureTarget, mEGLImage);
   gl()->fActiveTexture(LOCAL_GL_TEXTURE0);
 }
 
 bool
-GrallocTextureHostOGL::IsValid() const
+GrallocDeprecatedTextureHostOGL::IsValid() const
 {
   return !!gl() && !!mGraphicBuffer.get();
 }
 
-GrallocTextureHostOGL::~GrallocTextureHostOGL()
+GrallocDeprecatedTextureHostOGL::~GrallocDeprecatedTextureHostOGL()
 {
   DeleteTextures();
 
   // only done for hacky fix in gecko 23 for bug 862324.
   if (mBuffer) {
     // make sure that if the GrallocBufferActor survives us, it doesn't keep a dangling
     // pointer to us.
-    RegisterTextureHostAtGrallocBufferActor(nullptr, *mBuffer);
+    RegisterDeprecatedTextureHostAtGrallocBufferActor(nullptr, *mBuffer);
   }
 }
 
 bool
-GrallocTextureHostOGL::Lock()
+GrallocDeprecatedTextureHostOGL::Lock()
 {
   // Lock/Unlock is done internally when binding the gralloc buffer to a gl texture
   return IsValid();
 }
 
 void
-GrallocTextureHostOGL::Unlock()
+GrallocDeprecatedTextureHostOGL::Unlock()
 {
   // Lock/Unlock is done internally when binding the gralloc buffer to a gl texture
 }
 
 gfx::SurfaceFormat
-GrallocTextureHostOGL::GetFormat() const
+GrallocDeprecatedTextureHostOGL::GetFormat() const
 {
   return mFormat;
 }
 
 void
-GrallocTextureHostOGL::SetBuffer(SurfaceDescriptor* aBuffer, ISurfaceAllocator* aAllocator)
+GrallocDeprecatedTextureHostOGL::SetBuffer(SurfaceDescriptor* aBuffer, ISurfaceAllocator* aAllocator)
 {
   MOZ_ASSERT(!mBuffer, "Will leak the old mBuffer");
   mBuffer = aBuffer;
   mDeAllocator = aAllocator;
 
   // only done for hacky fix in gecko 23 for bug 862324.
   // Doing this in SwapTextures is not enough, as the crash could occur right after SetBuffer.
-  RegisterTextureHostAtGrallocBufferActor(this, *mBuffer);
+  RegisterDeprecatedTextureHostAtGrallocBufferActor(this, *mBuffer);
 }
 
 LayerRenderState
-GrallocTextureHostOGL::GetRenderState()
+GrallocDeprecatedTextureHostOGL::GetRenderState()
 {
   if (mBuffer && IsSurfaceDescriptorValid(*mBuffer)) {
 
     uint32_t flags = mFlags & NeedsYFlip ? LAYER_RENDER_STATE_Y_FLIPPED : 0;
 
     /*
      * The 32 bit format of gralloc buffer is created as RGBA8888 or RGBX888 by default.
      * For software rendering (non-GL rendering), the content is drawn with BGRA
@@ -859,37 +859,37 @@ GrallocTextureHostOGL::GetRenderState()
                             flags);
   }
 
   return LayerRenderState();
 }
 #endif // MOZ_WIDGET_GONK
 
 already_AddRefed<gfxImageSurface>
-TextureImageTextureHostOGL::GetAsSurface() {
+TextureImageDeprecatedTextureHostOGL::GetAsSurface() {
   nsRefPtr<gfxImageSurface> surf = IsValid() ?
     mGL->GetTexImage(mTexture->GetTextureID(),
                      false,
                      mTexture->GetTextureFormat())
     : nullptr;
   return surf.forget();
 }
 
 already_AddRefed<gfxImageSurface>
-YCbCrTextureHostOGL::GetAsSurface() {
+YCbCrDeprecatedTextureHostOGL::GetAsSurface() {
   nsRefPtr<gfxImageSurface> surf = IsValid() ?
     mGL->GetTexImage(mYTexture->mTexImage->GetTextureID(),
                      false,
                      mYTexture->mTexImage->GetTextureFormat())
     : nullptr;
   return surf.forget();
 }
 
 already_AddRefed<gfxImageSurface>
-SharedTextureHostOGL::GetAsSurface() {
+SharedDeprecatedTextureHostOGL::GetAsSurface() {
   nsRefPtr<gfxImageSurface> surf = IsValid() ?
     mGL->GetTexImage(GetTextureHandle(),
                      false,
                      GetTextureFormat())
     : nullptr;
   return surf.forget();
 }
 
@@ -899,28 +899,28 @@ SurfaceStreamHostOGL::GetAsSurface() {
     mGL->GetTexImage(mTextureHandle,
                      false,
                      GetTextureFormat())
     : nullptr;
   return surf.forget();
 }
 
 already_AddRefed<gfxImageSurface>
-TiledTextureHostOGL::GetAsSurface() {
+TiledDeprecatedTextureHostOGL::GetAsSurface() {
   nsRefPtr<gfxImageSurface> surf = IsValid() ?
     mGL->GetTexImage(mTextureHandle,
                      false,
                      GetTextureFormat())
     : nullptr;
   return surf.forget();
 }
 
 #ifdef MOZ_WIDGET_GONK
 already_AddRefed<gfxImageSurface>
-GrallocTextureHostOGL::GetAsSurface() {
+GrallocDeprecatedTextureHostOGL::GetAsSurface() {
   gl()->MakeCurrent();
 
   GLuint tex = mCompositor->GetTemporaryTexture(LOCAL_GL_TEXTURE0);
   gl()->fActiveTexture(LOCAL_GL_TEXTURE0);
   gl()->fBindTexture(mTextureTarget, tex);
   if (!mEGLImage) {
     mEGLImage = gl()->CreateEGLImageForNativeBuffer(mGraphicBuffer->getNativeBuffer());
   }
--- a/gfx/layers/opengl/TextureHostOGL.h
+++ b/gfx/layers/opengl/TextureHostOGL.h
@@ -15,17 +15,17 @@
 
 #ifdef MOZ_WIDGET_GONK
 #include <ui/GraphicBuffer.h>
 #endif
 
 namespace mozilla {
 namespace layers {
 
-class TextureImageTextureHostOGL;
+class TextureImageDeprecatedTextureHostOGL;
 class CompositorOGL;
 
 /*
  * TextureHost implementations for the OpenGL backend.
  *
  * Note that it is important to be careful about the ownership model with
  * the OpenGL backend, due to some widget limitation on Linux: before
  * the nsBaseWidget associated with our OpenGL context has been completely
@@ -52,83 +52,83 @@ public:
   virtual gfx::SurfaceFormat GetTextureFormat() const {
     MOZ_CRASH("unhandled texture format");
   }
   // TODO: Noone's implementing this anymore, should see if we need this.
   virtual GLenum GetTextureTarget() const { return LOCAL_GL_TEXTURE_2D; }
   virtual GLenum GetWrapMode() const = 0;// { return LOCAL_GL_CLAMP_TO_EDGE; } // default
   virtual gfx3DMatrix GetTextureTransform() { return gfx3DMatrix(); }
 
-  virtual TextureImageTextureHostOGL* AsTextureImageTextureHost() { return nullptr; }
+  virtual TextureImageDeprecatedTextureHostOGL* AsTextureImageDeprecatedTextureHost() { return nullptr; }
 };
 
 inline ShaderProgramType
-GetProgramTypeForTexture(const TextureHost *aTextureHost)
+GetProgramTypeForTexture(const DeprecatedTextureHost *aDeprecatedTextureHost)
 {
-  switch (aTextureHost->GetFormat()) {
+  switch (aDeprecatedTextureHost->GetFormat()) {
   case gfx::FORMAT_B8G8R8A8:
     return BGRALayerProgramType;;
   case gfx::FORMAT_B8G8R8X8:
     return BGRXLayerProgramType;;
   case gfx::FORMAT_R8G8B8X8:
     return RGBXLayerProgramType;;
   case gfx::FORMAT_R8G8B8A8:
     return RGBALayerProgramType;;
   default:
     MOZ_CRASH("unhandled program type");
   }
 }
 
 /**
- * TextureHost implementation using a TextureImage as the underlying texture.
+ * DeprecatedTextureHost implementation using a TextureImage as the underlying texture.
  */
-class TextureImageTextureHostOGL : public TextureHost
-                                 , public TextureSourceOGL
-                                 , public TileIterator
+class TextureImageDeprecatedTextureHostOGL : public DeprecatedTextureHost
+                                           , public TextureSourceOGL
+                                           , public TileIterator
 {
 public:
-  TextureImageTextureHostOGL(gl::TextureImage* aTexImage = nullptr)
+  TextureImageDeprecatedTextureHostOGL(gl::TextureImage* aTexImage = nullptr)
     : mTexture(aTexImage)
     , mGL(nullptr)
     , mIterating(false)
   {
-    MOZ_COUNT_CTOR(TextureImageTextureHostOGL);
+    MOZ_COUNT_CTOR(TextureImageDeprecatedTextureHostOGL);
   }
 
-  ~TextureImageTextureHostOGL();
+  ~TextureImageDeprecatedTextureHostOGL();
 
   TextureSourceOGL* AsSourceOGL() MOZ_OVERRIDE
   {
     return this;
   }
 
-  virtual TextureImageTextureHostOGL* AsTextureImageTextureHost() MOZ_OVERRIDE
+  virtual TextureImageDeprecatedTextureHostOGL* AsTextureImageDeprecatedTextureHost() MOZ_OVERRIDE
   {
     return this;
   }
 
   // This is a hack that is here to not break on-main-thread ThebesLayerBuffer
   // please do not use it anywhere else, use SetCompositor instead.
   void SetGLContext(gl::GLContext* aGL)
   {
     mGL = aGL;
   }
 
-  // TextureHost
+  // DeprecatedTextureHost
 
   void UpdateImpl(const SurfaceDescriptor& aImage,
                   nsIntRegion* aRegion = nullptr,
                   nsIntPoint* aOffset = nullptr) MOZ_OVERRIDE;
 
   virtual void SetCompositor(Compositor* aCompositor) MOZ_OVERRIDE;
 
   virtual void EnsureBuffer(const nsIntSize& aSize, gfxContentType aType) MOZ_OVERRIDE;
 
   virtual void CopyTo(const nsIntRect& aSourceRect,
-                      TextureHost *aDest,
+                      DeprecatedTextureHost *aDest,
                       const nsIntRect& aDestRect) MOZ_OVERRIDE;
 
   bool IsValid() const MOZ_OVERRIDE
   {
     return !!mTexture;
   }
 
   virtual bool Lock() MOZ_OVERRIDE;
@@ -197,53 +197,53 @@ public:
   }
 
   bool NextTile() MOZ_OVERRIDE
   {
     return mTexture->NextTile();
   }
 
 #ifdef MOZ_LAYERS_HAVE_LOG
-  virtual const char* Name() { return "TextureImageTextureHostOGL"; }
+  virtual const char* Name() { return "TextureImageDeprecatedTextureHostOGL"; }
 #endif
 
 protected:
   nsRefPtr<gl::TextureImage> mTexture;
   gl::GLContext* mGL;
   bool mIterating;
 };
 
 
 /**
- * TextureHost implementation for YCbCr images in the OpenGL backend.
+ * DeprecatedTextureHost implementation for YCbCr images in the OpenGL backend.
  *
- * This TextureHost is a little bit particular in that it implements
- * the TextureSource interface, as it is required that a TextureHost
+ * This DeprecatedTextureHost is a little bit particular in that it implements
+ * the TextureSource interface, as it is required that a DeprecatedTextureHost
  * provides access to a TextureSource, but does not implement the
- * TextureHostOGL interface. Instead it contains 3 channels (one per
+ * DeprecatedTextureHostOGL interface. Instead it contains 3 channels (one per
  * plane) that implement the TextureSourceOGL interface, and
- * YCbCrTextureHostOGL's TextureSource implementation provide access
+ * YCbCrDeprecatedTextureHostOGL's TextureSource implementation provide access
  * to these channels with the GetSubSource method.
  */
-class YCbCrTextureHostOGL : public TextureHost
+class YCbCrDeprecatedTextureHostOGL : public DeprecatedTextureHost
 {
 public:
-  YCbCrTextureHostOGL()
+  YCbCrDeprecatedTextureHostOGL()
     : mGL(nullptr)
   {
-    MOZ_COUNT_CTOR(YCbCrTextureHostOGL);
+    MOZ_COUNT_CTOR(YCbCrDeprecatedTextureHostOGL);
     mYTexture  = new Channel;
     mCbTexture = new Channel;
     mCrTexture = new Channel;
     mFormat = gfx::FORMAT_YUV;
   }
 
-  ~YCbCrTextureHostOGL()
+  ~YCbCrDeprecatedTextureHostOGL()
   {
-    MOZ_COUNT_DTOR(YCbCrTextureHostOGL);
+    MOZ_COUNT_DTOR(YCbCrDeprecatedTextureHostOGL);
   }
 
   virtual void SetCompositor(Compositor* aCompositor) MOZ_OVERRIDE;
 
   virtual void UpdateImpl(const SurfaceDescriptor& aImage,
                           nsIntRegion* aRegion = nullptr,
                           nsIntPoint* aOffset = nullptr) MOZ_OVERRIDE;
 
@@ -297,70 +297,70 @@ public:
       case 2 : return mCrTexture.get();
     }
     return nullptr;
   }
 
   gfx::IntSize GetSize() const MOZ_OVERRIDE
   {
     if (!mYTexture->mTexImage) {
-      NS_WARNING("YCbCrTextureHost::GetSize called but no data has been set yet");
+      NS_WARNING("YCbCrDeprecatedTextureHost::GetSize called but no data has been set yet");
       return gfx::IntSize(0,0);
     }
     return mYTexture->GetSize();
   }
 
   virtual already_AddRefed<gfxImageSurface> GetAsSurface() MOZ_OVERRIDE;
 
 #ifdef MOZ_LAYERS_HAVE_LOG
-  virtual const char* Name() { return "YCbCrTextureHostOGL"; }
+  virtual const char* Name() { return "YCbCrDeprecatedTextureHostOGL"; }
 #endif
 
 private:
   RefPtr<Channel> mYTexture;
   RefPtr<Channel> mCbTexture;
   RefPtr<Channel> mCrTexture;
   gl::GLContext* mGL;
 };
 
-class SharedTextureHostOGL : public TextureHost
+class SharedDeprecatedTextureHostOGL : public DeprecatedTextureHost
                            , public TextureSourceOGL
 {
 public:
   typedef gfxASurface::gfxContentType ContentType;
   typedef mozilla::gl::GLContext GLContext;
   typedef mozilla::gl::TextureImage TextureImage;
 
-  SharedTextureHostOGL()
+  SharedDeprecatedTextureHostOGL()
     : mGL(nullptr)
     , mTextureHandle(0)
     , mWrapMode(LOCAL_GL_CLAMP_TO_EDGE)
     , mSharedHandle(0)
     , mShareType(GLContext::SameProcess)
   {}
 
   virtual void SetCompositor(Compositor* aCompositor) MOZ_OVERRIDE;
 
-  virtual ~SharedTextureHostOGL()
+  virtual ~SharedDeprecatedTextureHostOGL()
   {
     if (mSharedHandle || mTextureHandle) {
       DeleteTextures();
     }
   }
 
   virtual GLuint GetTextureHandle()
   {
     return mTextureHandle;
   }
 
   virtual TextureSourceOGL* AsSourceOGL() MOZ_OVERRIDE { return this; }
 
   bool IsValid() const MOZ_OVERRIDE { return !!mSharedHandle; }
 
-  // override from TextureHost, we support both buffered
+  // override from DeprecatedTextureHost, we support both buffered
   // and unbuffered operation.
   virtual void UpdateImpl(const SurfaceDescriptor& aImage,
                           nsIntRegion* aRegion = nullptr,
                           nsIntPoint* aOffset = nullptr) MOZ_OVERRIDE;
   virtual void SwapTexturesImpl(const SurfaceDescriptor& aImage,
                                 nsIntRegion* aRegion = nullptr) MOZ_OVERRIDE;
   virtual bool Lock() MOZ_OVERRIDE;
   virtual void Unlock() MOZ_OVERRIDE;
@@ -397,32 +397,32 @@ public:
              gfxASurface::CONTENT_COLOR;
   }
 
   virtual gfx3DMatrix GetTextureTransform() MOZ_OVERRIDE;
 
   virtual already_AddRefed<gfxImageSurface> GetAsSurface() MOZ_OVERRIDE;
 
 #ifdef MOZ_LAYERS_HAVE_LOG
-  virtual const char* Name() { return "SharedTextureHostOGL"; }
+  virtual const char* Name() { return "SharedDeprecatedTextureHostOGL"; }
 #endif
 
 protected:
   void DeleteTextures();
 
   gfx::IntSize mSize;
   nsRefPtr<gl::GLContext> mGL;
   GLuint mTextureHandle;
   GLenum mWrapMode;
   GLenum mTextureTarget;
   gl::SharedTextureHandle mSharedHandle;
   gl::GLContext::SharedTextureShareType mShareType;
 };
 
-class SurfaceStreamHostOGL : public TextureHost
+class SurfaceStreamHostOGL : public DeprecatedTextureHost
                            , public TextureSourceOGL
 {
 public:
   typedef gfxASurface::gfxContentType ContentType;
   typedef mozilla::gl::GLContext GLContext;
   typedef mozilla::gl::TextureImage TextureImage;
 
   virtual ~SurfaceStreamHostOGL()
@@ -437,17 +437,17 @@ public:
   {
     return mTextureHandle;
   }
 
   virtual TextureSourceOGL* AsSourceOGL() MOZ_OVERRIDE { return this; }
 
   bool IsValid() const MOZ_OVERRIDE { return true; }
 
-  // override from TextureHost
+  // override from DeprecatedTextureHost
   virtual void SwapTexturesImpl(const SurfaceDescriptor& aImage,
                                 nsIntRegion* aRegion = nullptr) MOZ_OVERRIDE;
   virtual bool Lock() MOZ_OVERRIDE;
   virtual void Unlock() MOZ_OVERRIDE;
 
   virtual GLenum GetWrapMode() const MOZ_OVERRIDE {
     return mWrapMode;
   }
@@ -501,25 +501,25 @@ protected:
 
   gfx::IntSize mSize;
   nsRefPtr<GLContext> mGL;
   GLuint mTextureHandle;
   GLuint mUploadTexture;
   GLenum mWrapMode;
 };
 
-class TiledTextureHostOGL : public TextureHost
+class TiledDeprecatedTextureHostOGL : public DeprecatedTextureHost
                           , public TextureSourceOGL
 {
 public:
-  TiledTextureHostOGL()
+  TiledDeprecatedTextureHostOGL()
     : mTextureHandle(0)
     , mGL(nullptr)
   {}
-  ~TiledTextureHostOGL();
+  ~TiledDeprecatedTextureHostOGL();
 
   virtual void SetCompositor(Compositor* aCompositor);
 
   // have to pass the size in here (every time) because of DrawQuad API :-(
   virtual void Update(gfxReusableSurfaceWrapper* aReusableSurface, TextureFlags aFlags, const gfx::IntSize& aSize) MOZ_OVERRIDE;
   virtual bool Lock() MOZ_OVERRIDE;
   virtual void Unlock() MOZ_OVERRIDE {}
 
@@ -544,17 +544,17 @@ public:
 
   virtual void SwapTexturesImpl(const SurfaceDescriptor& aImage,
                                 nsIntRegion* aRegion = nullptr)
   { MOZ_ASSERT(false, "Tiles should not use this path"); }
 
   virtual already_AddRefed<gfxImageSurface> GetAsSurface() MOZ_OVERRIDE;
 
 #ifdef MOZ_LAYERS_HAVE_LOG
-  virtual const char* Name() { return "TiledTextureHostOGL"; }
+  virtual const char* Name() { return "TiledDeprecatedTextureHostOGL"; }
 #endif
 
 protected:
   void DeleteTextures();
 
   virtual uint64_t GetIdentifier() const MOZ_OVERRIDE {
     return static_cast<uint64_t>(mTextureHandle);
   }
@@ -569,28 +569,28 @@ private:
   gfx::IntSize mSize;
   GLuint mTextureHandle;
   GLenum mGLFormat;
   nsRefPtr<gl::GLContext> mGL;
 };
 
 #ifdef MOZ_WIDGET_GONK
 
-// For direct texturing with gralloc buffers. The corresponding TextureClient is TextureClientShmem,
+// For direct texturing with gralloc buffers. The corresponding DeprecatedTextureClient is DeprecatedTextureClientShmem,
 // which automatically gets gralloc when it can, in which case the compositor sees that the
-// SurfaceDescriptor is gralloc, and decides to use a GrallocTextureHostOGL to do direct texturing,
+// SurfaceDescriptor is gralloc, and decides to use a GrallocDeprecatedTextureHostOGL to do direct texturing,
 // saving the cost of a texture upload.
-class GrallocTextureHostOGL
-  : public TextureHost
+class GrallocDeprecatedTextureHostOGL
+  : public DeprecatedTextureHost
   , public TextureSourceOGL
 {
 public:
-  GrallocTextureHostOGL();
+  GrallocDeprecatedTextureHostOGL();
 
-  ~GrallocTextureHostOGL();
+  ~GrallocDeprecatedTextureHostOGL();
 
   virtual void SetCompositor(Compositor* aCompositor) MOZ_OVERRIDE;
 
   virtual void UpdateImpl(const SurfaceDescriptor& aImage,
                           nsIntRegion* aRegion = nullptr,
                           nsIntPoint* aOffset = nullptr) MOZ_OVERRIDE;
   virtual void SwapTexturesImpl(const SurfaceDescriptor& aImage,
                           nsIntRegion* aRegion = nullptr) MOZ_OVERRIDE;
@@ -616,17 +616,17 @@ public:
     return LOCAL_GL_CLAMP_TO_EDGE;
   }
 
   bool IsValid() const MOZ_OVERRIDE;
 
   virtual already_AddRefed<gfxImageSurface> GetAsSurface() MOZ_OVERRIDE;
 
 #ifdef MOZ_LAYERS_HAVE_LOG
-  virtual const char* Name() { return "GrallocTextureHostOGL"; }
+  virtual const char* Name() { return "GrallocDeprecatedTextureHostOGL"; }
 #endif
 
   void BindTexture(GLenum aTextureUnit) MOZ_OVERRIDE;
   void ReleaseTexture() MOZ_OVERRIDE {}
 
   virtual gfx::SurfaceFormat GetFormat() const;
 
   virtual TextureSourceOGL* AsSourceOGL() MOZ_OVERRIDE
--- a/ipc/glue/IPCMessageUtils.h
+++ b/ipc/glue/IPCMessageUtils.h
@@ -1144,24 +1144,24 @@ struct ParamTraits<mozilla::layers::Text
 template<>
 struct ParamTraits<mozilla::layers::TextureInfo>
 {
   typedef mozilla::layers::TextureInfo paramType;
   
   static void Write(Message* aMsg, const paramType& aParam)
   {
     WriteParam(aMsg, aParam.mCompositableType);
-    WriteParam(aMsg, aParam.mTextureHostFlags);
+    WriteParam(aMsg, aParam.mDeprecatedTextureHostFlags);
     WriteParam(aMsg, aParam.mTextureFlags);
   }
 
   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
   {
     return ReadParam(aMsg, aIter, &aResult->mCompositableType) &&
-           ReadParam(aMsg, aIter, &aResult->mTextureHostFlags) &&
+           ReadParam(aMsg, aIter, &aResult->mDeprecatedTextureHostFlags) &&
            ReadParam(aMsg, aIter, &aResult->mTextureFlags);
   }
 };
 
 template <>
 struct ParamTraits<mozilla::layers::CompositableType>
   : public EnumSerializer<mozilla::layers::CompositableType,
                           mozilla::layers::BUFFER_UNKNOWN,