diff --git a/webrtc/modules/audio_processing/aec/aec_core.c b/webrtc/modules/audio_processing/aec/aec_core.c
index 1b747b858..d638b7256 100644
--- a/webrtc/modules/audio_processing/aec/aec_core.c
+++ b/webrtc/modules/audio_processing/aec/aec_core.c
@@ -164,54 +164,57 @@ int WebRtcAec_CreateAec(AecCore** aecInst)
         return -1;
     }
 
-    if (WebRtc_CreateBuffer(&aec->nearFrBuf,
-                            FRAME_LEN + PART_LEN,
-                            sizeof(int16_t)) == -1) {
+    aec->nearFrBuf = WebRtc_CreateBuffer(FRAME_LEN + PART_LEN,
+                                         sizeof(int16_t));
+    if (!aec->nearFrBuf) {
         WebRtcAec_FreeAec(aec);
         aec = NULL;
         return -1;
     }
 
-    if (WebRtc_CreateBuffer(&aec->outFrBuf,
-                            FRAME_LEN + PART_LEN,
-                            sizeof(int16_t)) == -1) {
+    aec->outFrBuf = WebRtc_CreateBuffer(FRAME_LEN + PART_LEN,
+                                        sizeof(int16_t));
+    if (!aec->outFrBuf) {
         WebRtcAec_FreeAec(aec);
         aec = NULL;
         return -1;
     }
 
-    if (WebRtc_CreateBuffer(&aec->nearFrBufH,
-                            FRAME_LEN + PART_LEN,
-                            sizeof(int16_t)) == -1) {
+    aec->nearFrBufH = WebRtc_CreateBuffer(FRAME_LEN + PART_LEN,
+                                          sizeof(int16_t));
+    if (!aec->nearFrBufH) {
         WebRtcAec_FreeAec(aec);
         aec = NULL;
         return -1;
     }
 
-    if (WebRtc_CreateBuffer(&aec->outFrBufH,
-                            FRAME_LEN + PART_LEN,
-                            sizeof(int16_t)) == -1) {
+    aec->outFrBufH = WebRtc_CreateBuffer(FRAME_LEN + PART_LEN,
+                                         sizeof(int16_t));
+    if (!aec->outFrBufH) {
         WebRtcAec_FreeAec(aec);
         aec = NULL;
         return -1;
     }
 
     // Create far-end buffers.
-    if (WebRtc_CreateBuffer(&aec->far_buf, kBufSizePartitions,
-                            sizeof(float) * 2 * PART_LEN1) == -1) {
+    aec->far_buf = WebRtc_CreateBuffer(kBufSizePartitions,
+                                       sizeof(float) * 2 * PART_LEN1);
+    if (!aec->far_buf) {
         WebRtcAec_FreeAec(aec);
         aec = NULL;
         return -1;
     }
-    if (WebRtc_CreateBuffer(&aec->far_buf_windowed, kBufSizePartitions,
-                            sizeof(float) * 2 * PART_LEN1) == -1) {
+    aec->far_buf_windowed = WebRtc_CreateBuffer(kBufSizePartitions,
+                                                sizeof(float) * 2 * PART_LEN1);
+    if (!aec->far_buf_windowed) {
         WebRtcAec_FreeAec(aec);
         aec = NULL;
         return -1;
     }
 #ifdef WEBRTC_AEC_DEBUG_DUMP
-    if (WebRtc_CreateBuffer(&aec->far_time_buf, kBufSizePartitions,
-                            sizeof(int16_t) * PART_LEN) == -1) {
+    aec->far_time_buf = WebRtc_CreateBuffer(kBufSizePartitions,
+                                            sizeof(int16_t) * PART_LEN);
+    if (!aec->far_time_buf) {
         WebRtcAec_FreeAec(aec);
         aec = NULL;
         return -1;
diff --git a/webrtc/modules/audio_processing/aec/echo_cancellation.c b/webrtc/modules/audio_processing/aec/echo_cancellation.c
index 406628122..8fd9fe92a 100644
--- a/webrtc/modules/audio_processing/aec/echo_cancellation.c
+++ b/webrtc/modules/audio_processing/aec/echo_cancellation.c
@@ -72,9 +72,9 @@ WebRtc_Word32 WebRtcAec_Create(void **aecInst)
     // Create far-end pre-buffer. The buffer size has to be large enough for
     // largest possible drift compensation (kResamplerBufferSize) + "almost" an
     // FFT buffer (PART_LEN2 - 1).
-    if (WebRtc_CreateBuffer(&aecpc->far_pre_buf,
-                            PART_LEN2 + kResamplerBufferSize,
-                            sizeof(float)) == -1) {
+    aecpc->far_pre_buf = WebRtc_CreateBuffer(PART_LEN2 + kResamplerBufferSize,
+                                             sizeof(float));
+    if (!aecpc->far_pre_buf) {
         WebRtcAec_Free(aecpc);
         aecpc = NULL;
         return -1;
@@ -84,9 +84,9 @@ WebRtc_Word32 WebRtcAec_Create(void **aecInst)
     aecpc->lastError = 0;
 
 #ifdef WEBRTC_AEC_DEBUG_DUMP
-    if (WebRtc_CreateBuffer(&aecpc->far_pre_buf_s16,
-                            PART_LEN2 + kResamplerBufferSize,
-                            sizeof(int16_t)) == -1) {
+    aecpc->far_pre_buf_s16 = WebRtc_CreateBuffer(
+        PART_LEN2 + kResamplerBufferSize, sizeof(float));
+    if (!aecpc->far_pre_buf_s16) {
         WebRtcAec_Free(aecpc);
         aecpc = NULL;
         return -1;
diff --git a/webrtc/modules/audio_processing/aecm/aecm_core.c b/webrtc/modules/audio_processing/aecm/aecm_core.c
index a81912e46..136826358 100644
--- a/webrtc/modules/audio_processing/aecm/aecm_core.c
+++ b/webrtc/modules/audio_processing/aecm/aecm_core.c
@@ -256,32 +256,36 @@ int WebRtcAecm_CreateCore(AecmCore_t **aecmInst)
         return -1;
     }
 
-    if (WebRtc_CreateBuffer(&aecm->farFrameBuf, FRAME_LEN + PART_LEN,
-                            sizeof(int16_t)) == -1)
+    aecm->farFrameBuf = WebRtc_CreateBuffer(FRAME_LEN + PART_LEN,
+                                            sizeof(int16_t));
+    if (!aecm->farFrameBuf)
     {
         WebRtcAecm_FreeCore(aecm);
         aecm = NULL;
         return -1;
     }
 
-    if (WebRtc_CreateBuffer(&aecm->nearNoisyFrameBuf, FRAME_LEN + PART_LEN,
-                            sizeof(int16_t)) == -1)
+    aecm->nearNoisyFrameBuf = WebRtc_CreateBuffer(FRAME_LEN + PART_LEN,
+                                                  sizeof(int16_t));
+    if (!aecm->nearNoisyFrameBuf)
     {
         WebRtcAecm_FreeCore(aecm);
         aecm = NULL;
         return -1;
     }
 
-    if (WebRtc_CreateBuffer(&aecm->nearCleanFrameBuf, FRAME_LEN + PART_LEN,
-                            sizeof(int16_t)) == -1)
+    aecm->nearCleanFrameBuf = WebRtc_CreateBuffer(FRAME_LEN + PART_LEN,
+                                                  sizeof(int16_t));
+    if (!aecm->nearCleanFrameBuf)
     {
         WebRtcAecm_FreeCore(aecm);
         aecm = NULL;
         return -1;
     }
 
-    if (WebRtc_CreateBuffer(&aecm->outFrameBuf, FRAME_LEN + PART_LEN,
-                            sizeof(int16_t)) == -1)
+    aecm->outFrameBuf = WebRtc_CreateBuffer(FRAME_LEN + PART_LEN,
+                                            sizeof(int16_t));
+    if (!aecm->outFrameBuf)
     {
         WebRtcAecm_FreeCore(aecm);
         aecm = NULL;
diff --git a/webrtc/modules/audio_processing/aecm/echo_control_mobile.c b/webrtc/modules/audio_processing/aecm/echo_control_mobile.c
index 85bbcd444..881f7a55e 100644
--- a/webrtc/modules/audio_processing/aecm/echo_control_mobile.c
+++ b/webrtc/modules/audio_processing/aecm/echo_control_mobile.c
@@ -102,8 +102,9 @@ WebRtc_Word32 WebRtcAecm_Create(void **aecmInst)
         return -1;
     }
 
-    if (WebRtc_CreateBuffer(&aecm->farendBuf, kBufSizeSamp,
-                            sizeof(int16_t)) == -1)
+    aecm->farendBuf = WebRtc_CreateBuffer(kBufSizeSamp,
+                                          sizeof(int16_t));
+    if (!aecm->farendBuf)
     {
         WebRtcAecm_Free(aecm);
         aecm = NULL;
diff --git a/webrtc/modules/audio_processing/utility/ring_buffer.c b/webrtc/modules/audio_processing/utility/ring_buffer.c
index bc21f85c2..617c30ff3 100644
--- a/webrtc/modules/audio_processing/utility/ring_buffer.c
+++ b/webrtc/modules/audio_processing/utility/ring_buffer.c
@@ -65,34 +65,28 @@ static size_t GetBufferReadRegions(RingBuffer* buf,
   return read_elements;
 }
 
-int WebRtc_CreateBuffer(RingBuffer** handle,
-                        size_t element_count,
-                        size_t element_size) {
+RingBuffer* WebRtc_CreateBuffer(size_t element_count, size_t element_size) {
   RingBuffer* self = NULL;
-  if (!handle) {
-    return -1;
-  }
   if (element_count == 0 || element_size == 0) {
-    return -1;
+    return NULL;
   }
 
   self = malloc(sizeof(RingBuffer));
   if (!self) {
-    return -1;
+    return NULL;
   }
-  *handle = self;
 
   self->data = malloc(element_count * element_size);
   if (!self->data) {
     free(self);
     self = NULL;
-    return -1;
+    return NULL;
   }
 
   self->element_count = element_count;
   self->element_size = element_size;
 
-  return 0;
+  return self;
 }
 
 int WebRtc_InitBuffer(RingBuffer* self) {
diff --git a/webrtc/modules/audio_processing/utility/ring_buffer.h b/webrtc/modules/audio_processing/utility/ring_buffer.h
index ee9a0c678..61d25baa2 100644
--- a/webrtc/modules/audio_processing/utility/ring_buffer.h
+++ b/webrtc/modules/audio_processing/utility/ring_buffer.h
@@ -18,9 +18,8 @@
 
 typedef struct RingBuffer RingBuffer;
 
-int WebRtc_CreateBuffer(RingBuffer** handle,
-                        size_t element_count,
-                        size_t element_size);
+// Returns NULL on failure.
+RingBuffer* WebRtc_CreateBuffer(size_t element_count, size_t element_size);
 int WebRtc_InitBuffer(RingBuffer* handle);
 void WebRtc_FreeBuffer(void* handle);
 
diff --git a/webrtc/modules/audio_processing/utility/ring_buffer_unittest.cc b/webrtc/modules/audio_processing/utility/ring_buffer_unittest.cc
index eef8b5fbb..365eb2d9a 100644
--- a/webrtc/modules/audio_processing/utility/ring_buffer_unittest.cc
+++ b/webrtc/modules/audio_processing/utility/ring_buffer_unittest.cc
@@ -58,9 +58,8 @@ static void RandomStressTest(int** data_ptr) {
     const int buffer_size = std::max(rand() % kMaxBufferSize, 1);
     scoped_array<int> write_data(new int[buffer_size]);
     scoped_array<int> read_data(new int[buffer_size]);
-    scoped_ring_buffer buffer;
-    ASSERT_EQ(0, WebRtc_CreateBuffer(buffer.accept(), buffer_size,
-                                     sizeof(int)));
+    scoped_ring_buffer buffer(WebRtc_CreateBuffer(buffer_size, sizeof(int)));
+    ASSERT_TRUE(buffer.get() != NULL);
     ASSERT_EQ(0, WebRtc_InitBuffer(buffer.get()));
     int buffer_consumed = 0;
     int write_element = 0;
@@ -112,13 +111,13 @@ TEST(RingBufferTest, RandomStressTestWithNullPtr) {
 }
 
 TEST(RingBufferTest, PassingNulltoReadBufferForcesMemcpy) {
-  scoped_ring_buffer buffer;
   const size_t kDataSize = 2;
   int write_data[kDataSize];
   int read_data[kDataSize];
   int* data_ptr;
 
-  ASSERT_EQ(0, WebRtc_CreateBuffer(buffer.accept(), kDataSize, sizeof(int)));
+  scoped_ring_buffer buffer(WebRtc_CreateBuffer(kDataSize, sizeof(int)));
+  ASSERT_TRUE(buffer.get() != NULL);
   ASSERT_EQ(0, WebRtc_InitBuffer(buffer.get()));
 
   SetIncrementingData(write_data, kDataSize, 0);
@@ -137,4 +136,12 @@ TEST(RingBufferTest, PassingNulltoReadBufferForcesMemcpy) {
   CheckIncrementingData(read_data, kDataSize, 0);
 }
 
+TEST(RingBufferTest, CreateHandlesErrors) {
+  EXPECT_TRUE(WebRtc_CreateBuffer(0, 1) == NULL);
+  EXPECT_TRUE(WebRtc_CreateBuffer(1, 0) == NULL);
+  RingBuffer* buffer = WebRtc_CreateBuffer(1, 1);
+  EXPECT_TRUE(buffer != NULL);
+  WebRtc_FreeBuffer(buffer);
+}
+
 }  // namespace webrtc