Convert ByteBufferWriter to be type uint8_t

and make follow-on changes.

Bug: webrtc:15665
Change-Id: Ice646f88ba5a09d6a8d9ce70415d8a14d7050d3c
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/329781
Commit-Queue: Harald Alvestrand <hta@webrtc.org>
Reviewed-by: Tomas Gunnarsson <tommi@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#41393}

15 files changed, 107 insertions, 73 deletions

diff --git a/api/transport/stun.cc b/api/transport/stun.cc
index 7ef6852260..97da5082e7 100644
--- a/api/transport/stun.cc
+++ b/api/transport/stun.cc
@@ -814,7 +814,7 @@ void StunAttribute::ConsumePadding(ByteBufferReader* buf) const {
 void StunAttribute::WritePadding(ByteBufferWriter* buf) const {
   int remainder = length_ % 4;
   if (remainder > 0) {
-    char zeroes[4] = {0};
+    uint8_t zeroes[4] = {0};
     buf->WriteBytes(zeroes, 4 - remainder);
   }
 }
@@ -949,12 +949,12 @@ bool StunAddressAttribute::Write(ByteBufferWriter* buf) const {
   switch (address_.family()) {
     case AF_INET: {
       in_addr v4addr = address_.ipaddr().ipv4_address();
-      buf->WriteBytes(reinterpret_cast<char*>(&v4addr), sizeof(v4addr));
+      buf->WriteBytes(reinterpret_cast<uint8_t*>(&v4addr), sizeof(v4addr));
       break;
     }
     case AF_INET6: {
       in6_addr v6addr = address_.ipaddr().ipv6_address();
-      buf->WriteBytes(reinterpret_cast<char*>(&v6addr), sizeof(v6addr));
+      buf->WriteBytes(reinterpret_cast<uint8_t*>(&v6addr), sizeof(v6addr));
       break;
     }
   }
@@ -1039,12 +1039,14 @@ bool StunXorAddressAttribute::Write(ByteBufferWriter* buf) const {
   switch (xored_ip.family()) {
     case AF_INET: {
       in_addr v4addr = xored_ip.ipv4_address();
-      buf->WriteBytes(reinterpret_cast<const char*>(&v4addr), sizeof(v4addr));
+      buf->WriteBytes(reinterpret_cast<const uint8_t*>(&v4addr),
+                      sizeof(v4addr));
       break;
     }
     case AF_INET6: {
       in6_addr v6addr = xored_ip.ipv6_address();
-      buf->WriteBytes(reinterpret_cast<const char*>(&v6addr), sizeof(v6addr));
+      buf->WriteBytes(reinterpret_cast<const uint8_t*>(&v6addr),
+                      sizeof(v6addr));
       break;
     }
   }
@@ -1170,7 +1172,7 @@ bool StunByteStringAttribute::Write(ByteBufferWriter* buf) const {
   if (!LengthValid(type(), length())) {
     return false;
   }
-  buf->WriteBytes(reinterpret_cast<const char*>(bytes_), length());
+  buf->WriteBytes(bytes_, length());
   WritePadding(buf);
   return true;
 }
diff --git a/p2p/base/p2p_transport_channel_unittest.cc b/p2p/base/p2p_transport_channel_unittest.cc
index 44b1bfc5e3..f4e66ff9ef 100644
--- a/p2p/base/p2p_transport_channel_unittest.cc
+++ b/p2p/base/p2p_transport_channel_unittest.cc
@@ -3601,7 +3601,8 @@ class P2PTransportChannelPingTest : public ::testing::Test,
     rtc::ByteBufferWriter buf;
     msg.Write(&buf);
     conn->OnReadPacket(rtc::ReceivedPacket::CreateFromLegacy(
-        buf.Data(), buf.Length(), rtc::TimeMicros()));
+        reinterpret_cast<const char*>(buf.Data()), buf.Length(),
+        rtc::TimeMicros()));
   }
 
   void ReceivePingOnConnection(Connection* conn,
diff --git a/p2p/base/port_unittest.cc b/p2p/base/port_unittest.cc
index f5f3ee07dc..de35d94259 100644
--- a/p2p/base/port_unittest.cc
+++ b/p2p/base/port_unittest.cc
@@ -257,6 +257,15 @@ class TestPort : public Port {
   int type_preference_ = 0;
 };
 
+bool GetStunMessageFromBufferWriter(TestPort* port,
+                                    ByteBufferWriter* buf,
+                                    const rtc::SocketAddress& addr,
+                                    std::unique_ptr<IceMessage>* out_msg,
+                                    std::string* out_username) {
+  return port->GetStunMessage(reinterpret_cast<const char*>(buf->Data()),
+                              buf->Length(), addr, out_msg, out_username);
+}
+
 static void SendPingAndReceiveResponse(Connection* lconn,
                                        TestPort* lport,
                                        Connection* rconn,
@@ -1529,7 +1538,8 @@ TEST_F(PortTest, TestLoopbackCall) {
   auto buf = std::make_unique<ByteBufferWriter>();
   WriteStunMessage(*modified_req, buf.get());
   conn1->OnReadPacket(rtc::ReceivedPacket::CreateFromLegacy(
-      buf->Data(), buf->Length(), /*packet_time_us=*/-1));
+      reinterpret_cast<const char*>(buf->Data()), buf->Length(),
+      /*packet_time_us=*/-1));
   ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, kDefaultTimeout);
   msg = lport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_ERROR_RESPONSE, msg->type());
