Back out Bug 773440 for causing M2 orange on Android on this CLOSED TREE.
authorAndrew McCreight <amccreight@mozilla.com>
Thu, 23 Aug 2012 10:01:14 -0700
changeset 103189 00dea115746d20840e13d816e8be618964464bf5
parent 103188 5853a841672ebbdd4f45e8d05610af903a4353d1
child 103190 f4e742d57ce7a24f38bbcd450d156d263955de9f
push id23332
push userryanvm@gmail.com
push dateFri, 24 Aug 2012 02:06:52 +0000
treeherdermozilla-central@e509c7472f30 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs773440
milestone17.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
Back out Bug 773440 for causing M2 orange on Android on this CLOSED TREE.
gfx/layers/ImageContainer.cpp
gfx/layers/ImageContainer.h
gfx/layers/basic/BasicImageLayer.cpp
gfx/layers/ipc/ImageContainerChild.cpp
gfx/layers/ipc/ImageContainerChild.h
gfx/layers/ipc/LayersSurfaces.ipdlh
--- a/gfx/layers/ImageContainer.cpp
+++ b/gfx/layers/ImageContainer.cpp
@@ -134,55 +134,21 @@ ImageContainer::ImageContainer(int flag)
 
 ImageContainer::~ImageContainer()
 {
   if (mImageContainerChild) {
     mImageContainerChild->DispatchStop();
   }
 }
 
-void ImageContainer::CopyPlane(uint8_t *aDst, uint8_t *aSrc,
-                               const gfxIntSize &aSize,
-                               int32_t aSrcStride, int32_t aDstStride,
-                               int32_t aOffset, int32_t aSkip)
-{
-  if (!aOffset && !aSkip && aSrcStride == aDstStride) {
-    // Fast path: planar input.
-    memcpy(aDst, aSrc, aSize.height * aSrcStride);
-  } else {
-    int32_t height = aSize.height;
-    int32_t width = aSize.width;
-    for (int y = 0; y < height; ++y) {
-      uint8_t *src = aSrc + aOffset;
-      uint8_t *dst = aDst;
-      if (!aSkip) {
-        // Fast path: offset only, no per-pixel skip.
-        memcpy(dst, src, width);
-      } else {
-        // Slow path
-        for (int x = 0; x < width; ++x) {
-          *dst++ = *src++;
-          src += aSkip;
-        }
-      }
-      aSrc += aSrcStride;
-      aDst += aDstStride;
-    }
-  }
-}
-
-
 already_AddRefed<Image>
 ImageContainer::CreateImage(const ImageFormat *aFormats,
                             uint32_t aNumFormats)
 {
   ReentrantMonitorAutoEnter mon(mReentrantMonitor);
-  if (IsAsync()) {
-    return mImageContainerChild->CreateImage(aFormats, aNumFormats);
-  }
   return mImageFactory->CreateImage(aFormats, aNumFormats, mScaleHint, mRecycleBin);
 }
 
 void 
 ImageContainer::SetCurrentImageInternal(Image *aImage)
 {
   ReentrantMonitorAutoEnter mon(mReentrantMonitor);
 
@@ -440,49 +406,81 @@ PlanarYCbCrImage::~PlanarYCbCrImage()
 }
 
 uint8_t* 
 PlanarYCbCrImage::AllocateBuffer(uint32_t aSize)
 {
   return mRecycleBin->GetBuffer(aSize); 
 }
 
