Removes uninitialized constructors for units.

Bug: webrtc:9155
Change-Id: I6e95cf123e7a74b5911cc101571cb04bee152381
Reviewed-on: https://webrtc-review.googlesource.com/73370
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Reviewed-by: Björn Terelius <terelius@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#23142}

modules/congestion_controller/network_control/units/data_rate.cc

@@ -19,8 +19,6 @@ std::string ToString(const DataRate& value) {
   rtc::SimpleStringBuilder sb(buf);
   if (value.IsInfinite()) {
     sb << "inf bps";
-  } else if (!value.IsInitialized()) {
-    sb << "? bps";
   } else {
     sb << value.bps() << " bps";
   }

modules/congestion_controller/network_control/units/data_rate.h

@@ -25,7 +25,6 @@
 namespace webrtc {
 namespace data_rate_impl {
 constexpr int64_t kPlusInfinityVal = std::numeric_limits<int64_t>::max();
-constexpr int64_t kNotInitializedVal = -1;
 
 inline int64_t Microbits(const DataSize& size) {
   constexpr int64_t kMaxBeforeConversion =
@@ -41,7 +40,7 @@ inline int64_t Microbits(const DataSize& size) {
 // second (bps).
 class DataRate {
  public:
-  DataRate() : DataRate(data_rate_impl::kNotInitializedVal) {}
+  DataRate() = delete;
   static DataRate Zero() { return DataRate(0); }
   static DataRate Infinity() {
     return DataRate(data_rate_impl::kPlusInfinityVal);
@@ -61,18 +60,12 @@ class DataRate {
     return bits_per_sec_;
   }
   int64_t bps() const { return bits_per_second(); }
-  int64_t bps_or(int64_t fallback) const {
-    return IsFinite() ? bits_per_second() : fallback;
-  }
   int64_t kbps() const { return (bps() + 500) / 1000; }
   bool IsZero() const { return bits_per_sec_ == 0; }
   bool IsInfinite() const {
     return bits_per_sec_ == data_rate_impl::kPlusInfinityVal;
   }
-  bool IsInitialized() const {
+  bool IsFinite() const { return !IsInfinite(); }
-    return bits_per_sec_ != data_rate_impl::kNotInitializedVal;
-  }
-  bool IsFinite() const { return IsInitialized() && !IsInfinite(); }
 
   bool operator==(const DataRate& other) const {
     return bits_per_sec_ == other.bits_per_sec_;

modules/congestion_controller/network_control/units/data_size.cc

@@ -19,8 +19,6 @@ std::string ToString(const DataSize& value) {
   rtc::SimpleStringBuilder sb(buf);
   if (value.IsInfinite()) {
     sb << "inf bytes";
-  } else if (!value.IsInitialized()) {
-    sb << "? bytes";
   } else {
     sb << value.bytes() << " bytes";
   }

modules/congestion_controller/network_control/units/data_size.h

@@ -21,13 +21,12 @@
 namespace webrtc {
 namespace data_size_impl {
 constexpr int64_t kPlusInfinityVal = std::numeric_limits<int64_t>::max();
-constexpr int64_t kNotInitializedVal = -1;
 }  // namespace data_size_impl
 
 // DataSize is a class represeting a count of bytes.
 class DataSize {
  public:
-  DataSize() : DataSize(data_size_impl::kNotInitializedVal) {}
+  DataSize() = delete;
   static DataSize Zero() { return DataSize(0); }
   static DataSize Infinity() {
     return DataSize(data_size_impl::kPlusInfinityVal);
@@ -43,10 +42,7 @@ class DataSize {
   int64_t kilobytes() const { return (bytes() + 500) / 1000; }
   bool IsZero() const { return bytes_ == 0; }
   bool IsInfinite() const { return bytes_ == data_size_impl::kPlusInfinityVal; }
-  bool IsInitialized() const {
+  bool IsFinite() const { return !IsInfinite(); }
-    return bytes_ != data_size_impl::kNotInitializedVal;
-  }
-  bool IsFinite() const { return IsInitialized() && !IsInfinite(); }
   DataSize operator-(const DataSize& other) const {
     return DataSize::bytes(bytes() - other.bytes());
   }

modules/congestion_controller/network_control/units/time_delta.cc

@@ -21,8 +21,6 @@ std::string ToString(const TimeDelta& value) {
     sb << "+inf ms";
   } else if (value.IsMinusInfinity()) {
     sb << "-inf ms";
-  } else if (!value.IsInitialized()) {
-    sb << "? ms";
   } else {
     sb << value.ms() << " ms";
   }

modules/congestion_controller/network_control/units/time_delta.h

@@ -22,8 +22,6 @@ namespace webrtc {
 namespace timedelta_impl {
 constexpr int64_t kPlusInfinityVal = std::numeric_limits<int64_t>::max();
 constexpr int64_t kMinusInfinityVal = std::numeric_limits<int64_t>::min();
-constexpr int64_t kSignedNotInitializedVal = kMinusInfinityVal + 1;
-
 }  // namespace timedelta_impl
 
 // TimeDelta represents the difference between two timestamps. Commonly this can
@@ -35,7 +33,7 @@ constexpr int64_t kSignedNotInitializedVal = kMinusInfinityVal + 1;
 // microseconds (us).
 class TimeDelta {
  public:
-  TimeDelta() : TimeDelta(timedelta_impl::kSignedNotInitializedVal) {}
+  TimeDelta() = delete;
   static TimeDelta Zero() { return TimeDelta(0); }
   static TimeDelta PlusInfinity() {
     return TimeDelta(timedelta_impl::kPlusInfinityVal);
@@ -53,7 +51,6 @@ class TimeDelta {
     // Infinities only allowed via use of explicit constants.
     RTC_DCHECK(microseconds > std::numeric_limits<int64_t>::min());
     RTC_DCHECK(microseconds < std::numeric_limits<int64_t>::max());
-    RTC_DCHECK(microseconds != timedelta_impl::kSignedNotInitializedVal);
     return TimeDelta(microseconds);
   }
   int64_t seconds() const {
@@ -69,10 +66,7 @@ class TimeDelta {
 
   TimeDelta Abs() const { return TimeDelta::us(std::abs(us())); }
   bool IsZero() const { return microseconds_ == 0; }
-  bool IsFinite() const { return IsInitialized() && !IsInfinite(); }
+  bool IsFinite() const { return !IsInfinite(); }
-  bool IsInitialized() const {
-    return microseconds_ != timedelta_impl::kSignedNotInitializedVal;
-  }
   bool IsInfinite() const {
     return microseconds_ == timedelta_impl::kPlusInfinityVal ||
            microseconds_ == timedelta_impl::kMinusInfinityVal;

modules/congestion_controller/network_control/units/timestamp.cc

@@ -16,8 +16,6 @@ namespace webrtc {
 double Timestamp::SecondsAsDouble() const {
   if (IsInfinite()) {
     return std::numeric_limits<double>::infinity();
-  } else if (!IsInitialized()) {
-    return std::numeric_limits<double>::signaling_NaN();
   } else {
     return us() * 1e-6;
   }
@@ -28,8 +26,6 @@ std::string ToString(const Timestamp& value) {
   rtc::SimpleStringBuilder sb(buf);
   if (value.IsInfinite()) {
     sb << "inf ms";
-  } else if (!value.IsInitialized()) {
-    sb << "? ms";
   } else {
     sb << value.ms() << " ms";
   }

modules/congestion_controller/network_control/units/timestamp.h

@@ -22,8 +22,6 @@ namespace webrtc {
 namespace timestamp_impl {
 constexpr int64_t kPlusInfinityVal = std::numeric_limits<int64_t>::max();
 constexpr int64_t kMinusInfinityVal = std::numeric_limits<int64_t>::min();
-constexpr int64_t kSignedNotInitializedVal = kMinusInfinityVal + 1;
-constexpr int64_t kNotInitializedVal = -1;
 }  // namespace timestamp_impl
 
 // Timestamp represents the time that has passed since some unspecified epoch.
@@ -32,7 +30,7 @@ constexpr int64_t kNotInitializedVal = -1;
 // difference of two Timestamps results in a TimeDelta.
 class Timestamp {
  public:
-  Timestamp() : Timestamp(timestamp_impl::kNotInitializedVal) {}
+  Timestamp() = delete;
   static Timestamp Infinity() {
     return Timestamp(timestamp_impl::kPlusInfinityVal);
   }
@@ -56,10 +54,7 @@ class Timestamp {
   bool IsInfinite() const {
     return microseconds_ == timestamp_impl::kPlusInfinityVal;
   }
-  bool IsInitialized() const {
+  bool IsFinite() const { return !IsInfinite(); }
-    return microseconds_ != timestamp_impl::kNotInitializedVal;
-  }
-  bool IsFinite() const { return IsInitialized() && !IsInfinite(); }
   TimeDelta operator-(const Timestamp& other) const {
     return TimeDelta::us(us() - other.us());
   }

modules/congestion_controller/network_control/units/timestamp_unittest.cc

@@ -37,7 +37,6 @@ TEST(TimestampTest, IdentityChecks) {
   EXPECT_TRUE(Timestamp::Infinity().IsInfinite());
   EXPECT_FALSE(Timestamp::ms(kValue).IsInfinite());
 
-  EXPECT_FALSE(Timestamp().IsFinite());
   EXPECT_FALSE(Timestamp::Infinity().IsFinite());
   EXPECT_TRUE(Timestamp::ms(kValue).IsFinite());
 }