Makes units constexpr when possible.

This makes the constructor and the unchecked create functions
constexpr on the unit classes Timestamp, TimeDelta, Datarate and
DataSize. This allows using the units in constexpr constants.
Unchecked access methods are made constexpr as well. Making them
usable in static asserts.

Constexpr create functions for checked construction is added in
a separate CL.

Bug: webrtc:9574
Change-Id: I605ae2e8572195dbb2078c283056208be0f43333
Reviewed-on: https://webrtc-review.googlesource.com/91160
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#24206}

api/units/data_rate.h

@@ -40,8 +40,8 @@ inline int64_t Microbits(const DataSize& size) {
 class DataRate {
  public:
   DataRate() = delete;
-  static DataRate Zero() { return DataRate(0); }
-  static DataRate Infinity() {
+  static constexpr DataRate Zero() { return DataRate(0); }
+  static constexpr DataRate Infinity() {
     return DataRate(data_rate_impl::kPlusInfinityVal);
   }
 
@@ -107,11 +107,11 @@ class DataRate {
     return bps<T>() * 1e-3;
   }
 
-  bool IsZero() const { return bits_per_sec_ == 0; }
-  bool IsInfinite() const {
+  constexpr bool IsZero() const { return bits_per_sec_ == 0; }
+  constexpr bool IsInfinite() const {
     return bits_per_sec_ == data_rate_impl::kPlusInfinityVal;
   }
-  bool IsFinite() const { return !IsInfinite(); }
+  constexpr bool IsFinite() const { return !IsInfinite(); }
 
   double operator/(const DataRate& other) const {
     return bps<double>() / other.bps<double>();
@@ -138,7 +138,8 @@ class DataRate {
  private:
   // Bits per second used internally to simplify debugging by making the value
   // more recognizable.
-  explicit DataRate(int64_t bits_per_second) : bits_per_sec_(bits_per_second) {}
+  explicit constexpr DataRate(int64_t bits_per_second)
+      : bits_per_sec_(bits_per_second) {}
   int64_t bits_per_sec_;
 };
 

api/units/data_rate_unittest.cc

@@ -13,6 +13,14 @@
 
 namespace webrtc {
 namespace test {
+
+TEST(DataRateTest, ConstExpr) {
+  constexpr DataRate kDataRateZero = DataRate::Zero();
+  constexpr DataRate kDataRateInf = DataRate::Infinity();
+  static_assert(kDataRateZero.IsZero(), "");
+  static_assert(kDataRateInf.IsInfinite(), "");
+}
+
 TEST(DataRateTest, GetBackSameValues) {
   const int64_t kValue = 123 * 8;
   EXPECT_EQ(DataRate::bps(kValue).bps(), kValue);

api/units/data_size.h

@@ -29,8 +29,8 @@ constexpr int64_t kPlusInfinityVal = std::numeric_limits<int64_t>::max();
 class DataSize {
  public:
   DataSize() = delete;
-  static DataSize Zero() { return DataSize(0); }
-  static DataSize Infinity() {
+  static constexpr DataSize Zero() { return DataSize(0); }
+  static constexpr DataSize Infinity() {
     return DataSize(data_size_impl::kPlusInfinityVal);
   }
 
@@ -73,9 +73,11 @@ class DataSize {
     }
   }
 
-  bool IsZero() const { return bytes_ == 0; }
-  bool IsInfinite() const { return bytes_ == data_size_impl::kPlusInfinityVal; }
-  bool IsFinite() const { return !IsInfinite(); }
+  constexpr bool IsZero() const { return bytes_ == 0; }
+  constexpr bool IsInfinite() const {
+    return bytes_ == data_size_impl::kPlusInfinityVal;
+  }
+  constexpr bool IsFinite() const { return !IsInfinite(); }
   DataSize operator-(const DataSize& other) const {
     return DataSize::bytes(bytes() - other.bytes());
   }
@@ -109,7 +111,7 @@ class DataSize {
   bool operator<(const DataSize& other) const { return bytes_ < other.bytes_; }
 
  private:
-  explicit DataSize(int64_t bytes) : bytes_(bytes) {}
+  explicit constexpr DataSize(int64_t bytes) : bytes_(bytes) {}
   int64_t bytes_;
 };
 

api/units/data_size_unittest.cc

@@ -14,6 +14,13 @@
 namespace webrtc {
 namespace test {
 
+TEST(DataSizeTest, ConstExpr) {
+  constexpr DataSize kDataSizeZero = DataSize::Zero();
+  constexpr DataSize kDataSizeInf = DataSize::Infinity();
+  static_assert(kDataSizeZero.IsZero(), "");
+  static_assert(kDataSizeInf.IsInfinite(), "");
+}
+
 TEST(DataSizeTest, GetBackSameValues) {
   const int64_t kValue = 123 * 8;
   EXPECT_EQ(DataSize::bytes(kValue).bytes(), kValue);

api/units/time_delta.h

@@ -35,11 +35,11 @@ constexpr int64_t kMinusInfinityVal = std::numeric_limits<int64_t>::min();
 class TimeDelta {
  public:
   TimeDelta() = delete;
-  static TimeDelta Zero() { return TimeDelta(0); }
-  static TimeDelta PlusInfinity() {
+  static constexpr TimeDelta Zero() { return TimeDelta(0); }
+  static constexpr TimeDelta PlusInfinity() {
     return TimeDelta(timedelta_impl::kPlusInfinityVal);
   }
-  static TimeDelta MinusInfinity() {
+  static constexpr TimeDelta MinusInfinity() {
     return TimeDelta(timedelta_impl::kMinusInfinityVal);
   }
 
@@ -145,16 +145,16 @@ class TimeDelta {
   }
 
   TimeDelta Abs() const { return TimeDelta::us(std::abs(us())); }
-  bool IsZero() const { return microseconds_ == 0; }
-  bool IsFinite() const { return !IsInfinite(); }
-  bool IsInfinite() const {
+  constexpr bool IsZero() const { return microseconds_ == 0; }
+  constexpr bool IsFinite() const { return !IsInfinite(); }
+  constexpr bool IsInfinite() const {
     return microseconds_ == timedelta_impl::kPlusInfinityVal ||
            microseconds_ == timedelta_impl::kMinusInfinityVal;
   }
-  bool IsPlusInfinity() const {
+  constexpr bool IsPlusInfinity() const {
     return microseconds_ == timedelta_impl::kPlusInfinityVal;
   }
-  bool IsMinusInfinity() const {
+  constexpr bool IsMinusInfinity() const {
     return microseconds_ == timedelta_impl::kMinusInfinityVal;
   }
   TimeDelta operator+(const TimeDelta& other) const {
@@ -194,7 +194,7 @@ class TimeDelta {
   }
 
  private:
-  explicit TimeDelta(int64_t us) : microseconds_(us) {}
+  explicit constexpr TimeDelta(int64_t us) : microseconds_(us) {}
   int64_t microseconds_;
 };
 

api/units/time_delta_unittest.cc

@@ -14,6 +14,14 @@
 
 namespace webrtc {
 namespace test {
+TEST(TimeDeltaTest, ConstExpr) {
+  constexpr TimeDelta kTimeDeltaZero = TimeDelta::Zero();
+  constexpr TimeDelta kTimeDeltaPlusInf = TimeDelta::PlusInfinity();
+  constexpr TimeDelta kTimeDeltaMinusInf = TimeDelta::MinusInfinity();
+  static_assert(kTimeDeltaZero.IsZero(), "");
+  static_assert(kTimeDeltaPlusInf.IsPlusInfinity(), "");
+  static_assert(kTimeDeltaMinusInf.IsMinusInfinity(), "");
+}
 
 TEST(TimeDeltaTest, GetBackSameValues) {
   const int64_t kValue = 499;

api/units/timestamp.h

@@ -32,7 +32,7 @@ constexpr int64_t kMinusInfinityVal = std::numeric_limits<int64_t>::min();
 class Timestamp {
  public:
   Timestamp() = delete;
-  static Timestamp Infinity() {
+  static constexpr Timestamp Infinity() {
     return Timestamp(timestamp_impl::kPlusInfinityVal);
   }
 
@@ -124,10 +124,10 @@ class Timestamp {
     }
   }
 
-  bool IsInfinite() const {
+  constexpr bool IsInfinite() const {
     return microseconds_ == timestamp_impl::kPlusInfinityVal;
   }
-  bool IsFinite() const { return !IsInfinite(); }
+  constexpr bool IsFinite() const { return !IsInfinite(); }
   TimeDelta operator-(const Timestamp& other) const {
     return TimeDelta::us(us() - other.us());
   }
@@ -165,7 +165,7 @@ class Timestamp {
   }
 
  private:
-  explicit Timestamp(int64_t us) : microseconds_(us) {}
+  explicit constexpr Timestamp(int64_t us) : microseconds_(us) {}
   int64_t microseconds_;
 };
 

api/units/timestamp_unittest.cc

@@ -13,6 +13,11 @@
 
 namespace webrtc {
 namespace test {
+TEST(TimestampTest, ConstExpr) {
+  constexpr Timestamp kTimestampInf = Timestamp::Infinity();
+  static_assert(kTimestampInf.IsInfinite(), "");
+}
+
 TEST(TimestampTest, GetBackSameValues) {
   const int64_t kValue = 499;
   EXPECT_EQ(Timestamp::ms(kValue).ms(), kValue);