diff --git a/rtc_base/test_utils.h b/rtc_base/test_utils.h
index 4746e962ae..7068e73881 100644
--- a/rtc_base/test_utils.h
+++ b/rtc_base/test_utils.h
@@ -17,25 +17,23 @@
 #include <utility>
 
 #include "rtc_base/async_socket.h"
-#include "rtc_base/stream.h"
 #include "rtc_base/third_party/sigslot/sigslot.h"
 
 namespace webrtc {
 namespace testing {
 
 ///////////////////////////////////////////////////////////////////////////////
-// StreamSink - Monitor asynchronously signalled events from StreamInterface
-// or AsyncSocket (which should probably be a StreamInterface.
+// StreamSink - Monitor asynchronously signalled events from AsyncSocket.
 ///////////////////////////////////////////////////////////////////////////////
 
-// Note: Any event that is an error is treaded as SSE_ERROR instead of that
+// Note: Any event that is an error is treated as SSE_ERROR instead of that
 // event.
 
 enum StreamSinkEvent {
-  SSE_OPEN = rtc::SE_OPEN,
-  SSE_READ = rtc::SE_READ,
-  SSE_WRITE = rtc::SE_WRITE,
-  SSE_CLOSE = rtc::SE_CLOSE,
+  SSE_OPEN = 1,
+  SSE_READ = 2,
+  SSE_WRITE = 4,
+  SSE_CLOSE = 8,
   SSE_ERROR = 16
 };
 
@@ -44,24 +42,6 @@ class StreamSink : public sigslot::has_slots<> {
   StreamSink();
   ~StreamSink() override;
 
-  void Monitor(rtc::StreamInterface* stream) {
-    stream->SignalEvent.connect(this, &StreamSink::OnEvent);
-    events_.erase(stream);
-  }
-  void Unmonitor(rtc::StreamInterface* stream) {
-    stream->SignalEvent.disconnect(this);
-    // In case you forgot to unmonitor a previous object with this address
-    events_.erase(stream);
-  }
-  bool Check(rtc::StreamInterface* stream,
-             StreamSinkEvent event,
-             bool reset = true) {
-    return DoCheck(stream, event, reset);
-  }
-  int Events(rtc::StreamInterface* stream, bool reset = true) {
-    return DoEvents(stream, reset);
-  }
-
   void Monitor(rtc::AsyncSocket* socket) {
     socket->SignalConnectEvent.connect(this, &StreamSink::OnConnectEvent);
     socket->SignalReadEvent.connect(this, &StreamSink::OnReadEvent);
@@ -82,19 +62,10 @@ class StreamSink : public sigslot::has_slots<> {
              bool reset = true) {
     return DoCheck(socket, event, reset);
   }
-  int Events(rtc::AsyncSocket* socket, bool reset = true) {
-    return DoEvents(socket, reset);
-  }
 
  private:
-  typedef std::map<void*, int> EventMap;
+  typedef std::map<rtc::AsyncSocket*, int> EventMap;
 
-  void OnEvent(rtc::StreamInterface* stream, int events, int error) {
-    if (error) {
-      events = SSE_ERROR;
-    }
-    AddEvents(stream, events);
-  }
   void OnConnectEvent(rtc::AsyncSocket* socket) { AddEvents(socket, SSE_OPEN); }
   void OnReadEvent(rtc::AsyncSocket* socket) { AddEvents(socket, SSE_READ); }
   void OnWriteEvent(rtc::AsyncSocket* socket) { AddEvents(socket, SSE_WRITE); }
@@ -102,7 +73,7 @@ class StreamSink : public sigslot::has_slots<> {
     AddEvents(socket, (0 == error) ? SSE_CLOSE : SSE_ERROR);
   }
 
-  void AddEvents(void* obj, int events) {
+  void AddEvents(rtc::AsyncSocket* obj, int events) {
     EventMap::iterator it = events_.find(obj);
     if (events_.end() == it) {
       events_.insert(EventMap::value_type(obj, events));
@@ -110,7 +81,7 @@ class StreamSink : public sigslot::has_slots<> {
       it->second |= events;
     }
   }
-  bool DoCheck(void* obj, StreamSinkEvent event, bool reset) {
+  bool DoCheck(rtc::AsyncSocket* obj, StreamSinkEvent event, bool reset) {
     EventMap::iterator it = events_.find(obj);
     if ((events_.end() == it) || (0 == (it->second & event))) {
       return false;
@@ -120,16 +91,6 @@ class StreamSink : public sigslot::has_slots<> {
     }
     return true;
   }
-  int DoEvents(void* obj, bool reset) {
-    EventMap::iterator it = events_.find(obj);
-    if (events_.end() == it)
-      return 0;
-    int events = it->second;
-    if (reset) {
-      it->second = 0;
-    }
-    return events;
-  }
 
   EventMap events_;
 };