Revert of Removing HTTPS and SOCKS proxy server code.

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