git cl format the final third of the net/base directory

net/base/backoff_entry.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/base/backoff_entry.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 
@@ skipping 34 matching lines @@
     // time set by SetCustomReleaseTime and on the other we would like
     // to push every request up to our "horizon" when dealing with
     // multiple in-flight requests. Ex: If we send three requests and
     // we receive 2 failures and 1 success. The success that follows
     // those failures will not reset the release time, further
     // requests will then need to wait the delay caused by the 2
     // failures.
     base::TimeDelta delay;
     if (policy_->always_use_initial_delay)
       delay = base::TimeDelta::FromMilliseconds(policy_->initial_delay_ms);
-    exponential_backoff_release_time_ = std::max(
-        ImplGetTimeNow() + delay, exponential_backoff_release_time_);
+    exponential_backoff_release_time_ =
+        std::max(ImplGetTimeNow() + delay, exponential_backoff_release_time_);
   }
 }
 
 bool BackoffEntry::ShouldRejectRequest() const {
   return exponential_backoff_release_time_ > ImplGetTimeNow();
 }
 
 base::TimeDelta BackoffEntry::GetTimeUntilRelease() const {
   base::TimeTicks now = ImplGetTimeNow();
   if (exponential_backoff_release_time_ <= now)
@@ skipping 18 matching lines @@
   int64 unused_since_ms =
       (now - exponential_backoff_release_time_).InMilliseconds();
 
   // Release time is further than now, we are managing it.
   if (unused_since_ms < 0)
     return false;
 
   if (failure_count_ > 0) {
     // Need to keep track of failures until maximum back-off period
     // has passed (since further failures can add to back-off).
-    return unused_since_ms >= std::max(policy_->maximum_backoff_ms,
-                                       policy_->entry_lifetime_ms);
+    return unused_since_ms >=
+           std::max(policy_->maximum_backoff_ms, policy_->entry_lifetime_ms);
   }
 
   // Otherwise, consider the entry is outdated if it hasn't been used for the
   // specified lifetime period.
   return unused_since_ms >= policy_->entry_lifetime_ms;
 }
 
 void BackoffEntry::Reset() {
   failure_count_ = 0;
 
@@ skipping 45 matching lines @@
 
   base::internal::CheckedNumeric<int64> maximum_release_time_us = kint64max;
   if (policy_->maximum_backoff_ms >= 0) {
     maximum_release_time_us = policy_->maximum_backoff_ms;
     maximum_release_time_us *= base::Time::kMicrosecondsPerMillisecond;
     maximum_release_time_us += kTimeTicksNowUs;
   }
 
   // Decide between maximum release time and calculated release time, accounting
   // for overflow with both.
-  int64 release_time_us = std::min(
-      calculated_release_time_us.ValueOrDefault(kint64max),
-      maximum_release_time_us.ValueOrDefault(kint64max));
+  int64 release_time_us =
+      std::min(calculated_release_time_us.ValueOrDefault(kint64max),
+               maximum_release_time_us.ValueOrDefault(kint64max));
 
   // Never reduce previously set release horizon, e.g. due to Retry-After
   // header.
   return std::max(
       base::TimeTicks() + base::TimeDelta::FromMicroseconds(release_time_us),
       exponential_backoff_release_time_);
 }
 
 }  // namespace net