From e9ad37ca068ba5cf2bafe52692e548f7632c3c6c Mon Sep 17 00:00:00 2001 From: kthelgason Date: Fri, 17 Mar 2017 01:06:49 -0700 Subject: [PATCH] Delete unused classes from stream.cc BUG=webrtc:6424 Review-Url: https://codereview.webrtc.org/2754033003 Cr-Commit-Position: refs/heads/master@{#17281} --- webrtc/base/stream.cc | 158 ------------------------------------------ webrtc/base/stream.h | 135 ------------------------------------ 2 files changed, 293 deletions(-) diff --git a/webrtc/base/stream.cc b/webrtc/base/stream.cc index 67ef104044..520d1dd202 100644 --- a/webrtc/base/stream.cc +++ b/webrtc/base/stream.cc @@ -237,61 +237,6 @@ void StreamAdapterInterface::OnEvent(StreamInterface* stream, SignalEvent(this, events, err); } -/////////////////////////////////////////////////////////////////////////////// -// 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 /////////////////////////////////////////////////////////////////////////////// @@ -661,24 +606,6 @@ StreamResult MemoryStream::DoReserve(size_t size, int* error) { return SR_ERROR; } -/////////////////////////////////////////////////////////////////////////////// - -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(data); - seek_position_ = 0; -} - /////////////////////////////////////////////////////////////////////////////// // FifoBuffer /////////////////////////////////////////////////////////////////////////////// @@ -894,66 +821,6 @@ StreamResult FifoBuffer::WriteOffsetLocked(const void* buffer, 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 /////////////////////////////////////////////////////////////////////////////// @@ -1032,31 +899,6 @@ bool StringStream::ReserveSize(size_t 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) { -} - /////////////////////////////////////////////////////////////////////////////// StreamResult Flow(StreamInterface* source, diff --git a/webrtc/base/stream.h b/webrtc/base/stream.h index dbc2ad750a..211c1e1e4b 100644 --- a/webrtc/base/stream.h +++ b/webrtc/base/stream.h @@ -309,38 +309,6 @@ class StreamAdapterInterface : public StreamInterface, RTC_DISALLOW_COPY_AND_ASSIGN(StreamAdapterInterface); }; -/////////////////////////////////////////////////////////////////////////////// -// 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 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 @@ class MemoryStream : public MemoryStreamBase { 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. @@ -569,37 +525,6 @@ class FifoBuffer : public StreamInterface { RTC_DISALLOW_COPY_AND_ASSIGN(FifoBuffer); }; -/////////////////////////////////////////////////////////////////////////////// - -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 /////////////////////////////////////////////////////////////////////////////// @@ -631,66 +556,6 @@ class StringStream : public StreamInterface { 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