Clang format slam.

net/url_request/url_request_throttler_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/url_request/url_request_throttler_manager.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/pickle.h"
 #include "base/stl_util.h"
@@ skipping 77 matching lines @@
 
   void set_exponential_backoff_release_time(
       const base::TimeTicks& release_time) {
     GetBackoffEntry()->SetCustomReleaseTime(release_time);
   }
 
   base::TimeTicks sliding_window_release_time() const {
     return URLRequestThrottlerEntry::sliding_window_release_time();
   }
 
-  void set_sliding_window_release_time(
-      const base::TimeTicks& release_time) {
-    URLRequestThrottlerEntry::set_sliding_window_release_time(
-        release_time);
+  void set_sliding_window_release_time(const base::TimeTicks& release_time) {
+    URLRequestThrottlerEntry::set_sliding_window_release_time(release_time);
   }
 
   TimeTicks fake_time_now_;
   MockBackoffEntry mock_backoff_entry_;
 
  protected:
   virtual ~MockURLRequestThrottlerEntry() {}
 };
 
 class MockURLRequestThrottlerManager : public URLRequestThrottlerManager {
@@ skipping 12 matching lines @@
 
   void CreateEntry(bool is_outdated) {
     TimeTicks time = TimeTicks::Now();
     if (is_outdated) {
       time -= TimeDelta::FromMilliseconds(
           MockURLRequestThrottlerEntry::kDefaultEntryLifetimeMs + 1000);
     }
     std::string fake_url_string("http://www.fakeurl.com/");
     fake_url_string.append(base::IntToString(create_entry_index_++));
     GURL fake_url(fake_url_string);
-    OverrideEntryForTests(
-        fake_url,
-        new MockURLRequestThrottlerEntry(this, time, TimeTicks::Now(),
-                                         TimeTicks::Now()));
+    OverrideEntryForTests(fake_url,
+                          new MockURLRequestThrottlerEntry(
+                              this, time, TimeTicks::Now(), TimeTicks::Now()));
   }
 
  private:
   int create_entry_index_;
 };
 
 struct TimeAndBool {
   TimeAndBool(const TimeTicks& time_value, bool expected, int line_num) {
     time = time_value;
     result = expected;
@@ skipping 42 matching lines @@
   entry_->ResetToBlank(now_);
 }
 
 std::ostream& operator<<(std::ostream& out, const base::TimeTicks& time) {
   return out << time.ToInternalValue();
 }
 
 TEST_F(URLRequestThrottlerEntryTest, CanThrottleRequest) {
   TestNetworkDelegate d;
   context_.set_network_delegate(&d);
-  entry_->set_exponential_backoff_release_time(
-      entry_->fake_time_now_ + TimeDelta::FromMilliseconds(1));
+  entry_->set_exponential_backoff_release_time(entry_->fake_time_now_ +
+                                               TimeDelta::FromMilliseconds(1));
 
   d.set_can_throttle_requests(false);
   EXPECT_FALSE(entry_->ShouldRejectRequest(request_));
   d.set_can_throttle_requests(true);
   EXPECT_TRUE(entry_->ShouldRejectRequest(request_));
 }
 
 TEST_F(URLRequestThrottlerEntryTest, InterfaceDuringExponentialBackoff) {
   base::StatisticsDeltaReader statistics_delta_reader;
-  entry_->set_exponential_backoff_release_time(
-      entry_->fake_time_now_ + TimeDelta::FromMilliseconds(1));
+  entry_->set_exponential_backoff_release_time(entry_->fake_time_now_ +
+                                               TimeDelta::FromMilliseconds(1));
   EXPECT_TRUE(entry_->ShouldRejectRequest(request_));
 
   // Also end-to-end test the load flags exceptions.
   request_.SetLoadFlags(LOAD_MAYBE_USER_GESTURE);
   EXPECT_FALSE(entry_->ShouldRejectRequest(request_));
 
   scoped_ptr<base::HistogramSamples> samples(
       statistics_delta_reader.GetHistogramSamplesSinceCreation(
           kRequestThrottledHistogramName));
   ASSERT_EQ(1, samples->GetCount(0));
   ASSERT_EQ(1, samples->GetCount(1));
 }
 
 TEST_F(URLRequestThrottlerEntryTest, InterfaceNotDuringExponentialBackoff) {
   base::StatisticsDeltaReader statistics_delta_reader;
   entry_->set_exponential_backoff_release_time(entry_->fake_time_now_);
   EXPECT_FALSE(entry_->ShouldRejectRequest(request_));
-  entry_->set_exponential_backoff_release_time(
-      entry_->fake_time_now_ - TimeDelta::FromMilliseconds(1));
+  entry_->set_exponential_backoff_release_time(entry_->fake_time_now_ -
+                                               TimeDelta::FromMilliseconds(1));
   EXPECT_FALSE(entry_->ShouldRejectRequest(request_));
 
   scoped_ptr<base::HistogramSamples> samples(
       statistics_delta_reader.GetHistogramSamplesSinceCreation(
           kRequestThrottledHistogramName));
   ASSERT_EQ(2, samples->GetCount(0));
   ASSERT_EQ(0, samples->GetCount(1));
 }
 
 TEST_F(URLRequestThrottlerEntryTest, InterfaceUpdateFailure) {
@@ skipping 28 matching lines @@
   TimeAndBool test_values[] = {
       TimeAndBool(now_, false, __LINE__),
       TimeAndBool(now_ - kFiveMs, false, __LINE__),
       TimeAndBool(now_ + kFiveMs, false, __LINE__),
       TimeAndBool(now_ - (lifetime - kFiveMs), false, __LINE__),
       TimeAndBool(now_ - lifetime, true, __LINE__),
       TimeAndBool(now_ - (lifetime + kFiveMs), true, __LINE__)};
 
   for (unsigned int i = 0; i < arraysize(test_values); ++i) {
     entry_->set_exponential_backoff_release_time(test_values[i].time);
-    EXPECT_EQ(entry_->IsEntryOutdated(), test_values[i].result) <<
-        "Test case #" << i << " line " << test_values[i].line << " failed";
+    EXPECT_EQ(entry_->IsEntryOutdated(), test_values[i].result)
+        << "Test case #" << i << " line " << test_values[i].line << " failed";
   }
 }
 
 TEST_F(URLRequestThrottlerEntryTest, MaxAllowedBackoff) {
   for (int i = 0; i < 30; ++i) {
     MockURLRequestThrottlerHeaderAdapter response_adapter(503);
     entry_->UpdateWithResponse(std::string(), &response_adapter);
   }
 
   TimeDelta delay = entry_->GetExponentialBackoffReleaseTime() - now_;
@@ skipping 14 matching lines @@
   // is what happens in practice (if a body is received, then a non-500
   // response must also have been received).
   entry_->ReceivedContentWasMalformed(200);
   MockURLRequestThrottlerHeaderAdapter success_adapter(200);
   entry_->UpdateWithResponse(std::string(), &success_adapter);
   EXPECT_GT(entry_->GetExponentialBackoffReleaseTime(), release_after_failures);
 }
 
 TEST_F(URLRequestThrottlerEntryTest, SlidingWindow) {
   int max_send = URLRequestThrottlerEntry::kDefaultMaxSendThreshold;
-  int sliding_window =
-      URLRequestThrottlerEntry::kDefaultSlidingWindowPeriodMs;
+  int sliding_window = URLRequestThrottlerEntry::kDefaultSlidingWindowPeriodMs;
 
-  TimeTicks time_1 = entry_->fake_time_now_ +
-      TimeDelta::FromMilliseconds(sliding_window / 3);
+  TimeTicks time_1 =
+      entry_->fake_time_now_ + TimeDelta::FromMilliseconds(sliding_window / 3);
   TimeTicks time_2 = entry_->fake_time_now_ +
-      TimeDelta::FromMilliseconds(2 * sliding_window / 3);
-  TimeTicks time_3 = entry_->fake_time_now_ +
-      TimeDelta::FromMilliseconds(sliding_window);
-  TimeTicks time_4 = entry_->fake_time_now_ +
+                     TimeDelta::FromMilliseconds(2 * sliding_window / 3);
+  TimeTicks time_3 =
+      entry_->fake_time_now_ + TimeDelta::FromMilliseconds(sliding_window);
+  TimeTicks time_4 =
+      entry_->fake_time_now_ +
       TimeDelta::FromMilliseconds(sliding_window + 2 * sliding_window / 3);
 
   entry_->set_exponential_backoff_release_time(time_1);
 
   for (int i = 0; i < max_send / 2; ++i) {
     EXPECT_EQ(2 * sliding_window / 3,
               entry_->ReserveSendingTimeForNextRequest(time_2));
   }
   EXPECT_EQ(time_2, entry_->sliding_window_release_time());
 
@@ skipping 11 matching lines @@
       LOAD_MAYBE_USER_GESTURE));
   ASSERT_FALSE(MockURLRequestThrottlerEntry::ExplicitUserRequest(
       ~LOAD_MAYBE_USER_GESTURE));
 }
 
 class URLRequestThrottlerManagerTest : public testing::Test {
  protected:
   URLRequestThrottlerManagerTest()
       : request_(GURL(), DEFAULT_PRIORITY, NULL, &context_) {}
 
-  virtual void SetUp() {
-    request_.SetLoadFlags(0);
-  }
+  virtual void SetUp() { request_.SetLoadFlags(0); }
 
   // context_ must be declared before request_.
   TestURLRequestContext context_;
   TestURLRequest request_;
 };
 
 TEST_F(URLRequestThrottlerManagerTest, IsUrlStandardised) {
   MockURLRequestThrottlerManager manager;
   GurlAndString test_values[] = {
       GurlAndString(GURL("http://www.example.com"),
@@ skipping 16 matching lines @@
                     __LINE__),
       GurlAndString(GURL("http://www.example.com/index.php#superEntry"),
                     std::string("http://www.example.com/index.php"),
                     __LINE__),
       GurlAndString(GURL("http://www.example.com:1234/"),
                     std::string("http://www.example.com:1234/"),
                     __LINE__)};
 
   for (unsigned int i = 0; i < arraysize(test_values); ++i) {
     std::string temp = manager.DoGetUrlIdFromUrl(test_values[i].url);
-    EXPECT_EQ(temp, test_values[i].result) <<
-        "Test case #" << i << " line " << test_values[i].line << " failed";
+    EXPECT_EQ(temp, test_values[i].result) << "Test case #" << i << " line "
+                                           << test_values[i].line << " failed";
   }
 }
 
 TEST_F(URLRequestThrottlerManagerTest, AreEntriesBeingCollected) {
   MockURLRequestThrottlerManager manager;
 
   manager.CreateEntry(true);  // true = Entry is outdated.
   manager.CreateEntry(true);
   manager.CreateEntry(true);
   manager.DoGarbageCollectEntries();
@@ skipping 109 matching lines @@
         FAIL();
     }
 
     scoped_refptr<net::URLRequestThrottlerEntryInterface> entry_after =
         manager.RegisterRequestUrl(GURL("http://www.example.com/"));
     EXPECT_FALSE(entry_after->ShouldRejectRequest(request_));
   }
 }
 
 }  // namespace net