diff --git a/api/units/time_delta.h b/api/units/time_delta.h
index 030974f8c2..a53ffee74d 100644
--- a/api/units/time_delta.h
+++ b/api/units/time_delta.h
@@ -32,7 +32,26 @@ namespace webrtc {
 // microseconds (us).
 class TimeDelta final : public rtc_units_impl::RelativeUnit<TimeDelta> {
  public:
+  template <typename T>
+  static constexpr TimeDelta Seconds(T value) {
+    static_assert(std::is_arithmetic<T>::value, "");
+    return FromFraction(1'000'000, value);
+  }
+  template <typename T>
+  static constexpr TimeDelta Millis(T value) {
+    static_assert(std::is_arithmetic<T>::value, "");
+    return FromFraction(1'000, value);
+  }
+  template <typename T>
+  static constexpr TimeDelta Micros(T value) {
+    static_assert(std::is_arithmetic<T>::value, "");
+    return FromValue(value);
+  }
+
   TimeDelta() = delete;
+
+  // TODO(danilchap): Migrate all code to the 3 factories above and delete the
+  // 6 factories below.
   template <int64_t seconds>
   static constexpr TimeDelta Seconds() {
     return FromFraction(1'000'000, seconds);
diff --git a/api/units/time_delta_unittest.cc b/api/units/time_delta_unittest.cc
index a46ba835cb..cb43860531 100644
--- a/api/units/time_delta_unittest.cc
+++ b/api/units/time_delta_unittest.cc
@@ -28,9 +28,9 @@ TEST(TimeDeltaTest, ConstExpr) {
 
   static_assert(kTimeDeltaPlusInf > kTimeDeltaZero, "");
 
-  constexpr TimeDelta kTimeDeltaSeconds = TimeDelta::Seconds<kValue>();
-  constexpr TimeDelta kTimeDeltaMs = TimeDelta::Millis<kValue>();
-  constexpr TimeDelta kTimeDeltaUs = TimeDelta::Micros<kValue>();
+  constexpr TimeDelta kTimeDeltaSeconds = TimeDelta::Seconds(kValue);
+  constexpr TimeDelta kTimeDeltaMs = TimeDelta::Millis(kValue);
+  constexpr TimeDelta kTimeDeltaUs = TimeDelta::Micros(kValue);
 
   static_assert(kTimeDeltaSeconds.seconds_or(0) == kValue, "");
   static_assert(kTimeDeltaMs.ms_or(0) == kValue, "");
@@ -41,40 +41,40 @@ TEST(TimeDeltaTest, GetBackSameValues) {
   const int64_t kValue = 499;
   for (int sign = -1; sign <= 1; ++sign) {
     int64_t value = kValue * sign;
-    EXPECT_EQ(TimeDelta::ms(value).ms(), value);
-    EXPECT_EQ(TimeDelta::us(value).us(), value);
-    EXPECT_EQ(TimeDelta::seconds(value).seconds(), value);
-    EXPECT_EQ(TimeDelta::seconds(value).seconds(), value);
+    EXPECT_EQ(TimeDelta::Millis(value).ms(), value);
+    EXPECT_EQ(TimeDelta::Micros(value).us(), value);
+    EXPECT_EQ(TimeDelta::Seconds(value).seconds(), value);
+    EXPECT_EQ(TimeDelta::Seconds(value).seconds(), value);
   }
   EXPECT_EQ(TimeDelta::Zero().us(), 0);
 }
 
 TEST(TimeDeltaTest, GetDifferentPrefix) {
   const int64_t kValue = 3000000;
-  EXPECT_EQ(TimeDelta::us(kValue).seconds(), kValue / 1000000);
-  EXPECT_EQ(TimeDelta::ms(kValue).seconds(), kValue / 1000);
-  EXPECT_EQ(TimeDelta::us(kValue).ms(), kValue / 1000);
+  EXPECT_EQ(TimeDelta::Micros(kValue).seconds(), kValue / 1000000);
+  EXPECT_EQ(TimeDelta::Millis(kValue).seconds(), kValue / 1000);
+  EXPECT_EQ(TimeDelta::Micros(kValue).ms(), kValue / 1000);
 
-  EXPECT_EQ(TimeDelta::ms(kValue).us(), kValue * 1000);
-  EXPECT_EQ(TimeDelta::seconds(kValue).ms(), kValue * 1000);
-  EXPECT_EQ(TimeDelta::seconds(kValue).us(), kValue * 1000000);
+  EXPECT_EQ(TimeDelta::Millis(kValue).us(), kValue * 1000);
+  EXPECT_EQ(TimeDelta::Seconds(kValue).ms(), kValue * 1000);
+  EXPECT_EQ(TimeDelta::Seconds(kValue).us(), kValue * 1000000);
 }
 
 TEST(TimeDeltaTest, IdentityChecks) {
   const int64_t kValue = 3000;
   EXPECT_TRUE(TimeDelta::Zero().IsZero());
-  EXPECT_FALSE(TimeDelta::ms(kValue).IsZero());
+  EXPECT_FALSE(TimeDelta::Millis(kValue).IsZero());
 
   EXPECT_TRUE(TimeDelta::PlusInfinity().IsInfinite());
   EXPECT_TRUE(TimeDelta::MinusInfinity().IsInfinite());
   EXPECT_FALSE(TimeDelta::Zero().IsInfinite());
-  EXPECT_FALSE(TimeDelta::ms(-kValue).IsInfinite());
-  EXPECT_FALSE(TimeDelta::ms(kValue).IsInfinite());
+  EXPECT_FALSE(TimeDelta::Millis(-kValue).IsInfinite());
+  EXPECT_FALSE(TimeDelta::Millis(kValue).IsInfinite());
 
   EXPECT_FALSE(TimeDelta::PlusInfinity().IsFinite());
   EXPECT_FALSE(TimeDelta::MinusInfinity().IsFinite());
-  EXPECT_TRUE(TimeDelta::ms(-kValue).IsFinite());
-  EXPECT_TRUE(TimeDelta::ms(kValue).IsFinite());
+  EXPECT_TRUE(TimeDelta::Millis(-kValue).IsFinite());
+  EXPECT_TRUE(TimeDelta::Millis(kValue).IsFinite());
   EXPECT_TRUE(TimeDelta::Zero().IsFinite());
 
   EXPECT_TRUE(TimeDelta::PlusInfinity().IsPlusInfinity());
@@ -87,33 +87,33 @@ TEST(TimeDeltaTest, IdentityChecks) {
 TEST(TimeDeltaTest, ComparisonOperators) {
   const int64_t kSmall = 450;
   const int64_t kLarge = 451;
-  const TimeDelta small = TimeDelta::ms(kSmall);
-  const TimeDelta large = TimeDelta::ms(kLarge);
+  const TimeDelta small = TimeDelta::Millis(kSmall);
+  const TimeDelta large = TimeDelta::Millis(kLarge);
 
-  EXPECT_EQ(TimeDelta::Zero(), TimeDelta::ms(0));
+  EXPECT_EQ(TimeDelta::Zero(), TimeDelta::Millis(0));
   EXPECT_EQ(TimeDelta::PlusInfinity(), TimeDelta::PlusInfinity());
-  EXPECT_EQ(small, TimeDelta::ms(kSmall));
-  EXPECT_LE(small, TimeDelta::ms(kSmall));
-  EXPECT_GE(small, TimeDelta::ms(kSmall));
-  EXPECT_NE(small, TimeDelta::ms(kLarge));
-  EXPECT_LE(small, TimeDelta::ms(kLarge));
-  EXPECT_LT(small, TimeDelta::ms(kLarge));
-  EXPECT_GE(large, TimeDelta::ms(kSmall));
-  EXPECT_GT(large, TimeDelta::ms(kSmall));
+  EXPECT_EQ(small, TimeDelta::Millis(kSmall));
+  EXPECT_LE(small, TimeDelta::Millis(kSmall));
+  EXPECT_GE(small, TimeDelta::Millis(kSmall));
+  EXPECT_NE(small, TimeDelta::Millis(kLarge));
+  EXPECT_LE(small, TimeDelta::Millis(kLarge));
+  EXPECT_LT(small, TimeDelta::Millis(kLarge));
+  EXPECT_GE(large, TimeDelta::Millis(kSmall));
+  EXPECT_GT(large, TimeDelta::Millis(kSmall));
   EXPECT_LT(TimeDelta::Zero(), small);
-  EXPECT_GT(TimeDelta::Zero(), TimeDelta::ms(-kSmall));
-  EXPECT_GT(TimeDelta::Zero(), TimeDelta::ms(-kSmall));
+  EXPECT_GT(TimeDelta::Zero(), TimeDelta::Millis(-kSmall));
+  EXPECT_GT(TimeDelta::Zero(), TimeDelta::Millis(-kSmall));
 
   EXPECT_GT(TimeDelta::PlusInfinity(), large);
   EXPECT_LT(TimeDelta::MinusInfinity(), TimeDelta::Zero());
 }
 
 TEST(TimeDeltaTest, Clamping) {
-  const TimeDelta upper = TimeDelta::ms(800);
-  const TimeDelta lower = TimeDelta::ms(100);
-  const TimeDelta under = TimeDelta::ms(100);
-  const TimeDelta inside = TimeDelta::ms(500);
-  const TimeDelta over = TimeDelta::ms(1000);
+  const TimeDelta upper = TimeDelta::Millis(800);
+  const TimeDelta lower = TimeDelta::Millis(100);
+  const TimeDelta under = TimeDelta::Millis(100);
+  const TimeDelta inside = TimeDelta::Millis(500);
+  const TimeDelta over = TimeDelta::Millis(1000);
   EXPECT_EQ(under.Clamped(lower, upper), lower);
   EXPECT_EQ(inside.Clamped(lower, upper), inside);
   EXPECT_EQ(over.Clamped(lower, upper), upper);
@@ -131,9 +131,10 @@ TEST(TimeDeltaTest, Clamping) {
 
 TEST(TimeDeltaTest, CanBeInititializedFromLargeInt) {
   const int kMaxInt = std::numeric_limits<int>::max();
-  EXPECT_EQ(TimeDelta::seconds(kMaxInt).us(),
+  EXPECT_EQ(TimeDelta::Seconds(kMaxInt).us(),
             static_cast<int64_t>(kMaxInt) * 1000000);
-  EXPECT_EQ(TimeDelta::ms(kMaxInt).us(), static_cast<int64_t>(kMaxInt) * 1000);
+  EXPECT_EQ(TimeDelta::Millis(kMaxInt).us(),
+            static_cast<int64_t>(kMaxInt) * 1000);
 }
 
 TEST(TimeDeltaTest, ConvertsToAndFromDouble) {
@@ -143,16 +144,16 @@ TEST(TimeDeltaTest, ConvertsToAndFromDouble) {
   const double kMillisDouble = kMicros * 1e-3;
   const double kSecondsDouble = kMillisDouble * 1e-3;
 
-  EXPECT_EQ(TimeDelta::us(kMicros).seconds<double>(), kSecondsDouble);
-  EXPECT_EQ(TimeDelta::seconds(kSecondsDouble).us(), kMicros);
+  EXPECT_EQ(TimeDelta::Micros(kMicros).seconds<double>(), kSecondsDouble);
+  EXPECT_EQ(TimeDelta::Seconds(kSecondsDouble).us(), kMicros);
 
-  EXPECT_EQ(TimeDelta::us(kMicros).ms<double>(), kMillisDouble);
-  EXPECT_EQ(TimeDelta::ms(kMillisDouble).us(), kMicros);
+  EXPECT_EQ(TimeDelta::Micros(kMicros).ms<double>(), kMillisDouble);
+  EXPECT_EQ(TimeDelta::Millis(kMillisDouble).us(), kMicros);
 
-  EXPECT_EQ(TimeDelta::us(kMicros).us<double>(), kMicrosDouble);
-  EXPECT_EQ(TimeDelta::us(kMicrosDouble).us(), kMicros);
+  EXPECT_EQ(TimeDelta::Micros(kMicros).us<double>(), kMicrosDouble);
+  EXPECT_EQ(TimeDelta::Micros(kMicrosDouble).us(), kMicros);
 
-  EXPECT_NEAR(TimeDelta::us(kMicros).ns<double>(), kNanosDouble, 1);
+  EXPECT_NEAR(TimeDelta::Micros(kMicros).ns<double>(), kNanosDouble, 1);
 
   const double kPlusInfinity = std::numeric_limits<double>::infinity();
   const double kMinusInfinity = -kPlusInfinity;
@@ -166,44 +167,46 @@ TEST(TimeDeltaTest, ConvertsToAndFromDouble) {
   EXPECT_EQ(TimeDelta::PlusInfinity().ns<double>(), kPlusInfinity);
   EXPECT_EQ(TimeDelta::MinusInfinity().ns<double>(), kMinusInfinity);
 
-  EXPECT_TRUE(TimeDelta::seconds(kPlusInfinity).IsPlusInfinity());
-  EXPECT_TRUE(TimeDelta::seconds(kMinusInfinity).IsMinusInfinity());
-  EXPECT_TRUE(TimeDelta::ms(kPlusInfinity).IsPlusInfinity());
-  EXPECT_TRUE(TimeDelta::ms(kMinusInfinity).IsMinusInfinity());
-  EXPECT_TRUE(TimeDelta::us(kPlusInfinity).IsPlusInfinity());
-  EXPECT_TRUE(TimeDelta::us(kMinusInfinity).IsMinusInfinity());
+  EXPECT_TRUE(TimeDelta::Seconds(kPlusInfinity).IsPlusInfinity());
+  EXPECT_TRUE(TimeDelta::Seconds(kMinusInfinity).IsMinusInfinity());
+  EXPECT_TRUE(TimeDelta::Millis(kPlusInfinity).IsPlusInfinity());
+  EXPECT_TRUE(TimeDelta::Millis(kMinusInfinity).IsMinusInfinity());
+  EXPECT_TRUE(TimeDelta::Micros(kPlusInfinity).IsPlusInfinity());
+  EXPECT_TRUE(TimeDelta::Micros(kMinusInfinity).IsMinusInfinity());
 }
 
 TEST(TimeDeltaTest, MathOperations) {
   const int64_t kValueA = 267;
   const int64_t kValueB = 450;
-  const TimeDelta delta_a = TimeDelta::ms(kValueA);
-  const TimeDelta delta_b = TimeDelta::ms(kValueB);
+  const TimeDelta delta_a = TimeDelta::Millis(kValueA);
+  const TimeDelta delta_b = TimeDelta::Millis(kValueB);
   EXPECT_EQ((delta_a + delta_b).ms(), kValueA + kValueB);
   EXPECT_EQ((delta_a - delta_b).ms(), kValueA - kValueB);
 
   const int32_t kInt32Value = 123;
   const double kFloatValue = 123.0;
-  EXPECT_EQ((TimeDelta::us(kValueA) * kValueB).us(), kValueA * kValueB);
-  EXPECT_EQ((TimeDelta::us(kValueA) * kInt32Value).us(), kValueA * kInt32Value);
-  EXPECT_EQ((TimeDelta::us(kValueA) * kFloatValue).us(), kValueA * kFloatValue);
+  EXPECT_EQ((TimeDelta::Micros(kValueA) * kValueB).us(), kValueA * kValueB);
+  EXPECT_EQ((TimeDelta::Micros(kValueA) * kInt32Value).us(),
+            kValueA * kInt32Value);
+  EXPECT_EQ((TimeDelta::Micros(kValueA) * kFloatValue).us(),
+            kValueA * kFloatValue);
 
   EXPECT_EQ((delta_b / 10).ms(), kValueB / 10);
   EXPECT_EQ(delta_b / delta_a, static_cast<double>(kValueB) / kValueA);
 
-  EXPECT_EQ(TimeDelta::us(-kValueA).Abs().us(), kValueA);
-  EXPECT_EQ(TimeDelta::us(kValueA).Abs().us(), kValueA);
+  EXPECT_EQ(TimeDelta::Micros(-kValueA).Abs().us(), kValueA);
+  EXPECT_EQ(TimeDelta::Micros(kValueA).Abs().us(), kValueA);
 
-  TimeDelta mutable_delta = TimeDelta::ms(kValueA);
-  mutable_delta += TimeDelta::ms(kValueB);
-  EXPECT_EQ(mutable_delta, TimeDelta::ms(kValueA + kValueB));
-  mutable_delta -= TimeDelta::ms(kValueB);
-  EXPECT_EQ(mutable_delta, TimeDelta::ms(kValueA));
+  TimeDelta mutable_delta = TimeDelta::Millis(kValueA);
+  mutable_delta += TimeDelta::Millis(kValueB);
+  EXPECT_EQ(mutable_delta, TimeDelta::Millis(kValueA + kValueB));
+  mutable_delta -= TimeDelta::Millis(kValueB);
+  EXPECT_EQ(mutable_delta, TimeDelta::Millis(kValueA));
 }
 
 TEST(TimeDeltaTest, InfinityOperations) {
   const int64_t kValue = 267;
-  const TimeDelta finite = TimeDelta::ms(kValue);
+  const TimeDelta finite = TimeDelta::Millis(kValue);
   EXPECT_TRUE((TimeDelta::PlusInfinity() + finite).IsPlusInfinity());
   EXPECT_TRUE((TimeDelta::PlusInfinity() - finite).IsPlusInfinity());
   EXPECT_TRUE((finite + TimeDelta::PlusInfinity()).IsPlusInfinity());
diff --git a/api/units/timestamp.h b/api/units/timestamp.h
index f9ed408a22..f71edfc155 100644
--- a/api/units/timestamp.h
+++ b/api/units/timestamp.h
@@ -28,8 +28,26 @@ namespace webrtc {
 // difference of two Timestamps results in a TimeDelta.
 class Timestamp final : public rtc_units_impl::UnitBase<Timestamp> {
  public:
+  template <typename T>
+  static constexpr Timestamp Seconds(T value) {
+    static_assert(std::is_arithmetic<T>::value, "");
+    return FromFraction(1'000'000, value);
+  }
+  template <typename T>
+  static constexpr Timestamp Millis(T value) {
+    static_assert(std::is_arithmetic<T>::value, "");
+    return FromFraction(1'000, value);
+  }
+  template <typename T>
+  static constexpr Timestamp Micros(T value) {
+    static_assert(std::is_arithmetic<T>::value, "");
+    return FromValue(value);
+  }
+
   Timestamp() = delete;
 
+  // TODO(danilchap): Migrate all code to the 3 factories above and delete the
+  // 6 factories below.
   template <int64_t seconds>
   static constexpr Timestamp Seconds() {
     return FromFraction(1'000'000, seconds);
diff --git a/api/units/timestamp_unittest.cc b/api/units/timestamp_unittest.cc
index 6c2d1eea82..43b2985d43 100644
--- a/api/units/timestamp_unittest.cc
+++ b/api/units/timestamp_unittest.cc
@@ -8,6 +8,8 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <limits>
+
 #include "api/units/timestamp.h"
 #include "test/gtest.h"
 
@@ -19,9 +21,9 @@ TEST(TimestampTest, ConstExpr) {
   static_assert(kTimestampInf.IsInfinite(), "");
   static_assert(kTimestampInf.ms_or(-1) == -1, "");
 
-  constexpr Timestamp kTimestampSeconds = Timestamp::Seconds<kValue>();
-  constexpr Timestamp kTimestampMs = Timestamp::Millis<kValue>();
-  constexpr Timestamp kTimestampUs = Timestamp::Micros<kValue>();
+  constexpr Timestamp kTimestampSeconds = Timestamp::Seconds(kValue);
+  constexpr Timestamp kTimestampMs = Timestamp::Millis(kValue);
+  constexpr Timestamp kTimestampUs = Timestamp::Micros(kValue);
 
   static_assert(kTimestampSeconds.seconds_or(0) == kValue, "");
   static_assert(kTimestampMs.ms_or(0) == kValue, "");
@@ -36,20 +38,20 @@ TEST(TimestampTest, ConstExpr) {
 
 TEST(TimestampTest, GetBackSameValues) {
   const int64_t kValue = 499;
-  EXPECT_EQ(Timestamp::ms(kValue).ms(), kValue);
-  EXPECT_EQ(Timestamp::us(kValue).us(), kValue);
-  EXPECT_EQ(Timestamp::seconds(kValue).seconds(), kValue);
+  EXPECT_EQ(Timestamp::Millis(kValue).ms(), kValue);
+  EXPECT_EQ(Timestamp::Micros(kValue).us(), kValue);
+  EXPECT_EQ(Timestamp::Seconds(kValue).seconds(), kValue);
 }
 
 TEST(TimestampTest, GetDifferentPrefix) {
   const int64_t kValue = 3000000;
-  EXPECT_EQ(Timestamp::us(kValue).seconds(), kValue / 1000000);
-  EXPECT_EQ(Timestamp::ms(kValue).seconds(), kValue / 1000);
-  EXPECT_EQ(Timestamp::us(kValue).ms(), kValue / 1000);
+  EXPECT_EQ(Timestamp::Micros(kValue).seconds(), kValue / 1000000);
+  EXPECT_EQ(Timestamp::Millis(kValue).seconds(), kValue / 1000);
+  EXPECT_EQ(Timestamp::Micros(kValue).ms(), kValue / 1000);
 
-  EXPECT_EQ(Timestamp::ms(kValue).us(), kValue * 1000);
-  EXPECT_EQ(Timestamp::seconds(kValue).ms(), kValue * 1000);
-  EXPECT_EQ(Timestamp::seconds(kValue).us(), kValue * 1000000);
+  EXPECT_EQ(Timestamp::Millis(kValue).us(), kValue * 1000);
+  EXPECT_EQ(Timestamp::Seconds(kValue).ms(), kValue * 1000);
+  EXPECT_EQ(Timestamp::Seconds(kValue).us(), kValue * 1000000);
 }
 
 TEST(TimestampTest, IdentityChecks) {
@@ -57,11 +59,11 @@ TEST(TimestampTest, IdentityChecks) {
 
   EXPECT_TRUE(Timestamp::PlusInfinity().IsInfinite());
   EXPECT_TRUE(Timestamp::MinusInfinity().IsInfinite());
-  EXPECT_FALSE(Timestamp::ms(kValue).IsInfinite());
+  EXPECT_FALSE(Timestamp::Millis(kValue).IsInfinite());
 
   EXPECT_FALSE(Timestamp::PlusInfinity().IsFinite());
   EXPECT_FALSE(Timestamp::MinusInfinity().IsFinite());
-  EXPECT_TRUE(Timestamp::ms(kValue).IsFinite());
+  EXPECT_TRUE(Timestamp::Millis(kValue).IsFinite());
 
   EXPECT_TRUE(Timestamp::PlusInfinity().IsPlusInfinity());
   EXPECT_FALSE(Timestamp::MinusInfinity().IsPlusInfinity());
@@ -76,22 +78,23 @@ TEST(TimestampTest, ComparisonOperators) {
 
   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));
-  EXPECT_NE(Timestamp::ms(kSmall), Timestamp::ms(kLarge));
-  EXPECT_LE(Timestamp::ms(kSmall), Timestamp::ms(kLarge));
-  EXPECT_LT(Timestamp::ms(kSmall), Timestamp::ms(kLarge));
-  EXPECT_GE(Timestamp::ms(kLarge), Timestamp::ms(kSmall));
-  EXPECT_GT(Timestamp::ms(kLarge), Timestamp::ms(kSmall));
+  EXPECT_GT(Timestamp::PlusInfinity(), Timestamp::Millis(kLarge));
+  EXPECT_EQ(Timestamp::Millis(kSmall), Timestamp::Millis(kSmall));
+  EXPECT_LE(Timestamp::Millis(kSmall), Timestamp::Millis(kSmall));
+  EXPECT_GE(Timestamp::Millis(kSmall), Timestamp::Millis(kSmall));
+  EXPECT_NE(Timestamp::Millis(kSmall), Timestamp::Millis(kLarge));
+  EXPECT_LE(Timestamp::Millis(kSmall), Timestamp::Millis(kLarge));
+  EXPECT_LT(Timestamp::Millis(kSmall), Timestamp::Millis(kLarge));
+  EXPECT_GE(Timestamp::Millis(kLarge), Timestamp::Millis(kSmall));
+  EXPECT_GT(Timestamp::Millis(kLarge), Timestamp::Millis(kSmall));
 }
 
 TEST(TimestampTest, CanBeInititializedFromLargeInt) {
   const int kMaxInt = std::numeric_limits<int>::max();
-  EXPECT_EQ(Timestamp::seconds(kMaxInt).us(),
+  EXPECT_EQ(Timestamp::Seconds(kMaxInt).us(),
             static_cast<int64_t>(kMaxInt) * 1000000);
-  EXPECT_EQ(Timestamp::ms(kMaxInt).us(), static_cast<int64_t>(kMaxInt) * 1000);
+  EXPECT_EQ(Timestamp::Millis(kMaxInt).us(),
+            static_cast<int64_t>(kMaxInt) * 1000);
 }
 
 TEST(TimestampTest, ConvertsToAndFromDouble) {
@@ -100,14 +103,14 @@ TEST(TimestampTest, ConvertsToAndFromDouble) {
   const double kMillisDouble = kMicros * 1e-3;
   const double kSecondsDouble = kMillisDouble * 1e-3;
 
-  EXPECT_EQ(Timestamp::us(kMicros).seconds<double>(), kSecondsDouble);
-  EXPECT_EQ(Timestamp::seconds(kSecondsDouble).us(), kMicros);
+  EXPECT_EQ(Timestamp::Micros(kMicros).seconds<double>(), kSecondsDouble);
+  EXPECT_EQ(Timestamp::Seconds(kSecondsDouble).us(), kMicros);
 
-  EXPECT_EQ(Timestamp::us(kMicros).ms<double>(), kMillisDouble);
-  EXPECT_EQ(Timestamp::ms(kMillisDouble).us(), kMicros);
+  EXPECT_EQ(Timestamp::Micros(kMicros).ms<double>(), kMillisDouble);
+  EXPECT_EQ(Timestamp::Millis(kMillisDouble).us(), kMicros);
 
-  EXPECT_EQ(Timestamp::us(kMicros).us<double>(), kMicrosDouble);
-  EXPECT_EQ(Timestamp::us(kMicrosDouble).us(), kMicros);
+  EXPECT_EQ(Timestamp::Micros(kMicros).us<double>(), kMicrosDouble);
+  EXPECT_EQ(Timestamp::Micros(kMicrosDouble).us(), kMicros);
 
   const double kPlusInfinity = std::numeric_limits<double>::infinity();
   const double kMinusInfinity = -kPlusInfinity;
@@ -119,25 +122,25 @@ TEST(TimestampTest, ConvertsToAndFromDouble) {
   EXPECT_EQ(Timestamp::PlusInfinity().us<double>(), kPlusInfinity);
   EXPECT_EQ(Timestamp::MinusInfinity().us<double>(), kMinusInfinity);
 
-  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());
+  EXPECT_TRUE(Timestamp::Seconds(kPlusInfinity).IsPlusInfinity());
+  EXPECT_TRUE(Timestamp::Seconds(kMinusInfinity).IsMinusInfinity());
+  EXPECT_TRUE(Timestamp::Millis(kPlusInfinity).IsPlusInfinity());
+  EXPECT_TRUE(Timestamp::Millis(kMinusInfinity).IsMinusInfinity());
+  EXPECT_TRUE(Timestamp::Micros(kPlusInfinity).IsPlusInfinity());
+  EXPECT_TRUE(Timestamp::Micros(kMinusInfinity).IsMinusInfinity());
 }
 
 TEST(UnitConversionTest, TimestampAndTimeDeltaMath) {
   const int64_t kValueA = 267;
   const int64_t kValueB = 450;
-  const Timestamp time_a = Timestamp::ms(kValueA);
-  const Timestamp time_b = Timestamp::ms(kValueB);
-  const TimeDelta delta_a = TimeDelta::ms(kValueA);
-  const TimeDelta delta_b = TimeDelta::ms(kValueB);
+  const Timestamp time_a = Timestamp::Millis(kValueA);
+  const Timestamp time_b = Timestamp::Millis(kValueB);
+  const TimeDelta delta_a = TimeDelta::Millis(kValueA);
+  const TimeDelta delta_b = TimeDelta::Millis(kValueB);
 
-  EXPECT_EQ((time_a - time_b), TimeDelta::ms(kValueA - kValueB));
-  EXPECT_EQ((time_b - delta_a), Timestamp::ms(kValueB - kValueA));
-  EXPECT_EQ((time_b + delta_a), Timestamp::ms(kValueB + kValueA));
+  EXPECT_EQ((time_a - time_b), TimeDelta::Millis(kValueA - kValueB));
+  EXPECT_EQ((time_b - delta_a), Timestamp::Millis(kValueB - kValueA));
+  EXPECT_EQ((time_b + delta_a), Timestamp::Millis(kValueB + kValueA));
 
   Timestamp mutable_time = time_a;
   mutable_time += delta_b;
@@ -148,8 +151,8 @@ TEST(UnitConversionTest, TimestampAndTimeDeltaMath) {
 
 TEST(UnitConversionTest, InfinityOperations) {
   const int64_t kValue = 267;
-  const Timestamp finite_time = Timestamp::ms(kValue);
-  const TimeDelta finite_delta = TimeDelta::ms(kValue);
+  const Timestamp finite_time = Timestamp::Millis(kValue);
+  const TimeDelta finite_delta = TimeDelta::Millis(kValue);
   EXPECT_TRUE((Timestamp::PlusInfinity() + finite_delta).IsInfinite());
   EXPECT_TRUE((Timestamp::PlusInfinity() - finite_delta).IsInfinite());
   EXPECT_TRUE((finite_time + TimeDelta::PlusInfinity()).IsInfinite());