Bug 893301. Renaming and indentation fixes. r=nical
authorNicholas Cameron <ncameron@mozilla.com>
Thu, 28 Nov 2013 10:16:35 +1300
changeset 157863 05abcd9325c0f4ad306efc87b10d631ebd9778b4
parent 157862 0c21d59e99afe52f0992f5e8a15e7357c8d420cc
child 157864 1a704641cba803ffb7ec7de16035db38e899efe5
push id25726
push usercbook@mozilla.com
push dateThu, 28 Nov 2013 10:47:25 +0000
treeherdermozilla-central@cdca43b7657d [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersnical
bugs893301
milestone28.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 893301. Renaming and indentation fixes. r=nical
gfx/layers/client/ContentClient.cpp
gfx/layers/client/ContentClient.h
gfx/layers/composite/CompositableHost.cpp
gfx/layers/composite/ContentHost.cpp
gfx/layers/composite/ContentHost.h
gfx/layers/ipc/CompositableTransactionParent.cpp
--- a/gfx/layers/client/ContentClient.cpp
+++ b/gfx/layers/client/ContentClient.cpp
@@ -58,30 +58,30 @@ ContentClient::CreateContentClient(Compo
 #endif
   {
     useDoubleBuffering = LayerManagerComposite::SupportsDirectTexturing() ||
                          backend == LAYERS_BASIC;
   }
 
   if (useDoubleBuffering || PR_GetEnv("MOZ_FORCE_DOUBLE_BUFFERING")) {
     if (gfxPlatform::GetPlatform()->UseDeprecatedTextures()) {
-      return new ContentClientDoubleBuffered(aForwarder);
+      return new DeprecatedContentClientDoubleBuffered(aForwarder);
     } else {
-      return new ContentClientDoubleBufferedNew(aForwarder);
+      return new ContentClientDoubleBuffered(aForwarder);
     }
   }
 #ifdef XP_MACOSX
   if (backend == LAYERS_OPENGL) {
     return new ContentClientIncremental(aForwarder);
   }
 #endif
   if (gfxPlatform::GetPlatform()->UseDeprecatedTextures()) {
-    return new ContentClientSingleBuffered(aForwarder);
+    return new DeprecatedContentClientSingleBuffered(aForwarder);
   } else {
-    return new ContentClientSingleBufferedNew(aForwarder);
+    return new ContentClientSingleBuffered(aForwarder);
   }
 }
 
 ContentClientBasic::ContentClientBasic(CompositableForwarder* aForwarder,
                                        BasicLayerManager* aManager)
   : ContentClient(aForwarder)
   , RotatedContentBuffer(ContainsVisibleBounds)
   , mManager(aManager)
@@ -100,17 +100,17 @@ ContentClientBasic::CreateBuffer(Content
     gfxPlatform::GetPlatform()->OptimalFormatForContent(aType);
 
   *aBlackDT = gfxPlatform::GetPlatform()->CreateOffscreenContentDrawTarget(
     IntSize(aRect.width, aRect.height),
     ImageFormatToSurfaceFormat(format));
 }
 
 void
-ContentClientRemoteBufferNew::DestroyBuffers()
+ContentClientRemoteBuffer::DestroyBuffers()
 {
   if (!mTextureClient) {
     return;
   }
   MOZ_ASSERT(mTextureClient->GetAccessMode() == TextureClient::ACCESS_READ_WRITE);
 
   mOldTextures.AppendElement(mTextureClient);
   mTextureClient = nullptr;
@@ -118,30 +118,30 @@ ContentClientRemoteBufferNew::DestroyBuf
     mOldTextures.AppendElement(mTextureClientOnWhite);
     mTextureClientOnWhite = nullptr;
   }
 
   DestroyFrontBuffer();
 }
 
 void
-ContentClientRemoteBufferNew::BeginPaint()
+ContentClientRemoteBuffer::BeginPaint()
 {
   // 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) {
     SetNewBufferProvider(mTextureClient);
   }
   if (mTextureClientOnWhite) {
     SetNewBufferProviderOnWhite(mTextureClientOnWhite);
   }
 }
 
 void
-ContentClientRemoteBufferNew::EndPaint()
+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.
   SetNewBufferProvider(nullptr);
   SetNewBufferProviderOnWhite(nullptr);
   for (size_t i = 0; i < mOldTextures.Length(); ++i) {
     RemoveTextureClient(mOldTextures[i]);
   }
@@ -151,18 +151,18 @@ ContentClientRemoteBufferNew::EndPaint()
     mTextureClient->Unlock();
   }
   if (mTextureClientOnWhite) {
     mTextureClientOnWhite->Unlock();
   }
 }
 
 bool
-ContentClientRemoteBufferNew::CreateAndAllocateTextureClient(RefPtr<TextureClient>& aClient,
-                                                             TextureFlags aFlags)
+ContentClientRemoteBuffer::CreateAndAllocateTextureClient(RefPtr<TextureClient>& aClient,
+                                                          TextureFlags aFlags)
 {
   aClient = CreateTextureClientForDrawing(mSurfaceFormat,
                                           mTextureInfo.mTextureFlags | aFlags);
   if (!aClient) {
     return false;
   }
 
   if (!aClient->AsTextureClientDrawTarget()->AllocateForSurface(mSize)) {
@@ -178,19 +178,19 @@ ContentClientRemoteBufferNew::CreateAndA
     }
   }
 
   NS_WARN_IF_FALSE(aClient->IsValid(), "Created an invalid texture client");
   return true;
 }
 
 void
-ContentClientRemoteBufferNew::BuildTextureClients(SurfaceFormat aFormat,
-                                                  const nsIntRect& aRect,
-                                                  uint32_t aFlags)
+ContentClientRemoteBuffer::BuildTextureClients(SurfaceFormat aFormat,
+                                               const nsIntRect& aRect,
+                                               uint32_t aFlags)
 {
   // If we hit this assertion, then it might be due to an empty transaction
   // followed by a real transaction. Our buffers should be created (but not
   // painted in the empty transaction) and then painted (but not created) in the
   // real transaction. That is kind of fragile, and this assert will catch
   // circumstances where we screw that up, e.g., by unnecessarily recreating our
   // buffers.
   NS_ABORT_IF_FALSE(!mIsNewBuffer,
@@ -219,17 +219,17 @@ ContentClientRemoteBufferNew::BuildTextu
     }
     mTextureInfo.mTextureFlags |= TEXTURE_COMPONENT_ALPHA;
   }
 
   CreateFrontBuffer(aRect);
 }
 
 void