-void PlanarYCbCrImage::Allocate(Data& aData)
+static void
+CopyPlane(uint8_t *aDst, uint8_t *aSrc,
+          const gfxIntSize &aSize, int32_t aStride,
+          int32_t aOffset, int32_t aSkip)
 {
+  if (!aOffset && !aSkip) {
+    // Fast path: planar input.
+    memcpy(aDst, aSrc, aSize.height * aStride);
+  } else {
+    int32_t height = aSize.height;
+    int32_t width = aSize.width;
+    for (int y = 0; y < height; ++y) {
+      uint8_t *src = aSrc + aOffset;
+      uint8_t *dst = aDst;
+      if (!aSkip) {
+        // Fast path: offset only, no per-pixel skip.
+        memcpy(dst, src, width);
+      } else {
+        // Slow path
+        for (int x = 0; x < width; ++x) {
+          *dst++ = *src++;
+          src += aSkip;
+        }
+      }
+      aSrc += aStride;
+      aDst += aStride;
+    }
+  }
+}
+
+void
+PlanarYCbCrImage::CopyData(const Data& aData)
+{
+  mData = aData;
+
   // update buffer size
-  int bufferSize = aData.mCbCrStride * aData.mCbCrSize.height * 2 +
-                aData.mYStride * aData.mYSize.height;
+  mBufferSize = mData.mCbCrStride * mData.mCbCrSize.height * 2 +
+                mData.mYStride * mData.mYSize.height;
+
   // get new buffer
-  uint8_t* buffer = AllocateBuffer(bufferSize); 
-  if (!buffer)
+  mBuffer = AllocateBuffer(mBufferSize); 
+  if (!mBuffer)
     return;
 
-  aData.mYChannel = buffer;
-  aData.mCbChannel = aData.mYChannel + aData.mYStride * aData.mYSize.height;
-  aData.mCrChannel = aData.mCbChannel + aData.mCbCrStride * aData.mCbCrSize.height;
-  mBuffer = buffer;
+  mData.mYChannel = mBuffer;
+  mData.mCbChannel = mData.mYChannel + mData.mYStride * mData.mYSize.height;
+  mData.mCrChannel = mData.mCbChannel + mData.mCbCrStride * mData.mCbCrSize.height;
+
+  CopyPlane(mData.mYChannel, aData.mYChannel,
+            mData.mYSize, mData.mYStride,
+            mData.mYOffset, mData.mYSkip);
+  CopyPlane(mData.mCbChannel, aData.mCbChannel,
+            mData.mCbCrSize, mData.mCbCrStride,
+            mData.mCbOffset, mData.mCbSkip);
+  CopyPlane(mData.mCrChannel, aData.mCrChannel,
+            mData.mCbCrSize, mData.mCbCrStride,
+            mData.mCrOffset, mData.mCrSkip);
+
+  mSize = aData.mPicSize;
 }
 
 void
 PlanarYCbCrImage::SetData(const Data &aData)
 {
-  mData = aData;
-  mBufferSize = mData.mCbCrStride * mData.mCbCrSize.height * 2 +
-                 mData.mYStride * mData.mYSize.height;
-  mSize = mData.mPicSize;
-  // If mBuffer has not been allocated (through Allocate(aData)), allocate it.
-  // This code path is slower than the one used when Allocate has been called
-  // since it will trigger a full copy.
-  if (!mBuffer) {
-    mBuffer = AllocateBuffer(mBufferSize);
-    NS_ASSERTION(mBuffer, "Failed to Allocate!");
-  }
-  if (aData.mYChannel != mBuffer) {
-    memcpy(mBuffer.get(), aData.mYChannel, mBufferSize);
-  }
+  CopyData(aData);
 }
 
 already_AddRefed<gfxASurface>
 PlanarYCbCrImage::GetAsSurface()
 {
   if (mSurface) {
     nsRefPtr<gfxASurface> result = mSurface.get();
     return result.forget();
--- a/gfx/layers/ImageContainer.h
+++ b/gfx/layers/ImageContainer.h
@@ -34,17 +34,16 @@ namespace mozilla {
 class CrossProcessMutex;
 namespace ipc {
 class Shmem;
 }
     
 namespace layers {
 
 class ImageContainerChild;
-class SharedPlanarYCbCrImage;
 
 struct ImageBackendData
 {
   virtual ~ImageBackendData() {}
 
 protected:
   ImageBackendData() {}
 };
@@ -479,24 +478,16 @@ public:
    */
   void SetRemoteImageData(RemoteImageData *aRemoteData,
                           CrossProcessMutex *aRemoteDataMutex);
   /**
    * This can be used to check if the container has RemoteData set.
    */
   RemoteImageData *GetRemoteImageData() { return mRemoteData; }
 
-  /**
-   * Helper function to copy an image buffer respecting stride, offset and skip.
-   */
-  static void CopyPlane(uint8_t *aDst, uint8_t *aSrc,
-                        const gfxIntSize &aSize,
-                        int32_t aSrcStride, int32_t aDstStride,
-                        int32_t aOffset, int32_t aSkip);
-
 protected:
   typedef mozilla::ReentrantMonitor ReentrantMonitor;
 
   void SetCurrentImageInternal(Image* aImage);
 
   // This is called to ensure we have an active image, this may not be true
   // when we're storing image information in a RemoteImageData structure.
   // NOTE: If we have remote data mRemoteDataMutex should be locked when
@@ -655,58 +646,35 @@ public:
   };
 
   enum {
     MAX_DIMENSION = 16384
   };
 
   virtual ~PlanarYCbCrImage();
 
-  virtual SharedPlanarYCbCrImage* AsSharedPlanarYCbCrImage()
-  {
-    return nullptr;
-  }
-
   /**
-   * If Allocate has been invoked on aData, simply acquire aData's buffers.
-   * Otherwise make a copy of the data buffers, in order to support 
-   * functioning in all different layer managers.
+   * This makes a copy of the data buffers, in order to support functioning
+   * in all different layer managers.
    */
   virtual void SetData(const Data& aData);
 
   /**
    * Ask this Image to not convert YUV to RGB during SetData, and make
    * the original data available through GetData. This is optional,
    * and not all PlanarYCbCrImages will support it.
    */
   virtual void SetDelayedConversion(bool aDelayed) { }
 
   /**
    * Grab the original YUV data. This is optional.
    */
   virtual const Data* GetData() { return &mData; }
 
   /**
-   * Allocate image buffer(s) and give aData ownership of the image by filling
-   * the pointers in aData.
-   * The information about the size, stride, etc. must be set in aData
-   * prior to calling this method.
-   *
-   * This method is meant to be used with SetData in the following order:
-   * - The caller first fills the necessary information in aData for the data to
-   * be allocated properly.
-   * - The caller invoke Allocate(aData) which will fill the remaining pointers
-   * in aData with allocated memory.
-   * - The caller can fill the allocated buffer with actual image data.
-   * - The caller then invoke SetData(aData) with the same aData that was 
-   * passed in Allocate.
-   */
-  virtual void Allocate(Data& aData);
-
-  /**
    * Return the number of bytes of heap memory used to store this image.
    */
   virtual uint32_t GetDataSize() { return mBufferSize; }
 
   virtual bool IsValid() { return !!mBufferSize; }
 
   virtual gfxIntSize GetSize() { return mSize; }
 
--- a/gfx/layers/basic/BasicImageLayer.cpp
+++ b/gfx/layers/basic/BasicImageLayer.cpp
@@ -340,17 +340,17 @@ BasicShadowableImageLayer::Paint(gfxCont
              data->mCbChannel + i * data->mCbCrStride,
              data->mCbCrSize.width);
       memcpy(dv->Data() + i * dv->Stride(),
              data->mCrChannel + i * data->mCbCrStride,
              data->mCbCrSize.width);
     }
 
     YUVImage yuv(mBackBufferY, mBackBufferU, mBackBufferV,
-                 data->GetPictureRect(), 0);
+                 data->GetPictureRect());
 
     BasicManager()->PaintedImage(BasicManager()->Hold(this),
                                  yuv);
     return;
   }
 
   gfxIntSize oldSize = mSize;
   nsRefPtr<gfxPattern> pat = GetAndPaintCurrentImage
