diff --git a/camera/tests/CameraBinderTests.cpp b/camera/tests/CameraBinderTests.cpp
index b6b5492..e74a48c 100644
--- a/camera/tests/CameraBinderTests.cpp
+++ b/camera/tests/CameraBinderTests.cpp
@@ -49,9 +49,6 @@
 
 #include <com_android_graphics_libgui_flags.h>
 #include <gui/BufferItemConsumer.h>
-#if not COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
-#include <gui/IGraphicBufferProducer.h>
-#endif
 #include <gui/Surface.h>
 
 #include <gtest/gtest.h>
@@ -529,8 +526,7 @@
 
         // Setup a buffer queue; I'm just using the vendor opaque format here as that is
         // guaranteed to be present
-#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
-        sp<BufferItemConsumer> opaqueConsumer = new BufferItemConsumer(
+        auto [opaqueConsumer, surface] = BufferItemConsumer::create(
                 GRALLOC_USAGE_SW_READ_NEVER, /*maxImages*/ 2, /*controlledByApp*/ true);
         EXPECT_TRUE(opaqueConsumer.get() != nullptr);
         opaqueConsumer->setName(String8("nom nom nom"));
@@ -540,28 +536,9 @@
         EXPECT_EQ(OK,
                   opaqueConsumer->setDefaultBufferFormat(HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED));
 
-        sp<Surface> surface = opaqueConsumer->getSurface();
         ParcelableSurfaceType pSurface = flagtools::surfaceToParcelableSurfaceType(surface);
         std::string noPhysicalId;
         OutputConfiguration output(pSurface, /*rotation*/ 0, noPhysicalId);
-#else
-        sp<IGraphicBufferProducer> gbProducer;
-        sp<IGraphicBufferConsumer> gbConsumer;
-        BufferQueue::createBufferQueue(&gbProducer, &gbConsumer);
-        sp<BufferItemConsumer> opaqueConsumer = new BufferItemConsumer(gbConsumer,
-                GRALLOC_USAGE_SW_READ_NEVER, /*maxImages*/2, /*controlledByApp*/true);
-        EXPECT_TRUE(opaqueConsumer.get() != nullptr);
-        opaqueConsumer->setName(String8("nom nom nom"));
-
-        // Set to VGA dimens for default, as that is guaranteed to be present
-        EXPECT_EQ(OK, gbConsumer->setDefaultBufferSize(640, 480));
-        EXPECT_EQ(OK, gbConsumer->setDefaultBufferFormat(HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED));
-
-        sp<Surface> surface(new Surface(gbProducer, /*controlledByApp*/false));
-
-        std::string noPhysicalId;
-        OutputConfiguration output(gbProducer, /*rotation*/0, noPhysicalId);
-#endif  // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
 
         // Can we configure?
         res = device->beginConfigure();
@@ -698,18 +675,10 @@
 TEST_F(CameraClientBinderTest, CheckBinderCaptureRequest) {
     sp<CaptureRequest> requestOriginal, requestParceled;
 
-#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
-    sp<BufferItemConsumer> opaqueConsumer = new BufferItemConsumer(
+    auto [opaqueConsumer, surface] = BufferItemConsumer::create(
             GRALLOC_USAGE_SW_READ_NEVER, /*maxImages*/ 2, /*controlledByApp*/ true);
     EXPECT_TRUE(opaqueConsumer.get() != nullptr);
     opaqueConsumer->setName(String8("nom nom nom"));
-    sp<Surface> surface = opaqueConsumer->getSurface();
-#else
-    sp<IGraphicBufferProducer> gbProducer;
-    sp<IGraphicBufferConsumer> gbConsumer;
-    BufferQueue::createBufferQueue(&gbProducer, &gbConsumer);
-    sp<Surface> surface(new Surface(gbProducer, /*controlledByApp*/false));
-#endif
 
     Vector<sp<Surface>> surfaceList;
     surfaceList.push_back(surface);
diff --git a/services/camera/libcameraservice/api1/client2/CallbackProcessor.cpp b/services/camera/libcameraservice/api1/client2/CallbackProcessor.cpp
index 2fbf49e..6439101 100644
--- a/services/camera/libcameraservice/api1/client2/CallbackProcessor.cpp
+++ b/services/camera/libcameraservice/api1/client2/CallbackProcessor.cpp
@@ -19,6 +19,7 @@
 //#define LOG_NDEBUG 0
 
 #include <com_android_graphics_libgui_flags.h>
+#include <gui/CpuConsumer.h>
 #include <gui/Surface.h>
 #include <utils/Log.h>
 #include <utils/Trace.h>
@@ -114,20 +115,9 @@
     if (!mCallbackToApp && mCallbackConsumer == 0) {
         // Create CPU buffer queue endpoint, since app hasn't given us one
         // Make it async to avoid disconnect deadlocks
-#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
-        mCallbackConsumer = new CpuConsumer(kCallbackHeapCount);
+        std::tie(mCallbackConsumer, mCallbackWindow) = CpuConsumer::create(kCallbackHeapCount);
         mCallbackConsumer->setFrameAvailableListener(this);
         mCallbackConsumer->setName(String8("Camera2-CallbackConsumer"));
-        mCallbackWindow = mCallbackConsumer->getSurface();
-#else
-        sp<IGraphicBufferProducer> producer;
-        sp<IGraphicBufferConsumer> consumer;
-        BufferQueue::createBufferQueue(&producer, &consumer);
-        mCallbackConsumer = new CpuConsumer(consumer, kCallbackHeapCount);
-        mCallbackConsumer->setFrameAvailableListener(this);
-        mCallbackConsumer->setName(String8("Camera2-CallbackConsumer"));
-        mCallbackWindow = new Surface(producer);
-#endif  // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
     }
 
     if (mCallbackStreamId != NO_STREAM) {
diff --git a/services/camera/libcameraservice/api1/client2/JpegProcessor.cpp b/services/camera/libcameraservice/api1/client2/JpegProcessor.cpp
index 3a0489c..a9e045a 100755
--- a/services/camera/libcameraservice/api1/client2/JpegProcessor.cpp
+++ b/services/camera/libcameraservice/api1/client2/JpegProcessor.cpp
@@ -94,20 +94,9 @@
 
     if (mCaptureConsumer == 0) {
         // Create CPU buffer queue endpoint
-#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
-        mCaptureConsumer = new CpuConsumer(1);
+        std::tie(mCaptureConsumer, mCaptureWindow) = CpuConsumer::create(1);
         mCaptureConsumer->setFrameAvailableListener(this);
         mCaptureConsumer->setName(String8("Camera2-JpegConsumer"));
-        mCaptureWindow = mCaptureConsumer->getSurface();
-#else
-        sp<IGraphicBufferProducer> producer;
-        sp<IGraphicBufferConsumer> consumer;
-        BufferQueue::createBufferQueue(&producer, &consumer);
-        mCaptureConsumer = new CpuConsumer(consumer, 1);
-        mCaptureConsumer->setFrameAvailableListener(this);
-        mCaptureConsumer->setName(String8("Camera2-JpegConsumer"));
-        mCaptureWindow = new Surface(producer);
-#endif  // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
     }
 
     // Since ashmem heaps are rounded up to page size, don't reallocate if
diff --git a/services/camera/libcameraservice/api2/DepthCompositeStream.cpp b/services/camera/libcameraservice/api2/DepthCompositeStream.cpp
index 14618c4..4b732bc 100644
--- a/services/camera/libcameraservice/api2/DepthCompositeStream.cpp
+++ b/services/camera/libcameraservice/api2/DepthCompositeStream.cpp
@@ -616,20 +616,10 @@
         return NO_INIT;
     }
 
-#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
-    mBlobConsumer = new CpuConsumer(/*maxLockedBuffers*/ 1, /*controlledByApp*/ true);
+    std::tie(mBlobConsumer, mBlobSurface) =
+            CpuConsumer::create(/*maxLockedBuffers*/ 1, /*controlledByApp*/ true);
     mBlobConsumer->setFrameAvailableListener(this);
     mBlobConsumer->setName(String8("Camera3-JpegCompositeStream"));
-    mBlobSurface = mBlobConsumer->getSurface();
-#else
-    sp<IGraphicBufferProducer> producer;
-    sp<IGraphicBufferConsumer> consumer;
-    BufferQueue::createBufferQueue(&producer, &consumer);
-    mBlobConsumer = new CpuConsumer(consumer, /*maxLockedBuffers*/1, /*controlledByApp*/ true);
-    mBlobConsumer->setFrameAvailableListener(this);
-    mBlobConsumer->setName(String8("Camera3-JpegCompositeStream"));
-    mBlobSurface = new Surface(producer);
-#endif  // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
 
     ret = device->createStream(mBlobSurface, width, height, format, kJpegDataSpace, rotation,
             id, physicalCameraId, sensorPixelModesUsed, surfaceIds,
@@ -648,18 +638,11 @@
         return ret;
     }
 
-#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
-    mDepthConsumer = new CpuConsumer(/*maxLockedBuffers*/ 1, /*controlledByApp*/ true);
+    std::tie(mDepthConsumer, mDepthSurface) =
+            CpuConsumer::create(/*maxLockedBuffers*/ 1, /*controlledByApp*/ true);
     mDepthConsumer->setFrameAvailableListener(this);
     mDepthConsumer->setName(String8("Camera3-DepthCompositeStream"));
-    mDepthSurface = mDepthConsumer->getSurface();
-#else
-    BufferQueue::createBufferQueue(&producer, &consumer);
-    mDepthConsumer = new CpuConsumer(consumer, /*maxLockedBuffers*/ 1, /*controlledByApp*/ true);
-    mDepthConsumer->setFrameAvailableListener(this);
-    mDepthConsumer->setName(String8("Camera3-DepthCompositeStream"));
-    mDepthSurface = new Surface(producer);
-#endif  // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
+
     std::vector<int> depthSurfaceId;
     ret = device->createStream(mDepthSurface, depthWidth, depthHeight, kDepthMapPixelFormat,
             kDepthMapDataSpace, rotation, &mDepthStreamId, physicalCameraId, sensorPixelModesUsed,
diff --git a/services/camera/libcameraservice/api2/HeicCompositeStream.cpp b/services/camera/libcameraservice/api2/HeicCompositeStream.cpp
index 9dd3939..f9b6d5b 100644
--- a/services/camera/libcameraservice/api2/HeicCompositeStream.cpp
+++ b/services/camera/libcameraservice/api2/HeicCompositeStream.cpp
@@ -193,26 +193,15 @@
         return NO_INIT;
     }
 
-#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
     if (mAppSegmentSupported) {
-        mAppSegmentConsumer = new CpuConsumer(kMaxAcquiredAppSegment);
+        std::tie(mAppSegmentConsumer, mAppSegmentSurface) =
+                CpuConsumer::create(kMaxAcquiredAppSegment);
         mAppSegmentConsumer->setFrameAvailableListener(this);
         mAppSegmentConsumer->setName(String8("Camera3-HeicComposite-AppSegmentStream"));
-        mAppSegmentSurface = mAppSegmentConsumer->getSurface();
     }
-    sp<IGraphicBufferProducer> producer = mAppSegmentSurface.get() != nullptr ?
-        mAppSegmentSurface->getIGraphicBufferProducer() : nullptr;
-#else
-    sp<IGraphicBufferProducer> producer;
-    sp<IGraphicBufferConsumer> consumer;
-    if (mAppSegmentSupported) {
-        BufferQueue::createBufferQueue(&producer, &consumer);
-        mAppSegmentConsumer = new CpuConsumer(consumer, kMaxAcquiredAppSegment);
-        mAppSegmentConsumer->setFrameAvailableListener(this);
-        mAppSegmentConsumer->setName(String8("Camera3-HeicComposite-AppSegmentStream"));
-        mAppSegmentSurface = new Surface(producer);
-    }
-#endif  // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
+    sp<IGraphicBufferProducer> producer = mAppSegmentSurface.get() != nullptr
+                                                  ? mAppSegmentSurface->getIGraphicBufferProducer()
+                                                  : nullptr;
 
     if (mAppSegmentSupported) {
         std::vector<int> sourceSurfaceId;
@@ -243,13 +232,9 @@
             return res;
         }
     } else {
-#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
-        mMainImageConsumer = new CpuConsumer(1);
-        producer = mMainImageConsumer->getSurface()->getIGraphicBufferProducer();
-#else
-        BufferQueue::createBufferQueue(&producer, &consumer);
-        mMainImageConsumer = new CpuConsumer(consumer, 1);
-#endif  // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
+        sp<Surface> surface;
+        std::tie(mMainImageConsumer, surface) = CpuConsumer::create(1);
+        producer = surface->getIGraphicBufferProducer();
         mMainImageConsumer->setFrameAvailableListener(this);
         mMainImageConsumer->setName(String8("Camera3-HeicComposite-HevcInputYUVStream"));
     }
diff --git a/services/camera/libcameraservice/api2/JpegRCompositeStream.cpp b/services/camera/libcameraservice/api2/JpegRCompositeStream.cpp
index e0d7604..b8c9244 100644
--- a/services/camera/libcameraservice/api2/JpegRCompositeStream.cpp
+++ b/services/camera/libcameraservice/api2/JpegRCompositeStream.cpp
@@ -16,7 +16,7 @@
 
 #define LOG_TAG "Camera3-JpegRCompositeStream"
 #define ATRACE_TAG ATRACE_TAG_CAMERA
-//#define LOG_NDEBUG 0
+// #define LOG_NDEBUG 0
 
 #include <aidl/android/hardware/camera/device/CameraBlob.h>
 #include <aidl/android/hardware/camera/device/CameraBlobId.h>
@@ -25,6 +25,7 @@
 #include "utils/SessionConfigurationUtils.h"
 
 #include <com_android_graphics_libgui_flags.h>
+#include <gui/CpuConsumer.h>
 #include <gui/Surface.h>
 #include <hardware/gralloc.h>
 #include <system/graphics-base-v1.0.h>
@@ -575,20 +576,10 @@
             mStaticInfo, mP010DynamicRange,
             ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD);
 
-#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
-    mP010Consumer = new CpuConsumer(/*maxLockedBuffers*/ 1, /*controlledByApp*/ true);
+    std::tie(mP010Consumer, mP010Surface) =
+            CpuConsumer::create(/*maxLockedBuffers*/ 1, /*controlledByApp*/ true);
     mP010Consumer->setFrameAvailableListener(this);
     mP010Consumer->setName(String8("Camera3-P010CompositeStream"));
-    mP010Surface = mP010Consumer->getSurface();
-#else
-    sp<IGraphicBufferProducer> producer;
-    sp<IGraphicBufferConsumer> consumer;
-    BufferQueue::createBufferQueue(&producer, &consumer);
-    mP010Consumer = new CpuConsumer(consumer, /*maxLockedBuffers*/1, /*controlledByApp*/ true);
-    mP010Consumer->setFrameAvailableListener(this);
-    mP010Consumer->setName(String8("Camera3-P010CompositeStream"));
-    mP010Surface = new Surface(producer);
-#endif  // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
 
     auto ret = device->createStream(mP010Surface, width, height, kP010PixelFormat,
             static_cast<android_dataspace>(mP010DataSpace), rotation,
@@ -606,18 +597,11 @@
     }
 
     if (mSupportInternalJpeg) {
-#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
-        mBlobConsumer = new CpuConsumer(/*maxLockedBuffers*/ 1, /*controlledByApp*/ true);
+        std::tie(mBlobConsumer, mBlobSurface) =
+                CpuConsumer::create(/*maxLockedBuffers*/ 1, /*controlledByApp*/ true);
         mBlobConsumer->setFrameAvailableListener(this);
         mBlobConsumer->setName(String8("Camera3-JpegRCompositeStream"));
-        mBlobSurface = mBlobConsumer->getSurface();
-#else
-        BufferQueue::createBufferQueue(&producer, &consumer);
-        mBlobConsumer = new CpuConsumer(consumer, /*maxLockedBuffers*/ 1, /*controlledByApp*/ true);
-        mBlobConsumer->setFrameAvailableListener(this);
-        mBlobConsumer->setName(String8("Camera3-JpegRCompositeStream"));
-        mBlobSurface = new Surface(producer);
-#endif  // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
+
         std::vector<int> blobSurfaceId;
         ret = device->createStream(mBlobSurface, width, height, format,
                 kJpegDataSpace, rotation, &mBlobStreamId, physicalCameraId, sensorPixelModesUsed,
diff --git a/services/camera/libcameraservice/common/Camera2ClientBase.cpp b/services/camera/libcameraservice/common/Camera2ClientBase.cpp
index ec9cf68..d29f685 100644
--- a/services/camera/libcameraservice/common/Camera2ClientBase.cpp
+++ b/services/camera/libcameraservice/common/Camera2ClientBase.cpp
@@ -24,7 +24,8 @@
 #include <utils/Trace.h>
 
 #include <cutils/properties.h>
-#include <gui/Surface.h>
+#include <gui/BufferItem.h>
+#include <gui/BufferItemConsumer.h>
 #include <gui/Surface.h>
 
 #include <android/hardware/ICameraService.h>
diff --git a/services/camera/libcameraservice/device3/Camera3InputStream.cpp b/services/camera/libcameraservice/device3/Camera3InputStream.cpp
index 999f563..0c77303 100644
--- a/services/camera/libcameraservice/device3/Camera3InputStream.cpp
+++ b/services/camera/libcameraservice/device3/Camera3InputStream.cpp
@@ -257,15 +257,8 @@
     mLastTimestamp = 0;
 
     if (mConsumer.get() == 0) {
-#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
-        sp<BufferItemConsumer> bufferItemConsumer = new BufferItemConsumer(mUsage);
-        sp<IGraphicBufferProducer> producer =
-                bufferItemConsumer->getSurface()->getIGraphicBufferProducer();
-#else
-        sp<IGraphicBufferProducer> producer;
-        sp<IGraphicBufferConsumer> consumer;
-        BufferQueue::createBufferQueue(&producer, &consumer);
-#endif  // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
+        auto [bufferItemConsumer, surface] = BufferItemConsumer::create(mUsage);
+        sp<IGraphicBufferProducer> producer = surface->getIGraphicBufferProducer();
 
         int minUndequeuedBuffers = 0;
         res = producer->query(NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, &minUndequeuedBuffers);
@@ -301,17 +294,15 @@
         mConsumer->setMaxAcquiredBufferCount(mTotalBufferCount);
 
 #if WB_CAMERA3_AND_PROCESSORS_WITH_DEPENDENCIES
-        mSurface = mConsumer->getSurface();
+        mSurface = surface;
 #else
-        mProducer = mConsumer->getSurface()->getIGraphicBufferProducer();
+        mProducer = producer;
 #endif // WB_CAMERA3_AND_PROCESSORS_WITH_DEPENDENCIES
 
 #else
-        mConsumer = new BufferItemConsumer(consumer, mUsage,
-                                           mTotalBufferCount);
+        std::tie(mConsumer, surface) = BufferItemConsumer::create(mUsage, mTotalBufferCount);
+        mProducer = surface->getIGraphicBufferProducer();
         mConsumer->setName(String8::format("Camera3-InputStream-%d", mId));
-
-        mProducer = producer;
 #endif  // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
 
         mConsumer->setBufferFreedListener(this);
diff --git a/services/camera/libcameraservice/device3/Camera3StreamSplitter.cpp b/services/camera/libcameraservice/device3/Camera3StreamSplitter.cpp
index a6424c7..3e4470e 100644
--- a/services/camera/libcameraservice/device3/Camera3StreamSplitter.cpp
+++ b/services/camera/libcameraservice/device3/Camera3StreamSplitter.cpp
@@ -95,18 +95,8 @@
     // the output's attachBuffer().
     mMaxConsumerBuffers++;
 
-#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
-    mBufferItemConsumer = sp<BufferItemConsumer>::make(consumerUsage, mMaxConsumerBuffers);
-    mSurface = mBufferItemConsumer->getSurface();
-#else
-    // Create BufferQueue for input
-    sp<IGraphicBufferProducer> bqProducer;
-    sp<IGraphicBufferConsumer> bqConsumer;
-    BufferQueue::createBufferQueue(&bqProducer, &bqConsumer);
-
-    mBufferItemConsumer = new BufferItemConsumer(bqConsumer, consumerUsage, mMaxConsumerBuffers);
-    mSurface = new Surface(bqProducer);
-#endif  // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
+    std::tie(mBufferItemConsumer, mSurface) =
+            BufferItemConsumer::create(consumerUsage, mMaxConsumerBuffers);
 
     if (mBufferItemConsumer == nullptr) {
         return NO_MEMORY;
diff --git a/services/camera/libcameraservice/device3/aidl/AidlCamera3SharedDevice.cpp b/services/camera/libcameraservice/device3/aidl/AidlCamera3SharedDevice.cpp
index 50c1463..775e1a9 100644
--- a/services/camera/libcameraservice/device3/aidl/AidlCamera3SharedDevice.cpp
+++ b/services/camera/libcameraservice/device3/aidl/AidlCamera3SharedDevice.cpp
@@ -45,11 +45,13 @@
     } \
   } while (0)
 
+#include <gui/BufferItemConsumer.h>
 #include <utils/Log.h>
 #include <utils/Trace.h>
 #include <cstring>
 #include "../../common/aidl/AidlProviderInfo.h"
 #include "utils/SessionConfigurationUtils.h"
+
 #include "AidlCamera3SharedDevice.h"
 
 using namespace android::camera3;
@@ -247,20 +249,10 @@
             return INVALID_OPERATION;
         }
 
-        #if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
-            sp<BufferItemConsumer> consumer = sp<BufferItemConsumer>::make(
-                    AHARDWAREBUFFER_USAGE_CAMERA_READ);
-            mOpaqueConsumers.push_back(consumer);
-            mSharedSurfaces.push_back(consumer->getSurface());
-        #else
-            sp<IGraphicBufferProducer> producer;
-            sp<IGraphicBufferConsumer> consumer;
-            BufferQueue::createBufferQueue(&producer, &consumer);
-            sp<BufferItemConsumer> opaqueConsumer = sp<BufferItemConsumer>::make(consumer,
-                    AHARDWAREBUFFER_USAGE_CAMERA_READ);
-            mOpaqueConsumers.push_back(opaqueConsumer);
-            mSharedSurfaces.push_back(new Surface(producer));
-        #endif  // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
+        auto [consumer, surface] = BufferItemConsumer::create(AHARDWAREBUFFER_USAGE_CAMERA_READ);
+        mOpaqueConsumers.push_back(consumer);
+        mSharedSurfaces.push_back(surface);
+
         sp<OpaqueConsumerListener> consumerListener = sp<OpaqueConsumerListener>::make(
                 mOpaqueConsumers[i]);
         mOpaqueConsumers[i]->setFrameAvailableListener(consumerListener);
diff --git a/services/camera/libcameraservice/device3/deprecated/DeprecatedCamera3StreamSplitter.cpp b/services/camera/libcameraservice/device3/deprecated/DeprecatedCamera3StreamSplitter.cpp
index 7be6563..a9fd359 100644
--- a/services/camera/libcameraservice/device3/deprecated/DeprecatedCamera3StreamSplitter.cpp
+++ b/services/camera/libcameraservice/device3/deprecated/DeprecatedCamera3StreamSplitter.cpp
@@ -80,19 +80,28 @@
         }
     }
 
