Delete unused classes from stream.cc

webrtc/base/stream.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 220 matching lines @@
     delete stream_;
 }
 
 void StreamAdapterInterface::OnEvent(StreamInterface* stream,
                                      int events,
                                      int err) {
   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
 ///////////////////////////////////////////////////////////////////////////////
 
 NullStream::NullStream() {
 }
 
 NullStream::~NullStream() {
 }
 
 StreamState NullStream::GetState() const {
@@ skipping 349 matching lines @@
     return SR_SUCCESS;
   }
 
   if (error) {
     *error = ENOMEM;
   }
   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<char*>(data);
-  seek_position_ = 0;
-}
-
-///////////////////////////////////////////////////////////////////////////////
 // FifoBuffer
 ///////////////////////////////////////////////////////////////////////////////
 
 FifoBuffer::FifoBuffer(size_t size)
     : state_(SS_OPEN), buffer_(new char[size]), buffer_length_(size),
       data_length_(0), read_position_(0), owner_(Thread::Current()) {
   // all events are done on the owner_ thread
 }
 
 FifoBuffer::FifoBuffer(size_t size, Thread* owner)
@@ skipping 194 matching lines @@
   const char* const p = static_cast<const char*>(buffer);
   memcpy(&buffer_[write_position], p, tail_copy);
   memcpy(&buffer_[0], p + tail_copy, copy - tail_copy);
 
   if (bytes_written) {
     *bytes_written = copy;
   }
   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
 ///////////////////////////////////////////////////////////////////////////////
 
 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) {
@@ skipping 59 matching lines @@
 }
 
 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) {
-}
-
-///////////////////////////////////////////////////////////////////////////////
 
 StreamResult Flow(StreamInterface* source,
                   char* buffer,
                   size_t buffer_len,
                   StreamInterface* sink,
                   size_t* data_len /* = nullptr */) {
   RTC_DCHECK(buffer_len > 0);
 
   StreamResult result;
   size_t count, read_pos, write_pos;
@@ skipping 43 matching lines @@
 
   if (data_len) {
     *data_len = 0;
   }
   return SR_SUCCESS;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 }  // namespace rtc