Replace TimeDelta::FromXXX with namespace-scope functions.

This was done mechanically using a series of commands like the following:
$ git grep -l 'TimeDelta::FromDays' | xargs sed -i 's/TimeDelta::FromDays/Days/g'
$ git grep -l 'TimeDelta::FromHours' | xargs sed -i 's/TimeDelta::FromHours/Hours/g'
...
$ git cl format

No manual interventions were performed.

Bug: 1243777
Change-Id: I96d62f8b92d5660558671c61dc78b7ca9c8c78f1
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3197832
Commit-Queue: Peter Kasting <pkasting@chromium.org>
Commit-Queue: Peter Boström <pbos@chromium.org>
Owners-Override: Peter Kasting <pkasting@chromium.org>
Auto-Submit: Peter Kasting <pkasting@chromium.org>
Reviewed-by: Peter Boström <pbos@chromium.org>
Cr-Commit-Position: refs/heads/main@{#926867}

google_apis/common/time_util.cc

@@ -145,7 +145,7 @@ bool GetTimeFromString(base::StringPiece raw_value, base::Time* parsed_time) {
     if (!base::Time::FromUTCExploded(exploded, parsed_time))
       return false;
     if (offset_to_utc_in_minutes != 0)
-      *parsed_time -= base::TimeDelta::FromMinutes(offset_to_utc_in_minutes);
+      *parsed_time -= base::Minutes(offset_to_utc_in_minutes);
   } else {
     if (!base::Time::FromLocalExploded(exploded, parsed_time))
       return false;

google_apis/gaia/gaia_oauth_client_unittest.cc

@@ -318,7 +318,7 @@ TEST_F(GaiaOAuthClientTest, NetworkFailureRecoverBackoff) {
   //
   // ... so the whole thing should take at least 307s
   EXPECT_GE(task_environment_.GetMockTickClock()->NowTicks() - start,
-            base::TimeDelta::FromSeconds(307));
+            base::Seconds(307));
 }
 
 TEST_F(GaiaOAuthClientTest, OAuthFailure) {

google_apis/gaia/oauth2_access_token_fetcher_impl.cc

@@ -340,7 +340,7 @@ bool OAuth2AccessTokenFetcherImpl::ParseGetAccessTokenSuccessResponse(
             value->GetInteger(kExpiresInKey, &expires_in);
   if (ok) {
     token_response->expiration_time =
-        base::Time::Now() + base::TimeDelta::FromSeconds(9 * expires_in / 10);
+        base::Time::Now() + base::Seconds(9 * expires_in / 10);
   }
   return ok;
 }

google_apis/gaia/oauth2_access_token_manager.cc

@@ -343,7 +343,7 @@ OAuth2AccessTokenManager::Fetcher::ComputeExponentialBackOffMilliseconds(
 bool OAuth2AccessTokenManager::Fetcher::RetryIfPossible(
     const GoogleServiceAuthError& error) {
   if (retry_number_ < oauth2_access_token_manager_->max_fetch_retry_num_) {
-    base::TimeDelta backoff = base::TimeDelta::FromMilliseconds(
+    base::TimeDelta backoff = base::Milliseconds(
         ComputeExponentialBackOffMilliseconds(retry_number_));
     ++retry_number_;
     UMA_HISTOGRAM_ENUMERATION("Signin.OAuth2TokenGetRetry", error.state(),

google_apis/gaia/oauth2_mint_token_flow.cc

@@ -400,7 +400,7 @@ bool OAuth2MintTokenFlow::ParseRemoteConsentResponse(
 
     base::Time expiration_time = base::Time();
     if (max_age > 0)
-      expiration_time = time_now + base::TimeDelta::FromSeconds(max_age);
+      expiration_time = time_now + base::Seconds(max_age);
 
     std::unique_ptr<net::CanonicalCookie> cookie =
         net::CanonicalCookie::CreateSanitizedCookie(

google_apis/gaia/oauth_multilogin_result.cc

@@ -103,7 +103,7 @@ void OAuthMultiloginResult::TryParseCookiesFromValue(base::Value* json_value) {
     const std::string* same_site = cookie.FindStringKey("sameSite");
 
     base::TimeDelta before_expiration =
-        base::TimeDelta::FromSecondsD(expiration_delta.value_or(0.0));
+        base::Seconds(expiration_delta.value_or(0.0));
     std::string cookie_domain = domain ? *domain : "";
     std::string cookie_host = host ? *host : "";
     if (cookie_domain.empty() && !cookie_host.empty() &&

google_apis/gaia/oauth_multilogin_result_unittest.cc

@@ -79,8 +79,7 @@ TEST(OAuthMultiloginResultTest, TryParseCookiesFromValue) {
   result.TryParseCookiesFromValue(dictionary_value.get());
 
   base::Time time_now = base::Time::Now();
-  base::Time expiration_time =
-      (time_now + base::TimeDelta::FromSecondsD(63070000.));
+  base::Time expiration_time = (time_now + base::Seconds(63070000.));
   double now = time_now.ToDoubleT();
   double expiration = expiration_time.ToDoubleT();
   const std::vector<CanonicalCookie> cookies = {

google_apis/gcm/base/gcm_constants.cc

@@ -6,6 +6,6 @@
 
 namespace gcm {
 
-constexpr base::TimeDelta kIncomingMessageTTL = base::TimeDelta::FromDays(7);
+constexpr base::TimeDelta kIncomingMessageTTL = base::Days(7);
 
 }  // namespace gcm

google_apis/gcm/engine/connection_factory_impl.cc

@@ -48,8 +48,7 @@ const int kConnectionResetWindowSecs = 10;  // 10 seconds.
 bool ShouldRestorePreviousBackoff(const base::TimeTicks& login_time,
                                   const base::TimeTicks& now_ticks) {
   return !login_time.is_null() &&
-      now_ticks - login_time <=
-          base::TimeDelta::FromSeconds(kConnectionResetWindowSecs);
+         now_ticks - login_time <= base::Seconds(kConnectionResetWindowSecs);
 }
 
 }  // namespace
@@ -114,8 +113,7 @@ ConnectionHandler* ConnectionFactoryImpl::GetConnectionHandler() const {
 void ConnectionFactoryImpl::Connect() {
   if (!connection_handler_) {
     connection_handler_ = CreateConnectionHandler(
-        base::TimeDelta::FromMilliseconds(kReadTimeoutMs), read_callback_,
-        write_callback_,
+        base::Milliseconds(kReadTimeoutMs), read_callback_, write_callback_,
         base::BindRepeating(&ConnectionFactoryImpl::ConnectionHandlerCallback,
                             weak_ptr_factory_.GetWeakPtr()));
   }
@@ -208,10 +206,8 @@ void ConnectionFactoryImpl::SignalConnectionReset(
   recorder_->RecordConnectionResetSignaled(reason);
   if (!last_login_time_.is_null()) {
     UMA_HISTOGRAM_CUSTOM_TIMES("GCM.ConnectionUpTime",
-                               NowTicks() - last_login_time_,
-                               base::TimeDelta::FromSeconds(1),
-                               base::TimeDelta::FromHours(24),
-                               50);
+                               NowTicks() - last_login_time_, base::Seconds(1),
+                               base::Hours(24), 50);
     // |last_login_time_| will be reset below, before attempting the new
     // connection.
   }

google_apis/gcm/engine/connection_factory_impl_unittest.cc

@@ -176,7 +176,7 @@ TestConnectionFactoryImpl::TestConnectionFactoryImpl(
           base::BindRepeating(&WriteContinuation))),
       fake_handler_(scoped_handler_.get()) {
   // Set a non-null time.
-  tick_clock_.Advance(base::TimeDelta::FromMilliseconds(1));
+  tick_clock_.Advance(base::Milliseconds(1));
 
   EXPECT_EQ(mojo::CreateDataPipe(nullptr, receive_pipe_producer_,
                                  receive_pipe_consumer_),
@@ -524,8 +524,7 @@ TEST_F(ConnectionFactoryImplTest, CanarySucceedsRetryDuringLogin) {
 
   // Pump the loop, to ensure the pending backoff retry has no effect.
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-      FROM_HERE, GetRunLoop()->QuitWhenIdleClosure(),
-      base::TimeDelta::FromMilliseconds(1));
+      FROM_HERE, GetRunLoop()->QuitWhenIdleClosure(), base::Milliseconds(1));
   WaitForConnections();
 }
 
@@ -611,7 +610,7 @@ TEST_F(ConnectionFactoryImplTest, DISABLED_SuppressConnectWhenNoNetwork) {
   EXPECT_TRUE(factory()->IsEndpointReachable());
 
   // Advance clock so the login window reset isn't encountered.
-  factory()->tick_clock()->Advance(base::TimeDelta::FromSeconds(11));
+  factory()->tick_clock()->Advance(base::Seconds(11));
 
   // Will trigger reset, but will not attempt a new connection.
   factory()->OnConnectionChanged(

google_apis/gcm/engine/gcm_request_test_base.cc

@@ -130,8 +130,7 @@ void GCMRequestTestBase::FastForwardToTriggerNextRetry() {
   int next_retry_delay_ms = kDefaultBackoffPolicy.initial_delay_ms;
   next_retry_delay_ms *=
       pow(kDefaultBackoffPolicy.multiply_factor, retry_count_);
-  task_environment_.FastForwardBy(
-      base::TimeDelta::FromMilliseconds(next_retry_delay_ms));
+  task_environment_.FastForwardBy(base::Milliseconds(next_retry_delay_ms));
 }
 
 }  // namespace gcm

google_apis/gcm/engine/gcm_store_impl.cc

@@ -1019,9 +1019,8 @@ bool GCMStoreImpl::Backend::LoadIncomingMessages(
             << data;
         expiration_time = 0LL;
       }
-      if (base::Time::Now() <
-          base::Time::FromDeltaSinceWindowsEpoch(
-              base::TimeDelta::FromMicroseconds(expiration_time))) {
+      if (base::Time::Now() < base::Time::FromDeltaSinceWindowsEpoch(
+                                  base::Microseconds(expiration_time))) {
         incoming_messages->push_back(std::move(persistent_id));
       } else {
         expired_incoming_messages.push_back(std::move(persistent_id));

google_apis/gcm/engine/gservices_settings.cc

@@ -178,7 +178,7 @@ namespace gcm {
 
 // static
 const base::TimeDelta GServicesSettings::MinimumCheckinInterval() {
-  return base::TimeDelta::FromSeconds(kMinimumCheckinInterval);
+  return base::Seconds(kMinimumCheckinInterval);
 }
 
 // static
@@ -279,7 +279,7 @@ base::TimeDelta GServicesSettings::GetCheckinInterval() const {
   if (checkin_interval < kMinimumCheckinInterval)
     checkin_interval = kMinimumCheckinInterval;
 
-  return base::TimeDelta::FromSeconds(checkin_interval);
+  return base::Seconds(checkin_interval);
 }
 
 GURL GServicesSettings::GetCheckinURL() const {

google_apis/gcm/engine/gservices_settings_unittest.cc

@@ -66,7 +66,7 @@ GServicesSettingsTest::GServicesSettingsTest()
 GServicesSettingsTest::~GServicesSettingsTest() {}
 
 void GServicesSettingsTest::CheckAllSetToDefault() {
-  EXPECT_EQ(base::TimeDelta::FromSeconds(kDefaultCheckinInterval),
+  EXPECT_EQ(base::Seconds(kDefaultCheckinInterval),
             settings().GetCheckinInterval());
   EXPECT_EQ(GURL(kDefaultCheckinURL), settings().GetCheckinURL());
   EXPECT_EQ(GURL("https://mtalk.google.com:5228"),
@@ -135,7 +135,7 @@ TEST_F(GServicesSettingsTest, UpdateFromLoadResult) {
   result.gservices_digest = kAlternativeSettingsDigest;
   settings().UpdateFromLoadResult(result);
 
-  EXPECT_EQ(base::TimeDelta::FromSeconds(kAlternativeCheckinInterval),
+  EXPECT_EQ(base::Seconds(kAlternativeCheckinInterval),
             settings().GetCheckinInterval());
   EXPECT_EQ(GURL(kAlternativeCheckinURL), settings().GetCheckinURL());
   EXPECT_EQ(GURL("https://alternative.gcm.host:7777"),
@@ -174,8 +174,7 @@ TEST_F(GServicesSettingsTest, CheckinResponseUpdateCheckinInterval) {
   EXPECT_TRUE(settings().UpdateFromCheckinResponse(checkin_response));
 
   // Only the checkin interval was updated:
-  EXPECT_EQ(base::TimeDelta::FromSeconds(86400),
-            settings().GetCheckinInterval());
+  EXPECT_EQ(base::Seconds(86400), settings().GetCheckinInterval());
 
   // Other settings still set to default.
   EXPECT_EQ(GURL("https://mtalk.google.com:5228"),
@@ -203,7 +202,7 @@ TEST_F(GServicesSettingsTest, CheckinResponseUpdateRegistrationURL) {
             settings().GetRegistrationURL());
 
   // Other settings still set to default.
-  EXPECT_EQ(base::TimeDelta::FromSeconds(kDefaultCheckinInterval),
+  EXPECT_EQ(base::Seconds(kDefaultCheckinInterval),
             settings().GetCheckinInterval());
   EXPECT_EQ(GURL("https://mtalk.google.com:5228"),
             settings().GetMCSMainEndpoint());
@@ -228,7 +227,7 @@ TEST_F(GServicesSettingsTest, CheckinResponseUpdateCheckinURL) {
   EXPECT_EQ(GURL("https://new.checkin.url"), settings().GetCheckinURL());
 
   // Other settings still set to default.
-  EXPECT_EQ(base::TimeDelta::FromSeconds(kDefaultCheckinInterval),
+  EXPECT_EQ(base::Seconds(kDefaultCheckinInterval),
             settings().GetCheckinInterval());
   EXPECT_EQ(GURL("https://mtalk.google.com:5228"),
             settings().GetMCSMainEndpoint());
@@ -256,7 +255,7 @@ TEST_F(GServicesSettingsTest, CheckinResponseUpdateMCSHostname) {
             settings().GetMCSFallbackEndpoint());
 
   // Other settings still set to default.
-  EXPECT_EQ(base::TimeDelta::FromSeconds(kDefaultCheckinInterval),
+  EXPECT_EQ(base::Seconds(kDefaultCheckinInterval),
             settings().GetCheckinInterval());
   EXPECT_EQ(GURL(kDefaultCheckinURL), settings().GetCheckinURL());
   EXPECT_EQ(GURL(kDefaultRegistrationURL), settings().GetRegistrationURL());
@@ -279,7 +278,7 @@ TEST_F(GServicesSettingsTest, CheckinResponseUpdateMCSSecurePort) {
             settings().GetMCSMainEndpoint());
 
   // Other settings still set to default.
-  EXPECT_EQ(base::TimeDelta::FromSeconds(kDefaultCheckinInterval),
+  EXPECT_EQ(base::Seconds(kDefaultCheckinInterval),
             settings().GetCheckinInterval());
   EXPECT_EQ(GURL(kDefaultCheckinURL), settings().GetCheckinURL());
   EXPECT_EQ(GURL("https://mtalk.google.com:443"),

google_apis/gcm/engine/heartbeat_manager.cc

@@ -156,7 +156,7 @@ void HeartbeatManager::OnResume() {
   // avoid any tight loop scenarios.
   // If the |send_heartbeat_callback_| is null, it means the heartbeat manager
   // hasn't been started, so do nothing.
-  if (elapsed > base::TimeDelta::FromMilliseconds(kMinSuspendTimeMs) &&
+  if (elapsed > base::Milliseconds(kMinSuspendTimeMs) &&
       !send_heartbeat_callback_.is_null())
     OnHeartbeatTriggered();
 }
@@ -186,9 +186,9 @@ void HeartbeatManager::RestartTimer() {
   }
 
   heartbeat_expected_time_ =
-      base::Time::Now() + base::TimeDelta::FromMilliseconds(interval_ms);
+      base::Time::Now() + base::Milliseconds(interval_ms);
   heartbeat_timer_->Start(
-      FROM_HERE, base::TimeDelta::FromMilliseconds(interval_ms),
+      FROM_HERE, base::Milliseconds(interval_ms),
       base::BindRepeating(&HeartbeatManager::OnHeartbeatTriggered,
                           weak_ptr_factory_.GetWeakPtr()));
 
@@ -200,7 +200,7 @@ void HeartbeatManager::RestartTimer() {
       FROM_HERE,
       base::BindOnce(&HeartbeatManager::CheckForMissedHeartbeat,
                      weak_ptr_factory_.GetWeakPtr()),
-      base::TimeDelta::FromMilliseconds(kHeartbeatMissedCheckMs));
+      base::Milliseconds(kHeartbeatMissedCheckMs));
 #endif  // defined(OS_LINUX) || BUILDFLAG(IS_CHROMEOS_LACROS)
 }
 
@@ -223,7 +223,7 @@ void HeartbeatManager::CheckForMissedHeartbeat() {
       FROM_HERE,
       base::BindOnce(&HeartbeatManager::CheckForMissedHeartbeat,
                      weak_ptr_factory_.GetWeakPtr()),
-      base::TimeDelta::FromMilliseconds(kHeartbeatMissedCheckMs));
+      base::Milliseconds(kHeartbeatMissedCheckMs));
 #endif  // defined(OS_LINUX) || BUILDFLAG(IS_CHROMEOS_LACROS)
 }
 

google_apis/gcm/engine/heartbeat_manager_unittest.cc

@@ -156,7 +156,7 @@ TEST_F(HeartbeatManagerTest, UpdateIntervalThenStart) {
   EXPECT_TRUE(manager()->GetNextHeartbeatTime().is_null());
   StartManager();
   EXPECT_LE(manager()->GetNextHeartbeatTime() - base::TimeTicks::Now(),
-            base::TimeDelta::FromMilliseconds(kIntervalMs));
+            base::Milliseconds(kIntervalMs));
 }
 
 // Updating the heartbeat interval after starting should only use the new
@@ -166,7 +166,7 @@ TEST_F(HeartbeatManagerTest, StartThenUpdateInterval) {
   StartManager();
   base::TimeTicks heartbeat = manager()->GetNextHeartbeatTime();
   EXPECT_GT(heartbeat - base::TimeTicks::Now(),
-            base::TimeDelta::FromMilliseconds(kIntervalMs));
+            base::Milliseconds(kIntervalMs));
 
   // Updating the interval should not affect an outstanding heartbeat.
   manager()->UpdateHeartbeatConfig(BuildHeartbeatConfig(kIntervalMs));
@@ -178,7 +178,7 @@ TEST_F(HeartbeatManagerTest, StartThenUpdateInterval) {
   manager()->OnHeartbeatAcked();
 
   EXPECT_LE(manager()->GetNextHeartbeatTime() - base::TimeTicks::Now(),
-            base::TimeDelta::FromMilliseconds(kIntervalMs));
+            base::Milliseconds(kIntervalMs));
   EXPECT_NE(heartbeat, manager()->GetNextHeartbeatTime());
 }
 
@@ -215,7 +215,7 @@ TEST_F(HeartbeatManagerTest, SetClientHeartbeatInterval) {
 
   base::TimeTicks heartbeat = manager()->GetNextHeartbeatTime();
   EXPECT_GT(heartbeat - base::TimeTicks::Now(),
-            base::TimeDelta::FromMilliseconds(kIntervalMs));
+            base::Milliseconds(kIntervalMs));
 
   manager()->SetClientHeartbeatIntervalMs(kIntervalMs);
   EXPECT_EQ(1, reconnects_triggered());
@@ -226,7 +226,7 @@ TEST_F(HeartbeatManagerTest, SetClientHeartbeatInterval) {
   manager()->OnHeartbeatAcked();
 
   EXPECT_LE(manager()->GetNextHeartbeatTime() - base::TimeTicks::Now(),
-            base::TimeDelta::FromMilliseconds(kIntervalMs));
+            base::Milliseconds(kIntervalMs));
   EXPECT_GT(heartbeat, manager()->GetNextHeartbeatTime());
 
   const int kLongerIntervalMs = 2 * kIntervalMs;
@@ -241,7 +241,7 @@ TEST_F(HeartbeatManagerTest, SetClientHeartbeatInterval) {
   manager()->OnHeartbeatAcked();
 
   EXPECT_LE(manager()->GetNextHeartbeatTime() - base::TimeTicks::Now(),
-            base::TimeDelta::FromMilliseconds(kIntervalMs));
+            base::Milliseconds(kIntervalMs));
 }
 
 // Verifies that setting the client interval too low or too high will set it to
@@ -254,10 +254,10 @@ TEST_F(HeartbeatManagerTest, ClientIntervalInvalid) {
   StartManager();
   base::TimeDelta till_heartbeat = manager()->GetNextHeartbeatTime() -
       base::TimeTicks::Now();
-  EXPECT_GT(till_heartbeat, base::TimeDelta::FromMilliseconds(
-      manager()->GetMinClientHeartbeatIntervalMs()));
-  EXPECT_LE(till_heartbeat, base::TimeDelta::FromMilliseconds(
-      manager()->GetMaxClientHeartbeatIntervalMs()));
+  EXPECT_GT(till_heartbeat,
+            base::Milliseconds(manager()->GetMinClientHeartbeatIntervalMs()));
+  EXPECT_LE(till_heartbeat,
+            base::Milliseconds(manager()->GetMaxClientHeartbeatIntervalMs()));
 
   // More than max value.
   interval_ms = manager()->GetMaxClientHeartbeatIntervalMs() + 60 * 1000;
@@ -267,8 +267,8 @@ TEST_F(HeartbeatManagerTest, ClientIntervalInvalid) {
   manager()->OnHeartbeatAcked();
 
   till_heartbeat = manager()->GetNextHeartbeatTime() - base::TimeTicks::Now();
-  EXPECT_LE(till_heartbeat, base::TimeDelta::FromMilliseconds(
-      manager()->GetMaxClientHeartbeatIntervalMs()));
+  EXPECT_LE(till_heartbeat,
+            base::Milliseconds(manager()->GetMaxClientHeartbeatIntervalMs()));
 }
 
 // Verifies that client interval is reset appropriately after the heartbeat is
@@ -283,15 +283,15 @@ TEST_F(HeartbeatManagerTest, ClientIntervalAfterHeartbeatTriggered) {
   const int kDefaultAckIntervalMs = 60 * 1000;  // 60 seconds.
   base::TimeTicks heartbeat = manager()->GetNextHeartbeatTime();
   EXPECT_LE(heartbeat - base::TimeTicks::Now(),
-            base::TimeDelta::FromMilliseconds(kDefaultAckIntervalMs));
+            base::Milliseconds(kDefaultAckIntervalMs));
 
   // This should reset the interval to the custom interval.
   manager()->OnHeartbeatAcked();
   heartbeat = manager()->GetNextHeartbeatTime();
   EXPECT_GT(heartbeat - base::TimeTicks::Now(),
-            base::TimeDelta::FromMilliseconds(kDefaultAckIntervalMs));
+            base::Milliseconds(kDefaultAckIntervalMs));
   EXPECT_LE(heartbeat - base::TimeTicks::Now(),
-            base::TimeDelta::FromMilliseconds(kCustomIntervalMs));
+            base::Milliseconds(kCustomIntervalMs));
 }
 
 }  // namespace