diff --git a/rtc_base/openssl_stream_adapter.cc b/rtc_base/openssl_stream_adapter.cc
index 63b8069..ab2289b 100644
--- a/rtc_base/openssl_stream_adapter.cc
+++ b/rtc_base/openssl_stream_adapter.cc
@@ -288,7 +288,7 @@
 
 OpenSSLStreamAdapter::OpenSSLStreamAdapter(
     std::unique_ptr<StreamInterface> stream)
-    : SSLStreamAdapter(std::move(stream)),
+    : stream_(std::move(stream)),
       owner_(rtc::Thread::Current()),
       state_(SSL_NONE),
       role_(SSL_CLIENT),
@@ -300,7 +300,9 @@
       ssl_max_version_(SSL_PROTOCOL_TLS_12),
       // Default is to support legacy TLS protocols.
       // This will be changed to default non-support in M82 or M83.
-      support_legacy_tls_protocols_flag_(ShouldAllowLegacyTLSProtocols()) {}
+      support_legacy_tls_protocols_flag_(ShouldAllowLegacyTLSProtocols()) {
+  stream_->SignalEvent.connect(this, &OpenSSLStreamAdapter::OnEvent);
+}
 
 OpenSSLStreamAdapter::~OpenSSLStreamAdapter() {
   timeout_task_.Stop();
@@ -519,7 +521,7 @@
     return -1;
   }
 
-  if (StreamAdapterInterface::GetState() != SS_OPEN) {
+  if (stream_->GetState() != SS_OPEN) {
     state_ = SSL_WAIT;
     return 0;
   }
@@ -561,7 +563,7 @@
   switch (state_) {
     case SSL_NONE:
       // pass-through in clear text
-      return StreamAdapterInterface::Write(data, data_len, written, error);
+      return stream_->Write(data, data_len, written, error);
 
     case SSL_WAIT:
     case SSL_CONNECTING:
@@ -629,7 +631,7 @@
   switch (state_) {
     case SSL_NONE:
       // pass-through in clear text
-      return StreamAdapterInterface::Read(data, data_len, read, error);
+      return stream_->Read(data, data_len, read, error);
     case SSL_WAIT:
     case SSL_CONNECTING:
       return SR_BLOCK;
@@ -733,7 +735,7 @@
   // When we're closed at SSL layer, also close the stream level which
   // performs necessary clean up. Otherwise, a new incoming packet after
   // this could overflow the stream buffer.
-  StreamAdapterInterface::Close();
+  stream_->Close();
 }
 
 StreamState OpenSSLStreamAdapter::GetState() const {
@@ -757,7 +759,7 @@
                                    int err) {
   int events_to_signal = 0;
   int signal_error = 0;
-  RTC_DCHECK(stream == this->stream());
+  RTC_DCHECK(stream == stream_.get());
 
   if ((events & SE_OPEN)) {
     RTC_DLOG(LS_VERBOSE) << "OpenSSLStreamAdapter::OnEvent SE_OPEN";
@@ -809,7 +811,9 @@
   }
 
   if (events_to_signal) {
-    StreamAdapterInterface::OnEvent(stream, events_to_signal, signal_error);
+    // Note that the adapter presents itself as the origin of the stream events,
+    // since users of the adapter may not recognize the adapted object.
+    SignalEvent(this, events_to_signal, signal_error);
   }
 }
 
@@ -854,7 +858,7 @@
     return -1;
   }
 
-  bio = BIO_new_stream(static_cast<StreamInterface*>(stream()));
+  bio = BIO_new_stream(stream_.get());
   if (!bio) {
     return -1;
   }
@@ -912,8 +916,7 @@
         // The caller of ContinueSSL may be the same object listening for these
         // events and may not be prepared for reentrancy.
         // PostEvent(SE_OPEN | SE_READ | SE_WRITE, 0);
-        StreamAdapterInterface::OnEvent(stream(), SE_OPEN | SE_READ | SE_WRITE,
-                                        0);
+        SignalEvent(this, SE_OPEN | SE_READ | SE_WRITE, 0);
       }
       break;
 
