Delete unused FifoBuffer methods
Unused since https://webrtc-review.googlesource.com/c/src/+/186665
Bug: webrtc:11988, webrtc:6424
Change-Id: Ib09e6b862f7550d07d5adf8ce82b74698419730a
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/233081
Reviewed-by: Tommi <tommi@webrtc.org>
Commit-Queue: Niels Moller <nisse@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#35097}
diff --git a/rtc_base/memory/fifo_buffer.cc b/rtc_base/memory/fifo_buffer.cc
index 3fbea8d..116badd 100644
--- a/rtc_base/memory/fifo_buffer.cc
+++ b/rtc_base/memory/fifo_buffer.cc
@@ -44,41 +44,6 @@
return true;
}
-bool FifoBuffer::SetCapacity(size_t size) {
- webrtc::MutexLock lock(&mutex_);
- if (data_length_ > size) {
- return false;
- }
-
- if (size != buffer_length_) {
- char* buffer = new char[size];
- const size_t copy = data_length_;
- const size_t tail_copy = std::min(copy, buffer_length_ - read_position_);
- memcpy(buffer, &buffer_[read_position_], tail_copy);
- memcpy(buffer + tail_copy, &buffer_[0], copy - tail_copy);
- buffer_.reset(buffer);
- read_position_ = 0;
- buffer_length_ = size;
- }
- return true;
-}
-
-StreamResult FifoBuffer::ReadOffset(void* buffer,
- size_t bytes,
- size_t offset,
- size_t* bytes_read) {
- webrtc::MutexLock lock(&mutex_);
- return ReadOffsetLocked(buffer, bytes, offset, bytes_read);
-}
-
-StreamResult FifoBuffer::WriteOffset(const void* buffer,
- size_t bytes,
- size_t offset,
- size_t* bytes_written) {
- webrtc::MutexLock lock(&mutex_);
- return WriteOffsetLocked(buffer, bytes, offset, bytes_written);
-}
-
StreamState FifoBuffer::GetState() const {
webrtc::MutexLock lock(&mutex_);
return state_;
@@ -91,7 +56,7 @@
webrtc::MutexLock lock(&mutex_);
const bool was_writable = data_length_ < buffer_length_;
size_t copy = 0;
- StreamResult result = ReadOffsetLocked(buffer, bytes, 0, ©);
+ StreamResult result = ReadLocked(buffer, bytes, ©);
if (result == SR_SUCCESS) {
// If read was successful then adjust the read position and number of
@@ -118,7 +83,7 @@
const bool was_readable = (data_length_ > 0);
size_t copy = 0;
- StreamResult result = WriteOffsetLocked(buffer, bytes, 0, ©);
+ StreamResult result = WriteLocked(buffer, bytes, ©);
if (result == SR_SUCCESS) {
// If write was successful then adjust the number of readable bytes.
@@ -189,22 +154,15 @@
}
}
-bool FifoBuffer::GetWriteRemaining(size_t* size) const {
- webrtc::MutexLock lock(&mutex_);
- *size = buffer_length_ - data_length_;
- return true;
-}
-
-StreamResult FifoBuffer::ReadOffsetLocked(void* buffer,
- size_t bytes,
- size_t offset,
- size_t* bytes_read) {
- if (offset >= data_length_) {
+StreamResult FifoBuffer::ReadLocked(void* buffer,
+ size_t bytes,
+ size_t* bytes_read) {
+ if (data_length_ == 0) {
return (state_ != SS_CLOSED) ? SR_BLOCK : SR_EOS;
}
- const size_t available = data_length_ - offset;
- const size_t read_position = (read_position_ + offset) % buffer_length_;
+ const size_t available = data_length_;
+ const size_t read_position = read_position_ % buffer_length_;
const size_t copy = std::min(bytes, available);
const size_t tail_copy = std::min(copy, buffer_length_ - read_position);
char* const p = static_cast<char*>(buffer);
@@ -217,21 +175,20 @@
return SR_SUCCESS;
}
-StreamResult FifoBuffer::WriteOffsetLocked(const void* buffer,
- size_t bytes,
- size_t offset,
- size_t* bytes_written) {
+StreamResult FifoBuffer::WriteLocked(const void* buffer,
+ size_t bytes,
+ size_t* bytes_written) {
if (state_ == SS_CLOSED) {
return SR_EOS;
}
- if (data_length_ + offset >= buffer_length_) {
+ if (data_length_ >= buffer_length_) {
return SR_BLOCK;
}
- const size_t available = buffer_length_ - data_length_ - offset;
+ const size_t available = buffer_length_ - data_length_;
const size_t write_position =
- (read_position_ + data_length_ + offset) % buffer_length_;
+ (read_position_ + data_length_) % buffer_length_;
const size_t copy = std::min(bytes, available);
const size_t tail_copy = std::min(copy, buffer_length_ - write_position);
const char* const p = static_cast<const char*>(buffer);
diff --git a/rtc_base/memory/fifo_buffer.h b/rtc_base/memory/fifo_buffer.h
index de3ebcd..0bc943a 100644
--- a/rtc_base/memory/fifo_buffer.h
+++ b/rtc_base/memory/fifo_buffer.h
@@ -31,26 +31,6 @@
~FifoBuffer() override;
// Gets the amount of data currently readable from the buffer.
bool GetBuffered(size_t* data_len) const;
- // Resizes the buffer to the specified capacity. Fails if data_length_ > size
- bool SetCapacity(size_t length);
-
- // Read into `buffer` with an offset from the current read position, offset
- // is specified in number of bytes.
- // This method doesn't adjust read position nor the number of available
- // bytes, user has to call ConsumeReadData() to do this.
- StreamResult ReadOffset(void* buffer,
- size_t bytes,
- size_t offset,
- size_t* bytes_read);
-
- // Write `buffer` with an offset from the current write position, offset is
- // specified in number of bytes.
- // This method doesn't adjust the number of buffered bytes, user has to call
- // ConsumeWriteBuffer() to do this.
- StreamResult WriteOffset(const void* buffer,
- size_t bytes,
- size_t offset,
- size_t* bytes_written);
// StreamInterface methods
StreamState GetState() const override;
@@ -95,10 +75,6 @@
void* GetWriteBuffer(size_t* buf_len);
void ConsumeWriteBuffer(size_t used);
- // Return the number of Write()-able bytes remaining before end-of-stream.
- // Returns false if not known.
- bool GetWriteRemaining(size_t* size) const;
-
private:
void PostEvent(int events, int err) {
owner_->PostTask(webrtc::ToQueuedTask(task_safety_, [this, events, err]() {
@@ -106,20 +82,16 @@
}));
}
- // Helper method that implements ReadOffset. Caller must acquire a lock
+ // Helper method that implements Read. Caller must acquire a lock
// when calling this method.
- StreamResult ReadOffsetLocked(void* buffer,
- size_t bytes,
- size_t offset,
- size_t* bytes_read)
+ StreamResult ReadLocked(void* buffer, size_t bytes, size_t* bytes_read)
RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
- // Helper method that implements WriteOffset. Caller must acquire a lock
+ // Helper method that implements Write. Caller must acquire a lock
// when calling this method.
- StreamResult WriteOffsetLocked(const void* buffer,
- size_t bytes,
- size_t offset,
- size_t* bytes_written)
+ StreamResult WriteLocked(const void* buffer,
+ size_t bytes,
+ size_t* bytes_written)
RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
webrtc::ScopedTaskSafety task_safety_;
@@ -129,7 +101,7 @@
// the allocated buffer
std::unique_ptr<char[]> buffer_ RTC_GUARDED_BY(mutex_);
// size of the allocated buffer
- size_t buffer_length_ RTC_GUARDED_BY(mutex_);
+ const size_t buffer_length_;
// amount of readable data in the buffer
size_t data_length_ RTC_GUARDED_BY(mutex_);
// offset to the readable data
diff --git a/rtc_base/memory/fifo_buffer_unittest.cc b/rtc_base/memory/fifo_buffer_unittest.cc
index 5c8ef43..b602f0a 100644
--- a/rtc_base/memory/fifo_buffer_unittest.cc
+++ b/rtc_base/memory/fifo_buffer_unittest.cc
@@ -202,25 +202,6 @@
// Check that the stream is now empty
EXPECT_EQ(SR_BLOCK, buf.Read(out, kSize, &bytes, nullptr));
- // Try growing the buffer
- EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize, &bytes, nullptr));
- EXPECT_EQ(kSize, bytes);
- EXPECT_TRUE(buf.SetCapacity(kSize * 2));
- EXPECT_EQ(SR_SUCCESS, buf.Write(in + kSize, kSize, &bytes, nullptr));
- EXPECT_EQ(kSize, bytes);
- EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize * 2, &bytes, nullptr));
- EXPECT_EQ(kSize * 2, bytes);
- EXPECT_EQ(0, memcmp(in, out, kSize * 2));
-
- // Try shrinking the buffer
- EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize, &bytes, nullptr));
- EXPECT_EQ(kSize, bytes);
- EXPECT_TRUE(buf.SetCapacity(kSize));
- EXPECT_EQ(SR_BLOCK, buf.Write(in, kSize, &bytes, nullptr));
- EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize, &bytes, nullptr));
- EXPECT_EQ(kSize, bytes);
- EXPECT_EQ(0, memcmp(in, out, kSize));
-
// Write to the stream, close it, read the remaining bytes
EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize / 2, &bytes, nullptr));
buf.Close();
@@ -240,53 +221,4 @@
EXPECT_EQ(0U, free);
}
-TEST(FifoBufferTest, WriteOffsetAndReadOffset) {
- const size_t kSize = 16;
- const char in[kSize * 2 + 1] = "0123456789ABCDEFGHIJKLMNOPQRSTUV";
- char out[kSize * 2];
- FifoBuffer buf(kSize);
-
- // Write 14 bytes.
- EXPECT_EQ(SR_SUCCESS, buf.Write(in, 14, nullptr, nullptr));
-
- // Make sure data is in `buf`.
- size_t buffered;
- EXPECT_TRUE(buf.GetBuffered(&buffered));
- EXPECT_EQ(14u, buffered);
-
- // Read 10 bytes.
- buf.ConsumeReadData(10);
-
- // There should be now 12 bytes of available space.
- size_t remaining;
- EXPECT_TRUE(buf.GetWriteRemaining(&remaining));
- EXPECT_EQ(12u, remaining);
-
- // Write at offset 12, this should fail.
- EXPECT_EQ(SR_BLOCK, buf.WriteOffset(in, 10, 12, nullptr));
-
- // Write 8 bytes at offset 4, this wraps around the buffer.
- EXPECT_EQ(SR_SUCCESS, buf.WriteOffset(in, 8, 4, nullptr));
-
- // Number of available space remains the same until we call
- // ConsumeWriteBuffer().
- EXPECT_TRUE(buf.GetWriteRemaining(&remaining));
- EXPECT_EQ(12u, remaining);
- buf.ConsumeWriteBuffer(12);
-
- // There's 4 bytes bypassed and 4 bytes no read so skip them and verify the
- // 8 bytes written.
- size_t read;
- EXPECT_EQ(SR_SUCCESS, buf.ReadOffset(out, 8, 8, &read));
- EXPECT_EQ(8u, read);
- EXPECT_EQ(0, memcmp(out, in, 8));
-
- // There should still be 16 bytes available for reading.
- EXPECT_TRUE(buf.GetBuffered(&buffered));
- EXPECT_EQ(16u, buffered);
-
- // Read at offset 16, this should fail since we don't have that much data.
- EXPECT_EQ(SR_BLOCK, buf.ReadOffset(out, 10, 16, nullptr));
-}
-
} // namespace rtc
