mollyim/webrtc
1
0
Fork 0
mirror of https://github.com/mollyim/webrtc.git synced 2025-05-12 21:30:45 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Convert ByteBufferWriter to be type uint8_t

Browse source 
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}
This commit is contained in:
Harald Alvestrand 2023-12-12 12:05:20 +00:00 committed by WebRTC LUCI CQ
parent c30fb63f95
commit f0ddae8c22
15 changed files with 107 additions and 73 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
api/transport/stun.cc
View file

@ -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;
}

3
p2p/base/p2p_transport_channel_unittest.cc
View file

@ -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,

87
p2p/base/port_unittest.cc
View file

@ -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);

3
p2p/base/pseudo_tcp.cc
View file

@ -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) {

3
p2p/base/stun_server_unittest.cc
View file

@ -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);

2
p2p/base/turn_port.cc
View file

@ -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 =

3
p2p/base/turn_server.cc
View file

@ -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())) {

4
p2p/stunprober/stun_prober.cc
View file

@ -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;

2
rtc_base/byte_buffer.cc
View file

@ -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) {

36
rtc_base/byte_buffer.h
View file

@ -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;

4
rtc_base/byte_buffer_unittest.cc
View file

@ -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);

6
rtc_base/network/received_packet.cc
View file

@ -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))

9
rtc_base/network/received_packet.h
View file

@ -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:

2
rtc_base/socket_adapters.cc
View file

@ -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());

2
video/rtp_video_stream_receiver2_unittest.cc
View file

@ -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_;
};