Convert FifoBuffer to new StreamInterface API

Bug: webrtc:14632
Change-Id: Id6d17d0402c5e3a0e24258c7afa38ca34e7ab227
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/283541
Reviewed-by: Tomas Gunnarsson <tommi@webrtc.org>
Commit-Queue: Harald Alvestrand <hta@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#38640}

rtc_base/memory/fifo_buffer.cc

@@ -49,23 +49,20 @@ StreamState FifoBuffer::GetState() const {
   return state_;
 }
 
-StreamResult FifoBuffer::Read(void* buffer,
+StreamResult FifoBuffer::Read(rtc::ArrayView<uint8_t> buffer,
-                              size_t bytes,
+                              size_t& bytes_read,
-                              size_t* bytes_read,
+                              int& error) {
-                              int* error) {
   webrtc::MutexLock lock(&mutex_);
   const bool was_writable = data_length_ < buffer_length_;
   size_t copy = 0;
-  StreamResult result = ReadLocked(buffer, bytes, &copy);
+  StreamResult result = ReadLocked(buffer.data(), buffer.size(), &copy);
 
   if (result == SR_SUCCESS) {
     // If read was successful then adjust the read position and number of
     // bytes buffered.
     read_position_ = (read_position_ + copy) % buffer_length_;
     data_length_ -= copy;
-    if (bytes_read) {
+    bytes_read = copy;
-      *bytes_read = copy;
-    }
 
     // if we were full before, and now we're not, post an event
     if (!was_writable && copy > 0) {
@@ -75,23 +72,19 @@ StreamResult FifoBuffer::Read(void* buffer,
   return result;
 }
 
-StreamResult FifoBuffer::Write(const void* buffer,
+StreamResult FifoBuffer::Write(rtc::ArrayView<const uint8_t> buffer,
-                               size_t bytes,
+                               size_t& bytes_written,
-                               size_t* bytes_written,
+                               int& error) {
-                               int* error) {
   webrtc::MutexLock lock(&mutex_);
 
   const bool was_readable = (data_length_ > 0);
   size_t copy = 0;
-  StreamResult result = WriteLocked(buffer, bytes, &copy);
+  StreamResult result = WriteLocked(buffer.data(), buffer.size(), &copy);
 
   if (result == SR_SUCCESS) {
     // If write was successful then adjust the number of readable bytes.
     data_length_ += copy;
-    if (bytes_written) {
+    bytes_written = copy;
-      *bytes_written = copy;
-    }
-
     // if we didn't have any data to read before, and now we do, post an event
     if (!was_readable && copy > 0) {
       PostEvent(SE_READ, 0);

rtc_base/memory/fifo_buffer.h

@@ -37,14 +37,12 @@ class FifoBuffer final : public StreamInterface {
 
   // StreamInterface methods
   StreamState GetState() const override;
-  StreamResult Read(void* buffer,
+  StreamResult Read(rtc::ArrayView<uint8_t> buffer,
-                    size_t bytes,
+                    size_t& bytes_read,
-                    size_t* bytes_read,
+                    int& error) override;
-                    int* error) override;
+  StreamResult Write(rtc::ArrayView<const uint8_t> buffer,
-  StreamResult Write(const void* buffer,
+                     size_t& bytes_written,
-                     size_t bytes,
+                     int& error) override;
-                     size_t* bytes_written,
-                     int* error) override;
   void Close() override;
 
   // Seek to a byte offset from the beginning of the stream.  Returns false if

rtc_base/memory/fifo_buffer_unittest.cc

@@ -19,8 +19,8 @@ namespace rtc {
 TEST(FifoBufferTest, TestAll) {
   rtc::AutoThread main_thread;
   const size_t kSize = 16;
-  const char in[kSize * 2 + 1] = "0123456789ABCDEFGHIJKLMNOPQRSTUV";
+  const uint8_t in[kSize * 2 + 1] = "0123456789ABCDEFGHIJKLMNOPQRSTUV";
-  char out[kSize * 2];
+  uint8_t out[kSize * 2];
   void* p;
   const void* q;
   size_t bytes;
@@ -28,49 +28,58 @@ TEST(FifoBufferTest, TestAll) {
 
   // Test assumptions about base state
   EXPECT_EQ(SS_OPEN, buf.GetState());
-  EXPECT_EQ(SR_BLOCK, buf.Read(out, kSize, &bytes, nullptr));
+  int error;
+  EXPECT_EQ(SR_BLOCK, buf.Read(rtc::MakeArrayView(out, kSize), bytes, error));
   EXPECT_TRUE(nullptr != buf.GetWriteBuffer(&bytes));
   EXPECT_EQ(kSize, bytes);
   buf.ConsumeWriteBuffer(0);
 
   // Try a full write
-  EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS, buf.Write(rtc::MakeArrayView(in, kSize), bytes, error));
   EXPECT_EQ(kSize, bytes);
 
   // Try a write that should block
-  EXPECT_EQ(SR_BLOCK, buf.Write(in, kSize, &bytes, nullptr));
+  EXPECT_EQ(SR_BLOCK, buf.Write(rtc::MakeArrayView(in, kSize), bytes, error));
 
   // Try a full read
-  EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS, buf.Read(rtc::MakeArrayView(out, kSize), bytes, error));
   EXPECT_EQ(kSize, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize));
 
   // Try a read that should block
-  EXPECT_EQ(SR_BLOCK, buf.Read(out, kSize, &bytes, nullptr));
+  EXPECT_EQ(SR_BLOCK, buf.Read(rtc::MakeArrayView(out, kSize), bytes, error));
 
   // Try a too-big write
-  EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize * 2, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS,
+            buf.Write(rtc::MakeArrayView(in, kSize * 2), bytes, error));
   EXPECT_EQ(bytes, kSize);
 
   // Try a too-big read
-  EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize * 2, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS,
+            buf.Read(rtc::MakeArrayView(out, kSize * 2), bytes, error));
   EXPECT_EQ(kSize, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize));
 
   // Try some small writes and reads
-  EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize / 2, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS,
+            buf.Write(rtc::MakeArrayView(in, kSize / 2), bytes, error));
   EXPECT_EQ(kSize / 2, bytes);
-  EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize / 2, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS,
+            buf.Read(rtc::MakeArrayView(out, kSize / 2), bytes, error));
   EXPECT_EQ(kSize / 2, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize / 2));
-  EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize / 2, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS,
+            buf.Write(rtc::MakeArrayView(in, kSize / 2), bytes, error));
   EXPECT_EQ(kSize / 2, bytes);
-  EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize / 2, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS,
+            buf.Write(rtc::MakeArrayView(in, kSize / 2), bytes, error));
   EXPECT_EQ(kSize / 2, bytes);
-  EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize / 2, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS,
+            buf.Read(rtc::MakeArrayView(out, kSize / 2), bytes, error));
   EXPECT_EQ(kSize / 2, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize / 2));
