diff --git a/api/transport/network_types.cc b/api/transport/network_types.cc
index b4c09d47c0..48bdcab162 100644
--- a/api/transport/network_types.cc
+++ b/api/transport/network_types.cc
@@ -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);
     }
   }
diff --git a/api/transport/network_types.h b/api/transport/network_types.h
index e34bf0e7f1..eee1de0708 100644
--- a/api/transport/network_types.h
+++ b/api/transport/network_types.h
@@ -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
 
diff --git a/api/units/time_delta_unittest.cc b/api/units/time_delta_unittest.cc
index e5906bfd4a..bf8bbce69b 100644
--- a/api/units/time_delta_unittest.cc
+++ b/api/units/time_delta_unittest.cc
@@ -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) {
diff --git a/api/units/timestamp.h b/api/units/timestamp.h
index d7e6a8db34..0298f5da97 100644
--- a/api/units/timestamp.h
+++ b/api/units/timestamp.h
@@ -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;
diff --git a/api/units/timestamp_unittest.cc b/api/units/timestamp_unittest.cc
index ff0c79e071..6c2d1eea82 100644
--- a/api/units/timestamp_unittest.cc
+++ b/api/units/timestamp_unittest.cc
@@ -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());
 }
diff --git a/modules/congestion_controller/bbr/bandwidth_sampler.cc b/modules/congestion_controller/bbr/bandwidth_sampler.cc
index b9e2c27bdd..7978e4a056 100644
--- a/modules/congestion_controller/bbr/bandwidth_sampler.cc
+++ b/modules/congestion_controller/bbr/bandwidth_sampler.cc
@@ -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()),
diff --git a/modules/congestion_controller/bbr/bbr_network_controller.cc b/modules/congestion_controller/bbr/bbr_network_controller.cc
index e096a87d5a..1b89c5d866 100644
--- a/modules/congestion_controller/bbr/bbr_network_controller.cc
+++ b/modules/congestion_controller/bbr/bbr_network_controller.cc
@@ -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()),
diff --git a/modules/congestion_controller/bbr/data_transfer_tracker.h b/modules/congestion_controller/bbr/data_transfer_tracker.h
index 25e3997c8a..29dd7a3235 100644
--- a/modules/congestion_controller/bbr/data_transfer_tracker.h
+++ b/modules/congestion_controller/bbr/data_transfer_tracker.h
@@ -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();
   };
diff --git a/modules/congestion_controller/goog_cc/goog_cc_network_control.cc b/modules/congestion_controller/goog_cc/goog_cc_network_control.cc
index 7096440bfb..00b6810941 100644
--- a/modules/congestion_controller/goog_cc/goog_cc_network_control.cc
+++ b/modules/congestion_controller/goog_cc/goog_cc_network_control.cc
@@ -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;
diff --git a/modules/congestion_controller/goog_cc/goog_cc_network_control.h b/modules/congestion_controller/goog_cc/goog_cc_network_control.h
index 934511e2b5..7166310a05 100644
--- a/modules/congestion_controller/goog_cc/goog_cc_network_control.h
+++ b/modules/congestion_controller/goog_cc/goog_cc_network_control.h
@@ -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;
 
diff --git a/modules/congestion_controller/pcc/monitor_interval_unittest.cc b/modules/congestion_controller/pcc/monitor_interval_unittest.cc
index 6e8ad02c51..08316b5634 100644
--- a/modules/congestion_controller/pcc/monitor_interval_unittest.cc
+++ b/modules/congestion_controller/pcc/monitor_interval_unittest.cc
@@ -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},
       {}));
diff --git a/modules/congestion_controller/pcc/pcc_network_controller.cc b/modules/congestion_controller/pcc/pcc_network_controller.cc
index c0e561cc39..ca4af41172 100644
--- a/modules/congestion_controller/pcc/pcc_network_controller.cc
+++ b/modules/congestion_controller/pcc/pcc_network_controller.cc
@@ -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)),
diff --git a/modules/congestion_controller/pcc/rtt_tracker_unittest.cc b/modules/congestion_controller/pcc/rtt_tracker_unittest.cc
index 4d3424ce1a..3b90122de9 100644
--- a/modules/congestion_controller/pcc/rtt_tracker_unittest.cc
+++ b/modules/congestion_controller/pcc/rtt_tracker_unittest.cc
@@ -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;
 }
diff --git a/modules/congestion_controller/pcc/utility_function_unittest.cc b/modules/congestion_controller/pcc/utility_function_unittest.cc
index c3139eda05..5bc3dc4e53 100644
--- a/modules/congestion_controller/pcc/utility_function_unittest.cc
+++ b/modules/congestion_controller/pcc/utility_function_unittest.cc
@@ -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.
diff --git a/modules/congestion_controller/rtp/send_side_congestion_controller.cc b/modules/congestion_controller/rtp/send_side_congestion_controller.cc
index 53feee6eaf..51803da3fb 100644
--- a/modules/congestion_controller/rtp/send_side_congestion_controller.cc
+++ b/modules/congestion_controller/rtp/send_side_congestion_controller.cc
@@ -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) {