Delete unused classes from stream.cc
BUG=webrtc:6424
Review-Url: https://codereview.webrtc.org/2754033003
Cr-Commit-Position: refs/heads/master@{#17281}
diff --git a/webrtc/base/stream.cc b/webrtc/base/stream.cc
index 67ef104..520d1dd 100644
--- a/webrtc/base/stream.cc
+++ b/webrtc/base/stream.cc
@@ -238,61 +238,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
///////////////////////////////////////////////////////////////////////////////
@@ -662,24 +607,6 @@
}
///////////////////////////////////////////////////////////////////////////////
-
-ExternalMemoryStream::ExternalMemoryStream() {
-}
-
-ExternalMemoryStream::ExternalMemoryStream(void* data, size_t length) {
- SetData(data, length);
-}
-
-ExternalMemoryStream::~ExternalMemoryStream() {
-}
-
-void ExternalMemoryStream::SetData(void* data, size_t length) {
- data_length_ = buffer_length_ = length;
- buffer_ = static_cast<char*>(data);
- seek_position_ = 0;
-}
-
-///////////////////////////////////////////////////////////////////////////////
// FifoBuffer
///////////////////////////////////////////////////////////////////////////////
@@ -894,66 +821,6 @@
return SR_SUCCESS;
}
-
-
-///////////////////////////////////////////////////////////////////////////////
-// LoggingAdapter
-///////////////////////////////////////////////////////////////////////////////
-
-LoggingAdapter::LoggingAdapter(StreamInterface* stream, LoggingSeverity level,
- const std::string& label, bool hex_mode)
- : StreamAdapterInterface(stream), level_(level), hex_mode_(hex_mode) {
- set_label(label);
-}
-
-void LoggingAdapter::set_label(const std::string& label) {
- label_.assign("[");
- label_.append(label);
- label_.append("]");
-}
-
-StreamResult LoggingAdapter::Read(void* buffer, size_t buffer_len,
- size_t* read, int* error) {
- size_t local_read; if (!read) read = &local_read;
- StreamResult result = StreamAdapterInterface::Read(buffer, buffer_len, read,
- error);
- if (result == SR_SUCCESS) {
- LogMultiline(level_, label_.c_str(), true, buffer, *read, hex_mode_, &lms_);
- }
- return result;
-}
-
-StreamResult LoggingAdapter::Write(const void* data, size_t data_len,
- size_t* written, int* error) {
- size_t local_written;
- if (!written) written = &local_written;
- StreamResult result = StreamAdapterInterface::Write(data, data_len, written,
- error);
- if (result == SR_SUCCESS) {
- LogMultiline(level_, label_.c_str(), false, data, *written, hex_mode_,
- &lms_);
- }
- return result;
-}
-
-void LoggingAdapter::Close() {
- LogMultiline(level_, label_.c_str(), false, nullptr, 0, hex_mode_, &lms_);
- LogMultiline(level_, label_.c_str(), true, nullptr, 0, hex_mode_, &lms_);
- LOG_V(level_) << label_ << " Closed locally";
- StreamAdapterInterface::Close();
-}
-
-void LoggingAdapter::OnEvent(StreamInterface* stream, int events, int err) {
- if (events & SE_OPEN) {
- LOG_V(level_) << label_ << " Open";
- } else if (events & SE_CLOSE) {
- LogMultiline(level_, label_.c_str(), false, nullptr, 0, hex_mode_, &lms_);
- LogMultiline(level_, label_.c_str(), true, nullptr, 0, hex_mode_, &lms_);
- LOG_V(level_) << label_ << " Closed with error: " << err;
- }
- StreamAdapterInterface::OnEvent(stream, events, err);
-}
-
///////////////////////////////////////////////////////////////////////////////
// StringStream - Reads/Writes to an external std::string
///////////////////////////////////////////////////////////////////////////////
@@ -1033,31 +900,6 @@
}
///////////////////////////////////////////////////////////////////////////////
-// 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) {
-}
-
-///////////////////////////////////////////////////////////////////////////////
StreamResult Flow(StreamInterface* source,
char* buffer,
diff --git a/webrtc/base/stream.h b/webrtc/base/stream.h
index dbc2ad7..211c1e1 100644
--- a/webrtc/base/stream.h
+++ b/webrtc/base/stream.h
@@ -310,38 +310,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.
///////////////////////////////////////////////////////////////////////////////
@@ -480,18 +448,6 @@
char* buffer_alloc_;
};
-// ExternalMemoryStream adapts an external memory buffer, so writes which would
-// extend past the end of the buffer will return end-of-stream.
-
-class ExternalMemoryStream : public MemoryStreamBase {
- public:
- ExternalMemoryStream();
- ExternalMemoryStream(void* data, size_t length);
- ~ExternalMemoryStream() override;
-
- void SetData(void* data, size_t length);
-};
-
// FifoBuffer allows for efficient, thread-safe buffering of data between
// writer and reader. As the data can wrap around the end of the buffer,
// MemoryStreamBase can't help us here.
@@ -570,37 +526,6 @@
};
///////////////////////////////////////////////////////////////////////////////
-
-class LoggingAdapter : public StreamAdapterInterface {
- public:
- LoggingAdapter(StreamInterface* stream, LoggingSeverity level,
- const std::string& label, bool hex_mode = false);
-
- void set_label(const std::string& label);
-
- 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;
-
- protected:
- void OnEvent(StreamInterface* stream, int events, int err) override;
-
- private:
- LoggingSeverity level_;
- std::string label_;
- bool hex_mode_;
- LogMultilineState lms_;
-
- RTC_DISALLOW_COPY_AND_ASSIGN(LoggingAdapter);
-};
-
-///////////////////////////////////////////////////////////////////////////////
// StringStream - Reads/Writes to an external std::string
///////////////////////////////////////////////////////////////////////////////
@@ -632,66 +557,6 @@
};
///////////////////////////////////////////////////////////////////////////////
-// 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