@@ -956,7 +959,7 @@
   ssl_error_code_ = err;
   Cleanup(alert);
   if (signal) {
-    StreamAdapterInterface::OnEvent(stream(), SE_CLOSE, err);
+    SignalEvent(this, SE_CLOSE, err);
   }
 }
 
diff --git a/rtc_base/openssl_stream_adapter.h b/rtc_base/openssl_stream_adapter.h
index a09737c..58e15e3 100644
--- a/rtc_base/openssl_stream_adapter.h
+++ b/rtc_base/openssl_stream_adapter.h
@@ -136,9 +136,6 @@
   // using a fake clock.
   static void EnableTimeCallbackForTesting();
 
- protected:
-  void OnEvent(StreamInterface* stream, int events, int err) override;
-
  private:
   enum SSLState {
     // Before calling one of the StartSSL methods, data flows
@@ -151,6 +148,8 @@
     SSL_CLOSED       // Clean close
   };
 
+  void OnEvent(StreamInterface* stream, int events, int err);
+
   void PostEvent(int events, int err);
   void SetTimeout(int delay_ms);
 
@@ -203,6 +202,8 @@
            !peer_certificate_digest_value_.empty();
   }
 
+  const std::unique_ptr<StreamInterface> stream_;
+
   rtc::Thread* const owner_;
   webrtc::ScopedTaskSafety task_safety_;
   webrtc::RepeatingTaskHandle timeout_task_;
diff --git a/rtc_base/ssl_stream_adapter.cc b/rtc_base/ssl_stream_adapter.cc
index 354622e..5730af6 100644
--- a/rtc_base/ssl_stream_adapter.cc
+++ b/rtc_base/ssl_stream_adapter.cc
@@ -95,11 +95,6 @@
   return std::make_unique<OpenSSLStreamAdapter>(std::move(stream));
 }
 
-SSLStreamAdapter::SSLStreamAdapter(std::unique_ptr<StreamInterface> stream)
-    : StreamAdapterInterface(stream.release()) {}
-
-SSLStreamAdapter::~SSLStreamAdapter() {}
-
 bool SSLStreamAdapter::GetSslCipherSuite(int* cipher_suite) {
   return false;
 }
diff --git a/rtc_base/ssl_stream_adapter.h b/rtc_base/ssl_stream_adapter.h
index 977768a..6b44c76 100644
--- a/rtc_base/ssl_stream_adapter.h
+++ b/rtc_base/ssl_stream_adapter.h
@@ -118,7 +118,7 @@
 // Used to send back UMA histogram value. Logged when Dtls handshake fails.
 enum class SSLHandshakeError { UNKNOWN, INCOMPATIBLE_CIPHERSUITE, MAX_VALUE };
 
