diff --git a/rtc_base/ssl_stream_adapter_unittest.cc b/rtc_base/ssl_stream_adapter_unittest.cc
index 49cbbe0a02..f6a7e323de 100644
--- a/rtc_base/ssl_stream_adapter_unittest.cc
+++ b/rtc_base/ssl_stream_adapter_unittest.cc
@@ -583,10 +583,11 @@ class SSLStreamAdapterTestBase : public ::testing::Test,
     // SS_OPENING and writes should return SR_BLOCK.
     EXPECT_EQ(rtc::SS_OPENING, client_ssl_->GetState());
     EXPECT_EQ(rtc::SS_OPENING, server_ssl_->GetState());
-    unsigned char packet[1];
+    uint8_t packet[1];
     size_t sent;
-    EXPECT_EQ(rtc::SR_BLOCK, client_ssl_->Write(&packet, 1, &sent, 0));
-    EXPECT_EQ(rtc::SR_BLOCK, server_ssl_->Write(&packet, 1, &sent, 0));
+    int error;
+    EXPECT_EQ(rtc::SR_BLOCK, client_ssl_->Write(packet, sent, error));
+    EXPECT_EQ(rtc::SR_BLOCK, server_ssl_->Write(packet, sent, error));
 
     // Collect both of the certificate digests; needs to be done before calling
     // SetPeerCertificateDigest as that may reset the identity.
@@ -625,8 +626,10 @@ class SSLStreamAdapterTestBase : public ::testing::Test,
       EXPECT_EQ(rtc::SS_OPEN, client_ssl_->GetState());
       // If the client sends a packet while the server still hasn't verified the
       // client identity, the server should continue to return SR_BLOCK.
-      EXPECT_EQ(rtc::SR_SUCCESS, client_ssl_->Write(&packet, 1, &sent, 0));
-      EXPECT_EQ(rtc::SR_BLOCK, server_ssl_->Read(&packet, 1, 0, 0));
+      int error;
+      EXPECT_EQ(rtc::SR_SUCCESS, client_ssl_->Write(packet, sent, error));
+      size_t read;
+      EXPECT_EQ(rtc::SR_BLOCK, server_ssl_->Read(packet, read, error));
     } else {
       EXPECT_EQ(rtc::SS_CLOSED, client_ssl_->GetState());
     }
diff --git a/rtc_base/stream.h b/rtc_base/stream.h
index 7a9a588733..c57ee61fcc 100644
--- a/rtc_base/stream.h
+++ b/rtc_base/stream.h
@@ -13,6 +13,7 @@
 
 #include <memory>
 
+#include "api/array_view.h"
 #include "rtc_base/buffer.h"
 #include "rtc_base/system/rtc_export.h"
 #include "rtc_base/third_party/sigslot/sigslot.h"
@@ -72,10 +73,20 @@ class RTC_EXPORT StreamInterface {
                             size_t buffer_len,
                             size_t* read,
                             int* error) = 0;
+  virtual StreamResult Read(rtc::ArrayView<uint8_t> buffer,
+                            size_t& read,
+                            int& error) {
+    return Read(buffer.data(), buffer.size(), &read, &error);
+  }
   virtual StreamResult Write(const void* data,
                              size_t data_len,
                              size_t* written,
                              int* error) = 0;
+  virtual StreamResult Write(rtc::ArrayView<const uint8_t> data,
+                             size_t& written,
+                             int& error) {
+    return Write(data.data(), data.size(), &written, &error);
+  }
   // Attempt to transition to the SS_CLOSED state.  SE_CLOSE will not be
   // signalled as a result of this call.
   virtual void Close() = 0;
@@ -109,6 +120,10 @@ class RTC_EXPORT StreamInterface {
                         size_t* written,
                         int* error);
 
+  StreamResult WriteAll(ArrayView<uint8_t> data, size_t& written, int& error) {
+    return WriteAll(data.data(), data.size(), &written, &error);
+  }
+
  protected:
   StreamInterface();
 };