--- a/gfx/layers/ipc/ImageContainerChild.cpp
+++ b/gfx/layers/ipc/ImageContainerChild.cpp
@@ -7,18 +7,16 @@
 #include "ImageContainerChild.h"
 #include "gfxSharedImageSurface.h"
 #include "ShadowLayers.h"
 #include "mozilla/layers/PLayers.h"
 #include "mozilla/layers/SharedImageUtils.h"
 #include "ImageContainer.h"
 #include "GonkIOSurfaceImage.h"
 #include "GrallocImages.h"
-#include "mozilla/ReentrantMonitor.h"
-#include "nsThreadUtils.h"
 
 namespace mozilla {
 namespace layers {
 
 /*
  * - POOL_MAX_SHARED_IMAGES is the maximum number number of shared images to
  * store in the ImageContainerChild's pool.
  *
@@ -36,145 +34,16 @@ namespace layers {
  * (see ImageToSharedImage)
  *
  * The values for the two constants are arbitrary and should be tweaked if it 
  * happens that we run into shared memory problems.
  */
 static const unsigned int POOL_MAX_SHARED_IMAGES = 5;
 static const unsigned int MAX_ACTIVE_SHARED_IMAGES = 10;
 
-/**
- * A YCbCr image that stores its data in shared memory directly so that it's
- * data can be sent to the compositor without being copied.
- */
-class SharedPlanarYCbCrImage : public PlanarYCbCrImage
-{
-  friend class mozilla::layers::ImageContainerChild;
-public:
-  SharedPlanarYCbCrImage(ImageContainerChild* aProtocol)
-  : PlanarYCbCrImage(nullptr), mImageDataAllocator(aProtocol), mSent(false)
-  {
-    MOZ_COUNT_CTOR(SharedPlanarYCbCrImage);
-  }
-
-  ~SharedPlanarYCbCrImage()
-  {
-    if (mYSurface) {
-      SharedImage* sharedImg = new SharedImage();
-      ToSharedImage(sharedImg);
-      mImageDataAllocator->RecycleSharedImage(sharedImg);
-    }
-    MOZ_COUNT_DTOR(SharedPlanarYCbCrImage);
-  }
-
-  /**
-   * To prevent a SharedPlanarYCbCrImage from being sent several times we
-   * store a boolean state telling wether the image has already been sent to
-   * the compositor.
-   */
-  bool IsSent() const
-  {
-    return mSent;
-  }
-
-  SharedPlanarYCbCrImage* AsSharedPlanarYCbCrImage() MOZ_OVERRIDE
-  {
-    return this;
-  }
-
-  void ToSharedImage(SharedImage* aImage)
-  {
-    NS_ABORT_IF_FALSE(aImage, "aImage must be allocated");
-    *aImage = YUVImage(mYSurface->GetShmem(),
-                      mCbSurface->GetShmem(),
-                      mCrSurface->GetShmem(),
-                      mData.GetPictureRect(),
-                      reinterpret_cast<uintptr_t>(this));
-  }
-
-  /**
-   * Returns nullptr because in most cases the YCbCrImage has lost ownership of
-   * its data when this is called.
-   */
-  already_AddRefed<gfxASurface> GetAsSurface()
-  {
-    if (!mYSurface) {
-      return nullptr;
-    }
-    return PlanarYCbCrImage::GetAsSurface();
-  }
-
-  /**
-   * See PlanarYCbCrImage::SeData.
-   * This proxies a synchronous call to the ImageBridgeChild thread.
-   */
-  virtual void Allocate(Data& aData) MOZ_OVERRIDE
-  {
-    // copy aData into mData to have the sizes and strides info
-    // that will be needed by the ImageContainerChild to allocate
-    // shared buffers.
-    mData = aData;
-    // mImageDataAllocator will allocate the shared buffers and
-    // place them into 'this'
-    mImageDataAllocator->AllocateSharedBufferForImage(this);
-    // give aData the resulting buffers
-    aData.mYChannel  = mYSurface->Data();
-    aData.mCbChannel = mCbSurface->Data();
-    aData.mCrChannel = mCrSurface->Data();
-  }
-
-  /**
-   * See PlanarYCbCrImage::SeData.
-   */
-  virtual void SetData(const Data& aData)
-  {
-    // do not set mBuffer like in PlanarYCbCrImage because the later
-    // will try to manage this memory without knowing it belongs to a
-    // shmem.
-    mData = aData;
-    mBufferSize = mData.mCbCrStride * mData.mCbCrSize.height * 2 +
-                   mData.mYStride * mData.mYSize.height;
-    mSize = mData.mPicSize;
-
-    // If m*Surface has not been allocated (through Allocate(aData)), allocate it.
-    // This code path is slower than the one used when Allocate has been called
-    // since it will trigger a full copy.
-    if (!mYSurface) {
-      Data data = aData;
-      Allocate(data);
-    }
-    if (mYSurface->Data() != aData.mYChannel) {
-      ImageContainer::CopyPlane(mYSurface->Data(), aData.mYChannel,
-                                aData.mYSize,
-                                aData.mYStride, aData.mYSize.width,
-                                0,0);
-      ImageContainer::CopyPlane(mCbSurface->Data(), aData.mCbChannel,
-                                aData.mCbCrSize,
-                                aData.mCbCrStride, aData.mCbCrSize.width,
-                                0,0);
-      ImageContainer::CopyPlane(mCrSurface->Data(), aData.mCrChannel,
-                                aData.mCbCrSize,
-                                aData.mCbCrStride, aData.mCbCrSize.width,
-                                0,0);
-    }
-  }
-
-  void MarkAsSent() {
-    mSent = true;
-  }
-
-protected:
-  nsRefPtr<gfxSharedImageSurface> mYSurface;
-  nsRefPtr<gfxSharedImageSurface> mCbSurface;
-  nsRefPtr<gfxSharedImageSurface> mCrSurface;
-  nsRefPtr<ImageContainerChild>   mImageDataAllocator;
-  bool mSent;
-};
-
-
 ImageContainerChild::ImageContainerChild()
 : mImageContainerID(0), mActiveImageCount(0),
   mStop(false), mDispatchedDestroy(false) 
 {
   MOZ_COUNT_CTOR(ImageContainerChild);
   // the Release corresponding to this AddRef is in 
   // ImageBridgeChild::DeallocPImageContainer
   AddRef();
@@ -218,40 +87,32 @@ void ImageContainerChild::StopChildAndPa
   DispatchDestroy();
 }
 
 void ImageContainerChild::StopChild()
 {
   if (mStop) {
     return;
   }
-  mStop = true;
+  mStop = true;    
 
   DispatchDestroy();
 }
 
 bool ImageContainerChild::RecvReturnImage(const SharedImage& aImage)
 {
+  SharedImage* img = new SharedImage(aImage);
   // Remove oldest image from the queue.
   if (mImageQueue.Length() > 0) {
     mImageQueue.RemoveElementAt(0);
   }
-
-  if (aImage.type() == SharedImage::TYUVImage &&
-      aImage.get_YUVImage().imageID() != 0) {
-    // if the imageID is non-zero, it means that this image's buffers
-    // are used in a SharedPlanarYCbCrImage that is maybe used in the
-    // main thread. In this case we let ref counting take care of 
-    // deciding when to recycle the shared memory.
-    return true;
+  if (!AddSharedImageToPool(img) || mStop) {
+    DestroySharedImage(*img);
+    delete img;
   }
-
-  SharedImage* img = new SharedImage(aImage);
-  RecycleSharedImageNow(img);
-
   return true;
 }
 
 void ImageContainerChild::DestroySharedImage(const SharedImage& aImage)
 {
   NS_ABORT_IF_FALSE(InImageBridgeChildThread(),
                     "Should be in ImageBridgeChild thread.");
 
@@ -332,18 +193,17 @@ SharedImage* ImageContainerChild::Create
              data->mCrChannel + i * data->mCbCrStride,
              data->mCbCrSize.width);
     }
 
     SharedImage* result = new SharedImage( 
               YUVImage(tempBufferY->GetShmem(),
                        tempBufferU->GetShmem(),
                        tempBufferV->GetShmem(),
-                       data->GetPictureRect(),
-                       0));
+                       data->GetPictureRect()));
     NS_ABORT_IF_FALSE(result->type() == SharedImage::TYUVImage,
                       "SharedImage type not set correctly");
     return result;
 #ifdef MOZ_WIDGET_GONK
   } else if (image->GetFormat() == GONK_IO_SURFACE) {
     GonkIOSurfaceImage* gonkImage = static_cast<GonkIOSurfaceImage*>(image);
     SharedImage* result = new SharedImage(gonkImage->GetSurfaceDescriptor());
     return result;
@@ -456,42 +316,24 @@ public:
   nsRefPtr<Image> mImage;
 };
 
 SharedImage* ImageContainerChild::ImageToSharedImage(Image* aImage)
 {
   if (mStop) {
     return nullptr;
   }
-
-  NS_ABORT_IF_FALSE(InImageBridgeChildThread(),
-                    "Should be in ImageBridgeChild thread.");
-  if (aImage->GetFormat() == ImageFormat::PLANAR_YCBCR) {
-    SharedPlanarYCbCrImage* sharedYCbCr =
-      static_cast<PlanarYCbCrImage*>(aImage)->AsSharedPlanarYCbCrImage();
-    if (sharedYCbCr) {
-      if (sharedYCbCr->IsSent()) {
-        // don't send the same image twice
-        return nullptr;
-      }
-      // the image is already using shared memory, this means that we don't 
-      // need to copy it
-      SharedImage* result = new SharedImage();
-      sharedYCbCr->ToSharedImage(result);
-      sharedYCbCr->MarkAsSent();
-      return result;
-    }
-  }
-
   if (mActiveImageCount > (int)MAX_ACTIVE_SHARED_IMAGES) {
     // Too many active shared images, perhaps the compositor is hanging.
     // Skipping current image
     return nullptr;
   }
 
+  NS_ABORT_IF_FALSE(InImageBridgeChildThread(),
+                    "Should be in ImageBridgeChild thread.");
   SharedImage *img = GetSharedImageFor(aImage);
   if (img) {
     CopyDataIntoSharedImage(aImage, img);  
   } else {
     img = CreateSharedImageFromData(aImage);
   }
   // Keep a reference to the image we sent to compositor to maintain a
   // correct reference count.
@@ -547,118 +389,11 @@ void ImageContainerChild::DispatchDestro
     return;
   }
   mDispatchedDestroy = true;
   AddRef(); // corresponds to the Release in DestroyNow
   GetMessageLoop()->PostTask(FROM_HERE, 
                     NewRunnableMethod(this, &ImageContainerChild::DestroyNow));
 }
 