@@ -2247,8 +2257,8 @@ TEST_F(PortTest, TestHandleStunMessage) {
   in_msg->AddMessageIntegrity("rpass");
   in_msg->AddFingerprint();
   WriteStunMessage(*in_msg, buf.get());
-  EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg,
-                                   &username));
+  EXPECT_TRUE(GetStunMessageFromBufferWriter(port.get(), buf.get(), addr,
+                                             &out_msg, &username));
   EXPECT_TRUE(out_msg.get() != NULL);
   EXPECT_EQ("lfrag", username);
 
@@ -2259,8 +2269,8 @@ TEST_F(PortTest, TestHandleStunMessage) {
   in_msg->AddMessageIntegrity("rpass");
   in_msg->AddFingerprint();
   WriteStunMessage(*in_msg, buf.get());
-  EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg,
-                                   &username));
+  EXPECT_TRUE(GetStunMessageFromBufferWriter(port.get(), buf.get(), addr,
+                                             &out_msg, &username));
   EXPECT_TRUE(out_msg.get() != NULL);
   EXPECT_EQ("", username);
 
@@ -2271,8 +2281,8 @@ TEST_F(PortTest, TestHandleStunMessage) {
       STUN_ERROR_REASON_SERVER_ERROR));
   in_msg->AddFingerprint();
   WriteStunMessage(*in_msg, buf.get());
-  EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg,
-                                   &username));
+  EXPECT_TRUE(GetStunMessageFromBufferWriter(port.get(), buf.get(), addr,
+                                             &out_msg, &username));
   EXPECT_TRUE(out_msg.get() != NULL);
   EXPECT_EQ("", username);
   ASSERT_TRUE(out_msg->GetErrorCode() != NULL);
@@ -2295,8 +2305,8 @@ TEST_F(PortTest, TestHandleStunMessageBadUsername) {
   in_msg->AddMessageIntegrity("rpass");
   in_msg->AddFingerprint();
   WriteStunMessage(*in_msg, buf.get());
-  EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg,
-                                   &username));
+  EXPECT_TRUE(GetStunMessageFromBufferWriter(port.get(), buf.get(), addr,
+                                             &out_msg, &username));
   EXPECT_TRUE(out_msg.get() == NULL);
   EXPECT_EQ("", username);
   EXPECT_EQ(STUN_ERROR_BAD_REQUEST, port->last_stun_error_code());
