Delete unused rtc::Stream subclasses.
Also move StringStream to the only test using it.
Bug: webrtc:6424
Change-Id: Iad79c7becaa2764ac954c18711eaae4faf46ae72
Reviewed-on: https://webrtc-review.googlesource.com/84320
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Commit-Queue: Niels Moller <nisse@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#23721}diff --git a/rtc_base/logging_unittest.cc b/rtc_base/logging_unittest.cc
index 44d5805..158f204 100644
--- a/rtc_base/logging_unittest.cc
+++ b/rtc_base/logging_unittest.cc
@@ -19,6 +19,112 @@
namespace rtc {
+namespace {
+
+class StringStream : public StreamInterface {
+ public:
+ explicit StringStream(std::string* str);
+ explicit StringStream(const std::string& str);
+
+ StreamState GetState() const override;
+ StreamResult Read(void* buffer,
+ size_t buffer_len,
+ size_t* read,
+ int* error) override;
+ StreamResult Write(const void* data,
+ size_t data_len,
+ size_t* written,
+ int* error) override;
+ void Close() override;
+ bool SetPosition(size_t position) override;
+ bool GetPosition(size_t* position) const override;
+ bool GetSize(size_t* size) const override;
+ bool GetAvailable(size_t* size) const override;
+ bool ReserveSize(size_t size) override;
+
+ private:
+ std::string& str_;
+ size_t read_pos_;
+ bool read_only_;
+};
+
+StringStream::StringStream(std::string* str)
+ : str_(*str), read_pos_(0), read_only_(false) {}
+
+StringStream::StringStream(const std::string& str)
+ : str_(const_cast<std::string&>(str)), read_pos_(0), read_only_(true) {}
+
+StreamState StringStream::GetState() const {
+ return SS_OPEN;
+}
+
+StreamResult StringStream::Read(void* buffer,
+ size_t buffer_len,
+ size_t* read,
+ int* error) {
+ size_t available = std::min(buffer_len, str_.size() - read_pos_);
+ if (!available)
+ return SR_EOS;
+ memcpy(buffer, str_.data() + read_pos_, available);
+ read_pos_ += available;
+ if (read)
+ *read = available;
+ return SR_SUCCESS;
+}
+
+StreamResult StringStream::Write(const void* data,
+ size_t data_len,
+ size_t* written,
+ int* error) {
+ if (read_only_) {
+ if (error) {
+ *error = -1;
+ }
+ return SR_ERROR;
+ }
+ str_.append(static_cast<const char*>(data),
+ static_cast<const char*>(data) + data_len);
+ if (written)
+ *written = data_len;
+ return SR_SUCCESS;
+}
+
+void StringStream::Close() {}
+
+bool StringStream::SetPosition(size_t position) {
+ if (position > str_.size())
+ return false;
+ read_pos_ = position;
+ return true;
+}
+
+bool StringStream::GetPosition(size_t* position) const {
+ if (position)
+ *position = read_pos_;
+ return true;
+}
+
+bool StringStream::GetSize(size_t* size) const {
+ if (size)
+ *size = str_.size();
+ return true;
+}
+
+bool StringStream::GetAvailable(size_t* size) const {
+ if (size)
+ *size = str_.size() - read_pos_;
+ return true;
+}
+
+bool StringStream::ReserveSize(size_t size) {
+ if (read_only_)
+ return false;
+ str_.reserve(size);
+ return true;
+}
+
+} // namespace
+
template <typename Base>
class LogSinkImpl : public LogSink, public Base {
public:
@@ -170,9 +276,6 @@
// Ensure we don't crash when adding/removing streams while threads are going.
// We should restore the correct global state at the end.
-// This test also makes sure that the 'noop' stream() singleton object, can be
-// safely used from mutiple threads since the threads log at LS_SENSITIVE
-// (by default 'noop' entries).
TEST(LogTest, MultipleThreads) {
int sev = LogMessage::GetLogToStream(nullptr);
@@ -181,7 +284,8 @@
thread2.Start();
thread3.Start();
- LogSinkImpl<NullStream> stream1, stream2, stream3;
+ std::string s1, s2, s3;
+ LogSinkImpl<StringStream> stream1(&s1), stream2(&s2), stream3(&s3);
for (int i = 0; i < 1000; ++i) {
LogMessage::AddLogToStream(&stream1, LS_INFO);
LogMessage::AddLogToStream(&stream2, LS_VERBOSE);
diff --git a/rtc_base/stream.cc b/rtc_base/stream.cc
index 56c848a..b9691c5 100644
--- a/rtc_base/stream.cc
+++ b/rtc_base/stream.cc
@@ -239,99 +239,6 @@
}
///////////////////////////////////////////////////////////////////////////////
-// StreamTap
-///////////////////////////////////////////////////////////////////////////////
-
-StreamTap::StreamTap(StreamInterface* stream, StreamInterface* tap)
- : StreamAdapterInterface(stream),
- tap_(),
- tap_result_(SR_SUCCESS),
- tap_error_(0) {
- AttachTap(tap);
-}
-
-StreamTap::~StreamTap() = default;
-
-void StreamTap::AttachTap(StreamInterface* tap) {
- tap_.reset(tap);
-}
-
-StreamInterface* StreamTap::DetachTap() {
- return tap_.release();
-}
-
-StreamResult StreamTap::GetTapResult(int* error) {
- if (error) {
- *error = tap_error_;
- }
- return tap_result_;
-}
-
-StreamResult StreamTap::Read(void* buffer,
- size_t buffer_len,
- size_t* read,
- int* error) {
- size_t backup_read;
- if (!read) {
- read = &backup_read;
- }
- StreamResult res =
- StreamAdapterInterface::Read(buffer, buffer_len, read, error);
- if ((res == SR_SUCCESS) && (tap_result_ == SR_SUCCESS)) {
- tap_result_ = tap_->WriteAll(buffer, *read, nullptr, &tap_error_);
- }
- return res;
-}
-
-StreamResult StreamTap::Write(const void* data,
- size_t data_len,
- size_t* written,
- int* error) {
- size_t backup_written;
- if (!written) {
- written = &backup_written;
- }
- StreamResult res =
- StreamAdapterInterface::Write(data, data_len, written, error);
- if ((res == SR_SUCCESS) && (tap_result_ == SR_SUCCESS)) {
- tap_result_ = tap_->WriteAll(data, *written, nullptr, &tap_error_);
- }
- return res;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// NullStream
-///////////////////////////////////////////////////////////////////////////////
-
-NullStream::NullStream() {}
-
-NullStream::~NullStream() {}
-
-StreamState NullStream::GetState() const {
- return SS_OPEN;
-}
-
-StreamResult NullStream::Read(void* buffer,
- size_t buffer_len,
- size_t* read,
- int* error) {
- if (error)
- *error = -1;
- return SR_ERROR;
-}
-
-StreamResult NullStream::Write(const void* data,
- size_t data_len,
- size_t* written,
- int* error) {
- if (written)
- *written = data_len;
- return SR_SUCCESS;
-}
-
-void NullStream::Close() {}
-
-///////////////////////////////////////////////////////////////////////////////
// FileStream
///////////////////////////////////////////////////////////////////////////////
@@ -893,108 +800,6 @@
return SR_SUCCESS;
}
-///////////////////////////////////////////////////////////////////////////////
-// StringStream - Reads/Writes to an external std::string
-///////////////////////////////////////////////////////////////////////////////
-
-StringStream::StringStream(std::string* str)
- : str_(*str), read_pos_(0), read_only_(false) {}
-
-StringStream::StringStream(const std::string& str)
- : str_(const_cast<std::string&>(str)), read_pos_(0), read_only_(true) {}
-
-StreamState StringStream::GetState() const {
- return SS_OPEN;
-}
-
-StreamResult StringStream::Read(void* buffer,
- size_t buffer_len,
- size_t* read,
- int* error) {
- size_t available = std::min(buffer_len, str_.size() - read_pos_);
- if (!available)
- return SR_EOS;
- memcpy(buffer, str_.data() + read_pos_, available);
- read_pos_ += available;
- if (read)
- *read = available;
- return SR_SUCCESS;
-}
-
-StreamResult StringStream::Write(const void* data,
- size_t data_len,
- size_t* written,
- int* error) {
- if (read_only_) {
- if (error) {
- *error = -1;
- }
- return SR_ERROR;
- }
- str_.append(static_cast<const char*>(data),
- static_cast<const char*>(data) + data_len);
- if (written)
- *written = data_len;
- return SR_SUCCESS;
-}
-
-void StringStream::Close() {}
-
-bool StringStream::SetPosition(size_t position) {
- if (position > str_.size())
- return false;
- read_pos_ = position;
- return true;
-}
-
-bool StringStream::GetPosition(size_t* position) const {
- if (position)
- *position = read_pos_;
- return true;
-}
-
-bool StringStream::GetSize(size_t* size) const {
- if (size)
- *size = str_.size();
- return true;
-}
-
-bool StringStream::GetAvailable(size_t* size) const {
- if (size)
- *size = str_.size() - read_pos_;
- return true;
-}
-
-bool StringStream::ReserveSize(size_t size) {
- if (read_only_)
- return false;
- str_.reserve(size);
- return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// StreamReference
-///////////////////////////////////////////////////////////////////////////////
-
-StreamReference::StreamReference(StreamInterface* stream)
- : StreamAdapterInterface(stream, false) {
- // owner set to false so the destructor does not free the stream.
- stream_ref_count_ = new StreamRefCount(stream);
-}
-
-StreamInterface* StreamReference::NewReference() {
- stream_ref_count_->AddReference();
- return new StreamReference(stream_ref_count_, stream());
-}
-
-StreamReference::~StreamReference() {
- stream_ref_count_->Release();
-}
-
-StreamReference::StreamReference(StreamRefCount* stream_ref_count,
- StreamInterface* stream)
- : StreamAdapterInterface(stream, false),
- stream_ref_count_(stream_ref_count) {}
///////////////////////////////////////////////////////////////////////////////
diff --git a/rtc_base/stream.h b/rtc_base/stream.h
index d3f2f74..ee0f149 100644
--- a/rtc_base/stream.h
+++ b/rtc_base/stream.h
@@ -316,60 +316,6 @@
};
///////////////////////////////////////////////////////////////////////////////
-// StreamTap is a non-modifying, pass-through adapter, which copies all data
-// in either direction to the tap. Note that errors or blocking on writing to
-// the tap will prevent further tap writes from occurring.
-///////////////////////////////////////////////////////////////////////////////
-
-class StreamTap : public StreamAdapterInterface {
- public:
- explicit StreamTap(StreamInterface* stream, StreamInterface* tap);
- ~StreamTap() override;
-
- void AttachTap(StreamInterface* tap);
- StreamInterface* DetachTap();
- StreamResult GetTapResult(int* error);
-
- // StreamAdapterInterface Interface
- StreamResult Read(void* buffer,
- size_t buffer_len,
- size_t* read,
- int* error) override;
- StreamResult Write(const void* data,
- size_t data_len,
- size_t* written,
- int* error) override;
-
- private:
- std::unique_ptr<StreamInterface> tap_;
- StreamResult tap_result_;
- int tap_error_;
- RTC_DISALLOW_COPY_AND_ASSIGN(StreamTap);
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// NullStream gives errors on read, and silently discards all written data.
-///////////////////////////////////////////////////////////////////////////////
-
-class NullStream : public StreamInterface {
- public:
- NullStream();
- ~NullStream() override;
-
- // StreamInterface Interface
- StreamState GetState() const override;
- StreamResult Read(void* buffer,
- size_t buffer_len,
- size_t* read,
- int* error) override;
- StreamResult Write(const void* data,
- size_t data_len,
- size_t* written,
- int* error) override;
- void Close() override;
-};
-
-///////////////////////////////////////////////////////////////////////////////
// FileStream is a simple implementation of a StreamInterface, which does not
// support asynchronous notification.
///////////////////////////////////////////////////////////////////////////////
@@ -573,98 +519,6 @@
};
///////////////////////////////////////////////////////////////////////////////
-// StringStream - Reads/Writes to an external std::string
-///////////////////////////////////////////////////////////////////////////////
-
-class StringStream : public StreamInterface {
- public:
- explicit StringStream(std::string* str);
- explicit StringStream(const std::string& str);
-
- StreamState GetState() const override;
- StreamResult Read(void* buffer,
- size_t buffer_len,
- size_t* read,
- int* error) override;
- StreamResult Write(const void* data,
- size_t data_len,
- size_t* written,
- int* error) override;
- void Close() override;
- bool SetPosition(size_t position) override;
- bool GetPosition(size_t* position) const override;
- bool GetSize(size_t* size) const override;
- bool GetAvailable(size_t* size) const override;
- bool ReserveSize(size_t size) override;
-
- private:
- std::string& str_;
- size_t read_pos_;
- bool read_only_;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// StreamReference - A reference counting stream adapter
-///////////////////////////////////////////////////////////////////////////////
-
-// Keep in mind that the streams and adapters defined in this file are
-// not thread-safe, so this has limited uses.
-
-// A StreamRefCount holds the reference count and a pointer to the
-// wrapped stream. It deletes the wrapped stream when there are no
-// more references. We can then have multiple StreamReference
-// instances pointing to one StreamRefCount, all wrapping the same
-// stream.
-
-class StreamReference : public StreamAdapterInterface {
- class StreamRefCount;
-
- public:
- // Constructor for the first reference to a stream
- // Note: get more references through NewReference(). Use this
- // constructor only once on a given stream.
- explicit StreamReference(StreamInterface* stream);
- StreamInterface* GetStream() { return stream(); }
- StreamInterface* NewReference();
- ~StreamReference() override;
-
- private:
- class StreamRefCount {
- public:
- explicit StreamRefCount(StreamInterface* stream)
- : stream_(stream), ref_count_(1) {}
- void AddReference() {
- CritScope lock(&cs_);
- ++ref_count_;
- }
- void Release() {
- int ref_count;
- { // Atomic ops would have been a better fit here.
- CritScope lock(&cs_);
- ref_count = --ref_count_;
- }
- if (ref_count == 0) {
- delete stream_;
- delete this;
- }
- }
-
- private:
- StreamInterface* stream_;
- int ref_count_;
- CriticalSection cs_;
- RTC_DISALLOW_COPY_AND_ASSIGN(StreamRefCount);
- };
-
- // Constructor for adding references
- explicit StreamReference(StreamRefCount* stream_ref_count,
- StreamInterface* stream);
-
- StreamRefCount* stream_ref_count_;
- RTC_DISALLOW_COPY_AND_ASSIGN(StreamReference);
-};
-
-///////////////////////////////////////////////////////////////////////////////
// Flow attempts to move bytes from source to sink via buffer of size
// buffer_len. The function returns SR_SUCCESS when source reaches
