Bug 1135857 - Remove ContentClientIncremental. r=mattwoodrow
authorBenoit Girard <b56girard@gmail.com>
Mon, 23 Feb 2015 18:22:06 -0500
changeset 230417 580f6e27598969c00f357fa2e4b6c5aa9c519798
parent 230416 f0eb4d16ef84493c3c897a5b417468128e855f24
child 230418 a183ea96dc6ba7dc73a8954897359083db290d6a
push id28324
push usercbook@mozilla.com
push dateTue, 24 Feb 2015 11:56:37 +0000
treeherdermozilla-central@007c562fab9e [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersmattwoodrow
bugs1135857
milestone39.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 1135857 - Remove ContentClientIncremental. r=mattwoodrow
gfx/ipc/GfxMessageUtils.h
gfx/layers/CompositorTypes.h
gfx/layers/RotatedBuffer.h
gfx/layers/basic/BasicCompositor.cpp
gfx/layers/client/ClientLayerManager.cpp
gfx/layers/client/CompositableClient.h
gfx/layers/client/ContentClient.cpp
gfx/layers/client/ContentClient.h
gfx/layers/composite/CompositableHost.cpp
gfx/layers/composite/CompositableHost.h
gfx/layers/composite/ContentHost.cpp
gfx/layers/composite/ContentHost.h
gfx/layers/composite/PaintedLayerComposite.cpp
gfx/layers/ipc/CompositableForwarder.h
gfx/layers/ipc/CompositableTransactionParent.cpp
gfx/layers/ipc/ImageBridgeChild.cpp
gfx/layers/ipc/ImageBridgeChild.h
gfx/layers/ipc/LayersMessages.ipdlh
gfx/layers/ipc/ShadowLayers.cpp
gfx/layers/ipc/ShadowLayers.h
--- a/gfx/ipc/GfxMessageUtils.h
+++ b/gfx/ipc/GfxMessageUtils.h
@@ -273,31 +273,16 @@ struct ParamTraits<mozilla::gfx::ColorSp
 template <>
 struct ParamTraits<mozilla::layers::TextureFlags>
   : public BitFlagsEnumSerializer<
             mozilla::layers::TextureFlags,
             mozilla::layers::TextureFlags::ALL_BITS>
 {};
 
 template <>
-struct ParamTraits<mozilla::layers::TextureIdentifier>
-  : public ContiguousEnumSerializer<
-             mozilla::layers::TextureIdentifier,
-             mozilla::layers::TextureIdentifier::Front,
-             mozilla::layers::TextureIdentifier::HighBound>
-{};
-
-template <>
-struct ParamTraits<mozilla::layers::DeprecatedTextureHostFlags>
-  : public BitFlagsEnumSerializer<
-             mozilla::layers::DeprecatedTextureHostFlags,
-             mozilla::layers::DeprecatedTextureHostFlags::ALL_BITS>
-{};
-
-template <>
 struct ParamTraits<mozilla::layers::DiagnosticTypes>
   : public BitFlagsEnumSerializer<
              mozilla::layers::DiagnosticTypes,
              mozilla::layers::DiagnosticTypes::ALL_BITS>
 {};
 
 /*
 template <>
@@ -829,24 +814,22 @@ 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.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->mDeprecatedTextureHostFlags) &&
            ReadParam(aMsg, aIter, &aResult->mTextureFlags);
   }
 };
 
 template <>
 struct ParamTraits<mozilla::layers::CompositableType>
   : public ContiguousEnumSerializer<
              mozilla::layers::CompositableType,
--- a/gfx/layers/CompositorTypes.h
+++ b/gfx/layers/CompositorTypes.h
@@ -128,40 +128,25 @@ enum class EffectTypes : uint8_t {
   MAX  //sentinel for the count of all effect types
 };
 
 /**
  * How the Compositable should manage textures.
  */
 enum class CompositableType : uint8_t {
   UNKNOWN,
-  CONTENT_INC,     // painted layer interface, only sends incremental
-                   // updates to a texture on the compositor side.
   CONTENT_TILED,   // tiled painted layer
   IMAGE,           // image with single buffering
   IMAGE_OVERLAY,   // image without buffer
   IMAGE_BRIDGE,    // ImageBridge protocol
   CONTENT_SINGLE,  // painted layer interface, single buffering
   CONTENT_DOUBLE,  // painted layer interface, double buffering
   COUNT
 };
 
-/**
- * How the texture host is used for composition,
- * XXX - Only used by ContentClientIncremental
- */
-enum class DeprecatedTextureHostFlags : uint8_t {
-  DEFAULT = 0,       // The default texture host for the given SurfaceDescriptor
-  TILED = 1 << 0,    // A texture host that supports tiling
-  COPY_PREVIOUS = 1 << 1, // Texture contents should be initialized
-                                      // from the previous texture.
-  ALL_BITS = (1 << 2) - 1
-};
-MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(DeprecatedTextureHostFlags)
-
 #ifdef XP_WIN
 typedef void* SyncHandle;
 #else
 typedef uintptr_t SyncHandle;
 #endif // XP_WIN
 
 /**
  * Sent from the compositor to the content-side LayerManager, includes properties
@@ -190,60 +175,41 @@ struct TextureFactoryIdentifier
     , mMaxTextureSize(aMaxTextureSize)
     , mSupportsTextureBlitting(aSupportsTextureBlitting)
     , mSupportsPartialUploads(aSupportsPartialUploads)
     , mSyncHandle(aSyncHandle)
   {}
 };
 
 /**
- * Identify a texture to a compositable. Many textures can have the same id, but
- * the id is unique for any texture owned by a particular compositable.
- * XXX - We don't really need this, it will be removed along with the incremental
- * ContentClient/Host.
- */
-enum class TextureIdentifier : uint8_t {
-  Front = 1,
-  Back = 2,
-  OnWhiteFront = 3,
-  OnWhiteBack = 4,
-  HighBound
-};
-
-/**
  * Information required by the compositor from the content-side for creating or
  * using compositables and textures.
  * XXX - TextureInfo is a bad name: this information is useful for the compositable,
  * not the Texture. And ith new Textures, only the compositable type is really
  * useful. This may (should) be removed in the near future.
  */
 struct TextureInfo
 {
   CompositableType mCompositableType;
-  // XXX - only used by ContentClientIncremental
-  DeprecatedTextureHostFlags mDeprecatedTextureHostFlags;
   TextureFlags mTextureFlags;
 
   TextureInfo()
     : mCompositableType(CompositableType::UNKNOWN)
-    , mDeprecatedTextureHostFlags(DeprecatedTextureHostFlags::DEFAULT)
     , mTextureFlags(TextureFlags::NO_FLAGS)
   {}
 
   explicit TextureInfo(CompositableType aType,
                        TextureFlags aTextureFlags = TextureFlags::DEFAULT)
     : mCompositableType(aType)
-    , mDeprecatedTextureHostFlags(DeprecatedTextureHostFlags::DEFAULT)
     , mTextureFlags(aTextureFlags)
   {}
 
   bool operator==(const TextureInfo& aOther) const
   {
     return mCompositableType == aOther.mCompositableType &&
-           mDeprecatedTextureHostFlags == aOther.mDeprecatedTextureHostFlags &&
            mTextureFlags == aOther.mTextureFlags;
   }
 };
 
 /**
  * How a SurfaceDescriptor will be opened.
  *
  * See ShadowLayerForwarder::OpenDescriptor for example.
--- a/gfx/layers/RotatedBuffer.h
+++ b/gfx/layers/RotatedBuffer.h
@@ -267,17 +267,16 @@ public:
    * will need to call BorrowDrawTargetForPainting multiple times to achieve
    * this.
    */
   PaintState BeginPaint(PaintedLayer* aLayer,
                         uint32_t aFlags);
 
   struct DrawIterator {
     friend class RotatedContentBuffer;
-    friend class ContentClientIncremental;
     DrawIterator()
       : mCount(0)
     {}
 
     nsIntRegion mDrawRegion;
 
   private:
     uint32_t mCount;
--- a/gfx/layers/basic/BasicCompositor.cpp
+++ b/gfx/layers/basic/BasicCompositor.cpp
@@ -43,18 +43,16 @@ public:
   {
     return mSurface->GetSize();
   }
 
   virtual bool Update(gfx::DataSourceSurface* aSurface,
                       nsIntRegion* aDestRegion = nullptr,
                       gfx::IntPoint* aSrcOffset = nullptr) MOZ_OVERRIDE
   {
-    // XXX - For this to work with IncrementalContentHost we will need to support
-    // the aDestRegion and aSrcOffset parameters properly;
     mSurface = aSurface;
     return true;
   }
 
   virtual void DeallocateDeviceData() MOZ_OVERRIDE
   {
     mSurface = nullptr;
     SetUpdateSerial(0);
--- a/gfx/layers/client/ClientLayerManager.cpp
+++ b/gfx/layers/client/ClientLayerManager.cpp
@@ -582,27 +582,16 @@ ClientLayerManager::ForwardTransaction(b
         ContentClientRemote* contentClient =
           static_cast<ContentClientRemote*>(compositable);
         MOZ_ASSERT(contentClient);
 
         contentClient->SwapBuffers(obs.frontUpdatedRegion());
 
         break;
       }
-      case EditReply::TOpTextureSwap: {
-        MOZ_LAYERS_LOG(("[LayersForwarder] TextureSwap"));
-
-        const OpTextureSwap& ots = reply.get_OpTextureSwap();
-
-        CompositableClient* compositable =
-          CompositableClient::FromIPDLActor(ots.compositableChild());
-        MOZ_ASSERT(compositable);
-        compositable->SetDescriptorFromReply(ots.textureId(), ots.image());
-        break;
-      }
       case EditReply::TReturnReleaseFence: {
         const ReturnReleaseFence& rep = reply.get_ReturnReleaseFence();
         FenceHandle fence = rep.fence();
         PTextureChild* child = rep.textureChild();
 
         if (!fence.IsValid() || !child) {
           break;
         }
--- a/gfx/layers/client/CompositableClient.h
+++ b/gfx/layers/client/CompositableClient.h
@@ -138,22 +138,16 @@ public:
 
   TemporaryRef<TextureClient>
   CreateTextureClientForDrawing(gfx::SurfaceFormat aFormat,
                                 gfx::IntSize aSize,
                                 gfx::BackendType aMoz2DBackend,
                                 TextureFlags aTextureFlags,
                                 TextureAllocationFlags aAllocFlags = ALLOC_DEFAULT);
 
-  virtual void SetDescriptorFromReply(TextureIdentifier aTextureId,
-                                      const SurfaceDescriptor& aDescriptor)
-  {
-    MOZ_CRASH("If you want to call this, you should have implemented it");
-  }
-
   /**
    * Establishes the connection with compositor side through IPDL
    */
   virtual bool Connect();
 
   void Destroy();
 
   PCompositableChild* GetIPDLActor() const;
--- a/gfx/layers/client/ContentClient.cpp
+++ b/gfx/layers/client/ContentClient.cpp
@@ -88,21 +88,16 @@ ContentClient::CreateContentClient(Compo
     useDoubleBuffering = (LayerManagerComposite::SupportsDirectTexturing() &&
                          backend != LayersBackend::LAYERS_D3D9) ||
                          backend == LayersBackend::LAYERS_BASIC;
   }
 
   if (useDoubleBuffering || PR_GetEnv("MOZ_FORCE_DOUBLE_BUFFERING")) {
     return new ContentClientDoubleBuffered(aForwarder);
   }
-#ifdef XP_MACOSX
-  if (backend == LayersBackend::LAYERS_OPENGL) {
-    return new ContentClientIncremental(aForwarder);
-  }
-#endif
   return new ContentClientSingleBuffered(aForwarder);
 }
 
 void
 ContentClient::EndPaint(nsTArray<ReadbackProcessor::Update>* aReadbackUpdates)
 {
   // It is very important that this is called after any overridden EndPaint behaviour,
   // because destroying textures is a three stage process:
@@ -668,367 +663,10 @@ ContentClientSingleBuffered::FinalizeFra
     MOZ_ASSERT(locked);
   }
   if (mTextureClientOnWhite) {
     DebugOnly<bool> locked = mTextureClientOnWhite->Lock(OpenMode::OPEN_READ_WRITE);
     MOZ_ASSERT(locked);
   }
 }
 
-static void
-WrapRotationAxis(int32_t* aRotationPoint, int32_t aSize)
-{
-  if (*aRotationPoint < 0) {
-    *aRotationPoint += aSize;
-  } else if (*aRotationPoint >= aSize) {
-    *aRotationPoint -= aSize;
-  }
-}
-
-static void
-FillSurface(DrawTarget* aDT, const nsIntRegion& aRegion,
-            const nsIntPoint& aOffset, const gfxRGBA& aColor)
-{
-  nsIntRegionRectIterator iter(aRegion);
-  const nsIntRect* r;
-  while ((r = iter.Next()) != nullptr) {
-    aDT->FillRect(Rect(r->x - aOffset.x, r->y - aOffset.y,
-                       r->width, r->height),
-                  ColorPattern(ToColor(aColor)));
-  }
-}
-
-void
-ContentClientIncremental::NotifyBufferCreated(ContentType aType, TextureFlags aFlags)
-{
-  mTextureInfo.mTextureFlags = aFlags;
-  mContentType = aType;
-
-  mForwarder->CreatedIncrementalBuffer(this,
-                                        mTextureInfo,
-                                        mBufferRect);
-
-}
-
-RotatedContentBuffer::PaintState
-ContentClientIncremental::BeginPaintBuffer(PaintedLayer* aLayer,
-                                           uint32_t aFlags)
-{
-  mTextureInfo.mDeprecatedTextureHostFlags = DeprecatedTextureHostFlags::DEFAULT;
-  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 & RotatedContentBuffer::PAINT_WILL_RESAMPLE);
-
-  nsIntRegion validRegion = aLayer->GetValidRegion();
-
-  bool canUseOpaqueSurface = aLayer->CanUseOpaqueSurface();
-  ContentType contentType =
-    canUseOpaqueSurface ? gfxContentType::COLOR :
-                          gfxContentType::COLOR_ALPHA;
-
-  SurfaceMode mode;
-  nsIntRegion neededRegion;
-  bool canReuseBuffer;
-  nsIntRect destBufferRect;
-
-  while (true) {
-    mode = aLayer->GetSurfaceMode();
-    neededRegion = aLayer->GetVisibleRegion();
-    // If we're going to resample, we need a buffer that's in clamp mode.
-    canReuseBuffer = neededRegion.GetBounds().Size() <= mBufferRect.Size() &&
-      mHasBuffer && !(aFlags & RotatedContentBuffer::PAINT_WILL_RESAMPLE);
-
-    if (canReuseBuffer) {
-      if (mBufferRect.Contains(neededRegion.GetBounds())) {
-        // We don't need to adjust mBufferRect.
-        destBufferRect = mBufferRect;
-      } else {
-        // The buffer's big enough but doesn't contain everything that's
-        // going to be visible. We'll move it.
-        destBufferRect = nsIntRect(neededRegion.GetBounds().TopLeft(), mBufferRect.Size());
-      }
-    } else {
-      destBufferRect = neededRegion.GetBounds();
-    }
-
-    if (mode == SurfaceMode::SURFACE_COMPONENT_ALPHA) {
-      if (!gfxPrefs::ComponentAlphaEnabled() ||
-          !aLayer->GetParent() ||
-          !aLayer->GetParent()->SupportsComponentAlphaChildren()) {
-        mode = SurfaceMode::SURFACE_SINGLE_CHANNEL_ALPHA;
-      } else {
-        contentType = gfxContentType::COLOR;
-      }
-    }
-
-    if ((aFlags & RotatedContentBuffer::PAINT_WILL_RESAMPLE) &&
-        (!neededRegion.GetBounds().IsEqualInterior(destBufferRect) ||
-         neededRegion.GetNumRects() > 1)) {
-      // The area we add to neededRegion might not be painted opaquely
-      if (mode == SurfaceMode::SURFACE_OPAQUE) {
-        contentType = gfxContentType::COLOR_ALPHA;
-        mode = SurfaceMode::SURFACE_SINGLE_CHANNEL_ALPHA;
-      }
-      // For component alpha layers, we leave contentType as gfxContentType::COLOR.
-
-      // We need to validate the entire buffer, to make sure that only valid
-      // pixels are sampled
-      neededRegion = destBufferRect;
-    }
-
-    if (mHasBuffer &&
-        (mContentType != contentType ||
-         (mode == SurfaceMode::SURFACE_COMPONENT_ALPHA) != mHasBufferOnWhite)) {
-#ifdef MOZ_DUMP_PAINTING
-      if (nsLayoutUtils::InvalidationDebuggingIsEnabled()) {
-        if (mContentType != contentType) {
-          printf_stderr("Layer's content type has changed\n");
-        }
-        if ((mode == SurfaceMode::SURFACE_COMPONENT_ALPHA) != mHasBufferOnWhite) {
-          printf_stderr("Layer's component alpha status has changed\n");
-        }
-        printf_stderr("Invalidating entire layer %p: no buffer, or content type or component alpha changed\n", aLayer);
-      }
-#endif
-      // We're effectively clearing the valid region, so we need to draw
-      // the entire needed region now.
-      result.mRegionToInvalidate = aLayer->GetValidRegion();
-      validRegion.SetEmpty();
-      mHasBuffer = false;
-      mHasBufferOnWhite = false;
-      mBufferRect.SetRect(0, 0, 0, 0);
-      mBufferRotation.MoveTo(0, 0);
-      // Restart decision process with the cleared buffer. We can only go
-      // around the loop one more iteration, since mTexImage is null now.
-      continue;
-    }
-
-    break;
-  }
-
-  result.mRegionToDraw.Sub(neededRegion, validRegion);
-  if (result.mRegionToDraw.IsEmpty())
-    return result;
-
-  if (destBufferRect.width > mForwarder->GetMaxTextureSize() ||
-      destBufferRect.height > mForwarder->GetMaxTextureSize()) {
-    return result;
-  }
-
-  // BlitTextureImage depends on the FBO texture target being
-  // TEXTURE_2D.  This isn't the case on some older X1600-era Radeons.
-  if (!mForwarder->SupportsTextureBlitting() ||
-      !mForwarder->SupportsPartialUploads()) {
-    result.mRegionToDraw = neededRegion;
-    validRegion.SetEmpty();
-    mHasBuffer = false;
-    mHasBufferOnWhite = false;
-    mBufferRect.SetRect(0, 0, 0, 0);
-    mBufferRotation.MoveTo(0, 0);
-    canReuseBuffer = false;
-  }
-
-  nsIntRect drawBounds = result.mRegionToDraw.GetBounds();
-  bool createdBuffer = false;
-
-  TextureFlags bufferFlags = TextureFlags::NO_FLAGS;
-  if (mode == SurfaceMode::SURFACE_COMPONENT_ALPHA) {
-    bufferFlags |= TextureFlags::COMPONENT_ALPHA;
-  }
-  if (canReuseBuffer) {
-    nsIntRect keepArea;
-    if (keepArea.IntersectRect(destBufferRect, mBufferRect)) {
-      // Set mBufferRotation so that the pixels currently in mBuffer
-      // will still be rendered in the right place when mBufferRect
-      // changes to destBufferRect.
-      nsIntPoint newRotation = mBufferRotation +
-        (destBufferRect.TopLeft() - mBufferRect.TopLeft());
-      WrapRotationAxis(&newRotation.x, mBufferRect.width);
-      WrapRotationAxis(&newRotation.y, mBufferRect.height);
-      NS_ASSERTION(nsIntRect(nsIntPoint(0,0), mBufferRect.Size()).Contains(newRotation),
-                   "newRotation out of bounds");
-      int32_t xBoundary = destBufferRect.XMost() - newRotation.x;
-      int32_t yBoundary = destBufferRect.YMost() - newRotation.y;
-      if ((drawBounds.x < xBoundary && xBoundary < drawBounds.XMost()) ||
-          (drawBounds.y < yBoundary && yBoundary < drawBounds.YMost()) ||
-          (newRotation != nsIntPoint(0,0) && !canHaveRotation)) {
-        // The stuff we need to redraw will wrap around an edge of the
-        // buffer, so we will need to do a self-copy
-        // If mBufferRotation == nsIntPoint(0,0) we could do a real
-        // self-copy but we're not going to do that in GL yet.
-        // We can't do a real self-copy because the buffer is rotated.
-        // So allocate a new buffer for the destination.
-        destBufferRect = neededRegion.GetBounds();
-        createdBuffer = true;
-      } else {
-        mBufferRect = destBufferRect;
-        mBufferRotation = newRotation;
-      }
-    } else {
-      // No pixels are going to be kept. The whole visible region
-      // will be redrawn, so we don't need to copy anything, so we don't
-      // set destBuffer.
-      mBufferRect = destBufferRect;
-      mBufferRotation = nsIntPoint(0,0);
-    }
-  } else {
-    // The buffer's not big enough, so allocate a new one
-    createdBuffer = true;
-  }
-  NS_ASSERTION(!(aFlags & RotatedContentBuffer::PAINT_WILL_RESAMPLE) ||
-               destBufferRect == neededRegion.GetBounds(),
-               "If we're resampling, we need to validate the entire buffer");
-
-  if (!createdBuffer && !mHasBuffer) {
-    return result;
-  }
-
-  if (createdBuffer) {
-    if (mHasBuffer &&
-        (mode != SurfaceMode::SURFACE_COMPONENT_ALPHA || mHasBufferOnWhite)) {
-      mTextureInfo.mDeprecatedTextureHostFlags = DeprecatedTextureHostFlags::COPY_PREVIOUS;
-    }
-
-    mHasBuffer = true;
-    if (mode == SurfaceMode::SURFACE_COMPONENT_ALPHA) {
-      mHasBufferOnWhite = true;
-    }
-    mBufferRect = destBufferRect;
-    mBufferRotation = nsIntPoint(0,0);
-    NotifyBufferCreated(contentType, bufferFlags);
-  }
-
-  NS_ASSERTION(canHaveRotation || mBufferRotation == nsIntPoint(0,0),
-               "Rotation disabled, but we have nonzero rotation?");
-
-  nsIntRegion invalidate;
-  invalidate.Sub(aLayer->GetValidRegion(), destBufferRect);
-  result.mRegionToInvalidate.Or(result.mRegionToInvalidate, invalidate);
-
-  // If we do partial updates, we have to clip drawing to the regionToDraw.
-  // If we don't clip, background images will be fillrect'd to the region correctly,
-  // while text or lines will paint outside of the regionToDraw. This becomes apparent
-  // with concave regions. Right now the scrollbars invalidate a narrow strip of the bar
-  // although they never cover it. This leads to two draw rects, the narow strip and the actually
-  // newly exposed area. It would be wise to fix this glitch in any way to have simpler
-  // clip and draw regions.
-  result.mClip = DrawRegionClip::DRAW;
-  result.mMode = mode;
-
-  return result;
-}
-
-DrawTarget*
-ContentClientIncremental::BorrowDrawTargetForPainting(PaintState& aPaintState,
-                                                      RotatedContentBuffer::DrawIterator* aIter)
-{
-  if (aPaintState.mMode == SurfaceMode::SURFACE_NONE) {
-    return nullptr;
-  }
-
-  if (aIter) {
-    if (aIter->mCount++ > 0) {
-      return nullptr;
-    }
-    aIter->mDrawRegion = aPaintState.mRegionToDraw;
-  }
-
-  DrawTarget* result = nullptr;
-
-  nsIntRect drawBounds = aPaintState.mRegionToDraw.GetBounds();
-  MOZ_ASSERT(!mLoanedDrawTarget);
-
-  // BeginUpdate is allowed to modify the given region,
-  // if it wants more to be repainted than we request.
-  if (aPaintState.mMode == SurfaceMode::SURFACE_COMPONENT_ALPHA) {
-    nsIntRegion drawRegionCopy = aPaintState.mRegionToDraw;
-    RefPtr<DrawTarget> onBlack = GetUpdateSurface(BUFFER_BLACK, drawRegionCopy);
-    RefPtr<DrawTarget> onWhite = GetUpdateSurface(BUFFER_WHITE, aPaintState.mRegionToDraw);
-    if (onBlack && onWhite) {
-      NS_ASSERTION(aPaintState.mRegionToDraw == drawRegionCopy,
-                   "BeginUpdate should always modify the draw region in the same way!");
-      FillSurface(onBlack, aPaintState.mRegionToDraw, nsIntPoint(drawBounds.x, drawBounds.y), gfxRGBA(0.0, 0.0, 0.0, 1.0));
-      FillSurface(onWhite, aPaintState.mRegionToDraw, nsIntPoint(drawBounds.x, drawBounds.y), gfxRGBA(1.0, 1.0, 1.0, 1.0));
-      mLoanedDrawTarget = Factory::CreateDualDrawTarget(onBlack, onWhite);
-    } else {
-      mLoanedDrawTarget = nullptr;
-    }
-  } else {
-    mLoanedDrawTarget = GetUpdateSurface(BUFFER_BLACK, aPaintState.mRegionToDraw);
-  }
-  if (!mLoanedDrawTarget) {
-    NS_WARNING("unable to get context for update");
-    return nullptr;
-  }
-
-  result = mLoanedDrawTarget;
-  mLoanedTransform = mLoanedDrawTarget->GetTransform();
-  result->SetTransform(Matrix(mLoanedTransform).
-                         PreTranslate(-drawBounds.x, -drawBounds.y));
-
-  if (mContentType == gfxContentType::COLOR_ALPHA) {
-    gfxUtils::ClipToRegion(result, aPaintState.mRegionToDraw);
-    nsIntRect bounds = aPaintState.mRegionToDraw.GetBounds();
-    result->ClearRect(Rect(bounds.x, bounds.y, bounds.width, bounds.height));
-  }
-
-  return result;
-}
-
-void
-ContentClientIncremental::Updated(const nsIntRegion& aRegionToDraw,
-                                  const nsIntRegion& aVisibleRegion,
-                                  bool aDidSelfCopy)
-{
-  if (IsSurfaceDescriptorValid(mUpdateDescriptor)) {
-    mForwarder->UpdateTextureIncremental(this,
-                                         TextureIdentifier::Front,
-                                         mUpdateDescriptor,
-                                         aRegionToDraw,
-                                         mBufferRect,
-                                         mBufferRotation);
-    mUpdateDescriptor = SurfaceDescriptor();
-  }
-  if (IsSurfaceDescriptorValid(mUpdateDescriptorOnWhite)) {
-    mForwarder->UpdateTextureIncremental(this,
-                                         TextureIdentifier::OnWhiteFront,
-                                         mUpdateDescriptorOnWhite,
-                                         aRegionToDraw,
-                                         mBufferRect,
-                                         mBufferRotation);
-    mUpdateDescriptorOnWhite = SurfaceDescriptor();
-  }
-
-}
-
-TemporaryRef<DrawTarget>
-ContentClientIncremental::GetUpdateSurface(BufferType aType,
-                                           const nsIntRegion& aUpdateRegion)
-{
-  nsIntRect rgnSize = aUpdateRegion.GetBounds();
-  if (!mBufferRect.Contains(rgnSize)) {
-    NS_ERROR("update outside of image");
-    return nullptr;
-  }
-  SurfaceDescriptor desc;
-  if (!mForwarder->AllocSurfaceDescriptor(rgnSize.Size().ToIntSize(),
-                                          mContentType,
-                                          &desc)) {
-    NS_WARNING("creating SurfaceDescriptor failed!");
-    Clear();
-    return nullptr;
-  }
-
-  if (aType == BUFFER_BLACK) {
-    MOZ_ASSERT(!IsSurfaceDescriptorValid(mUpdateDescriptor));
-    mUpdateDescriptor = desc;
-  } else {
-    MOZ_ASSERT(!IsSurfaceDescriptorValid(mUpdateDescriptorOnWhite));
-    MOZ_ASSERT(aType == BUFFER_WHITE);
-    mUpdateDescriptorOnWhite = desc;
-  }
-
-  return GetDrawTargetForDescriptor(desc, gfx::BackendType::COREGRAPHICS);
-}
-
 }
 }