@@ -2306,8 +2316,8 @@ TEST_F(PortTest, TestHandleStunMessageBadUsername) {
   in_msg->AddMessageIntegrity("rpass");
   in_msg->AddFingerprint();
   WriteStunMessage(*in_msg, buf.get());
-  EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg,
-                                   &username));
+  EXPECT_TRUE(GetStunMessageFromBufferWriter(port.get(), buf.get(), addr,
+                                             &out_msg, &username));
   EXPECT_TRUE(out_msg.get() == NULL);
   EXPECT_EQ("", username);
   EXPECT_EQ(STUN_ERROR_UNAUTHORIZED, port->last_stun_error_code());
@@ -2317,8 +2327,8 @@ TEST_F(PortTest, TestHandleStunMessageBadUsername) {
   in_msg->AddMessageIntegrity("rpass");
   in_msg->AddFingerprint();
   WriteStunMessage(*in_msg, buf.get());
-  EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg,
-                                   &username));
+  EXPECT_TRUE(GetStunMessageFromBufferWriter(port.get(), buf.get(), addr,
+                                             &out_msg, &username));
   EXPECT_TRUE(out_msg.get() == NULL);
   EXPECT_EQ("", username);
   EXPECT_EQ(STUN_ERROR_UNAUTHORIZED, port->last_stun_error_code());
@@ -2328,8 +2338,8 @@ TEST_F(PortTest, TestHandleStunMessageBadUsername) {
   in_msg->AddMessageIntegrity("rpass");
   in_msg->AddFingerprint();
   WriteStunMessage(*in_msg, buf.get());
-  EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg,
-                                   &username));
+  EXPECT_TRUE(GetStunMessageFromBufferWriter(port.get(), buf.get(), addr,
+                                             &out_msg, &username));
   EXPECT_TRUE(out_msg.get() == NULL);
   EXPECT_EQ("", username);
   EXPECT_EQ(STUN_ERROR_UNAUTHORIZED, port->last_stun_error_code());
@@ -2339,8 +2349,8 @@ TEST_F(PortTest, TestHandleStunMessageBadUsername) {
   in_msg->AddMessageIntegrity("rpass");
   in_msg->AddFingerprint();
   WriteStunMessage(*in_msg, buf.get());
-  EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg,
-                                   &username));
+  EXPECT_TRUE(GetStunMessageFromBufferWriter(port.get(), buf.get(), addr,
+                                             &out_msg, &username));
   EXPECT_TRUE(out_msg.get() == NULL);
   EXPECT_EQ("", username);
   EXPECT_EQ(STUN_ERROR_UNAUTHORIZED, port->last_stun_error_code());
@@ -2361,8 +2371,8 @@ TEST_F(PortTest, TestHandleStunMessageBadMessageIntegrity) {
   in_msg = CreateStunMessageWithUsername(STUN_BINDING_REQUEST, "rfrag:lfrag");
   in_msg->AddFingerprint();
   WriteStunMessage(*in_msg, buf.get());
-  EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg,
-                                   &username));
+  EXPECT_TRUE(GetStunMessageFromBufferWriter(port.get(), buf.get(), addr,
+                                             &out_msg, &username));
   EXPECT_TRUE(out_msg.get() == NULL);
   EXPECT_EQ("", username);
   EXPECT_EQ(STUN_ERROR_BAD_REQUEST, port->last_stun_error_code());
@@ -2373,8 +2383,8 @@ TEST_F(PortTest, TestHandleStunMessageBadMessageIntegrity) {
   in_msg->AddMessageIntegrity("invalid");
   in_msg->AddFingerprint();
   WriteStunMessage(*in_msg, buf.get());
-  EXPECT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg,
-                                   &username));
+  EXPECT_TRUE(GetStunMessageFromBufferWriter(port.get(), buf.get(), addr,
+                                             &out_msg, &username));
   EXPECT_TRUE(out_msg.get() == NULL);
   EXPECT_EQ("", username);
   EXPECT_EQ(STUN_ERROR_UNAUTHORIZED, port->last_stun_error_code());