-ContentClientRemoteBufferNew::CreateBuffer(ContentType aType,
+ContentClientRemoteBuffer::CreateBuffer(ContentType aType,
                                         const nsIntRect& aRect,
                                         uint32_t aFlags,
                                         RefPtr<gfx::DrawTarget>* aBlackDT,
                                         RefPtr<gfx::DrawTarget>* aWhiteDT)
 {
   BuildTextureClients(gfxPlatform::GetPlatform()->Optimal2DFormatForContent(aType), aRect, aFlags);
   if (!mTextureClient) {
     return;
@@ -237,17 +237,17 @@ ContentClientRemoteBufferNew::CreateBuff
 
   *aBlackDT = mTextureClient->AsTextureClientDrawTarget()->GetAsDrawTarget();
   if (aFlags & BUFFER_COMPONENT_ALPHA) {
     *aWhiteDT = mTextureClientOnWhite->AsTextureClientDrawTarget()->GetAsDrawTarget();
   }
 }
 
 nsIntRegion
-ContentClientRemoteBufferNew::GetUpdatedRegion(const nsIntRegion& aRegionToDraw,
+ContentClientRemoteBuffer::GetUpdatedRegion(const nsIntRegion& aRegionToDraw,
                                             const nsIntRegion& aVisibleRegion,
                                             bool aDidSelfCopy)
 {
   nsIntRegion updatedRegion;
   if (mIsNewBuffer || aDidSelfCopy) {
     // A buffer reallocation clears both buffers. The front buffer has all the
     // content by now, but the back buffer is still clear. Here, in effect, we
     // are saying to copy all of the pixels of the front buffer to the back.
@@ -264,17 +264,17 @@ ContentClientRemoteBufferNew::GetUpdated
   NS_ASSERTION(BufferRect().Contains(aRegionToDraw.GetBounds()),
                "Update outside of buffer rect!");
   NS_ABORT_IF_FALSE(mTextureClient, "should have a back buffer by now");
 
   return updatedRegion;
 }
 
 void
-ContentClientRemoteBufferNew::Updated(const nsIntRegion& aRegionToDraw,
+ContentClientRemoteBuffer::Updated(const nsIntRegion& aRegionToDraw,
                                    const nsIntRegion& aVisibleRegion,
                                    bool aDidSelfCopy)
 {
   nsIntRegion updatedRegion = GetUpdatedRegion(aRegionToDraw,
                                                aVisibleRegion,
                                                aDidSelfCopy);
 
   MOZ_ASSERT(mTextureClient);
@@ -286,77 +286,77 @@ ContentClientRemoteBufferNew::Updated(co
   mForwarder->UseTexture(this, mTextureClient);
   mForwarder->UpdateTextureRegion(this,
                                   ThebesBufferData(BufferRect(),
                                                    BufferRotation()),
                                   updatedRegion);
 }
 
 void
-ContentClientRemoteBufferNew::SwapBuffers(const nsIntRegion& aFrontUpdatedRegion)
+ContentClientRemoteBuffer::SwapBuffers(const nsIntRegion& aFrontUpdatedRegion)
 {
   MOZ_ASSERT(mTextureClient->GetAccessMode() == TextureClient::ACCESS_NONE);
   MOZ_ASSERT(!mTextureClientOnWhite || mTextureClientOnWhite->GetAccessMode() == TextureClient::ACCESS_NONE);
   MOZ_ASSERT(mTextureClient);
 
   mFrontAndBackBufferDiffer = true;
   mTextureClient->SetAccessMode(TextureClient::ACCESS_READ_WRITE);
   if (mTextureClientOnWhite) {
     mTextureClientOnWhite->SetAccessMode(TextureClient::ACCESS_READ_WRITE);
   }
 }
 
 void
-ContentClientRemoteBuffer::DestroyBuffers()
+DeprecatedContentClientRemoteBuffer::DestroyBuffers()
 {
   if (!mDeprecatedTextureClient) {
     return;
   }
 
   MOZ_ASSERT(mDeprecatedTextureClient->GetAccessMode() == DeprecatedTextureClient::ACCESS_READ_WRITE);
   mDeprecatedTextureClient = nullptr;
   mDeprecatedTextureClientOnWhite = nullptr;
 
   DestroyFrontBuffer();
 
   mForwarder->DestroyThebesBuffer(this);
 }
 
 void
-ContentClientRemoteBuffer::BeginPaint()
+DeprecatedContentClientRemoteBuffer::BeginPaint()
 {
   // XXX: So we might not have a DeprecatedTextureClient yet.. because it will
   // only be created by CreateBuffer.. which will deliver a locked surface!.
   if (mDeprecatedTextureClient) {
     SetBufferProvider(mDeprecatedTextureClient);
   }
   if (mDeprecatedTextureClientOnWhite) {
     SetBufferProviderOnWhite(mDeprecatedTextureClientOnWhite);
   }
 }
 
 void
-ContentClientRemoteBuffer::EndPaint()
+DeprecatedContentClientRemoteBuffer::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 (mDeprecatedTextureClient) {
     mDeprecatedTextureClient->Unlock();
   }
   if (mDeprecatedTextureClientOnWhite) {
     mDeprecatedTextureClientOnWhite->Unlock();
   }
 }
 
 bool
-ContentClientRemoteBuffer::CreateAndAllocateDeprecatedTextureClient(RefPtr<DeprecatedTextureClient>& aClient)
+DeprecatedContentClientRemoteBuffer::CreateAndAllocateDeprecatedTextureClient(RefPtr<DeprecatedTextureClient>& aClient)
 {
   aClient = CreateDeprecatedTextureClient(TEXTURE_CONTENT, mContentType);
   MOZ_ASSERT(aClient, "Failed to create texture client");
 
   if (!aClient->EnsureAllocated(mSize, mContentType)) {
     aClient = CreateDeprecatedTextureClient(TEXTURE_FALLBACK, mContentType);
     MOZ_ASSERT(aClient, "Failed to create texture client");
     if (!aClient->EnsureAllocated(mSize, mContentType)) {
@@ -367,17 +367,17 @@ ContentClientRemoteBuffer::CreateAndAllo
     }
   }
 
   MOZ_ASSERT(IsSurfaceDescriptorValid(*aClient->GetDescriptor()));
   return true;
 }
 
 void
-ContentClientRemoteBuffer::BuildDeprecatedTextureClients(ContentType aType,
+DeprecatedContentClientRemoteBuffer::BuildDeprecatedTextureClients(ContentType aType,
                                                const nsIntRect& aRect,
                                                uint32_t aFlags)
 {
   NS_ABORT_IF_FALSE(!mIsNewBuffer,
                     "Bad! Did we create a buffer twice without painting?");
 
   if (mDeprecatedTextureClient) {
     mOldTextures.AppendElement(mDeprecatedTextureClient);
@@ -404,17 +404,17 @@ ContentClientRemoteBuffer::BuildDeprecat
     mTextureInfo.mTextureFlags |= TEXTURE_COMPONENT_ALPHA;
   }
 
   CreateFrontBufferAndNotify(aRect);
   mIsNewBuffer = true;
 }
 
 void
-ContentClientRemoteBuffer::CreateBuffer(ContentType aType,
+DeprecatedContentClientRemoteBuffer::CreateBuffer(ContentType aType,
                                         const nsIntRect& aRect,
                                         uint32_t aFlags,
                                         RefPtr<gfx::DrawTarget>* aBlackDT,
                                         RefPtr<gfx::DrawTarget>* aWhiteDT)
 {
   BuildDeprecatedTextureClients(aType, aRect, aFlags);
   if (!mDeprecatedTextureClient) {
     return;
@@ -424,17 +424,17 @@ ContentClientRemoteBuffer::CreateBuffer(
         mDeprecatedTextureClient->BackendType()));
   *aBlackDT = mDeprecatedTextureClient->LockDrawTarget();
   if (aFlags & BUFFER_COMPONENT_ALPHA) {
     *aWhiteDT = mDeprecatedTextureClientOnWhite->LockDrawTarget();
   }
 }
 
 nsIntRegion
-ContentClientRemoteBuffer::GetUpdatedRegion(const nsIntRegion& aRegionToDraw,
+DeprecatedContentClientRemoteBuffer::GetUpdatedRegion(const nsIntRegion& aRegionToDraw,
                                             const nsIntRegion& aVisibleRegion,
                                             bool aDidSelfCopy)
 {
   nsIntRegion updatedRegion;
   if (mIsNewBuffer || aDidSelfCopy) {
     // A buffer reallocation clears both buffers. The front buffer has all the
     // content by now, but the back buffer is still clear. Here, in effect, we
     // are saying to copy all of the pixels of the front buffer to the back.
@@ -451,17 +451,17 @@ ContentClientRemoteBuffer::GetUpdatedReg
   NS_ASSERTION(BufferRect().Contains(aRegionToDraw.GetBounds()),
                "Update outside of buffer rect!");
   NS_ABORT_IF_FALSE(mDeprecatedTextureClient, "should have a back buffer by now");
 
   return updatedRegion;
 }
 
 void
-ContentClientRemoteBuffer::Updated(const nsIntRegion& aRegionToDraw,
+DeprecatedContentClientRemoteBuffer::Updated(const nsIntRegion& aRegionToDraw,
                                    const nsIntRegion& aVisibleRegion,
                                    bool aDidSelfCopy)
 {
   nsIntRegion updatedRegion = GetUpdatedRegion(aRegionToDraw,
                                                aVisibleRegion,
                                                aDidSelfCopy);
 
   MOZ_ASSERT(mDeprecatedTextureClient);
@@ -472,46 +472,46 @@ ContentClientRemoteBuffer::Updated(const
   LockFrontBuffer();
   mForwarder->UpdateTextureRegion(this,
                                   ThebesBufferData(BufferRect(),
                                                    BufferRotation()),
                                   updatedRegion);
 }
 
 void
-ContentClientRemoteBuffer::SwapBuffers(const nsIntRegion& aFrontUpdatedRegion)
+DeprecatedContentClientRemoteBuffer::SwapBuffers(const nsIntRegion& aFrontUpdatedRegion)
 {
   MOZ_ASSERT(mDeprecatedTextureClient->GetAccessMode() == DeprecatedTextureClient::ACCESS_NONE);
   MOZ_ASSERT(!mDeprecatedTextureClientOnWhite || mDeprecatedTextureClientOnWhite->GetAccessMode() == DeprecatedTextureClient::ACCESS_NONE);
   MOZ_ASSERT(mDeprecatedTextureClient);
 
   mFrontAndBackBufferDiffer = true;
   mDeprecatedTextureClient->SetAccessMode(DeprecatedTextureClient::ACCESS_READ_WRITE);
   if (mDeprecatedTextureClientOnWhite) {
     mDeprecatedTextureClientOnWhite->SetAccessMode(DeprecatedTextureClient::ACCESS_READ_WRITE);
   }
 }
 
 
 void
-ContentClientRemoteBuffer::OnActorDestroy()
+DeprecatedContentClientRemoteBuffer::OnActorDestroy()
 {
   if (mDeprecatedTextureClient) {
     mDeprecatedTextureClient->OnActorDestroy();
   }
   if (mDeprecatedTextureClientOnWhite) {
     mDeprecatedTextureClientOnWhite->OnActorDestroy();
   }
   for (size_t i = 0; i < mOldTextures.Length(); ++i) {
     mOldTextures[i]->OnActorDestroy();
   }
 }
  
 void
-ContentClientDoubleBufferedNew::CreateFrontBuffer(const nsIntRect& aBufferRect)
+ContentClientDoubleBuffered::CreateFrontBuffer(const nsIntRect& aBufferRect)
 {
   if (!CreateAndAllocateTextureClient(mFrontClient, TEXTURE_ON_BLACK) ||
       !AddTextureClient(mFrontClient)) {
     AbortTextureClientCreation();
     return;
   }
   if (mTextureInfo.mTextureFlags & TEXTURE_COMPONENT_ALPHA) {
     if (!CreateAndAllocateTextureClient(mFrontClientOnWhite, TEXTURE_ON_WHITE) ||
@@ -521,41 +521,41 @@ ContentClientDoubleBufferedNew::CreateFr
     }
   }
 
   mFrontBufferRect = aBufferRect;
   mFrontBufferRotation = nsIntPoint();
 }
 
 void
-ContentClientDoubleBufferedNew::DestroyFrontBuffer()
+ContentClientDoubleBuffered::DestroyFrontBuffer()
 {
   MOZ_ASSERT(mFrontClient);
   MOZ_ASSERT(mFrontClient->GetAccessMode() != TextureClient::ACCESS_NONE);
 
   mOldTextures.AppendElement(mFrontClient);
   mFrontClient = nullptr;
   if (mFrontClientOnWhite) {
     mOldTextures.AppendElement(mFrontClientOnWhite);
     mFrontClientOnWhite = nullptr;
   }
 }
 
 void
-ContentClientDoubleBufferedNew::LockFrontBuffer()
+ContentClientDoubleBuffered::LockFrontBuffer()
 {
   MOZ_ASSERT(mFrontClient);
   mFrontClient->SetAccessMode(TextureClient::ACCESS_NONE);
   if (mFrontClientOnWhite) {
     mFrontClientOnWhite->SetAccessMode(TextureClient::ACCESS_NONE);
   }
 }
 
 void
-ContentClientDoubleBufferedNew::SwapBuffers(const nsIntRegion& aFrontUpdatedRegion)
+ContentClientDoubleBuffered::SwapBuffers(const nsIntRegion& aFrontUpdatedRegion)
 {
   mFrontUpdatedRegion = aFrontUpdatedRegion;
 
   RefPtr<TextureClient> oldBack = mTextureClient;
   mTextureClient = mFrontClient;
   mFrontClient = oldBack;
 
   oldBack = mTextureClientOnWhite;
@@ -571,21 +571,21 @@ ContentClientDoubleBufferedNew::SwapBuff
   mFrontBufferRotation = oldBufferRotation;
 
   MOZ_ASSERT(mFrontClient);
   mFrontClient->SetAccessMode(TextureClient::ACCESS_READ_ONLY);
   if (mFrontClientOnWhite) {
     mFrontClientOnWhite->SetAccessMode(TextureClient::ACCESS_READ_ONLY);
   }
 
-  ContentClientRemoteBufferNew::SwapBuffers(aFrontUpdatedRegion);
+  ContentClientRemoteBuffer::SwapBuffers(aFrontUpdatedRegion);
 }
 
 void
-ContentClientDoubleBufferedNew::SyncFrontBufferToBackBuffer()
+ContentClientDoubleBuffered::SyncFrontBufferToBackBuffer()
 {
   if (!mFrontAndBackBufferDiffer) {
     return;
   }
   MOZ_ASSERT(mFrontClient);
   MOZ_ASSERT(mFrontClient->GetAccessMode() == TextureClient::ACCESS_READ_ONLY);
   MOZ_ASSERT(!mFrontClientOnWhite ||
              mFrontClientOnWhite->GetAccessMode() == TextureClient::ACCESS_READ_ONLY);
@@ -643,17 +643,17 @@ ContentClientDoubleBufferedNew::SyncFron
   UpdateDestinationFrom(frontBuffer, updateRegion);
   mFrontClient->Unlock();
   if (mFrontClientOnWhite) {
     mFrontClientOnWhite->Unlock();
   }
 }
 
 void
-ContentClientDoubleBufferedNew::UpdateDestinationFrom(const RotatedBuffer& aSource,
+ContentClientDoubleBuffered::UpdateDestinationFrom(const RotatedBuffer& aSource,
                                                    const nsIntRegion& aUpdateRegion)
 {
   nsRefPtr<gfxContext> destCtx =
     GetContextForQuadrantUpdate(aUpdateRegion.GetBounds(), BUFFER_BLACK);
   destCtx->SetOperator(gfxContext::OPERATOR_SOURCE);
 
   bool isClippingCheap = IsClippingCheap(destCtx, aUpdateRegion);
   if (isClippingCheap) {
@@ -672,32 +672,32 @@ ContentClientDoubleBufferedNew::UpdateDe
     if (isClippingCheap) {
       gfxUtils::ClipToRegion(destCtx, aUpdateRegion);
     }
 
     aSource.DrawBufferWithRotation(destCtx->GetDrawTarget(), BUFFER_WHITE, 1.0, OP_SOURCE);
   }
 }
 
-ContentClientDoubleBuffered::~ContentClientDoubleBuffered()
+DeprecatedContentClientDoubleBuffered::~DeprecatedContentClientDoubleBuffered()
 {
   if (mDeprecatedTextureClient) {
     MOZ_ASSERT(mFrontClient);
     mDeprecatedTextureClient->SetDescriptor(SurfaceDescriptor());
     mFrontClient->SetDescriptor(SurfaceDescriptor());
   }
   if (mDeprecatedTextureClientOnWhite) {
     MOZ_ASSERT(mFrontClientOnWhite);
     mDeprecatedTextureClientOnWhite->SetDescriptor(SurfaceDescriptor());
     mFrontClientOnWhite->SetDescriptor(SurfaceDescriptor());
   }
 }
 
 void
-ContentClientDoubleBuffered::CreateFrontBufferAndNotify(const nsIntRect& aBufferRect)
+DeprecatedContentClientDoubleBuffered::CreateFrontBufferAndNotify(const nsIntRect& aBufferRect)
 {
   if (!CreateAndAllocateDeprecatedTextureClient(mFrontClient)) {
     mDeprecatedTextureClient->SetFlags(0);
     mDeprecatedTextureClient = nullptr;
     if (mDeprecatedTextureClientOnWhite) {
       mDeprecatedTextureClientOnWhite->SetFlags(0);
       mDeprecatedTextureClientOnWhite = nullptr;
     }
@@ -723,37 +723,37 @@ ContentClientDoubleBuffered::CreateFront
                                   *mFrontClient->LockSurfaceDescriptor(),
                                   *mDeprecatedTextureClient->LockSurfaceDescriptor(),
                                   mTextureInfo,
                                   mFrontClientOnWhite ? mFrontClientOnWhite->LockSurfaceDescriptor() : nullptr,
                                   mDeprecatedTextureClientOnWhite ? mDeprecatedTextureClientOnWhite->LockSurfaceDescriptor() : nullptr);
 }
 
 void
-ContentClientDoubleBuffered::DestroyFrontBuffer()
+DeprecatedContentClientDoubleBuffered::DestroyFrontBuffer()
 {
   MOZ_ASSERT(mFrontClient);
   MOZ_ASSERT(mFrontClient->GetAccessMode() != DeprecatedTextureClient::ACCESS_NONE);
 
   mFrontClient = nullptr;
   mFrontClientOnWhite = nullptr;
 }
 
 void
-ContentClientDoubleBuffered::LockFrontBuffer()
+DeprecatedContentClientDoubleBuffered::LockFrontBuffer()
 {
   MOZ_ASSERT(mFrontClient);
   mFrontClient->SetAccessMode(DeprecatedTextureClient::ACCESS_NONE);
   if (mFrontClientOnWhite) {
     mFrontClientOnWhite->SetAccessMode(DeprecatedTextureClient::ACCESS_NONE);
   }
 }
 
 void
-ContentClientDoubleBuffered::SwapBuffers(const nsIntRegion& aFrontUpdatedRegion)
+DeprecatedContentClientDoubleBuffered::SwapBuffers(const nsIntRegion& aFrontUpdatedRegion)
 {
   mFrontUpdatedRegion = aFrontUpdatedRegion;
 
   RefPtr<DeprecatedTextureClient> oldBack = mDeprecatedTextureClient;
   mDeprecatedTextureClient = mFrontClient;
   mFrontClient = oldBack;
 
   oldBack = mDeprecatedTextureClientOnWhite;
@@ -769,21 +769,21 @@ ContentClientDoubleBuffered::SwapBuffers
   mFrontBufferRotation = oldBufferRotation;
 
   MOZ_ASSERT(mFrontClient);
   mFrontClient->SetAccessMode(DeprecatedTextureClient::ACCESS_READ_ONLY);
   if (mFrontClientOnWhite) {
     mFrontClientOnWhite->SetAccessMode(DeprecatedTextureClient::ACCESS_READ_ONLY);
   }
 
-  ContentClientRemoteBuffer::SwapBuffers(aFrontUpdatedRegion);
+  DeprecatedContentClientRemoteBuffer::SwapBuffers(aFrontUpdatedRegion);
 }
 
 void
-ContentClientDoubleBuffered::OnActorDestroy()
+DeprecatedContentClientDoubleBuffered::OnActorDestroy()
 {
   if (mDeprecatedTextureClient) {
     mDeprecatedTextureClient->OnActorDestroy();
   }
   if (mDeprecatedTextureClientOnWhite) {
     mDeprecatedTextureClientOnWhite->OnActorDestroy();
   }
   for (size_t i = 0; i < mOldTextures.Length(); ++i) {
@@ -816,17 +816,17 @@ struct AutoDeprecatedTextureClient {
     }
     return nullptr;
   }
 private:
   DeprecatedTextureClient* mTexture;
 };
 
 void
-ContentClientDoubleBuffered::SyncFrontBufferToBackBuffer()
+DeprecatedContentClientDoubleBuffered::SyncFrontBufferToBackBuffer()
 {
   mIsNewBuffer = false;
 
   if (!mFrontAndBackBufferDiffer) {
     return;
   }
   MOZ_ASSERT(mFrontClient);
   MOZ_ASSERT(mFrontClient->GetAccessMode() == DeprecatedTextureClient::ACCESS_READ_ONLY);
@@ -872,17 +872,17 @@ ContentClientDoubleBuffered::SyncFrontBu
                             mFrontBufferRect,
                             mFrontBufferRotation);
   UpdateDestinationFrom(frontBuffer, updateRegion);
 
   mFrontAndBackBufferDiffer = false;
 }
 
 void
-ContentClientDoubleBuffered::UpdateDestinationFrom(const RotatedBuffer& aSource,
+DeprecatedContentClientDoubleBuffered::UpdateDestinationFrom(const RotatedBuffer& aSource,
                                                    const nsIntRegion& aUpdateRegion)
 {
   nsRefPtr<gfxContext> destCtx =
     GetContextForQuadrantUpdate(aUpdateRegion.GetBounds(), BUFFER_BLACK);
   if (!destCtx) {
     return;
   }
   destCtx->SetOperator(gfxContext::OPERATOR_SOURCE);
@@ -905,17 +905,17 @@ ContentClientDoubleBuffered::UpdateDesti
       gfxUtils::ClipToRegion(destCtx, aUpdateRegion);
     }
 
     aSource.DrawBufferWithRotation(destCtx->GetDrawTarget(), BUFFER_WHITE, 1.0, OP_SOURCE);
   }
 }
 
 void
-ContentClientSingleBufferedNew::SyncFrontBufferToBackBuffer()
+ContentClientSingleBuffered::SyncFrontBufferToBackBuffer()
 {
   if (!mFrontAndBackBufferDiffer) {
     return;
   }
 
   RefPtr<DrawTarget> backBuffer = GetDTBuffer();
   if (!backBuffer && mTextureClient) {
     backBuffer = mTextureClient->AsTextureClientDrawTarget()->GetAsDrawTarget();
@@ -932,37 +932,37 @@ ContentClientSingleBufferedNew::SyncFron
   }
 
   oldBuffer = SetDTBufferOnWhite(backBuffer);
 
   mIsNewBuffer = false;
   mFrontAndBackBufferDiffer = false;
 }
 
-ContentClientSingleBuffered::~ContentClientSingleBuffered()
+DeprecatedContentClientSingleBuffered::~DeprecatedContentClientSingleBuffered()
 {
   if (mDeprecatedTextureClient) {
     mDeprecatedTextureClient->SetDescriptor(SurfaceDescriptor());
   }
   if (mDeprecatedTextureClientOnWhite) {
     mDeprecatedTextureClientOnWhite->SetDescriptor(SurfaceDescriptor());
   }
 }
 
 void
-ContentClientSingleBuffered::CreateFrontBufferAndNotify(const nsIntRect& aBufferRect)
+DeprecatedContentClientSingleBuffered::CreateFrontBufferAndNotify(const nsIntRect& aBufferRect)
 {
   mForwarder->CreatedSingleBuffer(this,
                                   *mDeprecatedTextureClient->LockSurfaceDescriptor(),
                                   mTextureInfo,
                                   mDeprecatedTextureClientOnWhite ? mDeprecatedTextureClientOnWhite->LockSurfaceDescriptor() : nullptr);
 }
 
 void
-ContentClientSingleBuffered::SyncFrontBufferToBackBuffer()
+DeprecatedContentClientSingleBuffered::SyncFrontBufferToBackBuffer()
 {
   mIsNewBuffer = false;
   if (!mFrontAndBackBufferDiffer) {
     return;
   }
   mFrontAndBackBufferDiffer = false;
 
   DrawTarget* backBuffer = GetDTBuffer();
--- a/gfx/layers/client/ContentClient.h
+++ b/gfx/layers/client/ContentClient.h
@@ -178,23 +178,23 @@ private:
  * tells the compositor that TextureClients have been created and that the
  * compositor should assign the corresponding TextureHosts to our corresponding
  * ContentHost.
  *
  * If the size or type of our buffer(s) change(s), then we simply destroy and
  * create them.
  */
 // Version using new texture clients
-class ContentClientRemoteBufferNew : public ContentClientRemote
-                                   , protected RotatedContentBuffer
+class ContentClientRemoteBuffer : public ContentClientRemote
+                                , protected RotatedContentBuffer
 {
   using RotatedContentBuffer::BufferRect;
   using RotatedContentBuffer::BufferRotation;
 public:
-  ContentClientRemoteBufferNew(CompositableForwarder* aForwarder)
+  ContentClientRemoteBuffer(CompositableForwarder* aForwarder)
     : ContentClientRemote(aForwarder)
     , RotatedContentBuffer(ContainsVisibleBounds)
     , mIsNewBuffer(false)
     , mFrontAndBackBufferDiffer(false)
     , mSurfaceFormat(gfx::FORMAT_B8G8R8A8)
   {}
 
   typedef RotatedContentBuffer::PaintState PaintState;
@@ -280,23 +280,23 @@ protected:
 
   TextureInfo mTextureInfo;
   bool mIsNewBuffer;
   bool mFrontAndBackBufferDiffer;
   gfx::IntSize mSize;
   gfx::SurfaceFormat mSurfaceFormat;
 };
 
-class ContentClientRemoteBuffer : public ContentClientRemote
-                                , protected RotatedContentBuffer
+class DeprecatedContentClientRemoteBuffer : public ContentClientRemote
+                                          , protected RotatedContentBuffer
 {
   using RotatedContentBuffer::BufferRect;
   using RotatedContentBuffer::BufferRotation;
 public:
-  ContentClientRemoteBuffer(CompositableForwarder* aForwarder)
+  DeprecatedContentClientRemoteBuffer(CompositableForwarder* aForwarder)
     : ContentClientRemote(aForwarder)
     , RotatedContentBuffer(ContainsVisibleBounds)
     , mDeprecatedTextureClient(nullptr)
     , mIsNewBuffer(false)
     , mFrontAndBackBufferDiffer(false)
     , mContentType(GFX_CONTENT_COLOR_ALPHA)
   {}
 
@@ -388,25 +388,25 @@ protected:
  * not write to, when the compositor does not have the 'soft' lock. We can write
  * 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 ContentClientDoubleBufferedNew : public ContentClientRemoteBufferNew
+class ContentClientDoubleBuffered : public ContentClientRemoteBuffer
 {
 public:
-  ContentClientDoubleBufferedNew(CompositableForwarder* aFwd)
-    : ContentClientRemoteBufferNew(aFwd)
+  ContentClientDoubleBuffered(CompositableForwarder* aFwd)
+    : ContentClientRemoteBuffer(aFwd)
   {
     mTextureInfo.mCompositableType = COMPOSITABLE_CONTENT_DOUBLE;
   }
-  virtual ~ContentClientDoubleBufferedNew() {}
+  virtual ~ContentClientDoubleBuffered() {}
 
   virtual void SwapBuffers(const nsIntRegion& aFrontUpdatedRegion) MOZ_OVERRIDE;
 
   virtual void SyncFrontBufferToBackBuffer() MOZ_OVERRIDE;
 
 protected:
   virtual void CreateFrontBuffer(const nsIntRect& aBufferRect) MOZ_OVERRIDE;
   virtual void DestroyFrontBuffer() MOZ_OVERRIDE;
@@ -426,25 +426,25 @@ private:
 
   RefPtr<TextureClient> mFrontClient;
   RefPtr<TextureClient> mFrontClientOnWhite;
   nsIntRegion mFrontUpdatedRegion;
   nsIntRect mFrontBufferRect;
   nsIntPoint mFrontBufferRotation;
 };
 
-class ContentClientDoubleBuffered : public ContentClientRemoteBuffer
+class DeprecatedContentClientDoubleBuffered : public DeprecatedContentClientRemoteBuffer
 {
 public:
-  ContentClientDoubleBuffered(CompositableForwarder* aFwd)
-    : ContentClientRemoteBuffer(aFwd)
+  DeprecatedContentClientDoubleBuffered(CompositableForwarder* aFwd)
+    : DeprecatedContentClientRemoteBuffer(aFwd)
   {
     mTextureInfo.mCompositableType = BUFFER_CONTENT_DIRECT;
   }
-  ~ContentClientDoubleBuffered();
+  ~DeprecatedContentClientDoubleBuffered();
 
   virtual void SwapBuffers(const nsIntRegion& aFrontUpdatedRegion) MOZ_OVERRIDE;
 
   virtual void SyncFrontBufferToBackBuffer() MOZ_OVERRIDE;
 
 protected:
   virtual void CreateFrontBufferAndNotify(const nsIntRect& aBufferRect) MOZ_OVERRIDE;
   virtual void DestroyFrontBuffer() MOZ_OVERRIDE;
@@ -466,41 +466,41 @@ private:
 /**
  * A single buffered ContentClient. We have a single TextureClient/Host
  * which we update and then send a message to the compositor that we are
  * done updating. It is not safe for the compositor to use the corresponding
  * TextureHost's memory directly, it must upload it to video memory of some
  * kind. We are free to modify the TextureClient once we receive reply from
  * the compositor.
  */
-class ContentClientSingleBufferedNew : public ContentClientRemoteBufferNew
+class ContentClientSingleBuffered : public ContentClientRemoteBuffer
 {
 public:
-  ContentClientSingleBufferedNew(CompositableForwarder* aFwd)
-    : ContentClientRemoteBufferNew(aFwd)
+  ContentClientSingleBuffered(CompositableForwarder* aFwd)
+    : ContentClientRemoteBuffer(aFwd)
   {
     mTextureInfo.mCompositableType = COMPOSITABLE_CONTENT_SINGLE;
   }
-  virtual ~ContentClientSingleBufferedNew() {}
+  virtual ~ContentClientSingleBuffered() {}
 
   virtual void SyncFrontBufferToBackBuffer() MOZ_OVERRIDE;
 
 protected:
   virtual void CreateFrontBuffer(const nsIntRect& aBufferRect) MOZ_OVERRIDE {}
 };
 
-class ContentClientSingleBuffered : public ContentClientRemoteBuffer
+class DeprecatedContentClientSingleBuffered : public DeprecatedContentClientRemoteBuffer
 {
 public:
-  ContentClientSingleBuffered(CompositableForwarder* aFwd)
-    : ContentClientRemoteBuffer(aFwd)
+  DeprecatedContentClientSingleBuffered(CompositableForwarder* aFwd)
+    : DeprecatedContentClientRemoteBuffer(aFwd)
   {
     mTextureInfo.mCompositableType = BUFFER_CONTENT;    
   }
-  ~ContentClientSingleBuffered();
+  ~DeprecatedContentClientSingleBuffered();
 
   virtual void SyncFrontBufferToBackBuffer() MOZ_OVERRIDE;
 
 protected:
   virtual void CreateFrontBufferAndNotify(const nsIntRect& aBufferRect) MOZ_OVERRIDE;
 };
 
 /**
--- a/gfx/layers/composite/CompositableHost.cpp
+++ b/gfx/layers/composite/CompositableHost.cpp
@@ -178,35 +178,35 @@ CompositableHost::Create(const TextureIn
     break;
   case BUFFER_IMAGE_BUFFERED:
     result = new DeprecatedImageHostBuffered(aTextureInfo);
     break;
   case BUFFER_BRIDGE:
     MOZ_CRASH("Cannot create an image bridge compositable this way");
     break;
   case BUFFER_CONTENT:
-    result = new ContentHostSingleBuffered(aTextureInfo);
+    result = new DeprecatedContentHostSingleBuffered(aTextureInfo);
     break;
   case BUFFER_CONTENT_DIRECT:
-    result = new ContentHostDoubleBuffered(aTextureInfo);
+    result = new DeprecatedContentHostDoubleBuffered(aTextureInfo);
     break;
   case BUFFER_CONTENT_INC:
     result = new ContentHostIncremental(aTextureInfo);
     break;
   case BUFFER_TILED:
     result = new TiledContentHost(aTextureInfo);
     break;
   case COMPOSITABLE_IMAGE:
     result = new ImageHost(aTextureInfo);
     break;
   case COMPOSITABLE_CONTENT_SINGLE:
-    result = new ContentHostSingleBufferedNew(aTextureInfo);
+    result = new ContentHostSingleBuffered(aTextureInfo);
     break;
   case COMPOSITABLE_CONTENT_DOUBLE:
-    result = new ContentHostDoubleBufferedNew(aTextureInfo);
+    result = new ContentHostDoubleBuffered(aTextureInfo);
     break;
   default:
     MOZ_CRASH("Unknown CompositableType");
   }
   if (result) {
     RefPtr<CompositableBackendSpecificData> data = CreateCompositableBackendSpecificDataOGL();
     result->SetCompositableBackendSpecificData(data);
   }
--- a/gfx/layers/composite/ContentHost.cpp
+++ b/gfx/layers/composite/ContentHost.cpp
@@ -21,36 +21,36 @@ class gfxImageSurface;
 namespace mozilla {
 namespace gfx {
 class Matrix4x4;
 }
 using namespace gfx;
 
 namespace layers {
 
-ContentHostBaseNew::ContentHostBaseNew(const TextureInfo& aTextureInfo)
+ContentHostBase::ContentHostBase(const TextureInfo& aTextureInfo)
   : ContentHost(aTextureInfo)
   , mPaintWillResample(false)
   , mInitialised(false)
 {}
 
-ContentHostBaseNew::~ContentHostBaseNew()
+ContentHostBase::~ContentHostBase()
 {
   DestroyTextureHost();
   DestroyTextureHostOnWhite();
 }
 
 TextureHost*
-ContentHostBaseNew::GetAsTextureHost()
+ContentHostBase::GetAsTextureHost()
 {
   return mTextureHost;
 }
 
 void
-ContentHostBaseNew::DestroyTextureHost()
+ContentHostBase::DestroyTextureHost()
 {
   // The third clause in the if statement checks that we are in fact done with
   // this texture. We don't want to prematurely deallocate a texture we might
   // use again or double deallocate. Deallocation will happen in
   // RemoveTextureHost.
   // Note that GetTextureHost is linear in the number of texture hosts, but as
   // long as that number is small (I expect a maximum of 6 for now) then it
   // should be ok.
@@ -59,29 +59,29 @@ ContentHostBaseNew::DestroyTextureHost()
       !GetTextureHost(mTextureHost->GetID())) {
     MOZ_ASSERT(!(mTextureHost->GetFlags() & TEXTURE_DEALLOCATE_CLIENT));
     mTextureHost->DeallocateSharedData();
   }
   mTextureHost = nullptr;
 }
 
 void
-ContentHostBaseNew::DestroyTextureHostOnWhite()
+ContentHostBase::DestroyTextureHostOnWhite()
 {
   if (mTextureHostOnWhite &&
       mTextureHostOnWhite->GetFlags() & TEXTURE_DEALLOCATE_DEFERRED &&
       !GetTextureHost(mTextureHostOnWhite->GetID())) {
     MOZ_ASSERT(!(mTextureHostOnWhite->GetFlags() & TEXTURE_DEALLOCATE_CLIENT));
     mTextureHostOnWhite->DeallocateSharedData();
   }
   mTextureHostOnWhite = nullptr;
 }
 
 void
-ContentHostBaseNew::RemoveTextureHost(TextureHost* aTexture)
+ContentHostBase::RemoveTextureHost(TextureHost* aTexture)
 {
   if ((aTexture->GetFlags() & TEXTURE_DEALLOCATE_DEFERRED) &&
       !(mTextureHost && mTextureHost == aTexture) &&
       !(mTextureHostOnWhite && mTextureHostOnWhite == aTexture)) {
     MOZ_ASSERT(!(aTexture->GetFlags() & TEXTURE_DEALLOCATE_CLIENT));
     aTexture->DeallocateSharedData();
   }
 
@@ -110,17 +110,17 @@ public:
   }
 
 private:
   TextureHost* mHost;
   bool mLockSuccess;
 };
 
 void
-ContentHostBaseNew::Composite(EffectChain& aEffectChain,
+ContentHostBase::Composite(EffectChain& aEffectChain,
                            float aOpacity,
                            const gfx::Matrix4x4& aTransform,
                            const Filter& aFilter,
                            const Rect& aClipRect,
                            const nsIntRegion* aVisibleRegion,
                            TiledLayerProperties* aLayerProperties)
 {
   NS_ASSERTION(aVisibleRegion, "Requires a visible region");
@@ -280,42 +280,42 @@ ContentHostBaseNew::Composite(EffectChai
 
   DiagnosticTypes diagnostics = DIAGNOSTIC_CONTENT;
   diagnostics |= iterOnWhite ? DIAGNOSTIC_COMPONENT_ALPHA : 0;
   GetCompositor()->DrawDiagnostics(diagnostics, *aVisibleRegion, aClipRect, aTransform);
 }
 
 
 void
-ContentHostBaseNew::UseTextureHost(TextureHost* aTexture)
+ContentHostBase::UseTextureHost(TextureHost* aTexture)
 {
   if (aTexture->GetFlags() & TEXTURE_ON_WHITE) {
     DestroyTextureHost();
     mTextureHostOnWhite = aTexture;
   } else {
     DestroyTextureHostOnWhite();
     mTextureHost = aTexture;
   }
 }
 
 void
-ContentHostBaseNew::SetCompositor(Compositor* aCompositor)
+ContentHostBase::SetCompositor(Compositor* aCompositor)
 {
   CompositableHost::SetCompositor(aCompositor);
   if (mTextureHost) {
     mTextureHost->SetCompositor(aCompositor);
   }
   if (mTextureHostOnWhite) {
     mTextureHostOnWhite->SetCompositor(aCompositor);
   }
 }
 
 #ifdef MOZ_DUMP_PAINTING
 void
-ContentHostBaseNew::Dump(FILE* aFile,
+ContentHostBase::Dump(FILE* aFile,
                       const char* aPrefix,
                       bool aDumpHtml)
 {
   if (!aDumpHtml) {
     return;
   }
   if (!aFile) {
     aFile = stderr;
@@ -332,61 +332,61 @@ ContentHostBaseNew::Dump(FILE* aFile,
     fprintf(aFile, "<li> <a href=");
     DumpTextureHost(aFile, mTextureHostOnWhite);
     fprintf(aFile, "> Front buffer on white </a> </li> ");
   }
   fprintf(aFile, "</ul>");
 }
 #endif
 
-ContentHostBase::ContentHostBase(const TextureInfo& aTextureInfo)
+DeprecatedContentHostBase::DeprecatedContentHostBase(const TextureInfo& aTextureInfo)
   : ContentHost(aTextureInfo)
   , mPaintWillResample(false)
   , mInitialised(false)
 {}
 
-ContentHostBase::~ContentHostBase()
+DeprecatedContentHostBase::~DeprecatedContentHostBase()
 {}
 
 DeprecatedTextureHost*
-ContentHostBase::GetDeprecatedTextureHost()
+DeprecatedContentHostBase::GetDeprecatedTextureHost()
 {
   return mDeprecatedTextureHost;
 }
 
 void
-ContentHostBase::DestroyFrontHost()
+DeprecatedContentHostBase::DestroyFrontHost()
 {
   MOZ_ASSERT(!mDeprecatedTextureHost || mDeprecatedTextureHost->GetDeAllocator(),
              "We won't be able to destroy our SurfaceDescriptor");
   MOZ_ASSERT(!mDeprecatedTextureHostOnWhite || mDeprecatedTextureHostOnWhite->GetDeAllocator(),
              "We won't be able to destroy our SurfaceDescriptor");
   mDeprecatedTextureHost = nullptr;
   mDeprecatedTextureHostOnWhite = nullptr;
 }
 
 void
-ContentHostBase::OnActorDestroy()
+DeprecatedContentHostBase::OnActorDestroy()
 {
   if (mDeprecatedTextureHost) {
     mDeprecatedTextureHost->OnActorDestroy();
   }
   if (mDeprecatedTextureHostOnWhite) {
     mDeprecatedTextureHostOnWhite->OnActorDestroy();
   }
   if (mNewFrontHost) {
     mNewFrontHost->OnActorDestroy();
   }
   if (mNewFrontHostOnWhite) {
     mNewFrontHostOnWhite->OnActorDestroy();
   }
 }
 
 void
-ContentHostBase::Composite(EffectChain& aEffectChain,
+DeprecatedContentHostBase::Composite(EffectChain& aEffectChain,
                            float aOpacity,
                            const gfx::Matrix4x4& aTransform,
                            const Filter& aFilter,
                            const Rect& aClipRect,
                            const nsIntRegion* aVisibleRegion,
                            TiledLayerProperties* aLayerProperties)
 {
   NS_ASSERTION(aVisibleRegion, "Requires a visible region");
@@ -542,31 +542,31 @@ ContentHostBase::Composite(EffectChain& 
   }
 
   DiagnosticTypes diagnostics = DIAGNOSTIC_CONTENT;
   diagnostics |= iterOnWhite ? DIAGNOSTIC_COMPONENT_ALPHA : 0;
   GetCompositor()->DrawDiagnostics(diagnostics, *aVisibleRegion, aClipRect, aTransform);
 }
 
 void
-ContentHostBase::SetCompositor(Compositor* aCompositor)
+DeprecatedContentHostBase::SetCompositor(Compositor* aCompositor)
 {
   CompositableHost::SetCompositor(aCompositor);
   if (mDeprecatedTextureHost) {
     mDeprecatedTextureHost->SetCompositor(aCompositor);
   }
   if (mDeprecatedTextureHostOnWhite) {
     mDeprecatedTextureHostOnWhite->SetCompositor(aCompositor);
   }
 }
 
 #ifdef MOZ_DUMP_PAINTING
 
 void
-ContentHostBase::Dump(FILE* aFile,
+DeprecatedContentHostBase::Dump(FILE* aFile,
                       const char* aPrefix,
                       bool aDumpHtml)
 {
   if (!aDumpHtml) {
     return;
   }
   if (!aFile) {
     aFile = stderr;
@@ -585,17 +585,17 @@ ContentHostBase::Dump(FILE* aFile,
     fprintf_stderr(aFile, "> Front buffer on white </a> </li> ");
   }
   fprintf_stderr(aFile, "</ul>");
 }
 
 #endif
 
 void
-ContentHostSingleBufferedNew::UpdateThebes(const ThebesBufferData& aData,
+ContentHostSingleBuffered::UpdateThebes(const ThebesBufferData& aData,
                                         const nsIntRegion& aUpdated,
                                         const nsIntRegion& aOldValidRegionBack,
                                         nsIntRegion* aUpdatedRegionBack)
 {
   aUpdatedRegionBack->SetEmpty();
 
   if (!mTextureHost) {
     mInitialised = false;
@@ -626,24 +626,24 @@ ContentHostSingleBufferedNew::UpdateTheb
     mTextureHostOnWhite->Updated(&destRegion);
   }
   mInitialised = true;
 
   mBufferRect = aData.rect();
   mBufferRotation = aData.rotation();
 }
 
-ContentHostSingleBuffered::~ContentHostSingleBuffered()
+DeprecatedContentHostSingleBuffered::~DeprecatedContentHostSingleBuffered()
 {
   DestroyTextures();
   DestroyFrontHost();
 }
 
 void
-ContentHostSingleBuffered::EnsureDeprecatedTextureHost(TextureIdentifier aTextureId,
+DeprecatedContentHostSingleBuffered::EnsureDeprecatedTextureHost(TextureIdentifier aTextureId,
                                              const SurfaceDescriptor& aSurface,
                                              ISurfaceAllocator* aAllocator,
                                              const TextureInfo& aTextureInfo)
 {
   MOZ_ASSERT(aTextureId == TextureFront ||
              aTextureId == TextureOnWhiteFront);
   RefPtr<DeprecatedTextureHost> *newHost =
     (aTextureId == TextureFront) ? &mNewFrontHost : &mNewFrontHostOnWhite;
@@ -656,30 +656,30 @@ ContentHostSingleBuffered::EnsureDepreca
   (*newHost)->SetBuffer(new SurfaceDescriptor(aSurface), aAllocator);
   Compositor* compositor = GetCompositor();
   if (compositor) {
     (*newHost)->SetCompositor(compositor);
   }
 }
 
 void
-ContentHostSingleBuffered::DestroyTextures()
+DeprecatedContentHostSingleBuffered::DestroyTextures()
 {
   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 mDeprecatedTextureHost, we might need it for compositing
 }
 
 void
-ContentHostSingleBuffered::UpdateThebes(const ThebesBufferData& aData,
+DeprecatedContentHostSingleBuffered::UpdateThebes(const ThebesBufferData& aData,
                                         const nsIntRegion& aUpdated,
                                         const nsIntRegion& aOldValidRegionBack,
                                         nsIntRegion* aUpdatedRegionBack)
 {
   aUpdatedRegionBack->SetEmpty();
 
   if (!mDeprecatedTextureHost && !mNewFrontHost) {
     mInitialised = false;
@@ -724,17 +724,17 @@ ContentHostSingleBuffered::UpdateThebes(
   }
   mInitialised = true;
 
   mBufferRect = aData.rect();
   mBufferRotation = aData.rotation();
 }
 
 void
-ContentHostDoubleBufferedNew::UpdateThebes(const ThebesBufferData& aData,
+ContentHostDoubleBuffered::UpdateThebes(const ThebesBufferData& aData,
                                         const nsIntRegion& aUpdated,
                                         const nsIntRegion& aOldValidRegionBack,
                                         nsIntRegion* aUpdatedRegionBack)
 {
   if (!mTextureHost) {
     mInitialised = false;
 
     *aUpdatedRegionBack = aUpdated;
@@ -760,24 +760,24 @@ ContentHostDoubleBufferedNew::UpdateTheb
   // next back buffer sent back to the renderer.
   //
   // 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;
 }
 
-ContentHostDoubleBuffered::~ContentHostDoubleBuffered()
+DeprecatedContentHostDoubleBuffered::~DeprecatedContentHostDoubleBuffered()
 {
   DestroyTextures();
   DestroyFrontHost();
 }
 
 void
-ContentHostDoubleBuffered::EnsureDeprecatedTextureHost(TextureIdentifier aTextureId,
+DeprecatedContentHostDoubleBuffered::EnsureDeprecatedTextureHost(TextureIdentifier aTextureId,
                                              const SurfaceDescriptor& aSurface,
                                              ISurfaceAllocator* aAllocator,
                                              const TextureInfo& aTextureInfo)
 {
   RefPtr<DeprecatedTextureHost> newHost = DeprecatedTextureHost::CreateDeprecatedTextureHost(aSurface.type(),
                                                                aTextureInfo.mDeprecatedTextureHostFlags,
                                                                aTextureInfo.mTextureFlags,
                                                                this);
@@ -807,17 +807,17 @@ ContentHostDoubleBuffered::EnsureDepreca
     mBackHostOnWhite = newHost;
     return;
   }
 
   NS_ERROR("Bad texture identifier");
 }
 
 void
-ContentHostDoubleBuffered::DestroyTextures()
+DeprecatedContentHostDoubleBuffered::DestroyTextures()
 {
   if (mNewFrontHost) {
     MOZ_ASSERT(mNewFrontHost->GetDeAllocator(),
                "We won't be able to destroy our SurfaceDescriptor");
     mNewFrontHost = nullptr;
   }
   if (mNewFrontHostOnWhite) {
     MOZ_ASSERT(mNewFrontHostOnWhite->GetDeAllocator(),
@@ -834,17 +834,17 @@ ContentHostDoubleBuffered::DestroyTextur
                "We won't be able to destroy our SurfaceDescriptor");
     mBackHostOnWhite = nullptr;
   }
 
   // don't touch mDeprecatedTextureHost, we might need it for compositing
 }
 
 void
-ContentHostDoubleBuffered::OnActorDestroy()
+DeprecatedContentHostDoubleBuffered::OnActorDestroy()
 {
   if (mDeprecatedTextureHost) {
     mDeprecatedTextureHost->OnActorDestroy();
   }
   if (mDeprecatedTextureHostOnWhite) {
     mDeprecatedTextureHostOnWhite->OnActorDestroy();
   }
   if (mNewFrontHost) {
@@ -857,17 +857,17 @@ ContentHostDoubleBuffered::OnActorDestro
     mBackHost->OnActorDestroy();
   }
   if (mBackHostOnWhite) {
     mBackHostOnWhite->OnActorDestroy();
   }
 }
 
 void
-ContentHostDoubleBuffered::UpdateThebes(const ThebesBufferData& aData,
+DeprecatedContentHostDoubleBuffered::UpdateThebes(const ThebesBufferData& aData,
                                         const nsIntRegion& aUpdated,
                                         const nsIntRegion& aOldValidRegionBack,
                                         nsIntRegion* aUpdatedRegionBack)
 {
   if (!mDeprecatedTextureHost && !mNewFrontHost) {
     mInitialised = false;
 
     *aUpdatedRegionBack = aUpdated;
@@ -1142,20 +1142,20 @@ ContentHostIncremental::TextureUpdateReq
   if (mTextureId == TextureFront) {
     aHost->mDeprecatedTextureHost->Update(mDescriptor, &mUpdated, &offset);
   } else {
     aHost->mDeprecatedTextureHostOnWhite->Update(mDescriptor, &mUpdated, &offset);
   }
 }
 
 void
-ContentHostBaseNew::PrintInfo(nsACString& aTo, const char* aPrefix)
+ContentHostBase::PrintInfo(nsACString& aTo, const char* aPrefix)
 {
   aTo += aPrefix;
-  aTo += nsPrintfCString("ContentHostSingleBuffered (0x%p)", this);
+  aTo += nsPrintfCString("ContentHost (0x%p)", this);
 
   AppendToString(aTo, mBufferRect, " [buffer-rect=", "]");
   AppendToString(aTo, mBufferRotation, " [buffer-rotation=", "]");
   if (PaintWillResample()) {
     aTo += " [paint-will-resample]";
   }
 
   nsAutoCString pfx(aPrefix);
@@ -1163,20 +1163,20 @@ ContentHostBaseNew::PrintInfo(nsACString
 
   if (mTextureHost) {
     aTo += "\n";
     mTextureHost->PrintInfo(aTo, pfx.get());
   }
 }
 
 void
-ContentHostSingleBuffered::PrintInfo(nsACString& aTo, const char* aPrefix)
+DeprecatedContentHostSingleBuffered::PrintInfo(nsACString& aTo, const char* aPrefix)
 {
   aTo += aPrefix;
-  aTo += nsPrintfCString("ContentHostSingleBuffered (0x%p)", this);
+  aTo += nsPrintfCString("DeprecatedContentHostSingleBuffered (0x%p)", this);
 
   AppendToString(aTo, mBufferRect, " [buffer-rect=", "]");
   AppendToString(aTo, mBufferRotation, " [buffer-rotation=", "]");
   if (PaintWillResample()) {
     aTo += " [paint-will-resample]";
   }
 
   nsAutoCString pfx(aPrefix);
@@ -1184,20 +1184,20 @@ ContentHostSingleBuffered::PrintInfo(nsA
 
   if (mDeprecatedTextureHost) {
     aTo += "\n";
     mDeprecatedTextureHost->PrintInfo(aTo, pfx.get());
   }
 }
 
 void
-ContentHostDoubleBuffered::PrintInfo(nsACString& aTo, const char* aPrefix)
+DeprecatedContentHostDoubleBuffered::PrintInfo(nsACString& aTo, const char* aPrefix)
 {
   aTo += aPrefix;
-  aTo += nsPrintfCString("ContentHostDoubleBuffered (0x%p)", this);
+  aTo += nsPrintfCString("DeprecatedContentHostDoubleBuffered (0x%p)", this);
 
   AppendToString(aTo, mBufferRect, " [buffer-rect=", "]");
   AppendToString(aTo, mBufferRotation, " [buffer-rotation=", "]");
   if (PaintWillResample()) {
     aTo += " [paint-will-resample]";
   }
 
   nsAutoCString prefix(aPrefix);
@@ -1211,21 +1211,21 @@ ContentHostDoubleBuffered::PrintInfo(nsA
   if (mBackHost) {
     aTo += "\n";
     mBackHost->PrintInfo(aTo, prefix.get());
   }
 }
 
 #ifdef MOZ_DUMP_PAINTING
 void
-ContentHostDoubleBuffered::Dump(FILE* aFile,
+DeprecatedContentHostDoubleBuffered::Dump(FILE* aFile,
                                 const char* aPrefix,
                                 bool aDumpHtml)
 {
-  ContentHostBase::Dump(aFile, aPrefix, aDumpHtml);
+  DeprecatedContentHostBase::Dump(aFile, aPrefix, aDumpHtml);
   if (!aDumpHtml) {
     return;
   }
   if (!aFile) {
     aFile = stderr;
   }
   fprintf_stderr(aFile, "<ul>");
   if (mBackHost) {
@@ -1240,56 +1240,56 @@ ContentHostDoubleBuffered::Dump(FILE* aF
     DumpDeprecatedTextureHost(aFile, mBackHostOnWhite);
     fprintf_stderr(aFile, " >Back buffer on white</a> </li>");
   }
   fprintf_stderr(aFile, "</ul>");
 }
 #endif
 
 LayerRenderState
-ContentHostBaseNew::GetRenderState()
+ContentHostBase::GetRenderState()
 {
   if (!mTextureHost) {
     return LayerRenderState();
   }
 
   LayerRenderState result = mTextureHost->GetRenderState();
 
   if (mBufferRotation != nsIntPoint()) {
     result.mFlags |= LAYER_RENDER_STATE_BUFFER_ROTATION;
   }
   result.SetOffset(GetOriginOffset());
   return result;
 }
 
 LayerRenderState
-ContentHostBase::GetRenderState()
+DeprecatedContentHostBase::GetRenderState()
 {
   LayerRenderState result = mDeprecatedTextureHost->GetRenderState();
 
   if (mBufferRotation != nsIntPoint()) {
     result.mFlags |= LAYER_RENDER_STATE_BUFFER_ROTATION;
   }
   result.SetOffset(GetOriginOffset());
   return result;
 }
 
 #ifdef MOZ_DUMP_PAINTING
 already_AddRefed<gfxImageSurface>
-ContentHostBaseNew::GetAsSurface()
+ContentHostBase::GetAsSurface()
 {
   if (!mTextureHost) {
     return nullptr;
   }
 
   return mTextureHost->GetAsSurface();
 }
 
 already_AddRefed<gfxImageSurface>
-ContentHostBase::GetAsSurface()
+DeprecatedContentHostBase::GetAsSurface()
 {
   return mDeprecatedTextureHost->GetAsSurface();
 }
 #endif
 
 
 } // namespace
 } // namespace
--- a/gfx/layers/composite/ContentHost.h
+++ b/gfx/layers/composite/ContentHost.h
@@ -79,24 +79,24 @@ protected:
  * Ownership of the SurfaceDescriptor and the resources it represents is passed
  * 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 ContentHostBaseNew : public ContentHost
+class ContentHostBase : public ContentHost
 {
 public:
   typedef RotatedContentBuffer::ContentType ContentType;
   typedef RotatedContentBuffer::PaintState PaintState;
 
-  ContentHostBaseNew(const TextureInfo& aTextureInfo);
-  virtual ~ContentHostBaseNew();
+  ContentHostBase(const TextureInfo& aTextureInfo);
+  virtual ~ContentHostBase();
 
   virtual void Composite(EffectChain& aEffectChain,
                          float aOpacity,
                          const gfx::Matrix4x4& aTransform,
                          const gfx::Filter& aFilter,
                          const gfx::Rect& aClipRect,
                          const nsIntRegion* aVisibleRegion = nullptr,
                          TiledLayerProperties* aLayerProperties = nullptr);
@@ -138,24 +138,24 @@ protected:
 
   nsIntRect mBufferRect;
   nsIntPoint mBufferRotation;
   RefPtr<TextureHost> mTextureHost;
   RefPtr<TextureHost> mTextureHostOnWhite;
   bool mPaintWillResample;
   bool mInitialised;
 };
-class ContentHostBase : public ContentHost
+class DeprecatedContentHostBase : public ContentHost
 {
 public:
   typedef RotatedContentBuffer::ContentType ContentType;
   typedef RotatedContentBuffer::PaintState PaintState;
 
-  ContentHostBase(const TextureInfo& aTextureInfo);
-  ~ContentHostBase();
+  DeprecatedContentHostBase(const TextureInfo& aTextureInfo);
+  ~DeprecatedContentHostBase();
 
   virtual void Composite(EffectChain& aEffectChain,
                          float aOpacity,
                          const gfx::Matrix4x4& aTransform,
                          const gfx::Filter& aFilter,
                          const gfx::Rect& aClipRect,
                          const nsIntRegion* aVisibleRegion = nullptr,
                          TiledLayerProperties* aLayerProperties = nullptr);
@@ -213,44 +213,44 @@ protected:
   bool mInitialised;
 };
 
 /**
  * Double buffering is implemented by swapping the front and back TextureHosts.
  * We assume that whenever we use double buffering, then we have
  * render-to-texture and thus no texture upload to do.
  */
-class ContentHostDoubleBufferedNew : public ContentHostBaseNew
+class ContentHostDoubleBuffered : public ContentHostBase
 {
 public:
-  ContentHostDoubleBufferedNew(const TextureInfo& aTextureInfo)
-    : ContentHostBaseNew(aTextureInfo)
+  ContentHostDoubleBuffered(const TextureInfo& aTextureInfo)
+    : ContentHostBase(aTextureInfo)
   {}
 
-  virtual ~ContentHostDoubleBufferedNew() {}
+  virtual ~ContentHostDoubleBuffered() {}
 
   virtual CompositableType GetType() { return COMPOSITABLE_CONTENT_DOUBLE; }
 
   virtual void UpdateThebes(const ThebesBufferData& aData,
                             const nsIntRegion& aUpdated,
                             const nsIntRegion& aOldValidRegionBack,
                             nsIntRegion* aUpdatedRegionBack);
 
 protected:
   nsIntRegion mValidRegionForNextBackBuffer;
 };
 
-class ContentHostDoubleBuffered : public ContentHostBase
+class DeprecatedContentHostDoubleBuffered : public DeprecatedContentHostBase
 {
 public:
-  ContentHostDoubleBuffered(const TextureInfo& aTextureInfo)
-    : ContentHostBase(aTextureInfo)
+  DeprecatedContentHostDoubleBuffered(const TextureInfo& aTextureInfo)
+    : DeprecatedContentHostBase(aTextureInfo)
   {}
 
-  ~ContentHostDoubleBuffered();
+  ~DeprecatedContentHostDoubleBuffered();
 
   virtual CompositableType GetType() { return BUFFER_CONTENT_DIRECT; }
 
   virtual void UpdateThebes(const ThebesBufferData& aData,
                             const nsIntRegion& aUpdated,
                             const nsIntRegion& aOldValidRegionBack,
                             nsIntRegion* aUpdatedRegionBack);
 
@@ -277,39 +277,39 @@ protected:
   RefPtr<DeprecatedTextureHost> mBackHost;
   RefPtr<DeprecatedTextureHost> mBackHostOnWhite;
 };
 
 /**
  * Single buffered, therefore we must synchronously upload the image from the
  * DeprecatedTextureHost in the layers transaction (i.e., in UpdateThebes).
  */
-class ContentHostSingleBufferedNew : public ContentHostBaseNew
+class ContentHostSingleBuffered : public ContentHostBase
 {
 public:
-  ContentHostSingleBufferedNew(const TextureInfo& aTextureInfo)
-    : ContentHostBaseNew(aTextureInfo)
+  ContentHostSingleBuffered(const TextureInfo& aTextureInfo)
+    : ContentHostBase(aTextureInfo)
   {}
-  virtual ~ContentHostSingleBufferedNew() {}
+  virtual ~ContentHostSingleBuffered() {}
 
   virtual CompositableType GetType() { return COMPOSITABLE_CONTENT_SINGLE; }
 
   virtual void UpdateThebes(const ThebesBufferData& aData,
                             const nsIntRegion& aUpdated,
                             const nsIntRegion& aOldValidRegionBack,
                             nsIntRegion* aUpdatedRegionBack);
 };
 
-class ContentHostSingleBuffered : public ContentHostBase
+class DeprecatedContentHostSingleBuffered : public DeprecatedContentHostBase
 {
 public:
-  ContentHostSingleBuffered(const TextureInfo& aTextureInfo)
-    : ContentHostBase(aTextureInfo)
+  DeprecatedContentHostSingleBuffered(const TextureInfo& aTextureInfo)
+    : DeprecatedContentHostBase(aTextureInfo)
   {}
-  virtual ~ContentHostSingleBuffered();
+  virtual ~DeprecatedContentHostSingleBuffered();
 
   virtual CompositableType GetType() { return BUFFER_CONTENT; }
 
   virtual void UpdateThebes(const ThebesBufferData& aData,
                             const nsIntRegion& aUpdated,
                             const nsIntRegion& aOldValidRegionBack,
                             nsIntRegion* aUpdatedRegionBack);
 
@@ -327,21 +327,21 @@ public:
  * surfaces that only cover the changed pixels during an update.
  *
  * Takes ownership of the passed in update surfaces, and must
  * free them once texture upload is complete.
  *
  * Delays texture uploads until the next composite to
  * avoid blocking the main thread.
  */
-class ContentHostIncremental : public ContentHostBase
+class ContentHostIncremental : public DeprecatedContentHostBase
 {
 public:
   ContentHostIncremental(const TextureInfo& aTextureInfo)
-    : ContentHostBase(aTextureInfo)
+    : DeprecatedContentHostBase(aTextureInfo)
     , mDeAllocator(nullptr)
   {}
 
   virtual CompositableType GetType() { return BUFFER_CONTENT; }
 
   virtual void EnsureDeprecatedTextureHostIncremental(ISurfaceAllocator* aAllocator,
                                             const TextureInfo& aTextureInfo,
                                             const nsIntRect& aBufferRect) MOZ_OVERRIDE;
@@ -373,17 +373,17 @@ public:
                          const gfx::Matrix4x4& aTransform,
                          const gfx::Filter& aFilter,
                          const gfx::Rect& aClipRect,
                          const nsIntRegion* aVisibleRegion = nullptr,
                          TiledLayerProperties* aLayerProperties = nullptr)
   {
     ProcessTextureUpdates();
 
-    ContentHostBase::Composite(aEffectChain, aOpacity,
+    DeprecatedContentHostBase::Composite(aEffectChain, aOpacity,
                                aTransform, aFilter,
                                aClipRect, aVisibleRegion,
                                aLayerProperties);
   }
 
   virtual void DestroyTextures()
   {
     mDeprecatedTextureHost = nullptr;
--- a/gfx/layers/ipc/CompositableTransactionParent.cpp
+++ b/gfx/layers/ipc/CompositableTransactionParent.cpp
@@ -93,17 +93,17 @@ CompositableParentManager::ReceiveCompos
                                                  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());
-      ContentHostBase* content = static_cast<ContentHostBase*>(compositableParent->GetCompositableHost());
+      DeprecatedContentHostBase* content = static_cast<DeprecatedContentHostBase*>(compositableParent->GetCompositableHost());
       content->DestroyTextures();
 
       break;
     }
     case CompositableOperation::TOpPaintTexture: {
       MOZ_LAYERS_LOG(("[ParentSide] Paint Texture X"));
       const OpPaintTexture& op = aEdit.get_OpPaintTexture();