zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Replace rtc::Optional with absl::optional in modules/rtp_rtcp

Browse Source 
This is a no-op change because rtc::Optional is an alias to absl::optional

This CL generated using script:
#!/bin/bash
dir=modules/rtp_rtcp
find $dir -type f \( -name \*.h -o -name \*.cc \) \
-exec sed -i 's|rtc::Optional|absl::optional|' {} \+ \
-exec sed -i 's|rtc::nullopt|absl::nullopt|' {} \+ \
-exec sed -i 's|#include "api/optional.h"|#include "absl/types/optional.h"|' {} \+

find $dir -type f -name BUILD.gn \
-exec sed -r -i 's|"(../)*api:optional"|"//third_party/abseil-cpp/absl/types:optional"|' {} \+;

git cl format

Bug: webrtc:9078
Change-Id: Ife720849709959046329c1c9faa3f31aa13274dc
Reviewed-on: https://webrtc-review.googlesource.com/83584
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#23624}
This commit is contained in:
Danil Chapovalov
2018-06-14 12:59:38 +02:00
committed by Commit Bot
parent 394b4ebe38
commit d264df587f
27 changed files with 95 additions and 95 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
modules/rtp_rtcp/BUILD.gn
View File

@ -88,7 +88,6 @@ rtc_source_set("rtp_rtcp_format") {
"../../:typedefs",
"../../api:array_view",
"../../api:libjingle_peerconnection_api",
"../../api:optional",
"../../api/audio_codecs:audio_codecs_api",
"../../api/video:video_frame",
"../../common_video",
@ -96,6 +95,7 @@ rtc_source_set("rtp_rtcp_format") {
"../../rtc_base:deprecation",
"../../rtc_base:rtc_base_approved",
"../../system_wrappers",
"//third_party/abseil-cpp/absl/types:optional",
]
}
@ -196,7 +196,6 @@ rtc_static_library("rtp_rtcp") {
"../../:typedefs",
"../../api:array_view",
"../../api:libjingle_peerconnection_api",
"../../api:optional",
"../../api:transport_api",
"../../api/audio_codecs:audio_codecs_api",
"../../api/video:video_bitrate_allocation",
@ -221,6 +220,7 @@ rtc_static_library("rtp_rtcp") {
"../../system_wrappers:metrics_api",
"../audio_coding:audio_format_conversion",
"../remote_bitrate_estimator",
"//third_party/abseil-cpp/absl/types:optional",
]
# TODO(jschuh): Bug 1348: fix this warning.
@ -245,7 +245,6 @@ rtc_source_set("rtcp_transceiver") {
"../../:webrtc_common",
"../../api:array_view",
"../../api:libjingle_peerconnection_api",
"../../api:optional",
"../../api:transport_api",
"../../api/video:video_bitrate_allocation",
"../../rtc_base:checks",
@ -253,6 +252,7 @@ rtc_source_set("rtcp_transceiver") {
"../../rtc_base:rtc_task_queue",
"../../rtc_base:weak_ptr",
"../../system_wrappers",
"//third_party/abseil-cpp/absl/types:optional",
]
}
@ -292,11 +292,11 @@ rtc_source_set("mock_rtp_rtcp") {
":rtp_rtcp",
":rtp_rtcp_format",
"..:module_api",
"../../api:optional",
"../../api/video:video_bitrate_allocation",
"../../rtc_base:checks",
"../../rtc_base:rtc_base_approved",
"../../test:test_support",
"//third_party/abseil-cpp/absl/types:optional",
]
}
@ -410,7 +410,6 @@ if (rtc_include_tests) {
"../../:typedefs",
"../../api:array_view",
"../../api:libjingle_peerconnection_api",
"../../api:optional",
"../../api:transport_api",
"../../api/video:video_bitrate_allocation",
"../../api/video:video_frame",
@ -430,6 +429,7 @@ if (rtc_include_tests) {
"../../test:test_common",
"../../test:test_support",
"../audio_coding:audio_format_conversion",
"//third_party/abseil-cpp/absl/types:optional",
]
# TODO(jschuh): bugs.webrtc.org/1348: fix this warning.

4
modules/rtp_rtcp/include/rtp_payload_registry.h
View File

@ -14,8 +14,8 @@
#include <map>
#include <set>
#include "absl/types/optional.h"
#include "api/audio_codecs/audio_format.h"
#include "api/optional.h"
#include "api/video_codecs/video_codec.h"
#include "modules/rtp_rtcp/source/rtp_utility.h"
#include "rtc_base/criticalsection.h"
@ -42,7 +42,7 @@ class RTPPayloadRegistry {
int GetPayloadTypeFrequency(uint8_t payload_type) const;
rtc::Optional<RtpUtility::Payload> PayloadTypeToPayload(
absl::optional<RtpUtility::Payload> PayloadTypeToPayload(
uint8_t payload_type) const;
void ResetLastReceivedPayloadTypes() {

4
modules/rtp_rtcp/include/rtp_rtcp.h
View File

@ -16,7 +16,7 @@
#include <utility>
#include <vector>
#include "api/optional.h"
#include "absl/types/optional.h"
#include "api/video/video_bitrate_allocation.h"
#include "common_types.h" // NOLINT(build/include)
#include "modules/include/module.h"
@ -199,7 +199,7 @@ class RtpRtcp : public Module, public RtcpFeedbackSenderInterface {
int associated_payload_type) = 0;
// Returns the FlexFEC SSRC, if there is one.
virtual rtc::Optional<uint32_t> FlexfecSsrc() const = 0;
virtual absl::optional<uint32_t> FlexfecSsrc() const = 0;
// Sets sending status. Sends kRtcpByeCode when going from true to false.
// Returns -1 on failure else 0.

4
modules/rtp_rtcp/include/rtp_rtcp_defines.h
View File

@ -91,8 +91,8 @@ class PayloadUnion {
}
private:
rtc::Optional<AudioPayload> audio_payload_;
rtc::Optional<VideoPayload> video_payload_;
absl::optional<AudioPayload> audio_payload_;
absl::optional<VideoPayload> video_payload_;
};
enum RTPAliveType { kRtpDead = 0, kRtpNoRtp = 1, kRtpAlive = 2 };

4
modules/rtp_rtcp/mocks/mock_rtp_rtcp.h
View File

@ -16,7 +16,7 @@
#include <utility>
#include <vector>
#include "api/optional.h"
#include "absl/types/optional.h"
#include "api/video/video_bitrate_allocation.h"
#include "modules/include/module.h"
#include "modules/rtp_rtcp/include/rtp_rtcp.h"
@ -75,7 +75,7 @@ class MockRtpRtcp : public RtpRtcp {
MOCK_CONST_METHOD0(RtxSendStatus, int());
MOCK_METHOD1(SetRtxSsrc, void(uint32_t));
MOCK_METHOD2(SetRtxSendPayloadType, void(int, int));
MOCK_CONST_METHOD0(FlexfecSsrc, rtc::Optional<uint32_t>());
MOCK_CONST_METHOD0(FlexfecSsrc, absl::optional<uint32_t>());
MOCK_CONST_METHOD0(RtxSendPayloadType, std::pair<int, int>());
MOCK_METHOD1(SetSendingStatus, int32_t(bool sending));
MOCK_CONST_METHOD0(Sending, bool());

2
modules/rtp_rtcp/source/rtcp_packet/extended_reports.cc
View File

@ -57,7 +57,7 @@ bool ExtendedReports::Parse(const CommonHeader& packet) {
rrtr_block_.reset();
dlrr_block_.ClearItems();
voip_metric_block_.reset();
target_bitrate_ = rtc::nullopt;
target_bitrate_ = absl::nullopt;
const uint8_t* current_block = packet.payload() + kXrBaseLength;
const uint8_t* const packet_end =

14
modules/rtp_rtcp/source/rtcp_packet/extended_reports.h
View File

@ -13,7 +13,7 @@
#include <vector>
#include "api/optional.h"
#include "absl/types/optional.h"
#include "modules/rtp_rtcp/source/rtcp_packet.h"
#include "modules/rtp_rtcp/source/rtcp_packet/dlrr.h"
#include "modules/rtp_rtcp/source/rtcp_packet/rrtr.h"
@ -44,12 +44,12 @@ class ExtendedReports : public RtcpPacket {
void SetTargetBitrate(const TargetBitrate& target_bitrate);
uint32_t sender_ssrc() const { return sender_ssrc_; }
const rtc::Optional<Rrtr>& rrtr() const { return rrtr_block_; }
const absl::optional<Rrtr>& rrtr() const { return rrtr_block_; }
const Dlrr& dlrr() const { return dlrr_block_; }
const rtc::Optional<VoipMetric>& voip_metric() const {
const absl::optional<VoipMetric>& voip_metric() const {
return voip_metric_block_;
}
const rtc::Optional<TargetBitrate>& target_bitrate() const {
const absl::optional<TargetBitrate>& target_bitrate() const {
return target_bitrate_;
}
@ -76,10 +76,10 @@ class ExtendedReports : public RtcpPacket {
void ParseTargetBitrateBlock(const uint8_t* block, uint16_t block_length);
uint32_t sender_ssrc_;
rtc::Optional<Rrtr> rrtr_block_;
absl::optional<Rrtr> rrtr_block_;
Dlrr dlrr_block_; // Dlrr without items treated same as no dlrr block.
rtc::Optional<VoipMetric> voip_metric_block_;
rtc::Optional<TargetBitrate> target_bitrate_;
absl::optional<VoipMetric> voip_metric_block_;
absl::optional<TargetBitrate> target_bitrate_;
};
} // namespace rtcp
} // namespace webrtc

2
modules/rtp_rtcp/source/rtcp_packet/target_bitrate_unittest.cc
View File

@ -67,7 +67,7 @@ TEST(TargetBitrateTest, FullPacket) {
rtcp::ExtendedReports xr;
EXPECT_TRUE(ParseSinglePacket(kRtcpPacket, &xr));
EXPECT_EQ(kSsrc, xr.sender_ssrc());
const rtc::Optional<TargetBitrate>& target_bitrate = xr.target_bitrate();
const absl::optional<TargetBitrate>& target_bitrate = xr.target_bitrate();
ASSERT_TRUE(static_cast<bool>(target_bitrate));
CheckBitrateItems(target_bitrate->GetTargetBitrates());
}

2
modules/rtp_rtcp/source/rtcp_receiver.cc
View File

@ -72,7 +72,7 @@ struct RTCPReceiver::PacketInformation {
int64_t rtt_ms = 0;
uint32_t receiver_estimated_max_bitrate_bps = 0;
std::unique_ptr<rtcp::TransportFeedback> transport_feedback;
rtc::Optional<VideoBitrateAllocation> target_bitrate_allocation;
absl::optional<VideoBitrateAllocation> target_bitrate_allocation;
};
// Structure for handing TMMBR and TMMBN rtcp messages (RFC5104, section 3.5.4).

6
modules/rtp_rtcp/source/rtcp_sender.h
View File

@ -17,8 +17,8 @@
#include <string>
#include <vector>
#include "absl/types/optional.h"
#include "api/call/transport.h"
#include "api/optional.h"
#include "api/video/video_bitrate_allocation.h"
#include "modules/remote_bitrate_estimator/include/bwe_defines.h"
#include "modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h"
@ -237,7 +237,7 @@ class RTCPSender {
RTC_GUARDED_BY(critical_section_rtcp_sender_);
// XR VoIP metric
rtc::Optional<RTCPVoIPMetric> xr_voip_metric_
absl::optional<RTCPVoIPMetric> xr_voip_metric_
RTC_GUARDED_BY(critical_section_rtcp_sender_);
RtcpPacketTypeCounterObserver* const packet_type_counter_observer_;
@ -246,7 +246,7 @@ class RTCPSender {
RtcpNackStats nack_stats_ RTC_GUARDED_BY(critical_section_rtcp_sender_);
rtc::Optional<VideoBitrateAllocation> video_bitrate_allocation_
absl::optional<VideoBitrateAllocation> video_bitrate_allocation_
RTC_GUARDED_BY(critical_section_rtcp_sender_);
void SetFlag(uint32_t type, bool is_volatile)

2
modules/rtp_rtcp/source/rtcp_sender_unittest.cc
View File

@ -679,7 +679,7 @@ TEST_F(RtcpSenderTest, SendXrWithTargetBitrate) {
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
EXPECT_EQ(1, parser()->xr()->num_packets());
EXPECT_EQ(kSenderSsrc, parser()->xr()->sender_ssrc());
const rtc::Optional<rtcp::TargetBitrate>& target_bitrate =
const absl::optional<rtcp::TargetBitrate>& target_bitrate =
parser()->xr()->target_bitrate();
ASSERT_TRUE(target_bitrate);
const std::vector<rtcp::TargetBitrate::BitrateItem>& bitrates =

4
modules/rtp_rtcp/source/rtcp_transceiver_impl.cc
View File

@ -46,7 +46,7 @@ struct SenderReportTimes {
struct RtcpTransceiverImpl::RemoteSenderState {
uint8_t fir_sequence_number = 0;
rtc::Optional<SenderReportTimes> last_received_sender_report;
absl::optional<SenderReportTimes> last_received_sender_report;
std::vector<MediaReceiverRtcpObserver*> observers;
};
@ -245,7 +245,7 @@ void RtcpTransceiverImpl::HandleSenderReport(
return;
RemoteSenderState& remote_sender =
remote_senders_[sender_report.sender_ssrc()];
rtc::Optional<SenderReportTimes>& last =
absl::optional<SenderReportTimes>& last =
remote_sender.last_received_sender_report;
last.emplace();
last->local_received_time_us = now_us;

4
modules/rtp_rtcp/source/rtcp_transceiver_impl.h
View File

@ -16,8 +16,8 @@
#include <string>
#include <vector>
#include "absl/types/optional.h"
#include "api/array_view.h"
#include "api/optional.h"
#include "modules/rtp_rtcp/source/rtcp_packet/common_header.h"
#include "modules/rtp_rtcp/source/rtcp_packet/dlrr.h"
#include "modules/rtp_rtcp/source/rtcp_packet/remb.h"
@ -91,7 +91,7 @@ class RtcpTransceiverImpl {
const RtcpTransceiverConfig config_;
bool ready_to_send_;
rtc::Optional<rtcp::Remb> remb_;
absl::optional<rtcp::Remb> remb_;
// TODO(danilchap): Remove entries from remote_senders_ that are no longer
// needed.
std::map<uint32_t, RemoteSenderState> remote_senders_;

8
modules/rtp_rtcp/source/rtcp_transceiver_impl_unittest.cc
View File

@ -144,7 +144,7 @@ TEST(RtcpTransceiverImplTest, DelaysSendingFirstCompondPacket) {
config.outgoing_transport = &transport;
config.initial_report_delay_ms = 10;
config.task_queue = &queue;
rtc::Optional<RtcpTransceiverImpl> rtcp_transceiver;
absl::optional<RtcpTransceiverImpl> rtcp_transceiver;
int64_t started_ms = rtc::TimeMillis();
queue.PostTask([&] { rtcp_transceiver.emplace(config); });
@ -169,7 +169,7 @@ TEST(RtcpTransceiverImplTest, PeriodicallySendsPackets) {
config.initial_report_delay_ms = 0;
config.report_period_ms = kReportPeriodMs;
config.task_queue = &queue;
rtc::Optional<RtcpTransceiverImpl> rtcp_transceiver;
absl::optional<RtcpTransceiverImpl> rtcp_transceiver;
int64_t time_just_before_1st_packet_ms = 0;
queue.PostTask([&] {
// Because initial_report_delay_ms is set to 0, time_just_before_the_packet
@ -202,7 +202,7 @@ TEST(RtcpTransceiverImplTest, SendCompoundPacketDelaysPeriodicSendPackets) {
config.initial_report_delay_ms = 0;
config.report_period_ms = kReportPeriodMs;
config.task_queue = &queue;
rtc::Optional<RtcpTransceiverImpl> rtcp_transceiver;
absl::optional<RtcpTransceiverImpl> rtcp_transceiver;
queue.PostTask([&] { rtcp_transceiver.emplace(config); });
// Wait for first packet.
@ -288,7 +288,7 @@ TEST(RtcpTransceiverImplTest, SendsPeriodicRtcpWhenNetworkStateIsUp) {
config.initial_ready_to_send = false;
config.outgoing_transport = &transport;
config.task_queue = &queue;
rtc::Optional<RtcpTransceiverImpl> rtcp_transceiver;
absl::optional<RtcpTransceiverImpl> rtcp_transceiver;
rtcp_transceiver.emplace(config);
rtcp_transceiver->SetReadyToSend(true);

8
modules/rtp_rtcp/source/rtp_format_h264.cc
View File

@ -129,7 +129,7 @@ size_t RtpPacketizerH264::SetPayloadData(
// RtpDepacketizerH264::ParseSingleNalu (receive side, in orderer to
// protect us from unknown or legacy send clients).
rtc::Optional<SpsParser::SpsState> sps;
absl::optional<SpsParser::SpsState> sps;
std::unique_ptr<rtc::Buffer> output_buffer(new rtc::Buffer());
// Add the type header to the output buffer first, so that the rewriter
@ -514,7 +514,7 @@ bool RtpDepacketizerH264::ProcessStapAOrSingleNalu(
if (start_offset)
output_buffer->AppendData(payload_data, start_offset);
rtc::Optional<SpsParser::SpsState> sps;
absl::optional<SpsParser::SpsState> sps;
SpsVuiRewriter::ParseResult result = SpsVuiRewriter::ParseAndRewriteSps(
&payload_data[start_offset], end_offset - start_offset, &sps,
@ -596,7 +596,7 @@ bool RtpDepacketizerH264::ProcessStapAOrSingleNalu(
parsed_payload->frame_type = kVideoFrameKey;
RTC_FALLTHROUGH();
case H264::NaluType::kSlice: {
rtc::Optional<uint32_t> pps_id = PpsParser::ParsePpsIdFromSlice(
absl::optional<uint32_t> pps_id = PpsParser::ParsePpsIdFromSlice(
&payload_data[start_offset], end_offset - start_offset);
if (pps_id) {
nalu.pps_id = *pps_id;
@ -648,7 +648,7 @@ bool RtpDepacketizerH264::ParseFuaNalu(
if (first_fragment) {
offset_ = 0;
length_ -= kNalHeaderSize;
rtc::Optional<uint32_t> pps_id = PpsParser::ParsePpsIdFromSlice(
absl::optional<uint32_t> pps_id = PpsParser::ParsePpsIdFromSlice(
payload_data + 2 * kNalHeaderSize, length_ - kNalHeaderSize);
if (pps_id) {
nalu.pps_id = *pps_id;

10
modules/rtp_rtcp/source/rtp_packet_history.cc
View File

@ -84,7 +84,7 @@ void RtpPacketHistory::SetRtt(int64_t rtt_ms) {
void RtpPacketHistory::PutRtpPacket(std::unique_ptr<RtpPacketToSend> packet,
StorageType type,
rtc::Optional<int64_t> send_time_ms) {
absl::optional<int64_t> send_time_ms) {
RTC_DCHECK(packet);
rtc::CritScope cs(&lock_);
int64_t now_ms = clock_->TimeInMilliseconds();
@ -146,21 +146,21 @@ std::unique_ptr<RtpPacketToSend> RtpPacketHistory::GetPacketAndSetSendTime(
return rtc::MakeUnique<RtpPacketToSend>(*packet.packet);
}
rtc::Optional<RtpPacketHistory::PacketState> RtpPacketHistory::GetPacketState(
absl::optional<RtpPacketHistory::PacketState> RtpPacketHistory::GetPacketState(
uint16_t sequence_number,
bool verify_rtt) const {
rtc::CritScope cs(&lock_);
if (mode_ == StorageMode::kDisabled) {
return rtc::nullopt;
return absl::nullopt;
}
auto rtp_it = packet_history_.find(sequence_number);
if (rtp_it == packet_history_.end()) {
return rtc::nullopt;
return absl::nullopt;
}
if (verify_rtt && !VerifyRtt(rtp_it->second, clock_->TimeInMilliseconds())) {
return rtc::nullopt;
return absl::nullopt;
}
return StoredPacketToPacketState(rtp_it->second);

12
modules/rtp_rtcp/source/rtp_packet_history.h
View File

@ -42,7 +42,7 @@ class RtpPacketHistory {
~PacketState();
uint16_t rtp_sequence_number = 0;
rtc::Optional<int64_t> send_time_ms;
absl::optional<int64_t> send_time_ms;
int64_t capture_time_ms = 0;
uint32_t ssrc = 0;
size_t payload_size = 0;
@ -74,7 +74,7 @@ class RtpPacketHistory {
// be set accordingly.
void PutRtpPacket(std::unique_ptr<RtpPacketToSend> packet,
StorageType type,
rtc::Optional<int64_t> send_time_ms);
absl::optional<int64_t> send_time_ms);
// Gets stored RTP packet corresponding to the input |sequence number|.
// Returns nullptr if packet is not found. If |verify_rtt| is true, doesn't
@ -85,8 +85,8 @@ class RtpPacketHistory {
// Similar to GetPacketAndSetSendTime(), but only returns a snapshot of the
// current state for packet, and never updates internal state.
rtc::Optional<PacketState> GetPacketState(uint16_t sequence_number,
bool verify_rtt) const;
absl::optional<PacketState> GetPacketState(uint16_t sequence_number,
bool verify_rtt) const;
// Get the packet (if any) from the history, with size closest to
// |packet_size|. The exact size of the packet is not guaranteed.
@ -101,7 +101,7 @@ class RtpPacketHistory {
~StoredPacket();
// The time of last transmission, including retransmissions.
rtc::Optional<int64_t> send_time_ms;
absl::optional<int64_t> send_time_ms;
// Number of times RE-transmitted, ie excluding the first transmission.
size_t times_retransmitted = 0;
@ -140,7 +140,7 @@ class RtpPacketHistory {
// The earliest packet in the history. This might not be the lowest sequence
// number, in case there is a wraparound.
rtc::Optional<uint16_t> start_seqno_ RTC_GUARDED_BY(lock_);
absl::optional<uint16_t> start_seqno_ RTC_GUARDED_BY(lock_);
RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(RtpPacketHistory);
};

28
modules/rtp_rtcp/source/rtp_packet_history_unittest.cc
View File

@ -62,7 +62,7 @@ TEST_F(RtpPacketHistoryTest, ClearsHistoryAfterSetStoreStatus) {
hist_.SetStorePacketsStatus(StorageMode::kStore, 10);
// Store a packet, but with send-time. It should then not be removed.
hist_.PutRtpPacket(CreateRtpPacket(kStartSeqNum), kAllowRetransmission,
rtc::nullopt);
absl::nullopt);
EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum, false));
// Changing store status, even to the current one, will clear the history.
@ -74,7 +74,7 @@ TEST_F(RtpPacketHistoryTest, StartSeqResetAfterReset) {
hist_.SetStorePacketsStatus(StorageMode::kStoreAndCull, 10);
// Store a packet, but with send-time. It should then not be removed.
hist_.PutRtpPacket(CreateRtpPacket(kStartSeqNum), kAllowRetransmission,
rtc::nullopt);
absl::nullopt);
EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum, false));
// Changing store status, to clear the history.
@ -83,7 +83,7 @@ TEST_F(RtpPacketHistoryTest, StartSeqResetAfterReset) {
// Add a new packet.
hist_.PutRtpPacket(CreateRtpPacket(kStartSeqNum + 1), kAllowRetransmission,
rtc::nullopt);
absl::nullopt);
EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum + 1, false));
// Advance time past where packet expires.
@ -93,7 +93,7 @@ TEST_F(RtpPacketHistoryTest, StartSeqResetAfterReset) {
// Add one more packet and verify no state left from packet before reset.
hist_.PutRtpPacket(CreateRtpPacket(To16u(kStartSeqNum + 2)),
kAllowRetransmission, rtc::nullopt);
kAllowRetransmission, absl::nullopt);
EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum, false));
EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum + 1, false));
EXPECT_TRUE(hist_.GetPacketState(To16u(kStartSeqNum + 2), false));
@ -102,7 +102,7 @@ TEST_F(RtpPacketHistoryTest, StartSeqResetAfterReset) {
TEST_F(RtpPacketHistoryTest, NoStoreStatus) {
EXPECT_EQ(StorageMode::kDisabled, hist_.GetStorageMode());
std::unique_ptr<RtpPacketToSend> packet = CreateRtpPacket(kStartSeqNum);
hist_.PutRtpPacket(std::move(packet), kAllowRetransmission, rtc::nullopt);
hist_.PutRtpPacket(std::move(packet), kAllowRetransmission, absl::nullopt);
// Packet should not be stored.
EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum, false));
}
@ -117,7 +117,7 @@ TEST_F(RtpPacketHistoryTest, PutRtpPacket) {
std::unique_ptr<RtpPacketToSend> packet = CreateRtpPacket(kStartSeqNum);
EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum, false));
hist_.PutRtpPacket(std::move(packet), kAllowRetransmission, rtc::nullopt);
hist_.PutRtpPacket(std::move(packet), kAllowRetransmission, absl::nullopt);
EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum, false));
}
@ -127,7 +127,7 @@ TEST_F(RtpPacketHistoryTest, GetRtpPacket) {
std::unique_ptr<RtpPacketToSend> packet = CreateRtpPacket(kStartSeqNum);
packet->set_capture_time_ms(capture_time_ms);
rtc::CopyOnWriteBuffer buffer = packet->Buffer();
hist_.PutRtpPacket(std::move(packet), kAllowRetransmission, rtc::nullopt);
hist_.PutRtpPacket(std::move(packet), kAllowRetransmission, absl::nullopt);
std::unique_ptr<RtpPacketToSend> packet_out =
hist_.GetPacketAndSetSendTime(kStartSeqNum, false);
@ -143,7 +143,7 @@ TEST_F(RtpPacketHistoryTest, NoCaptureTime) {
std::unique_ptr<RtpPacketToSend> packet = CreateRtpPacket(kStartSeqNum);
packet->set_capture_time_ms(-1);
rtc::CopyOnWriteBuffer buffer = packet->Buffer();
hist_.PutRtpPacket(std::move(packet), kAllowRetransmission, rtc::nullopt);
hist_.PutRtpPacket(std::move(packet), kAllowRetransmission, absl::nullopt);
std::unique_ptr<RtpPacketToSend> packet_out =
hist_.GetPacketAndSetSendTime(kStartSeqNum, false);
@ -157,7 +157,7 @@ TEST_F(RtpPacketHistoryTest, DontRetransmit) {
int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
std::unique_ptr<RtpPacketToSend> packet = CreateRtpPacket(kStartSeqNum);
rtc::CopyOnWriteBuffer buffer = packet->Buffer();
hist_.PutRtpPacket(std::move(packet), kDontRetransmit, rtc::nullopt);
hist_.PutRtpPacket(std::move(packet), kDontRetransmit, absl::nullopt);
// Get the packet and verify data.
std::unique_ptr<RtpPacketToSend> packet_out;
@ -182,7 +182,7 @@ TEST_F(RtpPacketHistoryTest, PacketStateIsCorrect) {
hist_.PutRtpPacket(std::move(packet), StorageType::kAllowRetransmission,
fake_clock_.TimeInMilliseconds());
rtc::Optional<RtpPacketHistory::PacketState> state =
absl::optional<RtpPacketHistory::PacketState> state =
hist_.GetPacketState(kStartSeqNum, false);
ASSERT_TRUE(state);
EXPECT_EQ(state->rtp_sequence_number, kStartSeqNum);
@ -208,7 +208,7 @@ TEST_F(RtpPacketHistoryTest, MinResendTimeWithPacer) {
int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
std::unique_ptr<RtpPacketToSend> packet = CreateRtpPacket(kStartSeqNum);
size_t len = packet->size();
hist_.PutRtpPacket(std::move(packet), kAllowRetransmission, rtc::nullopt);
hist_.PutRtpPacket(std::move(packet), kAllowRetransmission, absl::nullopt);
// First transmission: TimeToSendPacket() call from pacer.
EXPECT_TRUE(hist_.GetPacketAndSetSendTime(kStartSeqNum, false));
@ -223,7 +223,7 @@ TEST_F(RtpPacketHistoryTest, MinResendTimeWithPacer) {
// 2) When the pacer determines that it is time to send the packet, it calls
// GetPacketAndSetSendTime(). This time we do not need to verify RTT as
// has that has already been done.
rtc::Optional<RtpPacketHistory::PacketState> packet_state =
absl::optional<RtpPacketHistory::PacketState> packet_state =
hist_.GetPacketState(kStartSeqNum, /*verify_rtt=*/true);
EXPECT_TRUE(packet_state);
EXPECT_EQ(len, packet_state->payload_size);
@ -313,7 +313,7 @@ TEST_F(RtpPacketHistoryTest, RemovesOldestPacketWhenAtMaxCapacity) {
for (size_t i = 0; i < kMaxNumPackets; ++i) {
std::unique_ptr<RtpPacketToSend> packet = CreateRtpPacket(kStartSeqNum + i);
// Don't mark packets as sent, preventing them from being removed.
hist_.PutRtpPacket(std::move(packet), kAllowRetransmission, rtc::nullopt);
hist_.PutRtpPacket(std::move(packet), kAllowRetransmission, absl::nullopt);
}
// First packet should still be there.
@ -338,7 +338,7 @@ TEST_F(RtpPacketHistoryTest, DontRemoveUnsentPackets) {
for (size_t i = 0; i < kMaxNumPackets; ++i) {
// Mark packets as unsent.
hist_.PutRtpPacket(CreateRtpPacket(To16u(kStartSeqNum + i)),
kAllowRetransmission, rtc::nullopt);
kAllowRetransmission, absl::nullopt);
}
fake_clock_.AdvanceTimeMilliseconds(RtpPacketHistory::kMinPacketDurationMs);

6
modules/rtp_rtcp/source/rtp_payload_registry.cc
View File

@ -227,13 +227,13 @@ int RTPPayloadRegistry::GetPayloadTypeFrequency(
: kVideoPayloadTypeFrequency;
}
rtc::Optional<RtpUtility::Payload> RTPPayloadRegistry::PayloadTypeToPayload(
absl::optional<RtpUtility::Payload> RTPPayloadRegistry::PayloadTypeToPayload(
uint8_t payload_type) const {
rtc::CritScope cs(&crit_sect_);
const auto it = payload_type_map_.find(payload_type);
return it == payload_type_map_.end()
? rtc::nullopt
: rtc::Optional<RtpUtility::Payload>(it->second);
? absl::nullopt
: absl::optional<RtpUtility::Payload>(it->second);
}
} // namespace webrtc

8
modules/rtp_rtcp/source/rtp_receiver_impl.cc
View File

@ -29,7 +29,7 @@
namespace webrtc {
namespace {
bool InOrderPacket(rtc::Optional<uint16_t> latest_sequence_number,
bool InOrderPacket(absl::optional<uint16_t> latest_sequence_number,
uint16_t current_sequence_number) {
if (!latest_sequence_number)
return true;
@ -174,8 +174,8 @@ bool RtpReceiverImpl::IncomingRtpPacket(const RTPHeader& rtp_header,
auto audio_level =
rtp_header.extension.hasAudioLevel
? rtc::Optional<uint8_t>(rtp_header.extension.audioLevel)
: rtc::nullopt;
? absl::optional<uint8_t>(rtp_header.extension.audioLevel)
: absl::nullopt;
UpdateSources(audio_level);
int32_t ret_val = rtp_media_receiver_->ParseRtpPacket(
@ -323,7 +323,7 @@ void RtpReceiverImpl::CheckCSRC(const WebRtcRTPHeader& rtp_header) {
}
void RtpReceiverImpl::UpdateSources(
const rtc::Optional<uint8_t>& ssrc_audio_level) {
const absl::optional<uint8_t>& ssrc_audio_level) {
rtc::CritScope lock(&critical_section_rtp_receiver_);
int64_t now_ms = clock_->TimeInMilliseconds();

6
modules/rtp_rtcp/source/rtp_receiver_impl.h
View File

@ -16,7 +16,7 @@
#include <unordered_map>
#include <vector>
#include "api/optional.h"
#include "absl/types/optional.h"
#include "modules/rtp_rtcp/include/rtp_receiver.h"
#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "modules/rtp_rtcp/source/rtp_receiver_strategy.h"
@ -74,7 +74,7 @@ class RtpReceiverImpl : public RtpReceiver {
int32_t CheckPayloadChanged(const RTPHeader& rtp_header,
PayloadUnion* payload);
void UpdateSources(const rtc::Optional<uint8_t>& ssrc_audio_level);
void UpdateSources(const absl::optional<uint8_t>& ssrc_audio_level);
void RemoveOutdatedSources(int64_t now_ms);
Clock* clock_;
@ -91,7 +91,7 @@ class RtpReceiverImpl : public RtpReceiver {
critical_section_rtp_receiver_);
// Sequence number and timestamps for the latest in-order packet.
rtc::Optional<uint16_t> last_received_sequence_number_
absl::optional<uint16_t> last_received_sequence_number_
RTC_GUARDED_BY(critical_section_rtp_receiver_);
uint32_t last_received_timestamp_
RTC_GUARDED_BY(critical_section_rtp_receiver_);

6
modules/rtp_rtcp/source/rtp_rtcp_impl.cc
View File

@ -266,10 +266,10 @@ void ModuleRtpRtcpImpl::SetRtxSendPayloadType(int payload_type,
rtp_sender_->SetRtxPayloadType(payload_type, associated_payload_type);
}
rtc::Optional<uint32_t> ModuleRtpRtcpImpl::FlexfecSsrc() const {
absl::optional<uint32_t> ModuleRtpRtcpImpl::FlexfecSsrc() const {
if (rtp_sender_)
return rtp_sender_->FlexfecSsrc();
return rtc::nullopt;
return absl::nullopt;
}
void ModuleRtpRtcpImpl::IncomingRtcpPacket(const uint8_t* rtcp_packet,
@ -898,7 +898,7 @@ void ModuleRtpRtcpImpl::SetRtcpReceiverSsrcs(uint32_t main_ssrc) {
ssrcs.insert(main_ssrc);
if (RtxSendStatus() != kRtxOff)
ssrcs.insert(rtp_sender_->RtxSsrc());
rtc::Optional<uint32_t> flexfec_ssrc = FlexfecSsrc();
absl::optional<uint32_t> flexfec_ssrc = FlexfecSsrc();
if (flexfec_ssrc)
ssrcs.insert(*flexfec_ssrc);
rtcp_receiver_.SetSsrcs(main_ssrc, ssrcs);

4
modules/rtp_rtcp/source/rtp_rtcp_impl.h
View File

@ -17,7 +17,7 @@
#include <utility>
#include <vector>
#include "api/optional.h"
#include "absl/types/optional.h"
#include "api/video/video_bitrate_allocation.h"
#include "modules/rtp_rtcp/include/rtp_rtcp.h"
#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
@ -102,7 +102,7 @@ class ModuleRtpRtcpImpl : public RtpRtcp, public RTCPReceiver::ModuleRtpRtcp {
void SetRtxSendPayloadType(int payload_type,
int associated_payload_type) override;
rtc::Optional<uint32_t> FlexfecSsrc() const override;
absl::optional<uint32_t> FlexfecSsrc() const override;
// Sends kRtcpByeCode when going from true to false.
int32_t SetSendingStatus(bool sending) override;

12
modules/rtp_rtcp/source/rtp_sender.cc
View File

@ -630,7 +630,7 @@ bool RTPSender::StorePackets() const {
int32_t RTPSender::ReSendPacket(uint16_t packet_id) {
// Try to find packet in RTP packet history. Also verify RTT here, so that we
// don't retransmit too often.
rtc::Optional<RtpPacketHistory::PacketState> stored_packet =
absl::optional<RtpPacketHistory::PacketState> stored_packet =
packet_history_.GetPacketState(packet_id, true);
if (!stored_packet) {
// Packet not found.
@ -908,7 +908,7 @@ bool RTPSender::SendToNetwork(std::unique_ptr<RtpPacketToSend> packet,
}
uint32_t ssrc = packet->Ssrc();
rtc::Optional<uint32_t> flexfec_ssrc = FlexfecSsrc();
absl::optional<uint32_t> flexfec_ssrc = FlexfecSsrc();
if (paced_sender_) {
uint16_t seq_no = packet->SequenceNumber();
// Correct offset between implementations of millisecond time stamps in
@ -919,9 +919,9 @@ bool RTPSender::SendToNetwork(std::unique_ptr<RtpPacketToSend> packet,
// Store FlexFEC packets in the history here, so they can be found
// when the pacer calls TimeToSendPacket.
flexfec_packet_history_.PutRtpPacket(std::move(packet), storage,
rtc::nullopt);
absl::nullopt);
} else {
packet_history_.PutRtpPacket(std::move(packet), storage, rtc::nullopt);
packet_history_.PutRtpPacket(std::move(packet), storage, absl::nullopt);
}
paced_sender_->InsertPacket(priority, ssrc, seq_no, corrected_time_ms,
@ -1155,11 +1155,11 @@ void RTPSender::SetMid(const std::string& mid) {
mid_ = mid;
}
rtc::Optional<uint32_t> RTPSender::FlexfecSsrc() const {
absl::optional<uint32_t> RTPSender::FlexfecSsrc() const {
if (video_) {
return video_->FlexfecSsrc();
}
return rtc::nullopt;
return absl::nullopt;
}
void RTPSender::SetCsrcs(const std::vector<uint32_t>& csrcs) {

10
modules/rtp_rtcp/source/rtp_sender.h
View File

@ -17,9 +17,9 @@
#include <utility>
#include <vector>
#include "absl/types/optional.h"
#include "api/array_view.h"
#include "api/call/transport.h"
#include "api/optional.h"
#include "common_types.h" // NOLINT(build/include)
#include "modules/rtp_rtcp/include/flexfec_sender.h"
#include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
@ -172,7 +172,7 @@ class RTPSender {
uint32_t SSRC() const;
rtc::Optional<uint32_t> FlexfecSsrc() const;
absl::optional<uint32_t> FlexfecSsrc() const;
bool SendToNetwork(std::unique_ptr<RtpPacketToSend> packet,
StorageType storage,
@ -315,9 +315,9 @@ class RTPSender {
bool sequence_number_forced_ RTC_GUARDED_BY(send_critsect_);
uint16_t sequence_number_ RTC_GUARDED_BY(send_critsect_);
uint16_t sequence_number_rtx_ RTC_GUARDED_BY(send_critsect_);
// Must be explicitly set by the application, use of rtc::Optional
// Must be explicitly set by the application, use of absl::optional
// only to keep track of correct use.
rtc::Optional<uint32_t> ssrc_ RTC_GUARDED_BY(send_critsect_);
absl::optional<uint32_t> ssrc_ RTC_GUARDED_BY(send_critsect_);
// MID value to send in the MID header extension.
std::string mid_ RTC_GUARDED_BY(send_critsect_);
uint32_t last_rtp_timestamp_ RTC_GUARDED_BY(send_critsect_);
@ -327,7 +327,7 @@ class RTPSender {
bool last_packet_marker_bit_ RTC_GUARDED_BY(send_critsect_);
std::vector<uint32_t> csrcs_ RTC_GUARDED_BY(send_critsect_);
int rtx_ RTC_GUARDED_BY(send_critsect_);
rtc::Optional<uint32_t> ssrc_rtx_ RTC_GUARDED_BY(send_critsect_);
absl::optional<uint32_t> ssrc_rtx_ RTC_GUARDED_BY(send_critsect_);
// Mapping rtx_payload_type_map_[associated] = rtx.
std::map<int8_t, int8_t> rtx_payload_type_map_ RTC_GUARDED_BY(send_critsect_);
size_t rtp_overhead_bytes_per_packet_ RTC_GUARDED_BY(send_critsect_);

6
modules/rtp_rtcp/source/rtp_sender_video.cc
View File

@ -264,11 +264,11 @@ void RTPSenderVideo::SetFecParameters(const FecProtectionParams& delta_params,
key_fec_params_ = key_params;
}
rtc::Optional<uint32_t> RTPSenderVideo::FlexfecSsrc() const {
absl::optional<uint32_t> RTPSenderVideo::FlexfecSsrc() const {
if (flexfec_sender_) {
return flexfec_sender_->ssrc();
}
return rtc::nullopt;
return absl::nullopt;
}
bool RTPSenderVideo::SendVideo(enum VideoCodecType video_type,
@ -503,7 +503,7 @@ bool RTPSenderVideo::UpdateConditionalRetransmit(
int64_t expected_next_frame_time = kUndefined;
for (int i = temporal_id - 1; i >= 0; --i) {
TemporalLayerStats* stats = &frame_stats_by_temporal_layer_[i];
rtc::Optional<uint32_t> rate = stats->frame_rate_fp1000s.Rate(now_ms);
absl::optional<uint32_t> rate = stats->frame_rate_fp1000s.Rate(now_ms);
if (rate) {
int64_t tl_next = stats->last_frame_time_ms + 1000000 / *rate;
if (tl_next - now_ms > -expected_retransmission_time_ms &&

4
modules/rtp_rtcp/source/rtp_sender_video.h
View File

@ -14,7 +14,7 @@
#include <map>
#include <memory>
#include "api/optional.h"
#include "absl/types/optional.h"
#include "common_types.h" // NOLINT(build/include)
#include "modules/rtp_rtcp/include/flexfec_sender.h"
#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
@ -70,7 +70,7 @@ class RTPSenderVideo {
const FecProtectionParams& key_params);
// FlexFEC.
rtc::Optional<uint32_t> FlexfecSsrc() const;
absl::optional<uint32_t> FlexfecSsrc() const;
uint32_t VideoBitrateSent() const;
uint32_t FecOverheadRate() const;