diff --git a/media/base/fake_network_interface.h b/media/base/fake_network_interface.h index 3df83edce0..02d53f6781 100644 --- a/media/base/fake_network_interface.h +++ b/media/base/fake_network_interface.h @@ -129,7 +129,8 @@ class FakeNetworkInterface : public MediaChannel::NetworkInterface, rtp_packets_.push_back(*packet); if (conf_) { for (size_t i = 0; i < conf_sent_ssrcs_.size(); ++i) { - if (!SetRtpSsrc(packet->data(), packet->size(), conf_sent_ssrcs_[i])) { + if (!SetRtpSsrc(packet->MutableData(), packet->size(), + conf_sent_ssrcs_[i])) { return false; } PostMessage(ST_RTP, *packet); diff --git a/media/base/rtp_data_engine.cc b/media/base/rtp_data_engine.cc index f05dffabfb..5fbb25f533 100644 --- a/media/base/rtp_data_engine.cc +++ b/media/base/rtp_data_engine.cc @@ -312,7 +312,7 @@ bool RtpDataMediaChannel::SendData(const SendDataParams& params, &header.timestamp); rtc::CopyOnWriteBuffer packet(kMinRtpPacketLen, packet_len); - if (!SetRtpHeader(packet.data(), packet.size(), header)) { + if (!SetRtpHeader(packet.MutableData(), packet.size(), header)) { return false; } packet.AppendData(kReservedSpace); diff --git a/media/engine/webrtc_video_engine_unittest.cc b/media/engine/webrtc_video_engine_unittest.cc index 9be59ebd1a..72fbc56885 100644 --- a/media/engine/webrtc_video_engine_unittest.cc +++ b/media/engine/webrtc_video_engine_unittest.cc @@ -2050,7 +2050,7 @@ TEST_F(WebRtcVideoChannelBaseTest, SetSink) { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; rtc::CopyOnWriteBuffer packet1(data1, sizeof(data1)); - rtc::SetBE32(packet1.data() + 8, kSsrc); + rtc::SetBE32(packet1.MutableData() + 8, kSsrc); channel_->SetDefaultSink(NULL); EXPECT_TRUE(SetDefaultCodec()); EXPECT_TRUE(SetSend(true)); diff --git a/media/sctp/sctp_transport.cc b/media/sctp/sctp_transport.cc index eb10ad20dc..6bb4a8fdf2 100644 --- a/media/sctp/sctp_transport.cc +++ b/media/sctp/sctp_transport.cc @@ -1136,14 +1136,14 @@ void SctpTransport::OnPacketFromSctpToNetwork( } int SctpTransport::InjectDataOrNotificationFromSctpForTesting( - void* data, + const void* data, size_t length, struct sctp_rcvinfo rcv, int flags) { return OnDataOrNotificationFromSctp(data, length, rcv, flags); } -int SctpTransport::OnDataOrNotificationFromSctp(void* data, +int SctpTransport::OnDataOrNotificationFromSctp(const void* data, size_t length, struct sctp_rcvinfo rcv, int flags) { @@ -1166,7 +1166,7 @@ int SctpTransport::OnDataOrNotificationFromSctp(void* data, << " length=" << length; // Copy and dispatch asynchronously - rtc::CopyOnWriteBuffer notification(reinterpret_cast(data), + rtc::CopyOnWriteBuffer notification(reinterpret_cast(data), length); network_thread_->PostTask(ToQueuedTask( task_safety_, [this, notification = std::move(notification)]() { @@ -1216,7 +1216,7 @@ int SctpTransport::OnDataOrNotificationFromSctp(void* data, params.timestamp = 0; // Append the chunk's data to the message buffer - partial_incoming_message_.AppendData(reinterpret_cast(data), + partial_incoming_message_.AppendData(reinterpret_cast(data), length); partial_params_ = params; partial_flags_ = flags; diff --git a/media/sctp/sctp_transport.h b/media/sctp/sctp_transport.h index 44a895512e..38a89fcb61 100644 --- a/media/sctp/sctp_transport.h +++ b/media/sctp/sctp_transport.h @@ -96,7 +96,7 @@ class SctpTransport : public SctpTransportInternal, void set_debug_name_for_testing(const char* debug_name) override { debug_name_ = debug_name; } - int InjectDataOrNotificationFromSctpForTesting(void* data, + int InjectDataOrNotificationFromSctpForTesting(const void* data, size_t length, struct sctp_rcvinfo rcv, int flags); @@ -182,7 +182,7 @@ class SctpTransport : public SctpTransportInternal, // Called on the SCTP thread. // Flags are standard socket API flags (RFC 6458). - int OnDataOrNotificationFromSctp(void* data, + int OnDataOrNotificationFromSctp(const void* data, size_t length, struct sctp_rcvinfo rcv, int flags); diff --git a/media/sctp/sctp_transport_unittest.cc b/media/sctp/sctp_transport_unittest.cc index 46fbbc8f13..98a91225b2 100644 --- a/media/sctp/sctp_transport_unittest.cc +++ b/media/sctp/sctp_transport_unittest.cc @@ -589,7 +589,7 @@ TEST_P(SctpTransportTestWithOrdered, SignalReadyToSendDataAfterBlocked) { params.sid = 1; params.ordered = GetParam(); rtc::CopyOnWriteBuffer buf(1024); - memset(buf.data(), 0, 1024); + memset(buf.MutableData(), 0, 1024); SendDataResult result; size_t message_count = 0; for (; message_count < kMaxMessages; ++message_count) { diff --git a/modules/rtp_rtcp/source/fec_test_helper.cc b/modules/rtp_rtcp/source/fec_test_helper.cc index f8579b48ff..ff736fd5f2 100644 --- a/modules/rtp_rtcp/source/fec_test_helper.cc +++ b/modules/rtp_rtcp/source/fec_test_helper.cc @@ -57,7 +57,7 @@ ForwardErrorCorrection::PacketList MediaPacketGenerator::ConstructMediaPackets( media_packet->data.SetSize( random_->Rand(min_packet_size_, max_packet_size_)); - uint8_t* data = media_packet->data.data(); + uint8_t* data = media_packet->data.MutableData(); // Generate random values for the first 2 bytes data[0] = random_->Rand(); data[1] = random_->Rand(); @@ -88,7 +88,7 @@ ForwardErrorCorrection::PacketList MediaPacketGenerator::ConstructMediaPackets( // Last packet, set marker bit. ForwardErrorCorrection::Packet* media_packet = media_packets.back().get(); RTC_DCHECK(media_packet); - media_packet->data[1] |= 0x80; + media_packet->data.MutableData()[1] |= 0x80; next_seq_num_ = seq_num; @@ -122,7 +122,7 @@ std::unique_ptr AugmentedPacketGenerator::NextPacket( std::unique_ptr packet(new AugmentedPacket()); packet->data.SetSize(length + kRtpHeaderSize); - uint8_t* data = packet->data.data(); + uint8_t* data = packet->data.MutableData(); for (size_t i = 0; i < length; ++i) data[i + kRtpHeaderSize] = offset + i; packet->data.SetSize(length + kRtpHeaderSize); @@ -132,7 +132,7 @@ std::unique_ptr AugmentedPacketGenerator::NextPacket( packet->header.sequenceNumber = seq_num_; packet->header.timestamp = timestamp_; packet->header.ssrc = ssrc_; - WriteRtpHeader(packet->header, packet->data.data()); + WriteRtpHeader(packet->header, data); ++seq_num_; --num_packets_; @@ -171,8 +171,8 @@ std::unique_ptr FlexfecPacketGenerator::BuildFlexfecPacket( std::unique_ptr packet_with_rtp_header( new AugmentedPacket()); packet_with_rtp_header->data.SetSize(kRtpHeaderSize + packet.data.size()); - WriteRtpHeader(header, packet_with_rtp_header->data.data()); - memcpy(packet_with_rtp_header->data.data() + kRtpHeaderSize, + WriteRtpHeader(header, packet_with_rtp_header->data.MutableData()); + memcpy(packet_with_rtp_header->data.MutableData() + kRtpHeaderSize, packet.data.cdata(), packet.data.size()); return packet_with_rtp_header; diff --git a/modules/rtp_rtcp/source/flexfec_header_reader_writer.cc b/modules/rtp_rtcp/source/flexfec_header_reader_writer.cc index ab0dcb68ae..8b4162fe2f 100644 --- a/modules/rtp_rtcp/source/flexfec_header_reader_writer.cc +++ b/modules/rtp_rtcp/source/flexfec_header_reader_writer.cc @@ -85,7 +85,7 @@ bool FlexfecHeaderReader::ReadFecHeader( RTC_LOG(LS_WARNING) << "Discarding truncated FlexFEC packet."; return false; } - uint8_t* const data = fec_packet->pkt->data.data(); + uint8_t* const data = fec_packet->pkt->data.MutableData(); bool r_bit = (data[0] & 0x80) != 0; if (r_bit) { RTC_LOG(LS_INFO) @@ -249,7 +249,7 @@ void FlexfecHeaderWriter::FinalizeFecHeader( const uint8_t* packet_mask, size_t packet_mask_size, ForwardErrorCorrection::Packet* fec_packet) const { - uint8_t* data = fec_packet->data.data(); + uint8_t* data = fec_packet->data.MutableData(); data[0] &= 0x7f; // Clear R bit. data[0] &= 0xbf; // Clear F bit. ByteWriter::WriteBigEndian(&data[8], kSsrcCount); @@ -260,8 +260,7 @@ void FlexfecHeaderWriter::FinalizeFecHeader( // // We treat the mask parts as unsigned integers with host order endianness // in order to simplify the bit shifting between bytes. - uint8_t* const written_packet_mask = - fec_packet->data.data() + kPacketMaskOffset; + uint8_t* const written_packet_mask = data + kPacketMaskOffset; if (packet_mask_size == kUlpfecPacketMaskSizeLBitSet) { // The packet mask is 48 bits long. uint16_t tmp_mask_part0 = diff --git a/modules/rtp_rtcp/source/flexfec_header_reader_writer_unittest.cc b/modules/rtp_rtcp/source/flexfec_header_reader_writer_unittest.cc index 1d86dd0eb4..4a24e90ec3 100644 --- a/modules/rtp_rtcp/source/flexfec_header_reader_writer_unittest.cc +++ b/modules/rtp_rtcp/source/flexfec_header_reader_writer_unittest.cc @@ -78,8 +78,9 @@ rtc::scoped_refptr WriteHeader(const uint8_t* packet_mask, FlexfecHeaderWriter writer; rtc::scoped_refptr written_packet(new Packet()); written_packet->data.SetSize(kMediaPacketLength); + uint8_t* data = written_packet->data.MutableData(); for (size_t i = 0; i < written_packet->data.size(); ++i) { - written_packet->data[i] = i; // Actual content doesn't matter. + data[i] = i; // Actual content doesn't matter. } writer.FinalizeFecHeader(kMediaSsrc, kMediaStartSeqNum, packet_mask, packet_mask_size, written_packet.get()); @@ -328,8 +329,9 @@ TEST(FlexfecHeaderWriterTest, FinalizesHeaderWithKBit0Set) { constexpr uint8_t kUlpfecPacketMask[] = {0x11, 0x02}; Packet written_packet; written_packet.data.SetSize(kMediaPacketLength); + uint8_t* data = written_packet.data.MutableData(); for (size_t i = 0; i < written_packet.data.size(); ++i) { - written_packet.data[i] = i; + data[i] = i; } FlexfecHeaderWriter writer; @@ -346,8 +348,9 @@ TEST(FlexfecHeaderWriterTest, FinalizesHeaderWithKBit1Set) { constexpr uint8_t kUlpfecPacketMask[] = {0x91, 0x02, 0x08, 0x44, 0x00, 0x84}; Packet written_packet; written_packet.data.SetSize(kMediaPacketLength); + uint8_t* data = written_packet.data.MutableData(); for (size_t i = 0; i < written_packet.data.size(); ++i) { - written_packet.data[i] = i; + data[i] = i; } FlexfecHeaderWriter writer; @@ -368,8 +371,9 @@ TEST(FlexfecHeaderWriterTest, FinalizesHeaderWithKBit2Set) { constexpr uint8_t kUlpfecPacketMask[] = {0x22, 0x22, 0x44, 0x44, 0x44, 0x41}; Packet written_packet; written_packet.data.SetSize(kMediaPacketLength); + uint8_t* data = written_packet.data.MutableData(); for (size_t i = 0; i < written_packet.data.size(); ++i) { - written_packet.data[i] = i; + data[i] = i; } FlexfecHeaderWriter writer; diff --git a/modules/rtp_rtcp/source/flexfec_receiver_unittest.cc b/modules/rtp_rtcp/source/flexfec_receiver_unittest.cc index 199d7860b2..b9391eeb74 100644 --- a/modules/rtp_rtcp/source/flexfec_receiver_unittest.cc +++ b/modules/rtp_rtcp/source/flexfec_receiver_unittest.cc @@ -165,10 +165,10 @@ TEST_F(FlexfecReceiverTest, FailsOnUnknownMediaSsrc) { PacketizeFrame(kNumMediaPackets, 0, &media_packets); auto& media_packet = media_packets.front(); // Corrupt the SSRC. - media_packet->data[8] = 0; - media_packet->data[9] = 1; - media_packet->data[10] = 2; - media_packet->data[11] = 3; + media_packet->data.MutableData()[8] = 0; + media_packet->data.MutableData()[9] = 1; + media_packet->data.MutableData()[10] = 2; + media_packet->data.MutableData()[11] = 3; EXPECT_FALSE(receiver_.AddReceivedPacket(ParsePacket(*media_packet))); } @@ -183,10 +183,10 @@ TEST_F(FlexfecReceiverTest, FailsOnUnknownFecSsrc) { const auto& media_packet = media_packets.front(); auto fec_packet = packet_generator_.BuildFlexfecPacket(*fec_packets.front()); // Corrupt the SSRC. - fec_packet->data[8] = 4; - fec_packet->data[9] = 5; - fec_packet->data[10] = 6; - fec_packet->data[11] = 7; + fec_packet->data.MutableData()[8] = 4; + fec_packet->data.MutableData()[9] = 5; + fec_packet->data.MutableData()[10] = 6; + fec_packet->data.MutableData()[11] = 7; std::unique_ptr received_packet = receiver_.AddReceivedPacket(ParsePacket(*media_packet)); diff --git a/modules/rtp_rtcp/source/forward_error_correction.cc b/modules/rtp_rtcp/source/forward_error_correction.cc index 1812fbf037..56eabc8a7f 100644 --- a/modules/rtp_rtcp/source/forward_error_correction.cc +++ b/modules/rtp_rtcp/source/forward_error_correction.cc @@ -151,7 +151,7 @@ int ForwardErrorCorrection::EncodeFec(const PacketList& media_packets, } for (int i = 0; i < num_fec_packets; ++i) { generated_fec_packets_[i].data.EnsureCapacity(IP_PACKET_SIZE); - memset(generated_fec_packets_[i].data.data(), 0, IP_PACKET_SIZE); + memset(generated_fec_packets_[i].data.MutableData(), 0, IP_PACKET_SIZE); // Use this as a marker for untouched packets. generated_fec_packets_[i].data.SetSize(0); fec_packets->push_back(&generated_fec_packets_[i]); @@ -231,7 +231,7 @@ void ForwardErrorCorrection::GenerateFecPayloads( fec_packet->data.SetSize(fec_packet_length); } if (first_protected_packet) { - uint8_t* data = fec_packet->data.data(); + uint8_t* data = fec_packet->data.MutableData(); // Write P, X, CC, M, and PT recovery fields. // Note that bits 0, 1, and 16 are overwritten in FinalizeFecHeaders. memcpy(&data[0], &media_packet_data[0], 2); @@ -567,11 +567,11 @@ bool ForwardErrorCorrection::StartPacketRecovery( // Copy bytes corresponding to minimum RTP header size. // Note that the sequence number and SSRC fields will be overwritten // at the end of packet recovery. - memcpy(recovered_packet->pkt->data.data(), fec_packet.pkt->data.cdata(), - kRtpHeaderSize); + memcpy(recovered_packet->pkt->data.MutableData(), + fec_packet.pkt->data.cdata(), kRtpHeaderSize); // Copy remaining FEC payload. if (fec_packet.protection_length > 0) { - memcpy(recovered_packet->pkt->data.data() + kRtpHeaderSize, + memcpy(recovered_packet->pkt->data.MutableData() + kRtpHeaderSize, fec_packet.pkt->data.cdata() + fec_packet.fec_header_size, fec_packet.protection_length); } @@ -581,7 +581,7 @@ bool ForwardErrorCorrection::StartPacketRecovery( bool ForwardErrorCorrection::FinishPacketRecovery( const ReceivedFecPacket& fec_packet, RecoveredPacket* recovered_packet) { - uint8_t* data = recovered_packet->pkt->data.data(); + uint8_t* data = recovered_packet->pkt->data.MutableData(); // Set the RTP version to 2. data[0] |= 0x80; // Set the 1st bit. data[0] &= 0xbf; // Clear the 2nd bit. @@ -603,7 +603,7 @@ bool ForwardErrorCorrection::FinishPacketRecovery( } void ForwardErrorCorrection::XorHeaders(const Packet& src, Packet* dst) { - uint8_t* dst_data = dst->data.data(); + uint8_t* dst_data = dst->data.MutableData(); const uint8_t* src_data = src.data.cdata(); // XOR the first 2 bytes of the header: V, P, X, CC, M, PT fields. dst_data[0] ^= src_data[0]; @@ -635,7 +635,7 @@ void ForwardErrorCorrection::XorPayloads(const Packet& src, if (dst_offset + payload_length > dst->data.size()) { dst->data.SetSize(dst_offset + payload_length); } - uint8_t* dst_data = dst->data.data(); + uint8_t* dst_data = dst->data.MutableData(); const uint8_t* src_data = src.data.cdata(); for (size_t i = 0; i < payload_length; ++i) { dst_data[dst_offset + i] ^= src_data[kRtpHeaderSize + i]; @@ -731,11 +731,11 @@ void ForwardErrorCorrection::DiscardOldRecoveredPackets( RTC_DCHECK_LE(recovered_packets->size(), max_media_packets); } -uint16_t ForwardErrorCorrection::ParseSequenceNumber(uint8_t* packet) { +uint16_t ForwardErrorCorrection::ParseSequenceNumber(const uint8_t* packet) { return (packet[2] << 8) + packet[3]; } -uint32_t ForwardErrorCorrection::ParseSsrc(uint8_t* packet) { +uint32_t ForwardErrorCorrection::ParseSsrc(const uint8_t* packet) { return (packet[8] << 24) + (packet[9] << 16) + (packet[10] << 8) + packet[11]; } diff --git a/modules/rtp_rtcp/source/forward_error_correction.h b/modules/rtp_rtcp/source/forward_error_correction.h index 566ce7428a..0c54ad984c 100644 --- a/modules/rtp_rtcp/source/forward_error_correction.h +++ b/modules/rtp_rtcp/source/forward_error_correction.h @@ -235,8 +235,8 @@ class ForwardErrorCorrection { // TODO(brandtr): Remove these functions when the Packet classes // have been refactored. - static uint16_t ParseSequenceNumber(uint8_t* packet); - static uint32_t ParseSsrc(uint8_t* packet); + static uint16_t ParseSequenceNumber(const uint8_t* packet); + static uint32_t ParseSsrc(const uint8_t* packet); protected: ForwardErrorCorrection(std::unique_ptr fec_header_reader, diff --git a/modules/rtp_rtcp/source/rtp_fec_unittest.cc b/modules/rtp_rtcp/source/rtp_fec_unittest.cc index eb559f2bd9..a90e61a731 100644 --- a/modules/rtp_rtcp/source/rtp_fec_unittest.cc +++ b/modules/rtp_rtcp/source/rtp_fec_unittest.cc @@ -127,7 +127,7 @@ void RtpFecTest::ReceivedPackets( // For media packets, the sequence number is obtained from the // RTP header as written by MediaPacketGenerator::ConstructMediaPackets. received_packet->seq_num = - ByteReader::ReadBigEndian(&packet->data[2]); + ByteReader::ReadBigEndian(packet->data.data() + 2); } else { received_packet->ssrc = ForwardErrorCorrectionType::kFecSsrc; // For FEC packets, we simulate the sequence numbers differently @@ -222,10 +222,10 @@ TYPED_TEST(RtpFecTest, WillProtectMediaPacketsWithLargeSequenceNumberGap) { this->media_packet_generator_.ConstructMediaPackets(kNumMediaPackets); // Create |kMaxMediaPackets - 1| sequence number difference. - ByteWriter::WriteBigEndian(&this->media_packets_.front()->data[2], - 1); - ByteWriter::WriteBigEndian(&this->media_packets_.back()->data[2], - kMaxMediaPackets); + ByteWriter::WriteBigEndian( + this->media_packets_.front()->data.MutableData() + 2, 1); + ByteWriter::WriteBigEndian( + this->media_packets_.back()->data.MutableData() + 2, kMaxMediaPackets); EXPECT_EQ( 0, this->fec_.EncodeFec(this->media_packets_, kProtectionFactor, @@ -245,10 +245,11 @@ TYPED_TEST(RtpFecTest, this->media_packet_generator_.ConstructMediaPackets(kNumMediaPackets); // Create |kMaxMediaPackets| sequence number difference. - ByteWriter::WriteBigEndian(&this->media_packets_.front()->data[2], - 1); - ByteWriter::WriteBigEndian(&this->media_packets_.back()->data[2], - kMaxMediaPackets + 1); + ByteWriter::WriteBigEndian( + this->media_packets_.front()->data.MutableData() + 2, 1); + ByteWriter::WriteBigEndian( + this->media_packets_.back()->data.MutableData() + 2, + kMaxMediaPackets + 1); EXPECT_EQ( -1, this->fec_.EncodeFec(this->media_packets_, kProtectionFactor, @@ -526,9 +527,9 @@ TEST_F(RtpFecTestFlexfecOnly, FecRecoveryWithSeqNumGapOneFrameNoRecovery) { // Overwrite the sequence numbers generated by ConstructMediaPackets, // to make sure that we do have a wrap. auto it = this->generated_fec_packets_.begin(); - ByteWriter::WriteBigEndian(&(*it)->data[2], 65535); + ByteWriter::WriteBigEndian(&(*it)->data.MutableData()[2], 65535); ++it; - ByteWriter::WriteBigEndian(&(*it)->data[2], 0); + ByteWriter::WriteBigEndian(&(*it)->data.MutableData()[2], 0); // Lose the last two media packets (seq# 65533, 65534). memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_)); diff --git a/modules/rtp_rtcp/source/rtp_packet.h b/modules/rtp_rtcp/source/rtp_packet.h index 67516e97e7..aa854f35ab 100644 --- a/modules/rtp_rtcp/source/rtp_packet.h +++ b/modules/rtp_rtcp/source/rtp_packet.h @@ -180,8 +180,10 @@ class RtpPacket { uint16_t SetExtensionLengthMaybeAddZeroPadding(size_t extensions_offset); - uint8_t* WriteAt(size_t offset) { return buffer_.data() + offset; } - void WriteAt(size_t offset, uint8_t byte) { buffer_.data()[offset] = byte; } + uint8_t* WriteAt(size_t offset) { return buffer_.MutableData() + offset; } + void WriteAt(size_t offset, uint8_t byte) { + buffer_.MutableData()[offset] = byte; + } const uint8_t* ReadAt(size_t offset) const { return buffer_.data() + offset; } // Header. diff --git a/modules/rtp_rtcp/source/ulpfec_header_reader_writer.cc b/modules/rtp_rtcp/source/ulpfec_header_reader_writer.cc index 261c8f739b..2aebbead68 100644 --- a/modules/rtp_rtcp/source/ulpfec_header_reader_writer.cc +++ b/modules/rtp_rtcp/source/ulpfec_header_reader_writer.cc @@ -57,7 +57,7 @@ UlpfecHeaderReader::~UlpfecHeaderReader() = default; bool UlpfecHeaderReader::ReadFecHeader( ForwardErrorCorrection::ReceivedFecPacket* fec_packet) const { - uint8_t* data = fec_packet->pkt->data.data(); + uint8_t* data = fec_packet->pkt->data.MutableData(); if (fec_packet->pkt->data.size() < kPacketMaskOffset) { return false; // Truncated packet. } @@ -108,7 +108,7 @@ void UlpfecHeaderWriter::FinalizeFecHeader( const uint8_t* packet_mask, size_t packet_mask_size, ForwardErrorCorrection::Packet* fec_packet) const { - uint8_t* data = fec_packet->data.data(); + uint8_t* data = fec_packet->data.MutableData(); // Set E bit to zero. data[0] &= 0x7f; // Set L bit based on packet mask size. (Note that the packet mask diff --git a/modules/rtp_rtcp/source/ulpfec_header_reader_writer_unittest.cc b/modules/rtp_rtcp/source/ulpfec_header_reader_writer_unittest.cc index 19da2c87c0..a190a548e4 100644 --- a/modules/rtp_rtcp/source/ulpfec_header_reader_writer_unittest.cc +++ b/modules/rtp_rtcp/source/ulpfec_header_reader_writer_unittest.cc @@ -53,8 +53,9 @@ std::unique_ptr WriteHeader(const uint8_t* packet_mask, UlpfecHeaderWriter writer; std::unique_ptr written_packet(new Packet()); written_packet->data.SetSize(kMediaPacketLength); + uint8_t* data = written_packet->data.MutableData(); for (size_t i = 0; i < written_packet->data.size(); ++i) { - written_packet->data[i] = i; // Actual content doesn't matter. + data[i] = i; // Actual content doesn't matter. } writer.FinalizeFecHeader(kMediaSsrc, kMediaStartSeqNum, packet_mask, packet_mask_size, written_packet.get()); @@ -85,7 +86,8 @@ void VerifyHeaders(size_t expected_fec_header_size, EXPECT_EQ(written_packet.data.size() - expected_fec_header_size, read_packet.protection_length); EXPECT_EQ(0, memcmp(expected_packet_mask, - &read_packet.pkt->data[read_packet.packet_mask_offset], + read_packet.pkt->data.MutableData() + + read_packet.packet_mask_offset, read_packet.packet_mask_size)); // Verify that the call to ReadFecHeader did not tamper with the payload. EXPECT_EQ(0, memcmp(written_packet.data.data() + expected_fec_header_size, @@ -147,8 +149,9 @@ TEST(UlpfecHeaderWriterTest, FinalizesSmallHeader) { auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd); Packet written_packet; written_packet.data.SetSize(kMediaPacketLength); + uint8_t* data = written_packet.data.MutableData(); for (size_t i = 0; i < written_packet.data.size(); ++i) { - written_packet.data[i] = i; + data[i] = i; } UlpfecHeaderWriter writer; @@ -171,8 +174,9 @@ TEST(UlpfecHeaderWriterTest, FinalizesLargeHeader) { auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd); Packet written_packet; written_packet.data.SetSize(kMediaPacketLength); + uint8_t* data = written_packet.data.MutableData(); for (size_t i = 0; i < written_packet.data.size(); ++i) { - written_packet.data[i] = i; + data[i] = i; } UlpfecHeaderWriter writer; diff --git a/modules/rtp_rtcp/source/ulpfec_receiver_impl.cc b/modules/rtp_rtcp/source/ulpfec_receiver_impl.cc index 26993cabb6..fee0b9c4da 100644 --- a/modules/rtp_rtcp/source/ulpfec_receiver_impl.cc +++ b/modules/rtp_rtcp/source/ulpfec_receiver_impl.cc @@ -135,8 +135,9 @@ bool UlpfecReceiverImpl::AddReceivedRedPacket( received_packet->pkt->data.SetData(rtp_packet.data(), rtp_packet.headers_size()); // Set payload type. - received_packet->pkt->data[1] &= 0x80; // Reset RED payload type. - received_packet->pkt->data[1] += payload_type; // Set media payload type. + uint8_t& payload_type_byte = received_packet->pkt->data.MutableData()[1]; + payload_type_byte &= 0x80; // Reset RED payload type. + payload_type_byte += payload_type; // Set media payload type. // Copy payload data. received_packet->pkt->data.AppendData(red_payload.data(), red_payload.size()); diff --git a/modules/rtp_rtcp/source/ulpfec_receiver_unittest.cc b/modules/rtp_rtcp/source/ulpfec_receiver_unittest.cc index 4d6aa3d2c9..9dbaeb81f3 100644 --- a/modules/rtp_rtcp/source/ulpfec_receiver_unittest.cc +++ b/modules/rtp_rtcp/source/ulpfec_receiver_unittest.cc @@ -158,7 +158,7 @@ void UlpfecReceiverTest::InjectGarbagePacketLength(size_t fec_garbage_offset) { std::list fec_packets; EncodeFec(media_packets, kNumFecPackets, &fec_packets); ByteWriter::WriteBigEndian( - &fec_packets.front()->data[fec_garbage_offset], 0x4711); + fec_packets.front()->data.MutableData() + fec_garbage_offset, 0x4711); // Inject first media packet, then first FEC packet, skipping the second media // packet to cause a recovery from the FEC packet. diff --git a/modules/rtp_rtcp/source/video_rtp_depacketizer_h264.cc b/modules/rtp_rtcp/source/video_rtp_depacketizer_h264.cc index 13788025c8..e87be031a8 100644 --- a/modules/rtp_rtcp/source/video_rtp_depacketizer_h264.cc +++ b/modules/rtp_rtcp/source/video_rtp_depacketizer_h264.cc @@ -264,7 +264,7 @@ absl::optional ParseFuaNalu( uint8_t original_nal_header = fnri | original_nal_type; rtp_payload = rtp_payload.Slice(kNalHeaderSize, rtp_payload.size() - kNalHeaderSize); - rtp_payload[0] = original_nal_header; + rtp_payload.MutableData()[0] = original_nal_header; parsed_payload->video_payload = std::move(rtp_payload); } else { parsed_payload->video_payload = diff --git a/modules/rtp_rtcp/test/testFec/test_fec.cc b/modules/rtp_rtcp/test/testFec/test_fec.cc index db5ff15166..5ac8feca21 100644 --- a/modules/rtp_rtcp/test/testFec/test_fec.cc +++ b/modules/rtp_rtcp/test/testFec/test_fec.cc @@ -254,7 +254,7 @@ void RunTest(bool use_flexfec) { random.Rand(kMinPacketSize, kMaxPacketSize); media_packet->data.SetSize(packet_length); - uint8_t* data = media_packet->data.data(); + uint8_t* data = media_packet->data.MutableData(); // Generate random values for the first 2 bytes. data[0] = random.Rand(); data[1] = random.Rand(); @@ -285,7 +285,7 @@ void RunTest(bool use_flexfec) { media_packet_list.push_back(std::move(media_packet)); seq_num++; } - media_packet_list.back()->data[1] |= 0x80; + media_packet_list.back()->data.MutableData()[1] |= 0x80; ASSERT_EQ(0, fec->EncodeFec(media_packet_list, protection_factor, num_imp_packets, kUseUnequalProtection, @@ -312,8 +312,8 @@ void RunTest(bool use_flexfec) { received_packet->pkt = new ForwardErrorCorrection::Packet(); received_packet->pkt->data = media_packet->data; received_packet->ssrc = media_ssrc; - received_packet->seq_num = - ByteReader::ReadBigEndian(&media_packet->data[2]); + received_packet->seq_num = ByteReader::ReadBigEndian( + media_packet->data.data() + 2); received_packet->is_fec = false; received_packet_list.push_back(std::move(received_packet)); } diff --git a/p2p/base/dtls_transport_unittest.cc b/p2p/base/dtls_transport_unittest.cc index c31062dd94..6822e55be7 100644 --- a/p2p/base/dtls_transport_unittest.cc +++ b/p2p/base/dtls_transport_unittest.cc @@ -52,7 +52,7 @@ void SetRemoteFingerprintFromCert( std::unique_ptr fingerprint = rtc::SSLFingerprint::CreateFromCertificate(*cert); if (modify_digest) { - ++fingerprint->digest[0]; + ++fingerprint->digest.MutableData()[0]; } // Even if digest is verified to be incorrect, should fail asynchrnously. EXPECT_TRUE(transport->SetRemoteFingerprint( diff --git a/pc/data_channel_unittest.cc b/pc/data_channel_unittest.cc index 7048dc82b7..7601c80b08 100644 --- a/pc/data_channel_unittest.cc +++ b/pc/data_channel_unittest.cc @@ -546,7 +546,7 @@ TEST_F(SctpDataChannelTest, ClosedWhenSendBufferFull) { SetChannelReady(); rtc::CopyOnWriteBuffer buffer(1024); - memset(buffer.data(), 0, buffer.size()); + memset(buffer.MutableData(), 0, buffer.size()); webrtc::DataBuffer packet(buffer, true); provider_->set_send_blocked(true); @@ -581,7 +581,7 @@ TEST_F(SctpDataChannelTest, ClosedOnTransportError) { TEST_F(SctpDataChannelTest, ClosedWhenReceivedBufferFull) { SetChannelReady(); rtc::CopyOnWriteBuffer buffer(1024); - memset(buffer.data(), 0, buffer.size()); + memset(buffer.MutableData(), 0, buffer.size()); cricket::ReceiveDataParams params; params.ssrc = 0; @@ -623,7 +623,7 @@ TEST_F(SctpDataChannelTest, TransportDestroyedWhileDataBuffered) { SetChannelReady(); rtc::CopyOnWriteBuffer buffer(1024); - memset(buffer.data(), 0, buffer.size()); + memset(buffer.MutableData(), 0, buffer.size()); webrtc::DataBuffer packet(buffer, true); // Send a packet while sending is blocked so it ends up buffered. diff --git a/pc/sctp_utils_unittest.cc b/pc/sctp_utils_unittest.cc index 690a9dc523..af14fe4f6b 100644 --- a/pc/sctp_utils_unittest.cc +++ b/pc/sctp_utils_unittest.cc @@ -178,15 +178,15 @@ TEST_F(SctpUtilsTest, WriteParseAckMessage) { TEST_F(SctpUtilsTest, TestIsOpenMessage) { rtc::CopyOnWriteBuffer open(1); - open[0] = 0x03; + open.MutableData()[0] = 0x03; EXPECT_TRUE(webrtc::IsOpenMessage(open)); rtc::CopyOnWriteBuffer openAck(1); - openAck[0] = 0x02; + openAck.MutableData()[0] = 0x02; EXPECT_FALSE(webrtc::IsOpenMessage(openAck)); rtc::CopyOnWriteBuffer invalid(1); - invalid[0] = 0x01; + invalid.MutableData()[0] = 0x01; EXPECT_FALSE(webrtc::IsOpenMessage(invalid)); rtc::CopyOnWriteBuffer empty; diff --git a/pc/srtp_transport.cc b/pc/srtp_transport.cc index 5c5b22004e..6acb6b327b 100644 --- a/pc/srtp_transport.cc +++ b/pc/srtp_transport.cc @@ -128,7 +128,7 @@ bool SrtpTransport::SendRtpPacket(rtc::CopyOnWriteBuffer* packet, rtc::PacketOptions updated_options = options; TRACE_EVENT0("webrtc", "SRTP Encode"); bool res; - uint8_t* data = packet->data(); + uint8_t* data = packet->MutableData(); int len = rtc::checked_cast(packet->size()); // If ENABLE_EXTERNAL_AUTH flag is on then packet authentication is not done // inside libsrtp for a RTP packet. A external HMAC module will be writing @@ -185,7 +185,7 @@ bool SrtpTransport::SendRtcpPacket(rtc::CopyOnWriteBuffer* packet, } TRACE_EVENT0("webrtc", "SRTP Encode"); - uint8_t* data = packet->data(); + uint8_t* data = packet->MutableData(); int len = rtc::checked_cast(packet->size()); if (!ProtectRtcp(data, len, static_cast(packet->capacity()), &len)) { int type = -1; @@ -208,7 +208,7 @@ void SrtpTransport::OnRtpPacketReceived(rtc::CopyOnWriteBuffer packet, return; } TRACE_EVENT0("webrtc", "SRTP Decode"); - char* data = packet.data(); + char* data = packet.MutableData(); int len = rtc::checked_cast(packet.size()); if (!UnprotectRtp(data, len, &len)) { int seq_num = -1; @@ -240,7 +240,7 @@ void SrtpTransport::OnRtcpPacketReceived(rtc::CopyOnWriteBuffer packet, return; } TRACE_EVENT0("webrtc", "SRTP Decode"); - char* data = packet.data(); + char* data = packet.MutableData(); int len = rtc::checked_cast(packet.size()); if (!UnprotectRtcp(data, len, &len)) { int type = -1; diff --git a/test/network/network_emulation.h b/test/network/network_emulation.h index 13d4386d0d..c4d79661aa 100644 --- a/test/network/network_emulation.h +++ b/test/network/network_emulation.h @@ -593,12 +593,12 @@ class FakePacketRoute : public EmulatedNetworkReceiverInterface { RTC_CHECK_GE(size, sizeof(int)); sent_.emplace(next_packet_id_, packet); rtc::CopyOnWriteBuffer buf(size); - reinterpret_cast(buf.data())[0] = next_packet_id_++; + reinterpret_cast(buf.MutableData())[0] = next_packet_id_++; route_->from->SendPacket(send_addr_, recv_addr_, buf); } void OnPacketReceived(EmulatedIpPacket packet) override { - int packet_id = reinterpret_cast(packet.data.data())[0]; + int packet_id = reinterpret_cast(packet.data.data())[0]; action_(std::move(sent_[packet_id]), packet.arrival_time); sent_.erase(packet_id); } diff --git a/test/network/traffic_route.cc b/test/network/traffic_route.cc index 2baf5a4662..98586337b9 100644 --- a/test/network/traffic_route.cc +++ b/test/network/traffic_route.cc @@ -88,7 +88,7 @@ void TrafficRoute::SendPacket(size_t packet_size) { void TrafficRoute::SendPacket(size_t packet_size, uint16_t dest_port) { rtc::CopyOnWriteBuffer data(packet_size); - std::fill_n(data.data(), data.size(), 0); + std::fill_n(data.MutableData(), data.size(), 0); receiver_->OnPacketReceived(EmulatedIpPacket( /*from=*/rtc::SocketAddress(), rtc::SocketAddress(endpoint_->GetPeerLocalAddress(), dest_port), data, diff --git a/test/peer_scenario/tests/unsignaled_stream_test.cc b/test/peer_scenario/tests/unsignaled_stream_test.cc index 5f470a833b..95510a24bd 100644 --- a/test/peer_scenario/tests/unsignaled_stream_test.cc +++ b/test/peer_scenario/tests/unsignaled_stream_test.cc @@ -114,8 +114,8 @@ TEST(UnsignaledStreamTest, ReplacesUnsignaledStreamOnCompletedSignaling) { first_ssrc && !got_unsignaled_packet) { rtc::CopyOnWriteBuffer updated_buffer = packet.data; - ByteWriter::WriteBigEndian(&updated_buffer.data()[8], - second_ssrc); + ByteWriter::WriteBigEndian( + updated_buffer.MutableData() + 8, second_ssrc); EmulatedIpPacket updated_packet( packet.from, packet.to, updated_buffer, packet.arrival_time); send_node->OnPacketReceived(std::move(updated_packet));