-  EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize / 2, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS,
+            buf.Read(rtc::MakeArrayView(out, kSize / 2), bytes, error));
   EXPECT_EQ(kSize / 2, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize / 2));
 
@@ -82,22 +91,29 @@ TEST(FifoBufferTest, TestAll) {
   // XXXXWWWWWWWWXXXX 4567012345670123
   // RRRRXXXXXXXXRRRR ....01234567....
   // ....RRRRRRRR.... ................
-  EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize * 3 / 4, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS,
+            buf.Write(rtc::MakeArrayView(in, kSize * 3 / 4), bytes, error));
   EXPECT_EQ(kSize * 3 / 4, bytes);
-  EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize / 2, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS,
+            buf.Read(rtc::MakeArrayView(out, kSize / 2), bytes, error));
   EXPECT_EQ(kSize / 2, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize / 2));
-  EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize / 2, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS,
+            buf.Write(rtc::MakeArrayView(in, kSize / 2), bytes, error));
   EXPECT_EQ(kSize / 2, bytes);
-  EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize / 4, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS,
+            buf.Read(rtc::MakeArrayView(out, kSize / 4), bytes, error));
   EXPECT_EQ(kSize / 4, bytes);
   EXPECT_EQ(0, memcmp(in + kSize / 2, out, kSize / 4));
-  EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize / 2, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS,
+            buf.Write(rtc::MakeArrayView(in, kSize / 2), bytes, error));
   EXPECT_EQ(kSize / 2, bytes);
-  EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize / 2, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS,
+            buf.Read(rtc::MakeArrayView(out, kSize / 2), bytes, error));
   EXPECT_EQ(kSize / 2, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize / 2));
-  EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize / 2, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS,
+            buf.Read(rtc::MakeArrayView(out, kSize / 2), bytes, error));
   EXPECT_EQ(kSize / 2, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize / 2));
 
@@ -106,16 +122,16 @@ TEST(FifoBufferTest, TestAll) {
   buf.ConsumeWriteBuffer(0);
 
   // Try using GetReadData to do a full read
-  EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS, buf.Write(rtc::MakeArrayView(in, kSize), bytes, error));
   q = buf.GetReadData(&bytes);
   EXPECT_TRUE(nullptr != q);
   EXPECT_EQ(kSize, bytes);
   EXPECT_EQ(0, memcmp(q, in, kSize));
   buf.ConsumeReadData(kSize);
-  EXPECT_EQ(SR_BLOCK, buf.Read(out, kSize, &bytes, nullptr));
+  EXPECT_EQ(SR_BLOCK, buf.Read(rtc::MakeArrayView(out, kSize), bytes, error));
 
   // Try using GetReadData to do some small reads
-  EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS, buf.Write(rtc::MakeArrayView(in, kSize), bytes, error));
   q = buf.GetReadData(&bytes);
   EXPECT_TRUE(nullptr != q);
   EXPECT_EQ(kSize, bytes);