-class SSLStreamAdapter : public StreamAdapterInterface {
+class SSLStreamAdapter : public StreamInterface, public sigslot::has_slots<> {
  public:
   // Instantiate an SSLStreamAdapter wrapping the given stream,
   // (using the selected implementation for the platform).
@@ -126,8 +126,8 @@
   static std::unique_ptr<SSLStreamAdapter> Create(
       std::unique_ptr<StreamInterface> stream);
 
-  explicit SSLStreamAdapter(std::unique_ptr<StreamInterface> stream);
-  ~SSLStreamAdapter() override;
+  SSLStreamAdapter() = default;
+  ~SSLStreamAdapter() override = default;
 
   // Specify our SSL identity: key and certificate. SSLStream takes ownership
   // of the SSLIdentity object and will free it when appropriate. Should be
diff --git a/rtc_base/stream.cc b/rtc_base/stream.cc
index ee72f8d..30c7678 100644
--- a/rtc_base/stream.cc
+++ b/rtc_base/stream.cc
@@ -49,68 +49,4 @@
 
 StreamInterface::StreamInterface() {}
 
-///////////////////////////////////////////////////////////////////////////////
-// StreamAdapterInterface
-///////////////////////////////////////////////////////////////////////////////
-
-StreamAdapterInterface::StreamAdapterInterface(StreamInterface* stream,
-                                               bool owned)
-    : stream_(stream), owned_(owned) {
-  if (nullptr != stream_)
-    stream_->SignalEvent.connect(this, &StreamAdapterInterface::OnEvent);
-}
-
-StreamState StreamAdapterInterface::GetState() const {
-  return stream_->GetState();
-}
-StreamResult StreamAdapterInterface::Read(void* buffer,
-                                          size_t buffer_len,
-                                          size_t* read,
-                                          int* error) {
-  return stream_->Read(buffer, buffer_len, read, error);
-}
-StreamResult StreamAdapterInterface::Write(const void* data,
-                                           size_t data_len,
-                                           size_t* written,
-                                           int* error) {
-  return stream_->Write(data, data_len, written, error);
-}
-void StreamAdapterInterface::Close() {
-  stream_->Close();
-}
-
-bool StreamAdapterInterface::Flush() {
-  return stream_->Flush();
-}
-
-void StreamAdapterInterface::Attach(StreamInterface* stream, bool owned) {
-  if (nullptr != stream_)
-    stream_->SignalEvent.disconnect(this);
-  if (owned_)
-    delete stream_;
-  stream_ = stream;
-  owned_ = owned;
-  if (nullptr != stream_)
-    stream_->SignalEvent.connect(this, &StreamAdapterInterface::OnEvent);
-}
-
-StreamInterface* StreamAdapterInterface::Detach() {
-  if (nullptr != stream_)
-    stream_->SignalEvent.disconnect(this);
-  StreamInterface* stream = stream_;
-  stream_ = nullptr;
-  return stream;
-}
-
-StreamAdapterInterface::~StreamAdapterInterface() {
-  if (owned_)
-    delete stream_;
-}
-
-void StreamAdapterInterface::OnEvent(StreamInterface* stream,
-                                     int events,
-                                     int err) {
-  SignalEvent(this, events, err);
-}
-
 }  // namespace rtc
diff --git a/rtc_base/stream.h b/rtc_base/stream.h
index 9bf11a2..70de65a 100644
--- a/rtc_base/stream.h
+++ b/rtc_base/stream.h
@@ -115,50 +115,6 @@
   RTC_DISALLOW_COPY_AND_ASSIGN(StreamInterface);
 };
 
-///////////////////////////////////////////////////////////////////////////////
-// StreamAdapterInterface is a convenient base-class for adapting a stream.
-// By default, all operations are pass-through.  Override the methods that you
-// require adaptation.  Streams should really be upgraded to reference-counted.
-// In the meantime, use the owned flag to indicate whether the adapter should
-// own the adapted stream.
-///////////////////////////////////////////////////////////////////////////////
-
-class StreamAdapterInterface : public StreamInterface,
-                               public sigslot::has_slots<> {
- public:
-  explicit StreamAdapterInterface(StreamInterface* stream, bool owned = true);
-
-  // Core Stream Interface
-  StreamState GetState() const override;
-  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;
-
-  bool Flush() override;
-
-  void Attach(StreamInterface* stream, bool owned = true);
-  StreamInterface* Detach();
-
- protected:
-  ~StreamAdapterInterface() override;
-
-  // Note that the adapter presents itself as the origin of the stream events,
-  // since users of the adapter may not recognize the adapted object.
-  virtual void OnEvent(StreamInterface* stream, int events, int err);
-  StreamInterface* stream() { return stream_; }
-
- private:
-  StreamInterface* stream_;
-  bool owned_;
-  RTC_DISALLOW_COPY_AND_ASSIGN(StreamAdapterInterface);
-};
-
 }  // namespace rtc
 
 #endif  // RTC_BASE_STREAM_H_