diff --git a/libs/gui/CpuConsumer.cpp b/libs/gui/CpuConsumer.cpp
index 513828c..90c8ea6 100644
--- a/libs/gui/CpuConsumer.cpp
+++ b/libs/gui/CpuConsumer.cpp
@@ -29,49 +29,18 @@
 
 namespace android {
 
-// Get an ID that's unique within this process.
-static int32_t createProcessUniqueId() {
-    static volatile int32_t globalCounter = 0;
-    return android_atomic_inc(&globalCounter);
-}
-
 CpuConsumer::CpuConsumer(uint32_t maxLockedBuffers) :
+    ConsumerBase(new BufferQueue(true, maxLockedBuffers) ),
     mMaxLockedBuffers(maxLockedBuffers),
     mCurrentLockedBuffers(0)
 {
-    mName = String8::format("cc-unnamed-%d-%d", getpid(),
-            createProcessUniqueId());
 
     for (int i = 0; i < BufferQueue::NUM_BUFFER_SLOTS; i++) {
         mBufferPointers[i] = NULL;
     }
 
-    mBufferQueue = new BufferQueue(true);
-
-    wp<BufferQueue::ConsumerListener> listener;
-    sp<BufferQueue::ConsumerListener> proxy;
-    listener = static_cast<BufferQueue::ConsumerListener*>(this);
-    proxy = new BufferQueue::ProxyConsumerListener(listener);
-
-    status_t err = mBufferQueue->consumerConnect(proxy);
-    if (err != NO_ERROR) {
-        ALOGE("CpuConsumer: error connecting to BufferQueue: %s (%d)",
-                strerror(-err), err);
-    } else {
-        mBufferQueue->setSynchronousMode(true);
-        mBufferQueue->setConsumerUsageBits(GRALLOC_USAGE_SW_READ_OFTEN);
-        mBufferQueue->setConsumerName(mName);
-    }
-}
-
-CpuConsumer::~CpuConsumer()
-{
-    Mutex::Autolock _l(mMutex);
-    for (int i = 0; i < BufferQueue::NUM_BUFFER_SLOTS; i++) {
-        freeBufferLocked(i);
-    }
-    mBufferQueue->consumerDisconnect();
-    mBufferQueue.clear();
+    mBufferQueue->setSynchronousMode(true);
+    mBufferQueue->setConsumerUsageBits(GRALLOC_USAGE_SW_READ_OFTEN);
 }
 
 void CpuConsumer::setName(const String8& name) {
@@ -92,7 +61,7 @@
 
     Mutex::Autolock _l(mMutex);
 
-    err = mBufferQueue->acquireBuffer(&b);
+    err = acquireBufferLocked(&b);
     if (err != OK) {
         if (err == BufferQueue::NO_BUFFER_AVAILABLE) {
             return BAD_VALUE;
@@ -104,16 +73,6 @@
 
     int buf = b.mBuf;
 
-    if (b.mGraphicBuffer != NULL) {
-        if (mBufferPointers[buf] != NULL) {
-            CC_LOGE("Reallocation of buffer %d while in consumer use!", buf);
-            mBufferQueue->releaseBuffer(buf, EGL_NO_DISPLAY, EGL_NO_SYNC_KHR,
-                    Fence::NO_FENCE);
-            return BAD_VALUE;
-        }
-        mBufferSlot[buf] = b.mGraphicBuffer;
-    }
-
     if (b.mFence.get()) {
         err = b.mFence->wait(Fence::TIMEOUT_NEVER);
         if (err != OK) {
@@ -123,7 +82,7 @@
         }
     }
 
-    err = mBufferSlot[buf]->lock(
+    err = mSlots[buf].mGraphicBuffer->lock(
         GraphicBuffer::USAGE_SW_READ_OFTEN,
         b.mCrop,
         &mBufferPointers[buf]);
@@ -135,10 +94,10 @@
     }
 
     nativeBuffer->data   = reinterpret_cast<uint8_t*>(mBufferPointers[buf]);
-    nativeBuffer->width  = mBufferSlot[buf]->getWidth();
-    nativeBuffer->height = mBufferSlot[buf]->getHeight();
-    nativeBuffer->format = mBufferSlot[buf]->getPixelFormat();
-    nativeBuffer->stride = mBufferSlot[buf]->getStride();
+    nativeBuffer->width  = mSlots[buf].mGraphicBuffer->getWidth();
+    nativeBuffer->height = mSlots[buf].mGraphicBuffer->getHeight();
+    nativeBuffer->format = mSlots[buf].mGraphicBuffer->getPixelFormat();
+    nativeBuffer->stride = mSlots[buf].mGraphicBuffer->getStride();
 
     nativeBuffer->crop        = b.mCrop;
     nativeBuffer->transform   = b.mTransform;
@@ -153,90 +112,44 @@
 
 status_t CpuConsumer::unlockBuffer(const LockedBuffer &nativeBuffer) {
     Mutex::Autolock _l(mMutex);
-    int buf = 0;
+    int slotIndex = 0;
     status_t err;
 
     void *bufPtr = reinterpret_cast<void *>(nativeBuffer.data);
-    for (; buf < BufferQueue::NUM_BUFFER_SLOTS; buf++) {
-        if (bufPtr == mBufferPointers[buf]) break;
+    for (; slotIndex < BufferQueue::NUM_BUFFER_SLOTS; slotIndex++) {
+        if (bufPtr == mBufferPointers[slotIndex]) break;
     }
-    if (buf == BufferQueue::NUM_BUFFER_SLOTS) {
+    if (slotIndex == BufferQueue::NUM_BUFFER_SLOTS) {
         CC_LOGE("%s: Can't find buffer to free", __FUNCTION__);
         return BAD_VALUE;
     }
 
-    mBufferPointers[buf] = NULL;
-    err = mBufferSlot[buf]->unlock();
+    mBufferPointers[slotIndex] = NULL;
+    err = mSlots[slotIndex].mGraphicBuffer->unlock();
     if (err != OK) {
-        CC_LOGE("%s: Unable to unlock graphic buffer %d", __FUNCTION__, buf);
+        CC_LOGE("%s: Unable to unlock graphic buffer %d", __FUNCTION__, slotIndex);
         return err;
     }
-    err = mBufferQueue->releaseBuffer(buf, EGL_NO_DISPLAY, EGL_NO_SYNC_KHR,
-            Fence::NO_FENCE);
-    if (err == BufferQueue::STALE_BUFFER_SLOT) {
-        freeBufferLocked(buf);
-    } else if (err != OK) {
-        CC_LOGE("%s: Unable to release graphic buffer %d to queue", __FUNCTION__,
-                buf);
-        return err;
-    }
+    releaseBufferLocked(slotIndex, EGL_NO_DISPLAY, EGL_NO_SYNC_KHR, Fence::NO_FENCE);
 
     mCurrentLockedBuffers--;
 
     return OK;
 }
 
-void CpuConsumer::setFrameAvailableListener(
-        const sp<FrameAvailableListener>& listener) {
-    CC_LOGV("setFrameAvailableListener");
-    Mutex::Autolock lock(mMutex);
-    mFrameAvailableListener = listener;
-}
-
-
-void CpuConsumer::onFrameAvailable() {
-    CC_LOGV("onFrameAvailable");
-    sp<FrameAvailableListener> listener;
-    { // scope for the lock
-        Mutex::Autolock _l(mMutex);
-        listener = mFrameAvailableListener;
-    }
-
-    if (listener != NULL) {
-        CC_LOGV("actually calling onFrameAvailable");
-        listener->onFrameAvailable();
-    }
-}
-
-void CpuConsumer::onBuffersReleased() {
-    CC_LOGV("onBuffersReleased");
-
-    Mutex::Autolock lock(mMutex);
-
-    uint32_t mask = 0;
-    mBufferQueue->getReleasedBuffers(&mask);
-    for (int i = 0; i < BufferQueue::NUM_BUFFER_SLOTS; i++) {
-        if (mask & (1 << i)) {
-            freeBufferLocked(i);
-        }
-    }
-
-}
-
-status_t CpuConsumer::freeBufferLocked(int buf) {
-    status_t err = OK;
-
-    if (mBufferPointers[buf] != NULL) {
-        CC_LOGW("Buffer %d freed while locked by consumer", buf);
-        mBufferPointers[buf] = NULL;
-        err = mBufferSlot[buf]->unlock();
+void CpuConsumer::freeBufferLocked(int slotIndex) {
+    if (mBufferPointers[slotIndex] != NULL) {
+        status_t err;
+        CC_LOGW("Buffer %d freed while locked by consumer", slotIndex);
+        mBufferPointers[slotIndex] = NULL;
+        err = mSlots[slotIndex].mGraphicBuffer->unlock();
         if (err != OK) {
-            CC_LOGE("%s: Unable to unlock graphic buffer %d", __FUNCTION__, buf);
+            CC_LOGE("%s: Unable to unlock graphic buffer %d", __FUNCTION__,
+                    slotIndex);
         }
         mCurrentLockedBuffers--;
     }
-    mBufferSlot[buf] = NULL;
-    return err;
+    ConsumerBase::freeBufferLocked(slotIndex);
 }
 
 } // namespace android