diff --git a/api/units/data_rate.h b/api/units/data_rate.h
index c7164e3446..1122d5e891 100644
--- a/api/units/data_rate.h
+++ b/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_;
 };
 
diff --git a/api/units/data_rate_unittest.cc b/api/units/data_rate_unittest.cc
index 073e80e7f3..b0cc0138dd 100644
--- a/api/units/data_rate_unittest.cc
+++ b/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);
diff --git a/api/units/data_size.h b/api/units/data_size.h
index 8c35766b1e..6fe1259e68 100644
--- a/api/units/data_size.h
+++ b/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_;
 };
 
diff --git a/api/units/data_size_unittest.cc b/api/units/data_size_unittest.cc
index 7747258dc8..e8e16362c5 100644
--- a/api/units/data_size_unittest.cc
+++ b/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);
diff --git a/api/units/time_delta.h b/api/units/time_delta.h
index 0f99e805af..1a636bd09d 100644
--- a/api/units/time_delta.h
+++ b/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_;
 };
 
diff --git a/api/units/time_delta_unittest.cc b/api/units/time_delta_unittest.cc
index 94a27f2383..a858f78482 100644
--- a/api/units/time_delta_unittest.cc
+++ b/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;
diff --git a/api/units/timestamp.h b/api/units/timestamp.h
index a66e061fb9..6f4dff88bc 100644
--- a/api/units/timestamp.h
+++ b/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_;
 };
 
diff --git a/api/units/timestamp_unittest.cc b/api/units/timestamp_unittest.cc
index eecfe02a9a..7dfe6695d2 100644
--- a/api/units/timestamp_unittest.cc
+++ b/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);