@@ -126,7 +142,7 @@ TEST(FifoBufferTest, TestAll) {
   EXPECT_EQ(kSize / 2, bytes);
   EXPECT_EQ(0, memcmp(q, in + kSize / 2, kSize / 2));
   buf.ConsumeReadData(kSize / 2);
-  EXPECT_EQ(SR_BLOCK, buf.Read(out, kSize, &bytes, nullptr));
+  EXPECT_EQ(SR_BLOCK, buf.Read(rtc::MakeArrayView(out, kSize), bytes, error));
 
   // Try using GetReadData in a wraparound case
   // WWWWWWWWWWWWWWWW 0123456789ABCDEF
@@ -134,9 +150,11 @@ TEST(FifoBufferTest, TestAll) {
   // WWWWWWWW....XXXX 01234567....CDEF
   // ............RRRR 01234567........
   // RRRRRRRR........ ................
-  EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS, buf.Write(rtc::MakeArrayView(in, kSize), bytes, error));
-  EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize * 3 / 4, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS,
-  EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize / 2, &bytes, nullptr));
+            buf.Read(rtc::MakeArrayView(out, kSize * 3 / 4), bytes, error));
+  EXPECT_EQ(SR_SUCCESS,
+            buf.Write(rtc::MakeArrayView(in, kSize / 2), bytes, error));
   q = buf.GetReadData(&bytes);
   EXPECT_TRUE(nullptr != q);
   EXPECT_EQ(kSize / 4, bytes);
@@ -158,7 +176,7 @@ TEST(FifoBufferTest, TestAll) {
   EXPECT_EQ(kSize, bytes);
   memcpy(p, in, kSize);
   buf.ConsumeWriteBuffer(kSize);
-  EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS, buf.Read(rtc::MakeArrayView(out, kSize), bytes, error));
   EXPECT_EQ(kSize, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize));
 
@@ -173,7 +191,7 @@ TEST(FifoBufferTest, TestAll) {
   EXPECT_EQ(kSize / 2, bytes);
   memcpy(p, in + kSize / 2, kSize / 2);
   buf.ConsumeWriteBuffer(kSize / 2);
-  EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS, buf.Read(rtc::MakeArrayView(out, kSize), bytes, error));
   EXPECT_EQ(kSize, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize));
 
@@ -183,8 +201,10 @@ TEST(FifoBufferTest, TestAll) {
   // ........XXXXWWWW ........89AB0123
   // WWWW....XXXXXXXX 4567....89AB0123
   // RRRR....RRRRRRRR ................
-  EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize * 3 / 4, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS,
-  EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize / 2, &bytes, nullptr));
+            buf.Write(rtc::MakeArrayView(in, kSize * 3 / 4), bytes, error));
+  EXPECT_EQ(SR_SUCCESS,
+            buf.Read(rtc::MakeArrayView(out, kSize / 2), bytes, error));
   p = buf.GetWriteBuffer(&bytes);
   EXPECT_TRUE(nullptr != p);
   EXPECT_EQ(kSize / 4, bytes);
@@ -195,22 +215,25 @@ TEST(FifoBufferTest, TestAll) {
   EXPECT_EQ(kSize / 2, bytes);
   memcpy(p, in + kSize / 4, kSize / 4);
   buf.ConsumeWriteBuffer(kSize / 4);
-  EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize * 3 / 4, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS,
+            buf.Read(rtc::MakeArrayView(out, kSize * 3 / 4), bytes, error));
   EXPECT_EQ(kSize * 3 / 4, bytes);
   EXPECT_EQ(0, memcmp(in + kSize / 2, out, kSize / 4));
   EXPECT_EQ(0, memcmp(in, out + kSize / 4, kSize / 4));
 
   // Check that the stream is now empty
-  EXPECT_EQ(SR_BLOCK, buf.Read(out, kSize, &bytes, nullptr));
+  EXPECT_EQ(SR_BLOCK, buf.Read(rtc::MakeArrayView(out, kSize), bytes, error));
 
   // Write to the stream, close it, read the remaining bytes
-  EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize / 2, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS,
+            buf.Write(rtc::MakeArrayView(in, kSize / 2), bytes, error));
   buf.Close();
   EXPECT_EQ(SS_CLOSED, buf.GetState());
-  EXPECT_EQ(SR_EOS, buf.Write(in, kSize / 2, &bytes, nullptr));
+  EXPECT_EQ(SR_EOS, buf.Write(rtc::MakeArrayView(in, kSize / 2), bytes, error));
-  EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize / 2, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS,
+            buf.Read(rtc::MakeArrayView(out, kSize / 2), bytes, error));
   EXPECT_EQ(0, memcmp(in, out, kSize / 2));
-  EXPECT_EQ(SR_EOS, buf.Read(out, kSize / 2, &bytes, nullptr));
+  EXPECT_EQ(SR_EOS, buf.Read(rtc::MakeArrayView(out, kSize / 2), bytes, error));
 }
 
 TEST(FifoBufferTest, FullBufferCheck) {