@@ -2399,16 +2409,16 @@ TEST_F(PortTest, TestHandleStunMessageBadFingerprint) {
   in_msg = CreateStunMessageWithUsername(STUN_BINDING_REQUEST, "rfrag:lfrag");
   in_msg->AddMessageIntegrity("rpass");
   WriteStunMessage(*in_msg, buf.get());
-  EXPECT_FALSE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg,
-                                    &username));
+  EXPECT_FALSE(GetStunMessageFromBufferWriter(port.get(), buf.get(), addr,
+                                              &out_msg, &username));
   EXPECT_EQ(0, port->last_stun_error_code());
 
   // Now, add a fingerprint, but munge the message so it's not valid.
   in_msg->AddFingerprint();
   in_msg->SetTransactionIdForTesting("TESTTESTBADD");
   WriteStunMessage(*in_msg, buf.get());
-  EXPECT_FALSE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg,
-                                    &username));
+  EXPECT_FALSE(GetStunMessageFromBufferWriter(port.get(), buf.get(), addr,
+                                              &out_msg, &username));
   EXPECT_EQ(0, port->last_stun_error_code());
 
   // Valid BINDING-RESPONSE, except no FINGERPRINT.
@@ -2417,16 +2427,16 @@ TEST_F(PortTest, TestHandleStunMessageBadFingerprint) {
       STUN_ATTR_XOR_MAPPED_ADDRESS, kLocalAddr2));
   in_msg->AddMessageIntegrity("rpass");
   WriteStunMessage(*in_msg, buf.get());
-  EXPECT_FALSE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg,
-                                    &username));
+  EXPECT_FALSE(GetStunMessageFromBufferWriter(port.get(), buf.get(), addr,
+                                              &out_msg, &username));
   EXPECT_EQ(0, port->last_stun_error_code());
 
   // Now, add a fingerprint, but munge the message so it's not valid.
   in_msg->AddFingerprint();
   in_msg->SetTransactionIdForTesting("TESTTESTBADD");
   WriteStunMessage(*in_msg, buf.get());
-  EXPECT_FALSE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg,
-                                    &username));
+  EXPECT_FALSE(GetStunMessageFromBufferWriter(port.get(), buf.get(), addr,
+                                              &out_msg, &username));
   EXPECT_EQ(0, port->last_stun_error_code());
 
   // Valid BINDING-ERROR-RESPONSE, except no FINGERPRINT.
@@ -2436,16 +2446,16 @@ TEST_F(PortTest, TestHandleStunMessageBadFingerprint) {
       STUN_ERROR_REASON_SERVER_ERROR));
   in_msg->AddMessageIntegrity("rpass");
   WriteStunMessage(*in_msg, buf.get());
-  EXPECT_FALSE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg,
-                                    &username));
+  EXPECT_FALSE(GetStunMessageFromBufferWriter(port.get(), buf.get(), addr,
+                                              &out_msg, &username));
   EXPECT_EQ(0, port->last_stun_error_code());
 
   // Now, add a fingerprint, but munge the message so it's not valid.
   in_msg->AddFingerprint();
   in_msg->SetTransactionIdForTesting("TESTTESTBADD");
   WriteStunMessage(*in_msg, buf.get());
-  EXPECT_FALSE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg,
-                                    &username));
+  EXPECT_FALSE(GetStunMessageFromBufferWriter(port.get(), buf.get(), addr,
+                                              &out_msg, &username));
   EXPECT_EQ(0, port->last_stun_error_code());
 }
 