-    // Create BufferQueue for input
-    BufferQueue::createBufferQueue(&mProducer, &mConsumer);
-
     // Allocate 1 extra buffer to handle the case where all buffers are detached
     // from input, and attached to the outputs. In this case, the input queue's
     // dequeueBuffer can still allocate 1 extra buffer before being blocked by
     // the output's attachBuffer().
     mMaxConsumerBuffers++;
-    mBufferItemConsumer = new BufferItemConsumer(mConsumer, consumerUsage, mMaxConsumerBuffers);
-    if (mBufferItemConsumer == nullptr) {
-        return NO_MEMORY;
+    BufferQueue::createBufferQueue(&mProducer, &mConsumer);
+    res = mConsumer->setConsumerName(toString8(mConsumerName));
+    if (res != OK) {
+        SP_LOGE("%s: Failed to set consumer name: %s(%d)", __FUNCTION__, strerror(-res), res);
+        return res;
     }
-    mConsumer->setConsumerName(toString8(mConsumerName));
+    res = mConsumer->setConsumerUsageBits(consumerUsage);
+    if (res != OK) {
+        SP_LOGE("%s: Failed to set consumer usage bits: %s(%d)", __FUNCTION__, strerror(-res), res);
+        return res;
+    }
+    res = mConsumer->setMaxAcquiredBufferCount(mMaxConsumerBuffers);
+    if (res != OK) {
+        SP_LOGE("%s: Failed to set consumer max acquired buffer count: %s(%d)", __FUNCTION__,
+                strerror(-res), res);
+        return res;
+    }
 
     *consumer = new Surface(mProducer);
     if (*consumer == nullptr) {
diff --git a/services/camera/libcameraservice/device3/deprecated/DeprecatedCamera3StreamSplitter.h b/services/camera/libcameraservice/device3/deprecated/DeprecatedCamera3StreamSplitter.h
index 3a2a8e1..64b1020 100644
--- a/services/camera/libcameraservice/device3/deprecated/DeprecatedCamera3StreamSplitter.h
+++ b/services/camera/libcameraservice/device3/deprecated/DeprecatedCamera3StreamSplitter.h
@@ -21,7 +21,6 @@
 
 #include <camera/CameraMetadata.h>
 
-#include <gui/BufferItemConsumer.h>
 #include <gui/IConsumerListener.h>
 #include <gui/Surface.h>
 
@@ -248,7 +247,6 @@
 
     sp<IGraphicBufferProducer> mProducer;
     sp<IGraphicBufferConsumer> mConsumer;
-    sp<BufferItemConsumer> mBufferItemConsumer;
     sp<Surface> mSurface;
 
     // Map graphic buffer ids -> buffer items
diff --git a/services/camera/libcameraservice/gui/RingBufferConsumer.h b/services/camera/libcameraservice/gui/RingBufferConsumer.h
index f8849c6..3161533 100644
--- a/services/camera/libcameraservice/gui/RingBufferConsumer.h
+++ b/services/camera/libcameraservice/gui/RingBufferConsumer.h
@@ -179,6 +179,7 @@
 #if WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
     Mutex mMutex;
 
+    sp<Surface> mSurface;
     sp<BufferItemConsumer> mBufferItemConsumer;
 #endif
 
diff --git a/services/camera/libcameraservice/gui/flagged_files/RingBufferConsumer.inc b/services/camera/libcameraservice/gui/flagged_files/RingBufferConsumer.inc
index 40395f7..f30669d 100644
--- a/services/camera/libcameraservice/gui/flagged_files/RingBufferConsumer.inc
+++ b/services/camera/libcameraservice/gui/flagged_files/RingBufferConsumer.inc
@@ -19,14 +19,16 @@
 #define ATRACE_TAG ATRACE_TAG_GRAPHICS
 
 #include <inttypes.h>
+#include <tuple>
 
 #include <utils/Log.h>
 
 #include <camera/StringUtils.h>
 #include <com_android_graphics_libgui_flags.h>
-#include <gui/Surface.h>
-#include <gui/RingBufferConsumer.h>
+#include <gui/BufferItemConsumer.h>
 #include <gui/Flags.h>
+#include <gui/RingBufferConsumer.h>
+#include <gui/Surface.h>
 
 #define BI_LOGV(x, ...) ALOGV(" " x, ##__VA_ARGS__)
 #define BI_LOGD(x, ...) ALOGD(" " x, ##__VA_ARGS__)
@@ -49,7 +51,8 @@
                                        uint64_t consumerUsage, int bufferCount)
     : mBufferCount(bufferCount), mLatestTimestamp(0) {
 #endif  // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
-    mBufferItemConsumer = sp<BufferItemConsumer>::make(consumerUsage, bufferCount);
+    std::tie(mBufferItemConsumer, mSurface) =
+            BufferItemConsumer::create(consumerUsage, bufferCount);
     assert(bufferCount > 0);
 }
 
@@ -164,7 +167,7 @@
 }
 
 sp<Surface> RingBufferConsumer::getSurface() const {
-    return mBufferItemConsumer->getSurface();
+    return mSurface;
 }
 
 void RingBufferConsumer::pinBufferLocked(const BufferItem& item) {
diff --git a/services/camera/libcameraservice/libcameraservice_fuzzer/camera_service_fuzzer.cpp b/services/camera/libcameraservice/libcameraservice_fuzzer/camera_service_fuzzer.cpp
index 0bdbb58..214832f 100644
--- a/services/camera/libcameraservice/libcameraservice_fuzzer/camera_service_fuzzer.cpp
+++ b/services/camera/libcameraservice/libcameraservice_fuzzer/camera_service_fuzzer.cpp
@@ -44,10 +44,7 @@
 #include <fakeservicemanager/FakeServiceManager.h>
 #include <fuzzbinder/random_binder.h>
 #include <gui/BufferItemConsumer.h>
-#include <gui/Flags.h> // remove with COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
-#if not COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
 #include <gui/IGraphicBufferProducer.h>
-#endif
 #include <gui/Surface.h>
 #include <gui/SurfaceComposerClient.h>
 #include <media/IAudioFlinger.h>
@@ -838,8 +835,7 @@
             continue;
         }
         device->beginConfigure();