-
-already_AddRefed<Image> ImageContainerChild::CreateImage(const ImageFormat *aFormats,
-                                                         uint32_t aNumFormats)
-{
-  // TODO: Add more image formats
-  nsRefPtr<Image> img = new SharedPlanarYCbCrImage(this);
-  return img.forget();
-}
-
-void ImageContainerChild::AllocateSharedBufferForImageNow(Image* aImage)
-{
-  NS_ABORT_IF_FALSE(InImageBridgeChildThread(),
-                    "Should be in ImageBridgeChild thread.");
-  NS_ABORT_IF_FALSE(aImage && aImage->GetFormat() == ImageFormat::PLANAR_YCBCR,
-                    "Only YUV images supported now");
-
-  SharedPlanarYCbCrImage* sharedYCbCr =
-    static_cast<PlanarYCbCrImage*>(aImage)->AsSharedPlanarYCbCrImage();
-
-  // try to reuse shared images from the pool first...
-  SharedImage* fromPool = GetSharedImageFor(aImage);
-  if (fromPool) {
-    YUVImage yuv = fromPool->get_YUVImage();
-    nsRefPtr<gfxSharedImageSurface> surfY =
-      gfxSharedImageSurface::Open(yuv.Ydata());
-    nsRefPtr<gfxSharedImageSurface> surfU =
-      gfxSharedImageSurface::Open(yuv.Udata());
-    nsRefPtr<gfxSharedImageSurface> surfV =
-      gfxSharedImageSurface::Open(yuv.Vdata());
-    sharedYCbCr->mYSurface  = surfY;
-    sharedYCbCr->mCbSurface = surfU;
-    sharedYCbCr->mCrSurface = surfV;
-  } else {
-    // ...else Allocate a shared image
-    nsRefPtr<gfxSharedImageSurface> surfY;
-    nsRefPtr<gfxSharedImageSurface> surfU;
-    nsRefPtr<gfxSharedImageSurface> surfV;
-    const PlanarYCbCrImage::Data* data = sharedYCbCr->GetData();
-    if (!AllocateSharedBuffer(this, data->mYSize, gfxASurface::CONTENT_ALPHA,
-                              getter_AddRefs(surfY)) ||
-        !AllocateSharedBuffer(this, data->mCbCrSize, gfxASurface::CONTENT_ALPHA,
-                              getter_AddRefs(surfU)) ||
-        !AllocateSharedBuffer(this, data->mCbCrSize, gfxASurface::CONTENT_ALPHA,
-                              getter_AddRefs(surfV))) {
-      NS_RUNTIMEABORT("creating SharedImage failed!");
-    }
-    sharedYCbCr->mYSurface  = surfY;
-    sharedYCbCr->mCbSurface = surfU;
-    sharedYCbCr->mCrSurface = surfV;
-  }
-
-}
-
-void ImageContainerChild::AllocateSharedBufferForImageSync(ReentrantMonitor* aBarrier,
-                                                           bool* aDone,
-                                                           Image* aImage)
-{
-  AllocateSharedBufferForImageNow(aImage);
-  ReentrantMonitorAutoEnter autoMon(*aBarrier);
-  *aDone = true;
-  aBarrier->NotifyAll();
-}
-
-
-void ImageContainerChild::AllocateSharedBufferForImage(Image* aImage)
-{
-  
-  if (InImageBridgeChildThread()) {
-    AllocateSharedBufferForImageNow(aImage);
-    return;
-  }
-
-  bool done = false;
-  ReentrantMonitor barrier("ImageBridgeChild::AllocateSharedBufferForImage");
-  ReentrantMonitorAutoEnter autoMon(barrier);
-  GetMessageLoop()->PostTask(FROM_HERE, 
-                             NewRunnableMethod(this,
-                                               &ImageContainerChild::AllocateSharedBufferForImageSync,
-                                               &barrier,
-                                               &done,
-                                               aImage));
-  while (!done) {
-    barrier.Wait();
-  }
-}
-
-void ImageContainerChild::RecycleSharedImageNow(SharedImage* aImage)
-{
-  NS_ABORT_IF_FALSE(InImageBridgeChildThread(),"Must be in the ImageBridgeChild Thread.");
-  
-  if (mStop || !AddSharedImageToPool(aImage)) {
-    DestroySharedImage(*aImage);
-    delete aImage;
-  }
-}
-
-void ImageContainerChild::RecycleSharedImage(SharedImage* aImage)
-{
-  if (InImageBridgeChildThread()) {
-    RecycleSharedImageNow(aImage);
-    return;
-  }
-  GetMessageLoop()->PostTask(FROM_HERE, 
-                             NewRunnableMethod(this,
-                                               &ImageContainerChild::RecycleSharedImageNow,
-                                               aImage));
-}
-
 } // namespace
 } // namespace
