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

net/base/backoff_entry_unittest.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 "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 using base::TimeDelta;
 using base::TimeTicks;
 using net::BackoffEntry;
 
-BackoffEntry::Policy base_policy = { 0, 1000, 2.0, 0.0, 20000, 2000, false };
+BackoffEntry::Policy base_policy = {0, 1000, 2.0, 0.0, 20000, 2000, false};
 
 class TestBackoffEntry : public BackoffEntry {
  public:
   explicit TestBackoffEntry(const Policy* const policy)
-      : BackoffEntry(policy),
-        now_(TimeTicks()) {
+      : BackoffEntry(policy), now_(TimeTicks()) {
     // Work around initialization in constructor not picking up
     // fake time.
     SetCustomReleaseTime(TimeTicks());
   }
 
   virtual ~TestBackoffEntry() {}
 
-  virtual TimeTicks ImplGetTimeNow() const override {
-    return now_;
-  }
+  virtual TimeTicks ImplGetTimeNow() const override { return now_; }
 
-  void set_now(const TimeTicks& now) {
-    now_ = now;
-  }
+  void set_now(const TimeTicks& now) { now_ = now; }
 
  private:
   TimeTicks now_;
 
   DISALLOW_COPY_AND_ASSIGN(TestBackoffEntry);
 };
 
 TEST(BackoffEntryTest, BaseTest) {
   TestBackoffEntry entry(&base_policy);
   EXPECT_FALSE(entry.ShouldRejectRequest());
@@ skipping 16 matching lines @@
 TEST(BackoffEntryTest, CanDiscard) {
   TestBackoffEntry entry(&base_policy);
   // Because lifetime is non-zero, we shouldn't be able to discard yet.
   EXPECT_FALSE(entry.CanDiscard());
 
   // Test the "being used" case.
   entry.InformOfRequest(false);
   EXPECT_FALSE(entry.CanDiscard());
 
   // Test the case where there are errors but we can time out.
+  entry.set_now(entry.GetReleaseTime() + TimeDelta::FromMilliseconds(1));
+  EXPECT_FALSE(entry.CanDiscard());
   entry.set_now(
-      entry.GetReleaseTime() + TimeDelta::FromMilliseconds(1));
-  EXPECT_FALSE(entry.CanDiscard());
-  entry.set_now(entry.GetReleaseTime() + TimeDelta::FromMilliseconds(
-      base_policy.maximum_backoff_ms + 1));
+      entry.GetReleaseTime() +
+      TimeDelta::FromMilliseconds(base_policy.maximum_backoff_ms + 1));
   EXPECT_TRUE(entry.CanDiscard());
 
   // Test the final case (no errors, dependent only on specified lifetime).
-  entry.set_now(entry.GetReleaseTime() + TimeDelta::FromMilliseconds(
-      base_policy.entry_lifetime_ms - 1));
+  entry.set_now(entry.GetReleaseTime() +
+                TimeDelta::FromMilliseconds(base_policy.entry_lifetime_ms - 1));
   entry.InformOfRequest(true);
   EXPECT_FALSE(entry.CanDiscard());
-  entry.set_now(entry.GetReleaseTime() + TimeDelta::FromMilliseconds(
-      base_policy.entry_lifetime_ms));
+  entry.set_now(entry.GetReleaseTime() +
+                TimeDelta::FromMilliseconds(base_policy.entry_lifetime_ms));
   EXPECT_TRUE(entry.CanDiscard());
 }
 
 TEST(BackoffEntryTest, CanDiscardAlwaysDelay) {
   BackoffEntry::Policy always_delay_policy = base_policy;
   always_delay_policy.always_use_initial_delay = true;
   always_delay_policy.entry_lifetime_ms = 0;
 
   TestBackoffEntry entry(&always_delay_policy);
 
@@ skipping 56 matching lines @@
   entry.InformOfRequest(false);
   result = entry.GetReleaseTime();
   EXPECT_EQ(entry.ImplGetTimeNow() + TimeDelta::FromMilliseconds(4000), result);
   EXPECT_EQ(TimeDelta::FromMilliseconds(4000), entry.GetTimeUntilRelease());
 
   // 6 errors (to check it doesn't pass maximum).
   entry.InformOfRequest(false);
   entry.InformOfRequest(false);
   entry.InformOfRequest(false);
   result = entry.GetReleaseTime();
-  EXPECT_EQ(
-      entry.ImplGetTimeNow() + TimeDelta::FromMilliseconds(20000), result);
+  EXPECT_EQ(entry.ImplGetTimeNow() + TimeDelta::FromMilliseconds(20000),
+            result);
 }
 
 TEST(BackoffEntryTest, ReleaseTimeCalculationAlwaysDelay) {
   BackoffEntry::Policy always_delay_policy = base_policy;
   always_delay_policy.always_use_initial_delay = true;
   always_delay_policy.num_errors_to_ignore = 2;
 
   TestBackoffEntry entry(&always_delay_policy);
 
   // With previous requests, should return "now".
@@ skipping 29 matching lines @@
   for (int i = 0; i < 10; ++i) {
     BackoffEntry::Policy jittery_policy = base_policy;
     jittery_policy.jitter_factor = 0.2;
 
     TestBackoffEntry entry(&jittery_policy);
 
     entry.InformOfRequest(false);
     entry.InformOfRequest(false);
     entry.InformOfRequest(false);
     TimeTicks result = entry.GetReleaseTime();
-    EXPECT_LE(
-        entry.ImplGetTimeNow() + TimeDelta::FromMilliseconds(3200), result);
-    EXPECT_GE(
-        entry.ImplGetTimeNow() + TimeDelta::FromMilliseconds(4000), result);
+    EXPECT_LE(entry.ImplGetTimeNow() + TimeDelta::FromMilliseconds(3200),
+              result);
+    EXPECT_GE(entry.ImplGetTimeNow() + TimeDelta::FromMilliseconds(4000),
+              result);
   }
 }
 
 TEST(BackoffEntryTest, FailureThenSuccess) {
   TestBackoffEntry entry(&base_policy);
 
   // Failure count 1, establishes horizon.
   entry.InformOfRequest(false);
   TimeTicks release_time = entry.GetReleaseTime();
   EXPECT_EQ(TimeTicks() + TimeDelta::FromMilliseconds(1000), release_time);
@@ skipping 69 matching lines @@
 
 TEST(BackoffEntryTest, OverflowProtection) {
   BackoffEntry::Policy large_multiply_policy = base_policy;
   large_multiply_policy.multiply_factor = 256;
   TestBackoffEntry custom(&large_multiply_policy);
 
   // Trigger enough failures such that more than 11 bits of exponent are used
   // to represent the exponential backoff intermediate values. Given a multiply
   // factor of 256 (2^8), 129 iterations is enough: 2^(8*(129-1)) = 2^1024.
   for (int i = 0; i < 129; ++i) {
-     custom.set_now(custom.ImplGetTimeNow() + custom.GetTimeUntilRelease());
-     custom.InformOfRequest(false);
-     ASSERT_TRUE(custom.ShouldRejectRequest());
+    custom.set_now(custom.ImplGetTimeNow() + custom.GetTimeUntilRelease());
+    custom.InformOfRequest(false);
+    ASSERT_TRUE(custom.ShouldRejectRequest());
   }
 
   // Max delay should still be respected.
   EXPECT_EQ(20000, custom.GetTimeUntilRelease().InMilliseconds());
 }
 
 }  // namespace