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

Adds signed infinity to timestamps.

Browse Source 
Negative infinity is useful in comparisons as it represents a value
guaranteed to be less than any other timestamp. This avoid using
Timestamp::ms(0) to represent such a value or having to use optional
for the special case of first time execution.

To avoid ambiguity, Timestamp::Infinity is renamed to PlusInfinity.

Bug: webrtc:9709
Change-Id: Ib2debff91036e94d1dc903ec0c6faae30febde4e
Reviewed-on: https://webrtc-review.googlesource.com/79440
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#24556}
This commit is contained in:
Sebastian Jansson
2018-09-04 17:32:36 +02:00
committed by Commit Bot
parent 376e1147e6
commit 9de4ef4b24
15 changed files with 130 additions and 72 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
api/transport/network_types.cc
View File

@ -48,7 +48,7 @@ std::vector<PacketResult> TransportPacketsFeedback::ReceivedWithSendInfo()
std::vector<PacketResult> TransportPacketsFeedback::LostWithSendInfo() const {
std::vector<PacketResult> res;
for (const PacketResult& fb : packet_feedbacks) {
if (fb.receive_time.IsInfinite() && fb.sent_packet.has_value()) {
if (fb.receive_time.IsPlusInfinity() && fb.sent_packet.has_value()) {
res.push_back(fb);
}
}

34
api/transport/network_types.h
View File

@ -30,7 +30,7 @@ struct StreamsConfig {
StreamsConfig();
StreamsConfig(const StreamsConfig&);
~StreamsConfig();
Timestamp at_time = Timestamp::Infinity();
Timestamp at_time = Timestamp::PlusInfinity();
bool requests_alr_probing = false;
absl::optional<double> pacing_factor;
absl::optional<DataRate> min_pacing_rate;
@ -42,7 +42,7 @@ struct TargetRateConstraints {
TargetRateConstraints();
TargetRateConstraints(const TargetRateConstraints&);
~TargetRateConstraints();
Timestamp at_time = Timestamp::Infinity();
Timestamp at_time = Timestamp::PlusInfinity();
absl::optional<DataRate> min_data_rate;
absl::optional<DataRate> max_data_rate;
// The initial bandwidth estimate to base target rate on. This should be used
@ -53,7 +53,7 @@ struct TargetRateConstraints {
// Send side information
struct NetworkAvailability {
Timestamp at_time = Timestamp::Infinity();
Timestamp at_time = Timestamp::PlusInfinity();
bool network_available = false;
};
@ -61,7 +61,7 @@ struct NetworkRouteChange {
NetworkRouteChange();
NetworkRouteChange(const NetworkRouteChange&);
~NetworkRouteChange();
Timestamp at_time = Timestamp::Infinity();
Timestamp at_time = Timestamp::PlusInfinity();
// The TargetRateConstraints are set here so they can be changed synchronously
// when network route changes.
TargetRateConstraints constraints;
@ -84,7 +84,7 @@ struct PacedPacketInfo {
};
struct SentPacket {
Timestamp send_time = Timestamp::Infinity();
Timestamp send_time = Timestamp::PlusInfinity();
DataSize size = DataSize::Zero();
PacedPacketInfo pacing_info;
// Transport independent sequence number, any tracked packet should have a
@ -98,20 +98,20 @@ struct SentPacket {
// Transport level feedback
struct RemoteBitrateReport {
Timestamp receive_time = Timestamp::Infinity();
Timestamp receive_time = Timestamp::PlusInfinity();
DataRate bandwidth = DataRate::Infinity();
};
struct RoundTripTimeUpdate {
Timestamp receive_time = Timestamp::Infinity();
Timestamp receive_time = Timestamp::PlusInfinity();
TimeDelta round_trip_time = TimeDelta::PlusInfinity();
bool smoothed = false;
};
struct TransportLossReport {
Timestamp receive_time = Timestamp::Infinity();
Timestamp start_time = Timestamp::Infinity();
Timestamp end_time = Timestamp::Infinity();
Timestamp receive_time = Timestamp::PlusInfinity();
Timestamp start_time = Timestamp::PlusInfinity();
Timestamp end_time = Timestamp::PlusInfinity();
uint64_t packets_lost_delta = 0;
uint64_t packets_received_delta = 0;
};
@ -124,7 +124,7 @@ struct PacketResult {
~PacketResult();
absl::optional<SentPacket> sent_packet;
Timestamp receive_time = Timestamp::Infinity();
Timestamp receive_time = Timestamp::PlusInfinity();
};
struct TransportPacketsFeedback {
@ -132,7 +132,7 @@ struct TransportPacketsFeedback {
TransportPacketsFeedback(const TransportPacketsFeedback& other);
~TransportPacketsFeedback();
Timestamp feedback_time = Timestamp::Infinity();
Timestamp feedback_time = Timestamp::PlusInfinity();
DataSize data_in_flight = DataSize::Zero();
DataSize prior_in_flight = DataSize::Zero();
std::vector<PacketResult> packet_feedbacks;
@ -145,7 +145,7 @@ struct TransportPacketsFeedback {
// Network estimation
struct NetworkEstimate {
Timestamp at_time = Timestamp::Infinity();
Timestamp at_time = Timestamp::PlusInfinity();
DataRate bandwidth = DataRate::Infinity();
TimeDelta round_trip_time = TimeDelta::PlusInfinity();
TimeDelta bwe_period = TimeDelta::PlusInfinity();
@ -156,7 +156,7 @@ struct NetworkEstimate {
// Network control
struct PacerConfig {
Timestamp at_time = Timestamp::Infinity();
Timestamp at_time = Timestamp::PlusInfinity();
// Pacer should send at most data_window data over time_window duration.
DataSize data_window = DataSize::Infinity();
TimeDelta time_window = TimeDelta::PlusInfinity();
@ -167,14 +167,14 @@ struct PacerConfig {
};
struct ProbeClusterConfig {
Timestamp at_time = Timestamp::Infinity();
Timestamp at_time = Timestamp::PlusInfinity();
DataRate target_data_rate = DataRate::Zero();
TimeDelta target_duration = TimeDelta::Zero();
int32_t target_probe_count = 0;
};
struct TargetTransferRate {
Timestamp at_time = Timestamp::Infinity();
Timestamp at_time = Timestamp::PlusInfinity();
// The estimate on which the target rate is based on.
NetworkEstimate network_estimate;
DataRate target_rate = DataRate::Zero();
@ -195,7 +195,7 @@ struct NetworkControlUpdate {
// Process control
struct ProcessInterval {
Timestamp at_time = Timestamp::Infinity();
Timestamp at_time = Timestamp::PlusInfinity();
};
} // namespace webrtc

6
api/units/time_delta_unittest.cc
View File

@ -74,6 +74,12 @@ TEST(TimeDeltaTest, IdentityChecks) {
EXPECT_TRUE(TimeDelta::ms(-kValue).IsFinite());
EXPECT_TRUE(TimeDelta::ms(kValue).IsFinite());
EXPECT_TRUE(TimeDelta::Zero().IsFinite());
EXPECT_TRUE(TimeDelta::PlusInfinity().IsPlusInfinity());
EXPECT_FALSE(TimeDelta::MinusInfinity().IsPlusInfinity());
EXPECT_TRUE(TimeDelta::MinusInfinity().IsMinusInfinity());
EXPECT_FALSE(TimeDelta::PlusInfinity().IsMinusInfinity());
}
TEST(TimeDeltaTest, ComparisonOperators) {

72
api/units/timestamp.h
View File

@ -36,9 +36,12 @@ constexpr int64_t kMinusInfinityVal = std::numeric_limits<int64_t>::min();
class Timestamp {
public:
Timestamp() = delete;
static constexpr Timestamp Infinity() {
static constexpr Timestamp PlusInfinity() {
return Timestamp(timestamp_impl::kPlusInfinityVal);
}
static constexpr Timestamp MinusInfinity() {
return Timestamp(timestamp_impl::kMinusInfinityVal);
}
template <int64_t seconds>
static constexpr Timestamp Seconds() {
static_assert(seconds >= 0, "");
@ -103,7 +106,9 @@ class Timestamp {
nullptr>
static Timestamp us(T microseconds) {
if (microseconds == std::numeric_limits<double>::infinity()) {
return Infinity();
return PlusInfinity();
} else if (microseconds == -std::numeric_limits<double>::infinity()) {
return MinusInfinity();
} else {
RTC_DCHECK(!std::isnan(microseconds));
RTC_DCHECK_GE(microseconds, 0);
@ -141,7 +146,10 @@ class Timestamp {
template <typename T>
constexpr typename std::enable_if<std::is_floating_point<T>::value, T>::type
us() const {
return IsInfinite() ? std::numeric_limits<T>::infinity() : microseconds_;
return IsPlusInfinity()
? std::numeric_limits<T>::infinity()
: IsMinusInfinity() ? -std::numeric_limits<T>::infinity()
: microseconds_;
}
constexpr int64_t seconds_or(int64_t fallback_value) const {
@ -154,25 +162,53 @@ class Timestamp {
return IsFinite() ? microseconds_ : fallback_value;
}
constexpr bool IsInfinite() const {
return microseconds_ == timestamp_impl::kPlusInfinityVal;
}
constexpr bool IsFinite() const { return !IsInfinite(); }
constexpr bool IsInfinite() const {
return microseconds_ == timedelta_impl::kPlusInfinityVal ||
microseconds_ == timedelta_impl::kMinusInfinityVal;
}
constexpr bool IsPlusInfinity() const {
return microseconds_ == timedelta_impl::kPlusInfinityVal;
}
constexpr bool IsMinusInfinity() const {
return microseconds_ == timedelta_impl::kMinusInfinityVal;
}
Timestamp operator+(const TimeDelta& other) const {
if (IsPlusInfinity() || other.IsPlusInfinity()) {
RTC_DCHECK(!IsMinusInfinity());
RTC_DCHECK(!other.IsMinusInfinity());
return PlusInfinity();
} else if (IsMinusInfinity() || other.IsMinusInfinity()) {
RTC_DCHECK(!IsPlusInfinity());
RTC_DCHECK(!other.IsPlusInfinity());
return MinusInfinity();
}
return Timestamp::us(us() + other.us());
}
Timestamp operator-(const TimeDelta& other) const {
if (IsPlusInfinity() || other.IsMinusInfinity()) {
RTC_DCHECK(!IsMinusInfinity());
RTC_DCHECK(!other.IsPlusInfinity());
return PlusInfinity();
} else if (IsMinusInfinity() || other.IsPlusInfinity()) {
RTC_DCHECK(!IsPlusInfinity());
RTC_DCHECK(!other.IsMinusInfinity());
return MinusInfinity();
}
return Timestamp::us(us() - other.us());
}
TimeDelta operator-(const Timestamp& other) const {
if (IsPlusInfinity() || other.IsMinusInfinity()) {
RTC_DCHECK(!IsMinusInfinity());
RTC_DCHECK(!other.IsPlusInfinity());
return TimeDelta::PlusInfinity();
} else if (IsMinusInfinity() || other.IsPlusInfinity()) {
RTC_DCHECK(!IsPlusInfinity());
RTC_DCHECK(!other.IsMinusInfinity());
return TimeDelta::MinusInfinity();
}
return TimeDelta::us(us() - other.us());
}
Timestamp operator-(const TimeDelta& delta) const {
RTC_DCHECK(!delta.IsPlusInfinity());
if (IsInfinite() || delta.IsMinusInfinity())
return Infinity();
return Timestamp::us(us() - delta.us());
}
Timestamp operator+(const TimeDelta& delta) const {
RTC_DCHECK(!delta.IsMinusInfinity());
if (IsInfinite() || delta.IsPlusInfinity())
return Infinity();
return Timestamp::us(us() + delta.us());
}
Timestamp& operator-=(const TimeDelta& other) {
*this = *this - other;
return *this;

43
api/units/timestamp_unittest.cc
View File

@ -15,7 +15,7 @@ namespace webrtc {
namespace test {
TEST(TimestampTest, ConstExpr) {
constexpr int64_t kValue = 12345;
constexpr Timestamp kTimestampInf = Timestamp::Infinity();
constexpr Timestamp kTimestampInf = Timestamp::PlusInfinity();
static_assert(kTimestampInf.IsInfinite(), "");
static_assert(kTimestampInf.ms_or(-1) == -1, "");
@ -55,20 +55,28 @@ TEST(TimestampTest, GetDifferentPrefix) {
TEST(TimestampTest, IdentityChecks) {
const int64_t kValue = 3000;
EXPECT_TRUE(Timestamp::Infinity().IsInfinite());
EXPECT_TRUE(Timestamp::PlusInfinity().IsInfinite());
EXPECT_TRUE(Timestamp::MinusInfinity().IsInfinite());
EXPECT_FALSE(Timestamp::ms(kValue).IsInfinite());
EXPECT_FALSE(Timestamp::Infinity().IsFinite());
EXPECT_FALSE(Timestamp::PlusInfinity().IsFinite());
EXPECT_FALSE(Timestamp::MinusInfinity().IsFinite());
EXPECT_TRUE(Timestamp::ms(kValue).IsFinite());
EXPECT_TRUE(Timestamp::PlusInfinity().IsPlusInfinity());
EXPECT_FALSE(Timestamp::MinusInfinity().IsPlusInfinity());
EXPECT_TRUE(Timestamp::MinusInfinity().IsMinusInfinity());
EXPECT_FALSE(Timestamp::PlusInfinity().IsMinusInfinity());
}
TEST(TimestampTest, ComparisonOperators) {
const int64_t kSmall = 450;
const int64_t kLarge = 451;
EXPECT_EQ(Timestamp::Infinity(), Timestamp::Infinity());
EXPECT_GE(Timestamp::Infinity(), Timestamp::Infinity());
EXPECT_GT(Timestamp::Infinity(), Timestamp::ms(kLarge));
EXPECT_EQ(Timestamp::PlusInfinity(), Timestamp::PlusInfinity());
EXPECT_GE(Timestamp::PlusInfinity(), Timestamp::PlusInfinity());
EXPECT_GT(Timestamp::PlusInfinity(), Timestamp::ms(kLarge));
EXPECT_EQ(Timestamp::ms(kSmall), Timestamp::ms(kSmall));
EXPECT_LE(Timestamp::ms(kSmall), Timestamp::ms(kSmall));
EXPECT_GE(Timestamp::ms(kSmall), Timestamp::ms(kSmall));
@ -102,14 +110,21 @@ TEST(TimestampTest, ConvertsToAndFromDouble) {
EXPECT_EQ(Timestamp::us(kMicrosDouble).us(), kMicros);
const double kPlusInfinity = std::numeric_limits<double>::infinity();
const double kMinusInfinity = -kPlusInfinity;
EXPECT_EQ(Timestamp::Infinity().seconds<double>(), kPlusInfinity);
EXPECT_EQ(Timestamp::Infinity().ms<double>(), kPlusInfinity);
EXPECT_EQ(Timestamp::Infinity().us<double>(), kPlusInfinity);
EXPECT_EQ(Timestamp::PlusInfinity().seconds<double>(), kPlusInfinity);
EXPECT_EQ(Timestamp::MinusInfinity().seconds<double>(), kMinusInfinity);
EXPECT_EQ(Timestamp::PlusInfinity().ms<double>(), kPlusInfinity);
EXPECT_EQ(Timestamp::MinusInfinity().ms<double>(), kMinusInfinity);
EXPECT_EQ(Timestamp::PlusInfinity().us<double>(), kPlusInfinity);
EXPECT_EQ(Timestamp::MinusInfinity().us<double>(), kMinusInfinity);
EXPECT_TRUE(Timestamp::seconds(kPlusInfinity).IsInfinite());
EXPECT_TRUE(Timestamp::ms(kPlusInfinity).IsInfinite());
EXPECT_TRUE(Timestamp::us(kPlusInfinity).IsInfinite());
EXPECT_TRUE(Timestamp::seconds(kPlusInfinity).IsPlusInfinity());
EXPECT_TRUE(Timestamp::seconds(kMinusInfinity).IsMinusInfinity());
EXPECT_TRUE(Timestamp::ms(kPlusInfinity).IsPlusInfinity());
EXPECT_TRUE(Timestamp::ms(kMinusInfinity).IsMinusInfinity());
EXPECT_TRUE(Timestamp::us(kPlusInfinity).IsPlusInfinity());
EXPECT_TRUE(Timestamp::us(kMinusInfinity).IsMinusInfinity());
}
TEST(UnitConversionTest, TimestampAndTimeDeltaMath) {
@ -135,8 +150,8 @@ TEST(UnitConversionTest, InfinityOperations) {
const int64_t kValue = 267;
const Timestamp finite_time = Timestamp::ms(kValue);
const TimeDelta finite_delta = TimeDelta::ms(kValue);
EXPECT_TRUE((Timestamp::Infinity() + finite_delta).IsInfinite());
EXPECT_TRUE((Timestamp::Infinity() - finite_delta).IsInfinite());
EXPECT_TRUE((Timestamp::PlusInfinity() + finite_delta).IsInfinite());
EXPECT_TRUE((Timestamp::PlusInfinity() - finite_delta).IsInfinite());
EXPECT_TRUE((finite_time + TimeDelta::PlusInfinity()).IsInfinite());
EXPECT_TRUE((finite_time - TimeDelta::MinusInfinity()).IsInfinite());
}

2
modules/congestion_controller/bbr/bandwidth_sampler.cc
View File

@ -189,7 +189,7 @@ BandwidthSampler::ConnectionStateOnSentPacket::ConnectionStateOnSentPacket(
is_app_limited(sampler.is_app_limited_) {}
BandwidthSampler::ConnectionStateOnSentPacket::ConnectionStateOnSentPacket()
: sent_time(Timestamp::ms(0)),
: sent_time(Timestamp::MinusInfinity()),
size(DataSize::Zero()),
total_data_sent(DataSize::Zero()),
total_data_sent_at_last_acked_packet(DataSize::Zero()),

5
modules/congestion_controller/bbr/bbr_network_controller.cc
View File

@ -155,7 +155,6 @@ BbrNetworkController::BbrControllerConfig::FromTrial() {
webrtc::field_trial::FindFullName(kBbrConfigTrial));
}
BbrNetworkController::DebugState::DebugState(const BbrNetworkController& sender)
: mode(sender.mode_),
max_bandwidth(sender.max_bandwidth_.GetBest()),
@ -193,7 +192,7 @@ BbrNetworkController::BbrNetworkController(NetworkControllerConfig config)
max_aggregation_bytes_multiplier_(0),
min_rtt_(TimeDelta::Zero()),
last_rtt_(TimeDelta::Zero()),
min_rtt_timestamp_(Timestamp::ms(0)),
min_rtt_timestamp_(Timestamp::MinusInfinity()),
congestion_window_(config_.initial_congestion_window),
initial_congestion_window_(config_.initial_congestion_window),
min_congestion_window_(config_.min_congestion_window),
@ -203,7 +202,7 @@ BbrNetworkController::BbrNetworkController(NetworkControllerConfig config)
congestion_window_gain_constant_(kProbeBWCongestionWindowGain),
rtt_variance_weight_(kBbrRttVariationWeight),
cycle_current_offset_(0),
last_cycle_start_(Timestamp::ms(0)),
last_cycle_start_(Timestamp::MinusInfinity()),
is_at_full_bandwidth_(false),
rounds_without_bandwidth_gain_(0),
bandwidth_at_last_round_(DataRate::Zero()),

4
modules/congestion_controller/bbr/data_transfer_tracker.h
View File

@ -37,8 +37,8 @@ class DataTransferTracker {
private:
struct Sample {
Timestamp ack_time = Timestamp::Infinity();
Timestamp send_time = Timestamp::Infinity();
Timestamp ack_time = Timestamp::PlusInfinity();
Timestamp send_time = Timestamp::PlusInfinity();
DataSize size_delta = DataSize::Zero();
DataSize size_sum = DataSize::Zero();
};

2
modules/congestion_controller/goog_cc/goog_cc_network_control.cc
View File

@ -326,7 +326,7 @@ NetworkControlUpdate GoogCcNetworkController::OnTransportLossReport(
NetworkControlUpdate GoogCcNetworkController::OnTransportPacketsFeedback(
TransportPacketsFeedback report) {
TimeDelta feedback_max_rtt = TimeDelta::MinusInfinity();
Timestamp max_recv_time = Timestamp::ms(0);
Timestamp max_recv_time = Timestamp::MinusInfinity();
for (const auto& packet_feedback : report.ReceivedWithSendInfo()) {
TimeDelta rtt =
report.feedback_time - packet_feedback.sent_packet->send_time;

2
modules/congestion_controller/goog_cc/goog_cc_network_control.h
View File

@ -76,7 +76,7 @@ class GoogCcNetworkController : public NetworkControllerInterface {
absl::optional<NetworkControllerConfig> initial_config_;
Timestamp next_loss_update_ = Timestamp::ms(0);
Timestamp next_loss_update_ = Timestamp::MinusInfinity();
int lost_packets_since_last_loss_update_ = 0;
int expected_packets_since_last_loss_update_ = 0;

15
modules/congestion_controller/pcc/monitor_interval_unittest.cc
View File

@ -80,7 +80,7 @@ TEST(PccMonitorIntervalTest, LossRateIsOneThirdIfLostOnePacketOutOfThree) {
kStartTime + 2 * kIntervalDuration};
std::vector<Timestamp> end_times = {
kStartTime + 2 * kIntervalDuration, kStartTime + 2 * kIntervalDuration,
Timestamp::Infinity(), kStartTime + 2 * kIntervalDuration,
Timestamp::PlusInfinity(), kStartTime + 2 * kIntervalDuration,
kStartTime + 4 * kIntervalDuration};
std::vector<DataSize> packet_sizes = {
kDefaultPacketSize, 2 * kDefaultPacketSize, 3 * kDefaultPacketSize,
@ -99,8 +99,9 @@ TEST(PccMonitorIntervalTest, DelayGradientIsZeroIfNoChangeInPacketDelay) {
monitor_interval.OnPacketsFeedback(CreatePacketResults(
{kStartTime + kPacketsDelta, kStartTime + 2 * kPacketsDelta,
kStartTime + 3 * kPacketsDelta, kStartTime + 2 * kIntervalDuration},
{kStartTime + kDefaultDelay, Timestamp::Infinity(),
kStartTime + kDefaultDelay + 2 * kPacketsDelta, Timestamp::Infinity()},
{kStartTime + kDefaultDelay, Timestamp::PlusInfinity(),
kStartTime + kDefaultDelay + 2 * kPacketsDelta,
Timestamp::PlusInfinity()},
{}));
// Delay gradient should be zero, because both received packets have the
// same one way delay.
@ -127,7 +128,7 @@ TEST(PccMonitorIntervalTest, DelayGradientIsOne) {
monitor_interval.OnPacketsFeedback(CreatePacketResults(
{kStartTime + kPacketsDelta, kStartTime + 2 * kPacketsDelta,
kStartTime + 3 * kPacketsDelta, kStartTime + 3 * kIntervalDuration},
{kStartTime + kDefaultDelay, Timestamp::Infinity(),
{kStartTime + kDefaultDelay, Timestamp::PlusInfinity(),
kStartTime + 4 * kPacketsDelta + kDefaultDelay,
kStartTime + 3 * kIntervalDuration},
{}));
@ -141,7 +142,7 @@ TEST(PccMonitorIntervalTest, DelayGradientIsMinusOne) {
monitor_interval.OnPacketsFeedback(CreatePacketResults(
{kStartTime + kPacketsDelta, kStartTime + 2 * kPacketsDelta,
kStartTime + 5 * kPacketsDelta, kStartTime + 2 * kIntervalDuration},
{kStartTime + kDefaultDelay, Timestamp::Infinity(),
{kStartTime + kDefaultDelay, Timestamp::PlusInfinity(),
kStartTime + kDefaultDelay, kStartTime + 3 * kIntervalDuration},
{}));
EXPECT_DOUBLE_EQ(
@ -155,7 +156,7 @@ TEST(PccMonitorIntervalTest,
monitor_interval.OnPacketsFeedback(CreatePacketResults(
{kStartTime + kPacketsDelta, kStartTime + kPacketsDelta,
kStartTime + 102 * kPacketsDelta, kStartTime + 2 * kIntervalDuration},
{kStartTime + kDefaultDelay, Timestamp::Infinity(),
{kStartTime + kDefaultDelay, Timestamp::PlusInfinity(),
kStartTime + kDefaultDelay + kPacketsDelta,
kStartTime + 3 * kIntervalDuration},
{}));
@ -171,7 +172,7 @@ TEST(PccMonitorIntervalTest,
monitor_interval.OnPacketsFeedback(CreatePacketResults(
{kStartTime + kPacketsDelta, kStartTime + kPacketsDelta,
kStartTime + kPacketsDelta, kStartTime + 2 * kIntervalDuration},
{kStartTime + kDefaultDelay, Timestamp::Infinity(),
{kStartTime + kDefaultDelay, Timestamp::PlusInfinity(),
kStartTime + kDefaultDelay + kPacketsDelta,
kStartTime + 3 * kIntervalDuration},
{}));

4
modules/congestion_controller/pcc/pcc_network_controller.cc
View File

@ -49,8 +49,8 @@ const uint64_t kRandomSeed = 100;
} // namespace
PccNetworkController::PccNetworkController(NetworkControllerConfig config)
: start_time_(Timestamp::Infinity()),
last_sent_packet_time_(Timestamp::Infinity()),
: start_time_(Timestamp::PlusInfinity()),
last_sent_packet_time_(Timestamp::PlusInfinity()),
smoothed_packets_sending_interval_(TimeDelta::Zero()),
mode_(Mode::kStartup),
default_bandwidth_(DataRate::kbps(kInitialBandwidthKbps)),

2
modules/congestion_controller/pcc/rtt_tracker_unittest.cc
View File

@ -27,7 +27,7 @@ PacketResult GetPacketWithRtt(TimeDelta rtt) {
if (rtt.IsFinite()) {
packet_result.receive_time = kStartTime + rtt;
} else {
packet_result.receive_time = Timestamp::Infinity();
packet_result.receive_time = Timestamp::PlusInfinity();
}
return packet_result;
}

7
modules/congestion_controller/pcc/utility_function_unittest.cc
View File

@ -67,8 +67,9 @@ TEST(PccVivaceUtilityFunctionTest,
monitor_interval.OnPacketsFeedback(CreatePacketResults(
{kStartTime + kPacketsDelta, kStartTime + 2 * kPacketsDelta,
kStartTime + 3 * kPacketsDelta, kStartTime + 2 * kIntervalDuration},
{kStartTime + kPacketsDelta + kDefaultDelay, Timestamp::Infinity(),
kStartTime + kDefaultDelay + 3 * kPacketsDelta, Timestamp::Infinity()},
{kStartTime + kPacketsDelta + kDefaultDelay, Timestamp::PlusInfinity(),
kStartTime + kDefaultDelay + 3 * kPacketsDelta,
Timestamp::PlusInfinity()},
{kDefaultDataSize, kDefaultDataSize, kDefaultDataSize,
kDefaultDataSize}));
EXPECT_DOUBLE_EQ(utility_function.Compute(monitor_interval),
@ -86,7 +87,7 @@ TEST(PccVivaceUtilityFunctionTest,
monitor_interval.OnPacketsFeedback(CreatePacketResults(
{kStartTime + kPacketsDelta, kStartTime + 2 * kPacketsDelta,
kStartTime + 5 * kPacketsDelta, kStartTime + 2 * kIntervalDuration},
{kStartTime + kDefaultDelay, Timestamp::Infinity(),
{kStartTime + kDefaultDelay, Timestamp::PlusInfinity(),
kStartTime + kDefaultDelay, kStartTime + 3 * kIntervalDuration},
{}));
// The second packet was lost.

2
modules/congestion_controller/rtp/send_side_congestion_controller.cc
View File

@ -78,7 +78,7 @@ PacketResult NetworkPacketFeedbackFromRtpPacketFeedback(
const webrtc::PacketFeedback& pf) {
PacketResult feedback;
if (pf.arrival_time_ms == webrtc::PacketFeedback::kNotReceived)
feedback.receive_time = Timestamp::Infinity();
feedback.receive_time = Timestamp::PlusInfinity();
else
feedback.receive_time = Timestamp::ms(pf.arrival_time_ms);
if (pf.send_time_ms != webrtc::PacketFeedback::kNoSendTime) {