+
--- a/gfx/layers/ipc/ImageContainerChild.h
+++ b/gfx/layers/ipc/ImageContainerChild.h
@@ -3,22 +3,18 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef MOZILLA_GFX_IMAGECONTAINERCHILD_H
 #define MOZILLA_GFX_IMAGECONTAINERCHILD_H
 
 #include "mozilla/layers/PImageContainerChild.h"
 #include "mozilla/layers/ImageBridgeChild.h"
-#include "ImageTypes.h"
 
 namespace mozilla {
-
-class ReentrantMonitor;
-
 namespace layers {
 
 class ImageBridgeCopyAndSendTask;
 class ImageContainer;
 
 /**
  * ImageContainerChild is the content-side part of the ImageBridge IPDL protocol
  * acting at the ImageContainer level.
@@ -114,42 +110,17 @@ public:
    * Can be called on any thread.
    */
   void DispatchSetIdle();
 
   /**
    * Must be called on the ImageBridgeChild's thread.
    */
   void SetIdleNow();
-
-  /**
-   * Returns an instance of Image that should be of a Shared* subclass of Image
-   * and that should not need to be copied in order to be sent to the compositor.
-   */
-  already_AddRefed<Image> CreateImage(const ImageFormat *aFormats,
-                                      uint32_t aNumFormats);
-
-  /**
-   * Allocate shared buffers for the image.
-   *
-   * Can be called from any thread. If not called from the ImageBridge thread,
-   * it will synchronously proxy the call to the ImageBirdgeThread since shared
-   * memory can only be allocated in the IPDL thread. 
-   */
-  void AllocateSharedBufferForImage(Image* aImage);
-
-  /**
-   * Can be called from any thread.
-   * Deallocates or places aImage in the pool.
-   * If this method is not called from the ImageBridgeChild thread,
-   * a task is dispatched and the recycling is done asynchronously on
-   * the ImageBridgeChild thread.
-   */
-  void RecycleSharedImage(SharedImage* aImage);
-
+  
 protected:
   virtual PGrallocBufferChild*
   AllocPGrallocBuffer(const gfxIntSize&, const gfxContentType&,
                       MaybeMagicGrallocBufferHandle*) MOZ_OVERRIDE
 
   { return nullptr; }
 
   virtual bool
@@ -212,38 +183,16 @@ protected:
    */
   bool CopyDataIntoSharedImage(Image* src, SharedImage* dest);
 
   /**
    * Allocates a SharedImage and copy aImage's data into it.
    * Called by ImageToSharedImage.
    */
   SharedImage * CreateSharedImageFromData(Image* aImage);
-  /**
-   * Allocate shared buffers for the image.
-   * Must be called on the ImageBridgeChild thread.
-   */
-  void AllocateSharedBufferForImageNow(Image* aImage);
-
-  /**
-   * Calls AllocateSharedBufferForImageNow and notify the barrier monitor.
-   * This is meant to be called by AllocateSharedBufferForImage if the
-   * call must be proxied synchronously to the ImageBridgeChild's thread.
-   */
-  void AllocateSharedBufferForImageSync(ReentrantMonitor* aBarrier,
-                                        bool* aDone,
-                                        Image* aImage);
-
-  /**
-   * Either deallocate or place aImage in the shared image pool.
-   * Must be called on the ImageBridgeChild thread.
-   * aImage should not be used after this method is called.
-   */
-  void RecycleSharedImageNow(SharedImage* aImage);
-
 
 private:
   uint64_t mImageContainerID;
   nsTArray<SharedImage*> mSharedImagePool;
 
   /**
    * Save a reference to the outgoing images and remove the reference
    * once the image is returned from the compositor.
--- a/gfx/layers/ipc/LayersSurfaces.ipdlh
+++ b/gfx/layers/ipc/LayersSurfaces.ipdlh
@@ -68,24 +68,16 @@ union SurfaceDescriptor {
   SharedTextureDescriptor;
 };
 
 struct YUVImage {
   Shmem Ydata;
   Shmem Udata;
   Shmem Vdata;
   nsIntRect picture;
-  /**
-   * An ID meant to tell if the shared buffers are being reference counted
-   * on the content side and making it possible to find the reference counted
-   * object on the content side if needed.
-   * If this ID is zero, it means the data is not reference counted and can 
-   * be recycled right after being sent back to the content side.
-   */
-  uintptr_t imageID;
 };
 
 union SharedImage {
   SurfaceDescriptor;
   YUVImage;
   SharedImageID;
   null_t;
 };