Revert of Removing HTTPS and SOCKS proxy server code.

webrtc/base/stream.h

 /*
  *  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 292 matching lines @@
   virtual void OnEvent(StreamInterface* stream, int events, int err);
   StreamInterface* stream() { return stream_; }
 
  private:
   StreamInterface* stream_;
   bool owned_;
   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<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;
@@ skipping 118 matching lines @@
 
   void SetData(const void* data, size_t length);
 
  protected:
   StreamResult DoReserve(size_t size, int* error) override;
   // Memory Streams are aligned for efficiency.
   static const int kAlignment = 16;
   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.
 
 class FifoBuffer : public StreamInterface {
  public:
   // Creates a FIFO buffer with the specified capacity.
   explicit FifoBuffer(size_t length);
   // Creates a FIFO buffer with the specified capacity and owner
   FifoBuffer(size_t length, Thread* owner);
@@ skipping 58 matching lines @@
   // offset to the readable data
   size_t read_position_ GUARDED_BY(crit_);
   // stream callbacks are dispatched on this thread
   Thread* owner_;
   // object lock
   CriticalSection crit_;
   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
 ///////////////////////////////////////////////////////////////////////////////
 
 class StringStream : public StreamInterface {
  public:
   explicit StringStream(std::string* str);
   explicit StringStream(const std::string& str);
 
   StreamState GetState() const override;
   StreamResult Read(void* buffer,
@@ skipping 11 matching lines @@
   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
 // end-of-stream (returns SR_EOS), and all the data has been written successful
 // to sink.  Alternately, if source returns SR_BLOCK or SR_ERROR, or if sink
 // returns SR_BLOCK, SR_ERROR, or SR_EOS, then the function immediately returns
 // with the unexpected StreamResult value.
 // data_len is the length of the valid data in buffer. in case of error
 // this is the data that read from source but can't move to destination.
 // as a pass in parameter, it indicates data in buffer that should move to sink
 StreamResult Flow(StreamInterface* source,
                   char* buffer,
                   size_t buffer_len,
                   StreamInterface* sink,
                   size_t* data_len = nullptr);
 
 ///////////////////////////////////////////////////////////////////////////////
 
 }  // namespace rtc
 
 #endif  // WEBRTC_BASE_STREAM_H_