--- a/gfx/layers/client/ContentClient.h
+++ b/gfx/layers/client/ContentClient.h
@@ -392,95 +392,12 @@ public:
   virtual void FinalizeFrame(const nsIntRegion& aRegionToDraw) MOZ_OVERRIDE;
 
   virtual TextureInfo GetTextureInfo() const MOZ_OVERRIDE
   {
     return TextureInfo(CompositableType::CONTENT_SINGLE, mTextureFlags);
   }
 };
 
-/**
- * A single buffered ContentClient that creates temporary buffers which are
- * used to update the host-side texture. The ownership of the buffers is
- * passed to the host side during the transaction, and we need to create
- * new ones each frame.
- */
-class ContentClientIncremental : public ContentClientRemote
-                               , public BorrowDrawTarget
-{
-public:
-  explicit ContentClientIncremental(CompositableForwarder* aFwd)
-    : ContentClientRemote(aFwd)
-    , mContentType(gfxContentType::COLOR_ALPHA)
-    , mHasBuffer(false)
-    , mHasBufferOnWhite(false)
-  {
-    mTextureInfo.mCompositableType = CompositableType::CONTENT_INC;
-  }
-
-  typedef RotatedContentBuffer::PaintState PaintState;
-  typedef RotatedContentBuffer::ContentType ContentType;
-
-  virtual TextureInfo GetTextureInfo() const MOZ_OVERRIDE
-  {
-    return mTextureInfo;
-  }
-
-  virtual void Clear() MOZ_OVERRIDE
-  {
-    mBufferRect.SetEmpty();
-    mHasBuffer = false;
-    mHasBufferOnWhite = false;
-  }
-
-  virtual PaintState BeginPaintBuffer(PaintedLayer* aLayer,
-                                      uint32_t aFlags) MOZ_OVERRIDE;
-  virtual gfx::DrawTarget* BorrowDrawTargetForPainting(PaintState& aPaintState,
-                                                       RotatedContentBuffer::DrawIterator* aIter = nullptr) MOZ_OVERRIDE;
-  virtual void ReturnDrawTargetToBuffer(gfx::DrawTarget*& aReturned) MOZ_OVERRIDE
-  {
-    BorrowDrawTarget::ReturnDrawTarget(aReturned);
-  }
-
-  virtual void Updated(const nsIntRegion& aRegionToDraw,
-                       const nsIntRegion& aVisibleRegion,
-                       bool aDidSelfCopy) MOZ_OVERRIDE;
-
-  virtual void EndPaint(nsTArray<ReadbackProcessor::Update>* aReadbackUpdates = nullptr) MOZ_OVERRIDE
-  {
-    if (IsSurfaceDescriptorValid(mUpdateDescriptor)) {
-      mForwarder->DestroySharedSurface(&mUpdateDescriptor);
-    }
-    if (IsSurfaceDescriptorValid(mUpdateDescriptorOnWhite)) {
-      mForwarder->DestroySharedSurface(&mUpdateDescriptorOnWhite);
-    }
-    ContentClientRemote::EndPaint(aReadbackUpdates);
-  }
-
-private:
-
-  enum BufferType{
-    BUFFER_BLACK,
-    BUFFER_WHITE
-  };
-
-  void NotifyBufferCreated(ContentType aType, TextureFlags aFlags);
-
-  TemporaryRef<gfx::DrawTarget> GetUpdateSurface(BufferType aType,
-                                                 const nsIntRegion& aUpdateRegion);
-
-  TextureInfo mTextureInfo;
-  nsIntRect mBufferRect;
-  nsIntPoint mBufferRotation;
-
-  SurfaceDescriptor mUpdateDescriptor;
-  SurfaceDescriptor mUpdateDescriptorOnWhite;
-
-  ContentType mContentType;
-
-  bool mHasBuffer;
-  bool mHasBufferOnWhite;
-};
-
 }
 }
 
 #endif
