Clang format slam.

net/url_request/url_request_throttler_simulation_unittest.cc

Index: net/url_request/url_request_throttler_simulation_unittest.cc
diff --git a/net/url_request/url_request_throttler_simulation_unittest.cc b/net/url_request/url_request_throttler_simulation_unittest.cc
index c68f59a413903626463318a3c3adac1fbfec2da7..43f25f032d642666e348a64fc2bea027db081c19 100644
--- a/net/url_request/url_request_throttler_simulation_unittest.cc
+++ b/net/url_request/url_request_throttler_simulation_unittest.cc
@@ -77,9 +77,7 @@ class DiscreteTimeSimulation {
   // ownership of |actor| and must ensure its lifetime exceeds that of the
   // simulation. Actors should be added in the order you wish for them to
   // act at each tick of the simulation.
-  void AddActor(Actor* actor) {
-    actors_.push_back(actor);
-  }
+  void AddActor(Actor* actor) { actors_.push_back(actor); }
 
   // Runs the simulation for, pretending |time_between_ticks| passes from one
   // tick to the next. The start time will be the current real time. The
@@ -158,8 +156,8 @@ class Server : public DiscreteTimeSimulation::Actor {
   // the server.
   int HandleRequest() {
     ++num_current_tick_queries_;
-    if (!start_downtime_.is_null() &&
-        start_downtime_ < now_ && now_ < end_downtime_) {
+    if (!start_downtime_.is_null() && start_downtime_ < now_ &&
+        now_ < end_downtime_) {
       // For the simulation measuring the increase in perceived
       // downtime, it might be interesting to count separately the
       // queries seen by the server (assuming a front-end reverse proxy
@@ -179,24 +177,21 @@ class Server : public DiscreteTimeSimulation::Actor {
     return 200;
   }
 
-  int num_overloaded_ticks() const {
-    return num_overloaded_ticks_;
-  }
+  int num_overloaded_ticks() const { return num_overloaded_ticks_; }
 
   int max_experienced_queries_per_tick() const {
     return max_experienced_queries_per_tick_;
   }
 
-  const URLRequest& mock_request() const {
-    return mock_request_;
-  }
+  const URLRequest& mock_request() const { return mock_request_; }
 
   std::string VisualizeASCII(int terminal_width) {
     // Account for | characters we place at left of graph.
     terminal_width -= 1;
 
     VerboseOut("Overloaded for %d of %d ticks.\n",
-               num_overloaded_ticks_, requests_per_tick_.size());
+               num_overloaded_ticks_,
+               requests_per_tick_.size());
     VerboseOut("Got maximum of %d requests in a tick.\n\n",
                max_experienced_queries_per_tick_);
 
@@ -308,18 +303,14 @@ class MockURLRequestThrottlerEntry : public URLRequestThrottlerEntry {
     return &mock_backoff_entry_;
   }
 
-  virtual TimeTicks ImplGetTimeNow() const OVERRIDE {
-    return fake_now_;
-  }
+  virtual TimeTicks ImplGetTimeNow() const OVERRIDE { return fake_now_; }
 
   void SetFakeNow(const TimeTicks& fake_time) {
     fake_now_ = fake_time;
     mock_backoff_entry_.set_fake_now(fake_time);
   }
 
-  TimeTicks fake_now() const {
-    return fake_now_;
-  }
+  TimeTicks fake_now() const { return fake_now_; }
 
  protected:
   virtual ~MockURLRequestThrottlerEntry() {}
@@ -332,10 +323,9 @@ class MockURLRequestThrottlerEntry : public URLRequestThrottlerEntry {
 // Registry of results for a class of |Requester| objects (e.g. attackers vs.
 // regular clients).
 class RequesterResults {
-public:
+ public:
   RequesterResults()
-      : num_attempts_(0), num_successful_(0), num_failed_(0), num_blocked_(0) {
-  }
+      : num_attempts_(0), num_successful_(0), num_failed_(0), num_blocked_(0) {}
 
   void AddSuccess() {
     ++num_attempts_;
@@ -360,13 +350,13 @@ public:
   double GetBlockedRatio() {
     DCHECK(num_attempts_);
     return static_cast<double>(num_blocked_) /
-        static_cast<double>(num_attempts_);
+           static_cast<double>(num_attempts_);
   }
 
   double GetSuccessRatio() {
     DCHECK(num_attempts_);
     return static_cast<double>(num_successful_) /
-        static_cast<double>(num_attempts_);
+           static_cast<double>(num_attempts_);
   }
 
   void PrintResults(const char* class_description) {
@@ -463,7 +453,8 @@ class Requester : public DiscreteTimeSimulation::Actor {
   void SetStartupJitter(const TimeDelta& max_delay) {
     int delay_ms = base::RandInt(0, max_delay.InMilliseconds());
     time_of_last_attempt_ = TimeTicks() +
-        TimeDelta::FromMilliseconds(delay_ms) - time_between_requests_;
+                            TimeDelta::FromMilliseconds(delay_ms) -
+                            time_between_requests_;
   }
 
   void SetRequestJitter(const TimeDelta& request_jitter) {
@@ -503,7 +494,7 @@ void SimulateAttack(Server* server,
     if (!enable_throttling)
       throttler_entry->DisableBackoffThrottling();
 
-      Requester* attacker = new Requester(throttler_entry.get(),
+    Requester* attacker = new Requester(throttler_entry.get(),
                                         TimeDelta::FromMilliseconds(1),
                                         server,
                                         attacker_results);
@@ -614,8 +605,8 @@ double SimulateDowntime(const TimeDelta& duration,
   simulation.RunSimulation(duration * 2, time_between_ticks);
 
   return static_cast<double>(
-      requester.last_downtime_duration().InMilliseconds()) /
-      static_cast<double>(duration.InMilliseconds());
+             requester.last_downtime_duration().InMilliseconds()) /
+         static_cast<double>(duration.InMilliseconds());
 }
 
 TEST(URLRequestThrottlerSimulation, PerceivedDowntimeRatio) {
@@ -649,7 +640,7 @@ TEST(URLRequestThrottlerSimulation, PerceivedDowntimeRatio) {
       if (increase_ratio_out)
         *increase_ratio_out = increase_ratio;
       return expected_min_increase <= increase_ratio &&
-          increase_ratio <= expected_max_increase;
+             increase_ratio <= expected_max_increase;
     }
 
     void ReportTrialResult(double increase_ratio) {
@@ -660,7 +651,7 @@ TEST(URLRequestThrottlerSimulation, PerceivedDowntimeRatio) {
     }
   };
 
-  Stats global_stats = { 1.08, 1.15 };
+  Stats global_stats = {1.08, 1.15};
 
   struct Trial {
     TimeDelta duration;
@@ -673,7 +664,8 @@ TEST(URLRequestThrottlerSimulation, PerceivedDowntimeRatio) {
       double interval_minutes =
           static_cast<double>(average_client_interval.InSeconds()) / 60.0;
       VerboseOut("Trial with %.2f min downtime, avg. interval %.2f min.\n",
-                 duration_minutes, interval_minutes);
+                 duration_minutes,
+                 interval_minutes);
     }
   };
 
@@ -685,26 +677,26 @@ TEST(URLRequestThrottlerSimulation, PerceivedDowntimeRatio) {
   // in behavior between a client making requests every few minutes vs.
   // one that makes a request every 15 seconds).
   Trial trials[] = {
-    { TimeDelta::FromSeconds(10), TimeDelta::FromSeconds(3) },
-    { TimeDelta::FromSeconds(30), TimeDelta::FromSeconds(7) },
-    { TimeDelta::FromMinutes(5), TimeDelta::FromSeconds(30) },
-    { TimeDelta::FromMinutes(10), TimeDelta::FromSeconds(20) },
-    { TimeDelta::FromMinutes(20), TimeDelta::FromSeconds(15) },
-    { TimeDelta::FromMinutes(20), TimeDelta::FromSeconds(50) },
-    { TimeDelta::FromMinutes(30), TimeDelta::FromMinutes(2) },
-    { TimeDelta::FromMinutes(30), TimeDelta::FromMinutes(5) },
-    { TimeDelta::FromMinutes(40), TimeDelta::FromMinutes(7) },
-    { TimeDelta::FromMinutes(40), TimeDelta::FromMinutes(2) },
-    { TimeDelta::FromMinutes(40), TimeDelta::FromSeconds(15) },
-    { TimeDelta::FromMinutes(60), TimeDelta::FromMinutes(7) },
-    { TimeDelta::FromMinutes(60), TimeDelta::FromMinutes(2) },
-    { TimeDelta::FromMinutes(60), TimeDelta::FromSeconds(15) },
-    { TimeDelta::FromMinutes(80), TimeDelta::FromMinutes(20) },
-    { TimeDelta::FromMinutes(80), TimeDelta::FromMinutes(3) },
-    { TimeDelta::FromMinutes(80), TimeDelta::FromSeconds(15) },
-
-    // Most brutal?
-    { TimeDelta::FromMinutes(45), TimeDelta::FromMilliseconds(500) },
+      {TimeDelta::FromSeconds(10), TimeDelta::FromSeconds(3)},
+      {TimeDelta::FromSeconds(30), TimeDelta::FromSeconds(7)},
+      {TimeDelta::FromMinutes(5), TimeDelta::FromSeconds(30)},
+      {TimeDelta::FromMinutes(10), TimeDelta::FromSeconds(20)},
+      {TimeDelta::FromMinutes(20), TimeDelta::FromSeconds(15)},
+      {TimeDelta::FromMinutes(20), TimeDelta::FromSeconds(50)},
+      {TimeDelta::FromMinutes(30), TimeDelta::FromMinutes(2)},
+      {TimeDelta::FromMinutes(30), TimeDelta::FromMinutes(5)},
+      {TimeDelta::FromMinutes(40), TimeDelta::FromMinutes(7)},
+      {TimeDelta::FromMinutes(40), TimeDelta::FromMinutes(2)},
+      {TimeDelta::FromMinutes(40), TimeDelta::FromSeconds(15)},
+      {TimeDelta::FromMinutes(60), TimeDelta::FromMinutes(7)},
+      {TimeDelta::FromMinutes(60), TimeDelta::FromMinutes(2)},
+      {TimeDelta::FromMinutes(60), TimeDelta::FromSeconds(15)},
+      {TimeDelta::FromMinutes(80), TimeDelta::FromMinutes(20)},
+      {TimeDelta::FromMinutes(80), TimeDelta::FromMinutes(3)},
+      {TimeDelta::FromMinutes(80), TimeDelta::FromSeconds(15)},
+
+      // Most brutal?
+      {TimeDelta::FromMinutes(45), TimeDelta::FromMilliseconds(500)},
   };
 
   // If things don't converge by the time we've done 100K trials, then