-#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
-        sp<BufferItemConsumer> opaqueConsumer = new BufferItemConsumer(
+        auto [opaqueConsumer, surface] = BufferItemConsumer::create(
                 GRALLOC_USAGE_SW_READ_NEVER, /*maxImages*/ 8, /*controlledByApp*/ true);
         opaqueConsumer->setName(String8("Roger"));
 
@@ -847,34 +843,14 @@
         opaqueConsumer->setDefaultBufferSize(640, 480);
         opaqueConsumer->setDefaultBufferFormat(HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED);
 
-        sp<Surface> surface = opaqueConsumer->getSurface();
-
         std::string noPhysicalId;
         size_t rotations = sizeof(kRotations) / sizeof(int32_t) - 1;
         ParcelableSurfaceType pSurface = flagtools::surfaceToParcelableSurfaceType(surface);
         OutputConfiguration output(
-            pSurface, kRotations[mFuzzedDataProvider->ConsumeIntegralInRange<size_t>(0, rotations)],
-            noPhysicalId);
-#else
-        sp<IGraphicBufferProducer> gbProducer;
-        sp<IGraphicBufferConsumer> gbConsumer;
-        BufferQueue::createBufferQueue(&gbProducer, &gbConsumer);
-        sp<BufferItemConsumer> opaqueConsumer = new BufferItemConsumer(gbConsumer,
-                GRALLOC_USAGE_SW_READ_NEVER, /*maxImages*/8, /*controlledByApp*/true);
-        opaqueConsumer->setName(String8("Roger"));
-
-        // Set to VGA dimension for default, as that is guaranteed to be present
-        gbConsumer->setDefaultBufferSize(640, 480);
-        gbConsumer->setDefaultBufferFormat(HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED);
-
-        sp<Surface> surface(new Surface(gbProducer, /*controlledByApp*/false));
-
-        std::string noPhysicalId;
-        size_t rotations = sizeof(kRotations) / sizeof(int32_t) - 1;
-        OutputConfiguration output(gbProducer,
+                pSurface,
                 kRotations[mFuzzedDataProvider->ConsumeIntegralInRange<size_t>(0, rotations)],
                 noPhysicalId);
-#endif  // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
+
         int streamId;
         device->createStream(output, &streamId);
         CameraMetadata sessionParams;
diff --git a/services/camera/libcameraservice/tests/Camera3StreamSplitterTest.cpp b/services/camera/libcameraservice/tests/Camera3StreamSplitterTest.cpp
index 8d290bb..05959ec 100644
--- a/services/camera/libcameraservice/tests/Camera3StreamSplitterTest.cpp
+++ b/services/camera/libcameraservice/tests/Camera3StreamSplitterTest.cpp
@@ -58,16 +58,7 @@
 int64_t kDynamicRangeProfile = 0;
 
 std::tuple<sp<BufferItemConsumer>, sp<Surface>> createConsumerAndSurface() {
-#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
-    sp<BufferItemConsumer> consumer = sp<BufferItemConsumer>::make(kConsumerUsage);
-    return {consumer, consumer->getSurface()};
-#else
-    sp<IGraphicBufferProducer> producer;
-    sp<IGraphicBufferConsumer> consumer;
-    BufferQueue::createBufferQueue(&producer, &consumer);
-
-    return {sp<BufferItemConsumer>::make(consumer, kConsumerUsage), sp<Surface>::make(producer)};
-#endif  // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
+    return BufferItemConsumer::create(kConsumerUsage);
 }
 
 class Camera3StreamSplitterTest : public testing::Test {
diff --git a/services/camera/virtualcamera/util/EglSurfaceTexture.cc b/services/camera/virtualcamera/util/EglSurfaceTexture.cc
index dc07146..44da9b4 100644
--- a/services/camera/virtualcamera/util/EglSurfaceTexture.cc
+++ b/services/camera/virtualcamera/util/EglSurfaceTexture.cc
@@ -69,31 +69,15 @@
     return;
   }
 
-#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
-  mGlConsumer = sp<GLConsumer>::make(mTextureId, GLConsumer::TEXTURE_EXTERNAL,
-                                     false, false);
+  std::tie(mGlConsumer, mSurface) = GLConsumer::create(
+      mTextureId, GLConsumer::TEXTURE_EXTERNAL, false, false);
   mGlConsumer->setName(String8("VirtualCameraEglSurfaceTexture"));
   mGlConsumer->setDefaultBufferSize(mWidth, mHeight);
   mGlConsumer->setConsumerUsageBits(GRALLOC_USAGE_HW_TEXTURE);
   mGlConsumer->setDefaultBufferFormat(AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420);
 
-  mSurface = mGlConsumer->getSurface();
   mSurface->setMaxDequeuedBufferCount(kBufferProducerMaxDequeueBufferCount);
-#else
-  BufferQueue::createBufferQueue(&mBufferProducer, &mBufferConsumer);
-  // Set max dequeue buffer count for producer to maximal value to prevent
-  // blocking when dequeuing input buffers.
-  mBufferProducer->setMaxDequeuedBufferCount(
-      kBufferProducerMaxDequeueBufferCount);
-  mGlConsumer = sp<GLConsumer>::make(
-      mBufferConsumer, mTextureId, GLConsumer::TEXTURE_EXTERNAL, false, false);
-  mGlConsumer->setName(String8("VirtualCameraEglSurfaceTexture"));
-  mGlConsumer->setDefaultBufferSize(mWidth, mHeight);
-  mGlConsumer->setConsumerUsageBits(GRALLOC_USAGE_HW_TEXTURE);
-  mGlConsumer->setDefaultBufferFormat(AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420);
 
-  mSurface = sp<Surface>::make(mBufferProducer);
-#endif  // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
   mFrameAvailableListenerProxy = sp<FrameAvailableListenerProxy>::make(this);
   mGlConsumer->setFrameAvailableListener(mFrameAvailableListenerProxy);
 }
diff --git a/services/camera/virtualcamera/util/EglSurfaceTexture.h b/services/camera/virtualcamera/util/EglSurfaceTexture.h
index 087a7cf..dabeaf0 100644
--- a/services/camera/virtualcamera/util/EglSurfaceTexture.h
+++ b/services/camera/virtualcamera/util/EglSurfaceTexture.h
@@ -29,11 +29,6 @@
 
 namespace android {
 
-#if !COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
-class IGraphicBufferProducer;
-class IGraphicBufferConsumer;
-#endif  // !COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
-
 class GLConsumer;
 
 namespace companion {
@@ -105,10 +100,6 @@
   };
 
  private:
-#if !COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
-  sp<IGraphicBufferProducer> mBufferProducer;
-  sp<IGraphicBufferConsumer> mBufferConsumer;
-#endif  // !COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
   sp<GLConsumer> mGlConsumer;
   sp<Surface> mSurface;
   GLuint mTextureId;