--- a/gfx/layers/composite/CompositableHost.cpp
+++ b/gfx/layers/composite/CompositableHost.cpp
@@ -176,19 +176,16 @@ CompositableHost::RemoveMaskEffect()
 /* static */ TemporaryRef<CompositableHost>
 CompositableHost::Create(const TextureInfo& aTextureInfo)
 {
   RefPtr<CompositableHost> result;
   switch (aTextureInfo.mCompositableType) {
   case CompositableType::IMAGE_BRIDGE:
     NS_ERROR("Cannot create an image bridge compositable this way");
     break;
-  case CompositableType::CONTENT_INC:
-    result = new ContentHostIncremental(aTextureInfo);
-    break;
   case CompositableType::CONTENT_TILED:
     result = new TiledContentHost(aTextureInfo);
     break;
   case CompositableType::IMAGE:
     result = new ImageHost(aTextureInfo);
     break;
 #ifdef MOZ_WIDGET_GONK
   case CompositableType::IMAGE_OVERLAY:
--- a/gfx/layers/composite/CompositableHost.h
+++ b/gfx/layers/composite/CompositableHost.h
@@ -97,55 +97,16 @@ public:
                             const nsIntRegion& aOldValidRegionBack,
                             nsIntRegion* aUpdatedRegionBack)
   {
     NS_ERROR("should be implemented or not used");
     return false;
   }
 
   /**
-   * Update the content host using a surface that only contains the updated
-   * region.
-   *
-   * Takes ownership of aSurface, and is responsible for freeing it.
-   *
-   * @param aTextureId Texture to update.
-   * @param aSurface Surface containing the update area. Its contents are relative
-   *                 to aUpdated.TopLeft()
-   * @param aUpdated Area of the content host to update.
-   * @param aBufferRect New area covered by the content host.
-   * @param aBufferRotation New buffer rotation.
-   */
-  virtual void UpdateIncremental(TextureIdentifier aTextureId,
-                                 SurfaceDescriptor& aSurface,
-                                 const nsIntRegion& aUpdated,
-                                 const nsIntRect& aBufferRect,
-                                 const nsIntPoint& aBufferRotation)
-  {
-    MOZ_ASSERT(false, "should be implemented or not used");
-  }
-
-  /**
-   * 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 bool CreatedIncrementalTexture(ISurfaceAllocator* aAllocator,
-                                         const TextureInfo& aTextureInfo,
-                                         const nsIntRect& aBufferRect)
-  {
-    NS_ERROR("should be implemented or not used");
-    return false;
-  }
-
-  /**
    * Returns the front buffer.
    */
   virtual TextureHost* GetAsTextureHost() { return nullptr; }
 
   virtual LayerRenderState GetRenderState() = 0;
 
   virtual void SetPictureRect(const nsIntRect& aPictureRect)
   {
--- a/gfx/layers/composite/ContentHost.cpp
+++ b/gfx/layers/composite/ContentHost.cpp
@@ -383,439 +383,16 @@ 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;
 
   return true;
 }
 
-ContentHostIncremental::ContentHostIncremental(const TextureInfo& aTextureInfo)
-  : ContentHostBase(aTextureInfo)
-  , mDeAllocator(nullptr)
-  , mLocked(false)
-{
-}
-
-ContentHostIncremental::~ContentHostIncremental()
-{
-}
-
-bool
-ContentHostIncremental::CreatedIncrementalTexture(ISurfaceAllocator* aAllocator,
-                                                  const TextureInfo& aTextureInfo,
-                                                  const nsIntRect& aBufferRect)
-{
-  mUpdateList.AppendElement(new TextureCreationRequest(aTextureInfo,
-                                                       aBufferRect));
-  mDeAllocator = aAllocator;
-  FlushUpdateQueue();
-  return true;
-}
-
-void
-ContentHostIncremental::UpdateIncremental(TextureIdentifier aTextureId,
-                                          SurfaceDescriptor& aSurface,
-                                          const nsIntRegion& aUpdated,
-                                          const nsIntRect& aBufferRect,
-                                          const nsIntPoint& aBufferRotation)
-{
-  mUpdateList.AppendElement(new TextureUpdateRequest(mDeAllocator,
-                                                     aTextureId,
-                                                     aSurface,
-                                                     aUpdated,
-                                                     aBufferRect,
-                                                     aBufferRotation));
-  FlushUpdateQueue();
-}
-
-void
-ContentHostIncremental::Composite(EffectChain& aEffectChain,
-                                  float aOpacity,
-                                  const gfx::Matrix4x4& aTransform,
-                                  const Filter& aFilter,
-                                  const Rect& aClipRect,
-                                  const nsIntRegion* aVisibleRegion)
-{
-  NS_ASSERTION(aVisibleRegion, "Requires a visible region");
-
-  AutoLockCompositableHost lock(this);
-  if (lock.Failed()) {
-    return;
-  }
-
-  if (!mSource) {
-    return;
-  }
-
-  RefPtr<TexturedEffect> effect = CreateTexturedEffect(mSource.get(),
-                                                       mSourceOnWhite.get(),
-                                                       aFilter, true);
-  if (!effect) {
-    return;
-  }
-
-  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
-    // to avoid unexpected aliasing.
-    tmpRegion = aVisibleRegion->GetBounds();
-    renderRegion = &tmpRegion;
-  } else {
-    renderRegion = aVisibleRegion;
-  }
-
-  nsIntRegion region(*renderRegion);
-  nsIntPoint origin = GetOriginOffset();
-  // translate into TexImage space, buffer origin might not be at texture (0,0)
-  region.MoveBy(-origin);
-
-  // Figure out the intersecting draw region
-  gfx::IntSize texSize = mSource->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
-    return;
-  }
-
-  nsIntRegion screenRects;
-  nsIntRegion regionRects;
-
-  // Collect texture/screen coordinates for drawing
-  nsIntRegionRectIterator iter(subregion);
-  while (const nsIntRect* iterRect = iter.Next()) {
-    nsIntRect regionRect = *iterRect;
-    nsIntRect screenRect = regionRect;
-    screenRect.MoveBy(origin);
-
-    screenRects.Or(screenRects, screenRect);
-    regionRects.Or(regionRects, regionRect);
-  }
-
-  BigImageIterator* bigImgIter = mSource->AsBigImageIterator();
-  BigImageIterator* iterOnWhite = nullptr;
-  if (bigImgIter) {
-    bigImgIter->BeginBigImageIteration();
-  }
-
-  if (mSourceOnWhite) {
-    iterOnWhite = mSourceOnWhite->AsBigImageIterator();
-    MOZ_ASSERT(!bigImgIter || bigImgIter->GetTileCount() == iterOnWhite->GetTileCount(),
-               "Tile count mismatch on component alpha texture");
-    if (iterOnWhite) {
-      iterOnWhite->BeginBigImageIteration();
-    }
-  }
-
-  bool usingTiles = (bigImgIter && bigImgIter->GetTileCount() > 1);
-  do {
-    if (iterOnWhite) {
-      MOZ_ASSERT(iterOnWhite->GetTileRect() == bigImgIter->GetTileRect(),
-                 "component alpha textures should be the same size.");
-    }
-
-    nsIntRect texRect = bigImgIter ? bigImgIter->GetTileRect()
-                                   : nsIntRect(0, 0,
-                                               texSize.width,
-                                               texSize.height);
-
-    // Draw texture. If we're using tiles, we do repeating manually, as texture
-    // repeat would cause each individual tile to repeat instead of the
-    // compound texture as a whole. This involves drawing at most 4 sections,
-    // 2 for each axis that has texture repeat.
-    for (int y = 0; y < (usingTiles ? 2 : 1); y++) {
-      for (int x = 0; x < (usingTiles ? 2 : 1); x++) {
-        nsIntRect currentTileRect(texRect);
-        currentTileRect.MoveBy(x * texSize.width, y * texSize.height);
-
-        nsIntRegionRectIterator screenIter(screenRects);
-        nsIntRegionRectIterator regionIter(regionRects);
-
-        const nsIntRect* screenRect;
-        const nsIntRect* regionRect;
-        while ((screenRect = screenIter.Next()) &&
-               (regionRect = regionIter.Next())) {
-          nsIntRect tileScreenRect(*screenRect);
-          nsIntRect tileRegionRect(*regionRect);
-
-          // When we're using tiles, find the intersection between the tile
-          // rect and this region rect. Tiling is then handled by the
-          // outer for-loops and modifying the tile rect.
-          if (usingTiles) {
-            tileScreenRect.MoveBy(-origin);
-            tileScreenRect = tileScreenRect.Intersect(currentTileRect);
-            tileScreenRect.MoveBy(origin);
-
-            if (tileScreenRect.IsEmpty())
-              continue;
-
-            tileRegionRect = regionRect->Intersect(currentTileRect);
-            tileRegionRect.MoveBy(-currentTileRect.TopLeft());
-          }
-          gfx::Rect rect(tileScreenRect.x, tileScreenRect.y,
-                         tileScreenRect.width, tileScreenRect.height);
-
-          effect->mTextureCoords = Rect(Float(tileRegionRect.x) / texRect.width,
-                                        Float(tileRegionRect.y) / texRect.height,
-                                        Float(tileRegionRect.width) / texRect.width,
-                                        Float(tileRegionRect.height) / texRect.height);
-          GetCompositor()->DrawQuad(rect, aClipRect, aEffectChain, aOpacity, aTransform);
-          if (usingTiles) {
-            DiagnosticFlags diagnostics = DiagnosticFlags::CONTENT | DiagnosticFlags::BIGIMAGE;
-            if (iterOnWhite) {
-              diagnostics |= DiagnosticFlags::COMPONENT_ALPHA;
-            }
-            GetCompositor()->DrawDiagnostics(diagnostics, rect, aClipRect,
-                                             aTransform, mFlashCounter);
-          }
-        }
-      }
-    }
-
-    if (iterOnWhite) {
-      iterOnWhite->NextTile();
-    }
-  } while (usingTiles && bigImgIter->NextTile());
-
-  if (bigImgIter) {
-    bigImgIter->EndBigImageIteration();
-  }
-  if (iterOnWhite) {
-    iterOnWhite->EndBigImageIteration();
-  }
-
-  DiagnosticFlags diagnostics = DiagnosticFlags::CONTENT;
-  if (iterOnWhite) {
-    diagnostics |= DiagnosticFlags::COMPONENT_ALPHA;
-  }
-  GetCompositor()->DrawDiagnostics(diagnostics, nsIntRegion(mBufferRect), aClipRect,
-                                   aTransform, mFlashCounter);
-}
-
-void
-ContentHostIncremental::FlushUpdateQueue()
-{
-  // If we're not compositing for some reason (the window being minimized
-  // is one example), then we never process these updates and it can consume
-  // huge amounts of memory. Instead we forcibly process the updates (during the
-  // transaction) if the list gets too long.
-  static const uint32_t kMaxUpdateCount = 6;
-  if (mUpdateList.Length() >= kMaxUpdateCount) {
-    ProcessTextureUpdates();
-  }
-}
-
-void
-ContentHostIncremental::ProcessTextureUpdates()
-{
-  for (uint32_t i = 0; i < mUpdateList.Length(); i++) {
-    mUpdateList[i]->Execute(this);
-  }
-  mUpdateList.Clear();
-}
-
-void
-ContentHostIncremental::TextureCreationRequest::Execute(ContentHostIncremental* aHost)
-{
-  Compositor* compositor = aHost->GetCompositor();
-  MOZ_ASSERT(compositor);
-
-  RefPtr<DataTextureSource> temp =
-    compositor->CreateDataTextureSource(mTextureInfo.mTextureFlags);
-  MOZ_ASSERT(temp->AsSourceOGL() &&
-             temp->AsSourceOGL()->AsTextureImageTextureSource());
-  RefPtr<TextureImageTextureSourceOGL> newSource =
-    temp->AsSourceOGL()->AsTextureImageTextureSource();
-
-  RefPtr<TextureImageTextureSourceOGL> newSourceOnWhite;
-  if (mTextureInfo.mTextureFlags & TextureFlags::COMPONENT_ALPHA) {
-    temp =
-      compositor->CreateDataTextureSource(mTextureInfo.mTextureFlags);
-    MOZ_ASSERT(temp->AsSourceOGL() &&
-               temp->AsSourceOGL()->AsTextureImageTextureSource());
-    newSourceOnWhite = temp->AsSourceOGL()->AsTextureImageTextureSource();
-  }
-
-  if (mTextureInfo.mDeprecatedTextureHostFlags & DeprecatedTextureHostFlags::COPY_PREVIOUS) {
-    MOZ_ASSERT(aHost->mSource);
-    MOZ_ASSERT(aHost->mSource->IsValid());
-    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.
-    // |___|__|
-    // |3  |4 |
-    // |___|__|
-    //
-    // This is drawn to the screen as:
-    //  ______
-    // |4  |3 |  Where the center point is { width - mBufferRotation.x, height - mBufferRotation.y } from
-    // |___|__|  from the top left corner - rotationPoint.
-    // |2  |1 |
-    // |___|__|
-    //
-
-    // The basic idea below is to take all quadrant rectangles from the src and transform them into rectangles
-    // in the destination. Unfortunately, it seems it is overly complex and could perhaps be simplified.
-
-    nsIntRect srcBufferSpaceBottomRight(bufferRotation.x, bufferRotation.y, bufferRect.width - bufferRotation.x, bufferRect.height - bufferRotation.y);
-    nsIntRect srcBufferSpaceTopRight(bufferRotation.x, 0, bufferRect.width - bufferRotation.x, bufferRotation.y);
-    nsIntRect srcBufferSpaceTopLeft(0, 0, bufferRotation.x, bufferRotation.y);
-    nsIntRect srcBufferSpaceBottomLeft(0, bufferRotation.y, bufferRotation.x, bufferRect.height - bufferRotation.y);
-
-    overlap.IntersectRect(bufferRect, mBufferRect);
-
-    nsIntRect srcRect(overlap), dstRect(overlap);
-    srcRect.MoveBy(- bufferRect.TopLeft() + bufferRotation);
-
-    nsIntRect srcRectDrawTopRight(srcRect);
-    nsIntRect srcRectDrawTopLeft(srcRect);
-    nsIntRect srcRectDrawBottomLeft(srcRect);
-    // transform into the different quadrants
-    srcRectDrawTopRight  .MoveBy(-nsIntPoint(0, bufferRect.height));
-    srcRectDrawTopLeft   .MoveBy(-nsIntPoint(bufferRect.width, bufferRect.height));
-    srcRectDrawBottomLeft.MoveBy(-nsIntPoint(bufferRect.width, 0));
-
-    // Intersect with the quadrant
-    srcRect               = srcRect              .Intersect(srcBufferSpaceBottomRight);
-    srcRectDrawTopRight   = srcRectDrawTopRight  .Intersect(srcBufferSpaceTopRight);
-    srcRectDrawTopLeft    = srcRectDrawTopLeft   .Intersect(srcBufferSpaceTopLeft);
-    srcRectDrawBottomLeft = srcRectDrawBottomLeft.Intersect(srcBufferSpaceBottomLeft);
-
-    dstRect = srcRect;
-    nsIntRect dstRectDrawTopRight(srcRectDrawTopRight);
-    nsIntRect dstRectDrawTopLeft(srcRectDrawTopLeft);
-    nsIntRect dstRectDrawBottomLeft(srcRectDrawBottomLeft);
-
-    // transform back to src buffer space
-    dstRect              .MoveBy(-bufferRotation);
-    dstRectDrawTopRight  .MoveBy(-bufferRotation + nsIntPoint(0, bufferRect.height));
-    dstRectDrawTopLeft   .MoveBy(-bufferRotation + nsIntPoint(bufferRect.width, bufferRect.height));
-    dstRectDrawBottomLeft.MoveBy(-bufferRotation + nsIntPoint(bufferRect.width, 0));
-
-    // transform back to draw coordinates
-    dstRect              .MoveBy(bufferRect.TopLeft());
-    dstRectDrawTopRight  .MoveBy(bufferRect.TopLeft());
-    dstRectDrawTopLeft   .MoveBy(bufferRect.TopLeft());
-    dstRectDrawBottomLeft.MoveBy(bufferRect.TopLeft());
-
-    // transform to destBuffer space
-    dstRect              .MoveBy(-mBufferRect.TopLeft());
-    dstRectDrawTopRight  .MoveBy(-mBufferRect.TopLeft());
-    dstRectDrawTopLeft   .MoveBy(-mBufferRect.TopLeft());
-    dstRectDrawBottomLeft.MoveBy(-mBufferRect.TopLeft());
-
-    newSource->EnsureBuffer(mBufferRect.Size(),
-                           ContentForFormat(aHost->mSource->GetFormat()));
-
-    aHost->mSource->CopyTo(srcRect, newSource, 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->mSource->CopyTo(srcRectDrawTopRight,
-                               newSource, dstRectDrawTopRight);
-      if (!srcRectDrawTopLeft.IsEmpty())
-        aHost->mSource->CopyTo(srcRectDrawTopLeft,
-                               newSource, dstRectDrawTopLeft);
-      if (!srcRectDrawBottomLeft.IsEmpty())
-        aHost->mSource->CopyTo(srcRectDrawBottomLeft,
-                               newSource, dstRectDrawBottomLeft);
-    }
-
-    if (newSourceOnWhite) {
-      newSourceOnWhite->EnsureBuffer(mBufferRect.Size(),
-                                    ContentForFormat(aHost->mSourceOnWhite->GetFormat()));
-      aHost->mSourceOnWhite->CopyTo(srcRect, newSourceOnWhite, dstRect);
-      if (bufferRotation != nsIntPoint(0, 0)) {
-        // draw the remaining quadrants
-        if (!srcRectDrawTopRight.IsEmpty())
-          aHost->mSourceOnWhite->CopyTo(srcRectDrawTopRight,
-                                        newSourceOnWhite, dstRectDrawTopRight);
-        if (!srcRectDrawTopLeft.IsEmpty())
-          aHost->mSourceOnWhite->CopyTo(srcRectDrawTopLeft,
-                                        newSourceOnWhite, dstRectDrawTopLeft);
-        if (!srcRectDrawBottomLeft.IsEmpty())
-          aHost->mSourceOnWhite->CopyTo(srcRectDrawBottomLeft,
-                                        newSourceOnWhite, dstRectDrawBottomLeft);
-      }
-    }
-  }
-
-  aHost->mSource = newSource;
-  aHost->mSourceOnWhite = newSourceOnWhite;
-
-  aHost->mBufferRect = mBufferRect;
-  aHost->mBufferRotation = nsIntPoint();
-}
-
-nsIntRect
-ContentHostIncremental::TextureUpdateRequest::GetQuadrantRectangle(XSide aXSide,
-                                                                   YSide aYSide) const
-{
-  // quadrantTranslation is the amount we translate the top-left
-  // of the quadrant by to get coordinates relative to the layer
-  nsIntPoint quadrantTranslation = -mBufferRotation;
-  quadrantTranslation.x += aXSide == LEFT ? mBufferRect.width : 0;
-  quadrantTranslation.y += aYSide == TOP ? mBufferRect.height : 0;
-  return mBufferRect + quadrantTranslation;
-}
-
-void
-ContentHostIncremental::TextureUpdateRequest::Execute(ContentHostIncremental* aHost)
-{
-  nsIntRect drawBounds = mUpdated.GetBounds();
-
-  aHost->mBufferRect = mBufferRect;
-  aHost->mBufferRotation = mBufferRotation;
-
-  // Figure out which quadrant to draw in
-  int32_t xBoundary = mBufferRect.XMost() - mBufferRotation.x;
-  int32_t yBoundary = mBufferRect.YMost() - mBufferRotation.y;
-  XSide sideX = drawBounds.XMost() <= xBoundary ? RIGHT : LEFT;
-  YSide sideY = drawBounds.YMost() <= yBoundary ? BOTTOM : TOP;
-  nsIntRect quadrantRect = GetQuadrantRectangle(sideX, sideY);
-  NS_ASSERTION(quadrantRect.Contains(drawBounds), "Messed up quadrants");
-
-  mUpdated.MoveBy(-nsIntPoint(quadrantRect.x, quadrantRect.y));
-
-  IntPoint offset = ToIntPoint(-mUpdated.GetBounds().TopLeft());
-
-  RefPtr<DataSourceSurface> surf = GetSurfaceForDescriptor(mDescriptor);
-
-  if (mTextureId == TextureIdentifier::Front) {
-    aHost->mSource->Update(surf, &mUpdated, &offset);
-  } else {
-    aHost->mSourceOnWhite->Update(surf, &mUpdated, &offset);
-  }
-}
-
-void
-ContentHostIncremental::PrintInfo(std::stringstream& aStream, const char* aPrefix)
-{
-  aStream << aPrefix;
-  aStream << nsPrintfCString("ContentHostIncremental (0x%p)", this).get();
-
-  if (PaintWillResample()) {
-    aStream << " [paint-will-resample]";
-  }
-}
-
 void
 ContentHostTexture::PrintInfo(std::stringstream& aStream, const char* aPrefix)
 {
   aStream << aPrefix;
   aStream << nsPrintfCString("ContentHost (0x%p)", this).get();
 
   AppendToString(aStream, mBufferRect, " [buffer-rect=", "]");
   AppendToString(aStream, mBufferRotation, " [buffer-rotation=", "]");
@@ -864,25 +441,16 @@ ContentHostTexture::GenEffect(const gfx:
   if (mTextureHostOnWhite && !mTextureHostOnWhite->BindTextureSource(mTextureSourceOnWhite)) {
     return nullptr;
   }
   return CreateTexturedEffect(mTextureSource.get(),
                               mTextureSourceOnWhite.get(),
                               aFilter, true);
 }
 
-TemporaryRef<TexturedEffect>
-ContentHostIncremental::GenEffect(const gfx::Filter& aFilter)
-{
-  if (!mSource) {
-    return nullptr;
-  }
-  return CreateTexturedEffect(mSource, mSourceOnWhite, aFilter, true);
-}
-
 TemporaryRef<gfx::DataSourceSurface>
 ContentHostTexture::GetAsSurface()
 {
   if (!mTextureHost) {
     return nullptr;
   }
 
   return mTextureHost->GetAsSurface();
--- a/gfx/layers/composite/ContentHost.h
+++ b/gfx/layers/composite/ContentHost.h
@@ -218,166 +218,12 @@ public:
   virtual CompositableType GetType() { return CompositableType::CONTENT_SINGLE; }
 
   virtual bool UpdateThebes(const ThebesBufferData& aData,
                             const nsIntRegion& aUpdated,
                             const nsIntRegion& aOldValidRegionBack,
                             nsIntRegion* aUpdatedRegionBack);
 };
 
-/**
- * Maintains a host-side only texture, and gets provided with
- * 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
-{
-public:
-  explicit ContentHostIncremental(const TextureInfo& aTextureInfo);
-  ~ContentHostIncremental();
-
-  virtual CompositableType GetType() MOZ_OVERRIDE { return CompositableType::CONTENT_INC; }
-
-  virtual LayerRenderState GetRenderState() MOZ_OVERRIDE { return LayerRenderState(); }
-
-  virtual bool CreatedIncrementalTexture(ISurfaceAllocator* aAllocator,
-                                         const TextureInfo& aTextureInfo,
-                                         const nsIntRect& aBufferRect) MOZ_OVERRIDE;
-
-  virtual void UpdateIncremental(TextureIdentifier aTextureId,
-                                 SurfaceDescriptor& aSurface,
-                                 const nsIntRegion& aUpdated,
-                                 const nsIntRect& aBufferRect,
-                                 const nsIntPoint& aBufferRotation) MOZ_OVERRIDE;
-
-  virtual bool UpdateThebes(const ThebesBufferData& aData,
-                            const nsIntRegion& aUpdated,
-                            const nsIntRegion& aOldValidRegionBack,
-                            nsIntRegion* aUpdatedRegionBack) MOZ_OVERRIDE
-  {
-    NS_ERROR("Shouldn't call this");
-    return false;
-  }
-
-  virtual void Composite(EffectChain& aEffectChain,
-                         float aOpacity,
-                         const gfx::Matrix4x4& aTransform,
-                         const gfx::Filter& aFilter,
-                         const gfx::Rect& aClipRect,
-                         const nsIntRegion* aVisibleRegion = nullptr) MOZ_OVERRIDE;
-
-  virtual void PrintInfo(std::stringstream& aStream, const char* aPrefix) MOZ_OVERRIDE;
-
-  virtual bool Lock() MOZ_OVERRIDE {
-    MOZ_ASSERT(!mLocked);
-    ProcessTextureUpdates();
-    mLocked = true;
-    return true;
-  }
-
-  virtual void Unlock() MOZ_OVERRIDE {
-    MOZ_ASSERT(mLocked);
-    mLocked = false;
-  }
-
-  virtual TemporaryRef<TexturedEffect>
-  GenEffect(const gfx::Filter& aFilter) MOZ_OVERRIDE;
-
-private:
-
-  void FlushUpdateQueue();
-  void ProcessTextureUpdates();
-
-  class Request
-  {
-  public:
-    Request()
-    {
-      MOZ_COUNT_CTOR(ContentHostIncremental::Request);
-    }
-
-    virtual ~Request()
-    {
-      MOZ_COUNT_DTOR(ContentHostIncremental::Request);
-    }
-
-    virtual void Execute(ContentHostIncremental *aHost) = 0;
-  };
-
-  class TextureCreationRequest : public Request
-  {
-  public:
-    TextureCreationRequest(const TextureInfo& aTextureInfo,
-                           const nsIntRect& aBufferRect)
-      : mTextureInfo(aTextureInfo)
-      , mBufferRect(aBufferRect)
-    {}
-
-    virtual void Execute(ContentHostIncremental *aHost);
-
-  private:
-    TextureInfo mTextureInfo;
-    nsIntRect mBufferRect;
-  };
-
-  class TextureUpdateRequest : public Request
-  {
-  public:
-    TextureUpdateRequest(ISurfaceAllocator* aDeAllocator,
-                         TextureIdentifier aTextureId,
-                         SurfaceDescriptor& aDescriptor,
-                         const nsIntRegion& aUpdated,
-                         const nsIntRect& aBufferRect,
-                         const nsIntPoint& aBufferRotation)
-      : mDeAllocator(aDeAllocator)
-      , mTextureId(aTextureId)
-      , mDescriptor(aDescriptor)
-      , mUpdated(aUpdated)
-      , mBufferRect(aBufferRect)
-      , mBufferRotation(aBufferRotation)
-    {}
-
-    ~TextureUpdateRequest()
-    {
-      //TODO: Recycle these?
-      mDeAllocator->DestroySharedSurface(&mDescriptor);
-    }
-
-    virtual void Execute(ContentHostIncremental *aHost);
-
-  private:
-    enum XSide {
-      LEFT, RIGHT
-    };
-    enum YSide {
-      TOP, BOTTOM
-    };
-
-    nsIntRect GetQuadrantRectangle(XSide aXSide, YSide aYSide) const;
-
-    RefPtr<ISurfaceAllocator> mDeAllocator;
-    TextureIdentifier mTextureId;
-    SurfaceDescriptor mDescriptor;
-    nsIntRegion mUpdated;
-    nsIntRect mBufferRect;
-    nsIntPoint mBufferRotation;
-  };
-
-  nsTArray<UniquePtr<Request> > mUpdateList;
-
-  // Specific to OGL to avoid exposing methods on TextureSource that only
-  // have one implementation.
-  RefPtr<TextureImageTextureSourceOGL> mSource;
-  RefPtr<TextureImageTextureSourceOGL> mSourceOnWhite;
-
-  RefPtr<ISurfaceAllocator> mDeAllocator;
-  bool mLocked;
-};
-
 }
 }
 
 #endif
--- a/gfx/layers/composite/PaintedLayerComposite.cpp
+++ b/gfx/layers/composite/PaintedLayerComposite.cpp
@@ -48,17 +48,16 @@ PaintedLayerComposite::~PaintedLayerComp
   MOZ_COUNT_DTOR(PaintedLayerComposite);
   CleanupResources();
 }
 
 bool
 PaintedLayerComposite::SetCompositableHost(CompositableHost* aHost)
 {
   switch (aHost->GetType()) {
-    case CompositableType::CONTENT_INC:
     case CompositableType::CONTENT_TILED:
     case CompositableType::CONTENT_SINGLE:
     case CompositableType::CONTENT_DOUBLE:
       mBuffer = static_cast<ContentHost*>(aHost);
       return true;
     default:
       return false;
   }
--- a/gfx/layers/ipc/CompositableForwarder.h
+++ b/gfx/layers/ipc/CompositableForwarder.h
@@ -51,24 +51,16 @@ public:
 
   /**
    * Setup the IPDL actor for aCompositable to be part of layers
    * transactions.
    */
   virtual void Connect(CompositableClient* aCompositable) = 0;
 
   /**
-   * Notify the CompositableHost that it should create host-side-only
-   * texture(s), that we will update incrementally using UpdateTextureIncremental.
-   */
-  virtual void CreatedIncrementalBuffer(CompositableClient* aCompositable,
-                                        const TextureInfo& aTextureInfo,
-                                        const nsIntRect& aBufferRect) = 0;
-
-  /**
    * Tell the CompositableHost on the compositor side what TiledLayerBuffer to
    * use for the next composition.
    */
   virtual void UseTiledLayerBuffer(CompositableClient* aCompositable,
                                    const SurfaceDescriptorTiles& aTiledDescriptor) = 0;
 
   /**
    * Create a TextureChild/Parent pair as as well as the TextureHost on the parent side.
@@ -79,33 +71,16 @@ public:
    * Communicate to the compositor that aRegion in the texture identified by
    * aCompositable and aIdentifier has been updated to aThebesBuffer.
    */
   virtual void UpdateTextureRegion(CompositableClient* aCompositable,
                                    const ThebesBufferData& aThebesBufferData,
                                    const nsIntRegion& aUpdatedRegion) = 0;
 
   /**
-   * Notify the compositor to update aTextureId using aDescriptor, and take
-   * ownership of aDescriptor.
-   *
-   * aDescriptor only contains the pixels for aUpdatedRegion, and is relative
-   * to aUpdatedRegion.TopLeft().
-   *
-   * aBufferRect/aBufferRotation define the new valid region contained
-   * within the texture after the update has been applied.
-   */
-  virtual void UpdateTextureIncremental(CompositableClient* aCompositable,
-                                        TextureIdentifier aTextureId,
-                                        SurfaceDescriptor& aDescriptor,
-                                        const nsIntRegion& aUpdatedRegion,
-                                        const nsIntRect& aBufferRect,
-                                        const nsIntPoint& aBufferRotation) = 0;
-
-  /**
    * Communicate the picture rect of a YUV image in aLayer to the compositor
    */
   virtual void UpdatePictureRect(CompositableClient* aCompositable,
                                  const nsIntRect& aRect) = 0;
 
 #ifdef MOZ_WIDGET_GONK
   virtual void UseOverlaySource(CompositableClient* aCompositabl,
                                 const OverlaySource& aOverlay) = 0;
--- a/gfx/layers/ipc/CompositableTransactionParent.cpp
+++ b/gfx/layers/ipc/CompositableTransactionParent.cpp
@@ -68,30 +68,16 @@ bool ScheduleComposition(const T& op)
   return true;
 }
 
 bool
 CompositableParentManager::ReceiveCompositableUpdate(const CompositableOperation& aEdit,
                                                      EditReplyVector& replyv)
 {
   switch (aEdit.type()) {
-    case CompositableOperation::TOpCreatedIncrementalTexture: {
-      MOZ_LAYERS_LOG(("[ParentSide] Created texture"));
-      const OpCreatedIncrementalTexture& op = aEdit.get_OpCreatedIncrementalTexture();
-      CompositableHost* compositable = AsCompositable(op);
-
-      bool success =
-        compositable->CreatedIncrementalTexture(this,
-                                                op.textureInfo(),
-                                                op.bufferRect());
-      if (!success) {
-        return false;
-      }
-      break;
-    }
     case CompositableOperation::TOpPaintTextureRegion: {
       MOZ_LAYERS_LOG(("[ParentSide] Paint PaintedLayer"));
 
       const OpPaintTextureRegion& op = aEdit.get_OpPaintTextureRegion();
       CompositableHost* compositable = AsCompositable(op);
       Layer* layer = compositable->GetLayer();
       if (!layer || layer->GetType() != Layer::TYPE_PAINTED) {
         return false;
@@ -111,32 +97,16 @@ CompositableParentManager::ReceiveCompos
         return false;
       }
       replyv.push_back(
         OpContentBufferSwap(op.compositableParent(), nullptr, frontUpdatedRegion));
 
       RenderTraceInvalidateEnd(thebes, "FF00FF");
       break;
     }
-    case CompositableOperation::TOpPaintTextureIncremental: {
-      MOZ_LAYERS_LOG(("[ParentSide] Paint PaintedLayer"));
-
-      const OpPaintTextureIncremental& op = aEdit.get_OpPaintTextureIncremental();
-
-      CompositableHost* compositable = AsCompositable(op);
-
-      SurfaceDescriptor desc = op.image();
-
-      compositable->UpdateIncremental(op.textureId(),
-                                      desc,
-                                      op.updatedRegion(),
-                                      op.bufferRect(),
-                                      op.bufferRotation());
-      break;
-    }
     case CompositableOperation::TOpUpdatePictureRect: {
       const OpUpdatePictureRect& op = aEdit.get_OpUpdatePictureRect();
       CompositableHost* compositable = AsCompositable(op);
       MOZ_ASSERT(compositable);
       compositable->SetPictureRect(op.picture());
       break;
     }
     case CompositableOperation::TOpUseTiledLayerBuffer: {
--- a/gfx/layers/ipc/ImageBridgeChild.cpp
+++ b/gfx/layers/ipc/ImageBridgeChild.cpp
@@ -536,27 +536,16 @@ ImageBridgeChild::EndTransaction()
     if (!SendUpdateNoSwap(cset)) {
       NS_WARNING("could not send async texture transaction (no swap)");
       return;
     }
   }
   for (nsTArray<EditReply>::size_type i = 0; i < replies.Length(); ++i) {
     const EditReply& reply = replies[i];
     switch (reply.type()) {
-    case EditReply::TOpTextureSwap: {
-      const OpTextureSwap& ots = reply.get_OpTextureSwap();
-
-      CompositableClient* compositable =
-        CompositableClient::FromIPDLActor(ots.compositableChild());
-
-      MOZ_ASSERT(compositable);
-
-      compositable->SetDescriptorFromReply(ots.textureId(), ots.image());
-      break;
-    }
     case EditReply::TReturnReleaseFence: {
       const ReturnReleaseFence& rep = reply.get_ReturnReleaseFence();
       FenceHandle fence = rep.fence();
       PTextureChild* child = rep.textureChild();
 
       if (!fence.IsValid() || !child) {
         break;
       }
--- a/gfx/layers/ipc/ImageBridgeChild.h
+++ b/gfx/layers/ipc/ImageBridgeChild.h
@@ -8,17 +8,17 @@
 
 #include <stddef.h>                     // for size_t
 #include <stdint.h>                     // for uint32_t, uint64_t
 #include "mozilla/Attributes.h"         // for MOZ_OVERRIDE
 #include "mozilla/RefPtr.h"             // for TemporaryRef
 #include "mozilla/ipc/SharedMemory.h"   // for SharedMemory, etc
 #include "mozilla/layers/AsyncTransactionTracker.h" // for AsyncTransactionTrackerHolder
 #include "mozilla/layers/CompositableForwarder.h"
-#include "mozilla/layers/CompositorTypes.h"  // for TextureIdentifier, etc
+#include "mozilla/layers/CompositorTypes.h"
 #include "mozilla/layers/PImageBridgeChild.h"
 #include "nsDebug.h"                    // for NS_RUNTIMEABORT
 #include "nsRegion.h"                   // for nsIntRegion
 
 class MessageLoop;
 struct nsIntPoint;
 struct nsIntRect;
 
@@ -243,39 +243,23 @@ public:
   virtual void RemoveTexture(TextureClient* aTexture) MOZ_OVERRIDE;
 
   virtual void UseTiledLayerBuffer(CompositableClient* aCompositable,
                                    const SurfaceDescriptorTiles& aTileLayerDescriptor) MOZ_OVERRIDE
   {
     NS_RUNTIMEABORT("should not be called");
   }
 
-  virtual void UpdateTextureIncremental(CompositableClient* aCompositable,
-                                        TextureIdentifier aTextureId,
-                                        SurfaceDescriptor& aDescriptor,
-                                        const nsIntRegion& aUpdatedRegion,
-                                        const nsIntRect& aBufferRect,
-                                        const nsIntPoint& aBufferRotation) MOZ_OVERRIDE
-  {
-    NS_RUNTIMEABORT("should not be called");
-  }
-
   /**
    * Communicate the picture rect of a YUV image in aLayer to the compositor
    */
   virtual void UpdatePictureRect(CompositableClient* aCompositable,
                                  const nsIntRect& aRect) MOZ_OVERRIDE;
 
 
-  virtual void CreatedIncrementalBuffer(CompositableClient* aCompositable,
-                                        const TextureInfo& aTextureInfo,
-                                        const nsIntRect& aBufferRect) MOZ_OVERRIDE
-  {
-    NS_RUNTIMEABORT("should not be called");
-  }
   virtual void UpdateTextureRegion(CompositableClient* aCompositable,
                                    const ThebesBufferData& aThebesBufferData,
                                    const nsIntRegion& aUpdatedRegion) MOZ_OVERRIDE {
     NS_RUNTIMEABORT("should not be called");
   }
 
   // ISurfaceAllocator
 
--- a/gfx/layers/ipc/LayersMessages.ipdlh
+++ b/gfx/layers/ipc/LayersMessages.ipdlh
@@ -36,17 +36,16 @@ using mozilla::LayerRect from "Units.h";
 using mozilla::layers::ScaleMode from "mozilla/layers/LayersTypes.h";
 using mozilla::layers::EventRegions from "mozilla/layers/LayersTypes.h";
 using mozilla::layers::EventRegionsOverride from "mozilla/layers/LayersTypes.h";
 using mozilla::layers::DiagnosticTypes from "mozilla/layers/CompositorTypes.h";
 using struct mozilla::layers::FrameMetrics from "FrameMetrics.h";
 using mozilla::layers::FrameMetrics::ViewID from "FrameMetrics.h";
 using struct mozilla::layers::FenceHandle from "mozilla/layers/FenceUtils.h";
 using struct mozilla::layers::FenceHandleFromChild from "mozilla/layers/FenceUtils.h";
-using mozilla::layers::TextureIdentifier from "mozilla/layers/CompositorTypes.h";
 using std::string from "string";
 
 namespace mozilla {
 namespace layers {
 
 struct TargetConfig {
   nsIntRect naturalBounds;
   ScreenRotation rotation;
@@ -334,37 +333,22 @@ struct OpUseTiledLayerBuffer {
   SurfaceDescriptorTiles tileLayerDescriptor;
 };
 
 struct OpUseOverlaySource {
   PCompositable compositable;
   OverlaySource overlay;
 };
 
-struct OpCreatedIncrementalTexture {
-  PCompositable compositable;
-  TextureInfo textureInfo;
-  nsIntRect bufferRect;
-};
-
 struct OpPaintTextureRegion {
   PCompositable compositable;
   ThebesBufferData bufferData;
   nsIntRegion updatedRegion;
 };
 
-struct OpPaintTextureIncremental {
-  PCompositable compositable;
-  TextureIdentifier textureId;
-  SurfaceDescriptor image;
-  nsIntRegion updatedRegion;
-  nsIntRect bufferRect;
-  nsIntPoint bufferRotation;
-};
-
 struct OpUpdatePictureRect {
   PCompositable compositable;
   nsIntRect picture;
 };
 
 /**
  * Tells the CompositableHost to remove the corresponding TextureHost
  */
@@ -433,20 +417,17 @@ struct OpDeliverFenceFromChild {
 
 struct OpReplyDeliverFence {
   uint64_t transactionId;
 };
 
 union CompositableOperation {
   OpUpdatePictureRect;
 
-  OpCreatedIncrementalTexture;
-
   OpPaintTextureRegion;
-  OpPaintTextureIncremental;
 
   OpUseTiledLayerBuffer;
 
   OpRemoveTexture;
   OpRemoveTextureAsync;
 
   OpUpdateTexture;
   OpUseTexture;
@@ -482,33 +463,26 @@ union Edit {
 
 // Replies to operations
 
 struct OpContentBufferSwap {
   PCompositable compositable;
   nsIntRegion frontUpdatedRegion;
 };
 
-struct OpTextureSwap {
-  PCompositable compositable;
-  TextureIdentifier textureId;
-  SurfaceDescriptor image;
-};
-
 struct ReturnReleaseFence {
   PCompositable compositable;
   PTexture texture;
   FenceHandle fence;
 };
 
 // Unit of a "changeset reply".  This is a weird abstraction, probably
 // only to be used for buffer swapping.
 union EditReply {
   OpContentBufferSwap;
-  OpTextureSwap;
 
   ReturnReleaseFence;
 };
 
 union AsyncParentMessageData {
   OpDeliverFence;
   OpDeliverFenceToTracker;
   OpReplyDeliverFence;
--- a/gfx/layers/ipc/ShadowLayers.cpp
+++ b/gfx/layers/ipc/ShadowLayers.cpp
@@ -348,36 +348,16 @@ ShadowLayerForwarder::UpdateTextureRegio
   MOZ_ASSERT(aCompositable);
   MOZ_ASSERT(aCompositable->GetIPDLActor());
   mTxn->AddPaint(OpPaintTextureRegion(nullptr, aCompositable->GetIPDLActor(),
                                       aThebesBufferData,
                                       aUpdatedRegion));
 }
 
 void
-ShadowLayerForwarder::UpdateTextureIncremental(CompositableClient* aCompositable,
-                                               TextureIdentifier aTextureId,
-                                               SurfaceDescriptor& aDescriptor,
-                                               const nsIntRegion& aUpdatedRegion,
-                                               const nsIntRect& aBufferRect,
-                                               const nsIntPoint& aBufferRotation)
-{
-  CheckSurfaceDescriptor(&aDescriptor);
-  MOZ_ASSERT(aCompositable);
-  MOZ_ASSERT(aCompositable->GetIPDLActor());
-  mTxn->AddNoSwapPaint(OpPaintTextureIncremental(nullptr, aCompositable->GetIPDLActor(),
-                                                 aTextureId,
-                                                 aDescriptor,
-                                                 aUpdatedRegion,
-                                                 aBufferRect,
-                                                 aBufferRotation));
-}
-
-
-void
 ShadowLayerForwarder::UpdatePictureRect(CompositableClient* aCompositable,
                                         const nsIntRect& aRect)
 {
   MOZ_ASSERT(aCompositable);
   MOZ_ASSERT(aCompositable->GetIPDLActor());
   mTxn->AddNoSwapPaint(OpUpdatePictureRect(nullptr, aCompositable->GetIPDLActor(), aRect));
 }
 
@@ -810,26 +790,16 @@ ShadowLayerForwarder::Connect(Compositab
     return;
   }
   PCompositableChild* actor =
     mShadowManager->SendPCompositableConstructor(aCompositable->GetTextureInfo());
   MOZ_ASSERT(actor);
   aCompositable->InitIPDLActor(actor);
 }
 
-void
-ShadowLayerForwarder::CreatedIncrementalBuffer(CompositableClient* aCompositable,
-                                               const TextureInfo& aTextureInfo,
-                                               const nsIntRect& aBufferRect)
-{
-  MOZ_ASSERT(aCompositable);
-  mTxn->AddNoSwapPaint(OpCreatedIncrementalTexture(nullptr, aCompositable->GetIPDLActor(),
-                                                   aTextureInfo, aBufferRect));
-}
-
 void ShadowLayerForwarder::Attach(CompositableClient* aCompositable,
                                   ShadowableLayer* aLayer)
 {
   MOZ_ASSERT(aLayer);
   MOZ_ASSERT(aCompositable);
   MOZ_ASSERT(aCompositable->GetIPDLActor());
   mTxn->AddEdit(OpAttachCompositable(nullptr, Shadow(aLayer),
                                      nullptr, aCompositable->GetIPDLActor()));
--- a/gfx/layers/ipc/ShadowLayers.h
+++ b/gfx/layers/ipc/ShadowLayers.h
@@ -128,35 +128,30 @@ class Transaction;
  * are always between the content thread and the compositor thread.
  * 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 ContentClientIncremental;
   friend class ClientLayerManager;
 
 public:
   virtual ~ShadowLayerForwarder();
 
   /**
    * Setup the IPDL actor for aCompositable to be part of layers
    * transactions.
    */
   void Connect(CompositableClient* aCompositable) MOZ_OVERRIDE;
 
   virtual PTextureChild* CreateTexture(const SurfaceDescriptor& aSharedData,
                                        TextureFlags aFlags) MOZ_OVERRIDE;
 
-  virtual void CreatedIncrementalBuffer(CompositableClient* aCompositable,
-                                        const TextureInfo& aTextureInfo,
-                                        const nsIntRect& aBufferRect) MOZ_OVERRIDE;
-
   /**
    * Adds an edit in the layers transaction in order to attach
    * the corresponding compositable and layer on the compositor side.
    * Connect must have been called on aCompositable beforehand.
    */
   void Attach(CompositableClient* aCompositable,
               ShadowableLayer* aLayer);
 
@@ -254,23 +249,16 @@ public:
   /**
    * Communicate to the compositor that aRegion in the texture identified by aLayer
    * and aIdentifier has been updated to aThebesBuffer.
    */
   virtual void UpdateTextureRegion(CompositableClient* aCompositable,
                                    const ThebesBufferData& aThebesBufferData,
                                    const nsIntRegion& aUpdatedRegion) MOZ_OVERRIDE;
 
-  virtual void UpdateTextureIncremental(CompositableClient* aCompositable,
-                                        TextureIdentifier aTextureId,
-                                        SurfaceDescriptor& aDescriptor,
-                                        const nsIntRegion& aUpdatedRegion,
-                                        const nsIntRect& aBufferRect,
-                                        const nsIntPoint& aBufferRotation) MOZ_OVERRIDE;
-
   /**
    * Communicate the picture rect of an image to the compositor
    */
   void UpdatePictureRect(CompositableClient* aCompositable,
                          const nsIntRect& aRect) MOZ_OVERRIDE;
 
   /**
    * See CompositableForwarder::UpdatedTexture