@@ -2472,8 +2482,8 @@ TEST_F(PortTest,
   in_msg->AddAttribute(StunAttribute::CreateUInt32(0xdead));
   in_msg->AddFingerprint();
   WriteStunMessage(*in_msg, buf.get());
-  ASSERT_TRUE(port->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg,
-                                   &username));
+  ASSERT_TRUE(GetStunMessageFromBufferWriter(port.get(), buf.get(), addr,
+                                             &out_msg, &username));
   IceMessage* error_response = port->last_stun_msg();
   ASSERT_NE(nullptr, error_response);
 
@@ -2522,7 +2532,8 @@ TEST_F(PortTest,
   ByteBufferWriter buf;
   WriteStunMessage(*modified_response, &buf);
   lconn->OnReadPacket(rtc::ReceivedPacket::CreateFromLegacy(
-      buf.Data(), buf.Length(), /*packet_time_us=*/-1));
+      reinterpret_cast<const char*>(buf.Data()), buf.Length(),
+      /*packet_time_us=*/-1));
   // Response should have been ignored, leaving us unwritable still.
   EXPECT_FALSE(lconn->writable());
 }
@@ -2570,8 +2581,8 @@ TEST_F(PortTest, TestHandleStunBindingIndication) {
   in_msg = CreateStunMessage(STUN_BINDING_INDICATION);
   in_msg->AddFingerprint();
   WriteStunMessage(*in_msg, buf.get());
-  EXPECT_TRUE(lport->GetStunMessage(buf->Data(), buf->Length(), addr, &out_msg,
-                                    &username));
+  EXPECT_TRUE(GetStunMessageFromBufferWriter(lport.get(), buf.get(), addr,
+                                             &out_msg, &username));
   EXPECT_TRUE(out_msg.get() != NULL);
   EXPECT_EQ(out_msg->type(), STUN_BINDING_INDICATION);
   EXPECT_EQ("", username);
diff --git a/p2p/base/pseudo_tcp.cc b/p2p/base/pseudo_tcp.cc
index 5a5ce0392b..9dec580b77 100644
--- a/p2p/base/pseudo_tcp.cc
+++ b/p2p/base/pseudo_tcp.cc
@@ -1183,7 +1183,8 @@ void PseudoTcp::queueConnectMessage() {
     buf.WriteUInt8(m_rwnd_scale);
   }
   m_snd_wnd = static_cast<uint32_t>(buf.Length());
-  queue(buf.Data(), static_cast<uint32_t>(buf.Length()), true);
+  queue(reinterpret_cast<const char*>(buf.Data()),
+        static_cast<uint32_t>(buf.Length()), true);
 }
 
 void PseudoTcp::parseOptions(const char* data, uint32_t len) {
diff --git a/p2p/base/stun_server_unittest.cc b/p2p/base/stun_server_unittest.cc
index e4ea30cba4..a2ac300b80 100644
--- a/p2p/base/stun_server_unittest.cc
+++ b/p2p/base/stun_server_unittest.cc
@@ -44,7 +44,8 @@ class StunServerTest : public ::testing::Test {
   void Send(const StunMessage& msg) {
     rtc::ByteBufferWriter buf;
     msg.Write(&buf);
-    Send(buf.Data(), static_cast<int>(buf.Length()));
+    Send(reinterpret_cast<const char*>(buf.Data()),
+         static_cast<int>(buf.Length()));
   }
   void Send(const char* buf, int len) {
     client_->SendTo(buf, len, server_addr);
diff --git a/p2p/base/turn_port.cc b/p2p/base/turn_port.cc
index e6f5e77114..f5d8e3d805 100644
--- a/p2p/base/turn_port.cc
+++ b/p2p/base/turn_port.cc
@@ -1802,7 +1802,7 @@ int TurnEntry::Send(const void* data,
     // If the channel is bound, we can send the data as a Channel Message.
     buf.WriteUInt16(channel_id_);
     buf.WriteUInt16(static_cast<uint16_t>(size));
-    buf.WriteBytes(reinterpret_cast<const char*>(data), size);
+    buf.WriteBytes(reinterpret_cast<const uint8_t*>(data), size);
   }
   rtc::PacketOptions modified_options(options);
   modified_options.info_signaled_after_sent.turn_overhead_bytes =
diff --git a/p2p/base/turn_server.cc b/p2p/base/turn_server.cc
index 3d633110a7..4e039dec24 100644
--- a/p2p/base/turn_server.cc
+++ b/p2p/base/turn_server.cc
@@ -784,8 +784,7 @@ void TurnServerAllocation::OnExternalPacket(rtc::AsyncPacketSocket* socket,
     rtc::ByteBufferWriter buf;
     buf.WriteUInt16(channel->id);
     buf.WriteUInt16(static_cast<uint16_t>(packet.payload().size()));
-    buf.WriteBytes(reinterpret_cast<const char*>(packet.payload().data()),
-                   packet.payload().size());
+    buf.WriteBytes(packet.payload().data(), packet.payload().size());
     server_->Send(&conn_, buf);
   } else if (!server_->enable_permission_checks_ ||
              HasPermission(packet.source_address().ipaddr())) {
diff --git a/p2p/stunprober/stun_prober.cc b/p2p/stunprober/stun_prober.cc
index c60e7ede89..d130d780dc 100644
--- a/p2p/stunprober/stun_prober.cc
+++ b/p2p/stunprober/stun_prober.cc
@@ -156,8 +156,8 @@ void StunProber::Requester::SendStunRequest() {
   // request timing could become too complicated. Callback is ignored by passing
   // empty AsyncCallback.
   rtc::PacketOptions options;
-  int rv = socket_->SendTo(const_cast<char*>(request_packet->Data()),
-                           request_packet->Length(), addr, options);
+  int rv = socket_->SendTo(request_packet->Data(), request_packet->Length(),
+                           addr, options);
   if (rv < 0) {
     prober_->ReportOnFinished(WRITE_FAILED);
     return;
diff --git a/rtc_base/byte_buffer.cc b/rtc_base/byte_buffer.cc
index 7438ef3058..8c3595617c 100644
--- a/rtc_base/byte_buffer.cc
+++ b/rtc_base/byte_buffer.cc
@@ -16,7 +16,7 @@ namespace rtc {
 
 ByteBufferWriter::ByteBufferWriter() : ByteBufferWriterT() {}
 
-ByteBufferWriter::ByteBufferWriter(const char* bytes, size_t len)
+ByteBufferWriter::ByteBufferWriter(const uint8_t* bytes, size_t len)
     : ByteBufferWriterT(bytes, len) {}
 
 ByteBufferReader::ByteBufferReader(rtc::ArrayView<const uint8_t> bytes) {
diff --git a/rtc_base/byte_buffer.h b/rtc_base/byte_buffer.h
index 43851f2116..9e169f221b 100644
--- a/rtc_base/byte_buffer.h
+++ b/rtc_base/byte_buffer.h
@@ -58,25 +58,25 @@ class ByteBufferWriterT {
   // Write value to the buffer. Resizes the buffer when it is
   // neccessary.
   void WriteUInt8(uint8_t val) {
-    WriteBytes(reinterpret_cast<const value_type*>(&val), 1);
+    WriteBytesInternal(reinterpret_cast<const value_type*>(&val), 1);
   }
   void WriteUInt16(uint16_t val) {
     uint16_t v = HostToNetwork16(val);
-    WriteBytes(reinterpret_cast<const value_type*>(&v), 2);
+    WriteBytesInternal(reinterpret_cast<const value_type*>(&v), 2);
   }
   void WriteUInt24(uint32_t val) {
     uint32_t v = HostToNetwork32(val);
     value_type* start = reinterpret_cast<value_type*>(&v);
     ++start;
-    WriteBytes(start, 3);
+    WriteBytesInternal(start, 3);
   }
   void WriteUInt32(uint32_t val) {
     uint32_t v = HostToNetwork32(val);
-    WriteBytes(reinterpret_cast<const value_type*>(&v), 4);
+    WriteBytesInternal(reinterpret_cast<const value_type*>(&v), 4);
   }
   void WriteUInt64(uint64_t val) {
     uint64_t v = HostToNetwork64(val);
-    WriteBytes(reinterpret_cast<const value_type*>(&v), 8);
+    WriteBytesInternal(reinterpret_cast<const value_type*>(&v), 8);
   }
   // Serializes an unsigned varint in the format described by
   // https://developers.google.com/protocol-buffers/docs/encoding#varints
@@ -86,17 +86,25 @@ class ByteBufferWriterT {
       // Write 7 bits at a time, then set the msb to a continuation byte
       // (msb=1).
       value_type byte = static_cast<value_type>(val) | 0x80;
-      WriteBytes(&byte, 1);
+      WriteBytesInternal(&byte, 1);
       val >>= 7;
     }
     value_type last_byte = static_cast<value_type>(val);
-    WriteBytes(&last_byte, 1);
+    WriteBytesInternal(&last_byte, 1);
   }
   void WriteString(absl::string_view val) {
-    WriteBytes(reinterpret_cast<const value_type*>(val.data()), val.size());
+    WriteBytesInternal(reinterpret_cast<const value_type*>(val.data()),
+                       val.size());
   }
-  void WriteBytes(const value_type* val, size_t len) {
-    buffer_.AppendData(val, len);
+  // Write an array of bytes (uint8_t)
+  void WriteBytes(const uint8_t* val, size_t len) {
+    WriteBytesInternal(reinterpret_cast<const value_type*>(val), len);
+  }
+  // For backwards compatibility: Write an array of char
+  // TODO(bugs.webrtc.org/15665): Remove when users converted
+  [[deprecated("Use WriteString")]] void WriteBytes(const char* val,
+                                                    size_t len) {
+    WriteBytesInternal(reinterpret_cast<const value_type*>(val), len);
   }
 
   // Reserves the given number of bytes and returns a value_type* that can be
@@ -124,16 +132,20 @@ class ByteBufferWriterT {
     }
   }
 
+  void WriteBytesInternal(const value_type* val, size_t len) {
+    buffer_.AppendData(val, len);
+  }
+
   BufferClassT buffer_;
 
   // There are sensible ways to define these, but they aren't needed in our code
   // base.
 };
 
-class ByteBufferWriter : public ByteBufferWriterT<BufferT<char>> {
+class ByteBufferWriter : public ByteBufferWriterT<BufferT<uint8_t>> {
  public:
   ByteBufferWriter();
-  ByteBufferWriter(const char* bytes, size_t len);
+  ByteBufferWriter(const uint8_t* bytes, size_t len);
 
   ByteBufferWriter(const ByteBufferWriter&) = delete;
   ByteBufferWriter& operator=(const ByteBufferWriter&) = delete;
diff --git a/rtc_base/byte_buffer_unittest.cc b/rtc_base/byte_buffer_unittest.cc
index 7d38d809f4..49e2e569f5 100644
--- a/rtc_base/byte_buffer_unittest.cc
+++ b/rtc_base/byte_buffer_unittest.cc
@@ -166,7 +166,7 @@ TEST(ByteBufferTest, TestReadWriteBuffer) {
   buffer.Clear();
 
   // Write and read bytes
-  char write_bytes[] = "foo";
+  uint8_t write_bytes[] = "foo";
   buffer.WriteBytes(write_bytes, 3);
   ByteBufferReader read_buf7(buffer);
   uint8_t read_bytes[3];
@@ -178,7 +178,7 @@ TEST(ByteBufferTest, TestReadWriteBuffer) {
   buffer.Clear();
 
   // Write and read reserved buffer space
-  char* write_dst = buffer.ReserveWriteBuffer(3);
+  uint8_t* write_dst = buffer.ReserveWriteBuffer(3);
   memcpy(write_dst, write_bytes, 3);
   ByteBufferReader read_buf8(buffer);
   memset(read_bytes, 0, 3);
diff --git a/rtc_base/network/received_packet.cc b/rtc_base/network/received_packet.cc
index 40d6e1142c..95f5e22d3b 100644
--- a/rtc_base/network/received_packet.cc
+++ b/rtc_base/network/received_packet.cc
@@ -25,14 +25,12 @@ ReceivedPacket::ReceivedPacket(rtc::ArrayView<const uint8_t> payload,
 
 // static
 ReceivedPacket ReceivedPacket::CreateFromLegacy(
-    const char* data,
+    const uint8_t* data,
     size_t size,
     int64_t packet_time_us,
     const rtc::SocketAddress& source_address) {
   RTC_DCHECK(packet_time_us == -1 || packet_time_us >= 0);
-  return ReceivedPacket(rtc::reinterpret_array_view<const uint8_t>(
-                            rtc::MakeArrayView(data, size)),
-                        source_address,
+  return ReceivedPacket(rtc::MakeArrayView(data, size), source_address,
                         (packet_time_us >= 0)
                             ? absl::optional<webrtc::Timestamp>(
                                   webrtc::Timestamp::Micros(packet_time_us))
diff --git a/rtc_base/network/received_packet.h b/rtc_base/network/received_packet.h
index e33361ca29..d898ccb2e9 100644
--- a/rtc_base/network/received_packet.h
+++ b/rtc_base/network/received_packet.h
@@ -47,6 +47,15 @@ class RTC_EXPORT ReceivedPacket {
       const char* data,
       size_t size,
       int64_t packet_time_us,
+      const rtc::SocketAddress& addr = rtc::SocketAddress()) {
+    return CreateFromLegacy(reinterpret_cast<const uint8_t*>(data), size,
+                            packet_time_us, addr);
+  }
+
+  static ReceivedPacket CreateFromLegacy(
+      const uint8_t* data,
+      size_t size,
+      int64_t packet_time_us,
       const rtc::SocketAddress& = rtc::SocketAddress());
 
  private:
diff --git a/rtc_base/socket_adapters.cc b/rtc_base/socket_adapters.cc
index f628929a46..a1eee5bd67 100644
--- a/rtc_base/socket_adapters.cc
+++ b/rtc_base/socket_adapters.cc
@@ -629,7 +629,7 @@ void AsyncSocksProxySocket::SendAuth() {
   size_t len = pass_.GetLength() + 1;
   char* sensitive = new char[len];
   pass_.CopyTo(sensitive, true);
-  request.WriteBytes(sensitive, pass_.GetLength());  // Password
+  request.WriteString(std::string(sensitive, pass_.GetLength()));  // Password
   ExplicitZeroMemory(sensitive, len);
   delete[] sensitive;
   DirectSend(request.Data(), request.Length());
diff --git a/video/rtp_video_stream_receiver2_unittest.cc b/video/rtp_video_stream_receiver2_unittest.cc
index d82f7bb9a5..bcc23e85d4 100644
--- a/video/rtp_video_stream_receiver2_unittest.cc
+++ b/video/rtp_video_stream_receiver2_unittest.cc
@@ -118,7 +118,7 @@ class MockOnCompleteFrameCallback
 
   void AppendExpectedBitstream(const uint8_t data[], size_t size_in_bytes) {
     // TODO(Johan): Let rtc::ByteBuffer handle uint8_t* instead of char*.
-    buffer_.WriteBytes(reinterpret_cast<const char*>(data), size_in_bytes);
+    buffer_.WriteBytes(data, size_in_bytes);
   }
   rtc::ByteBufferWriter buffer_;
 };