Clang format slam.

net/url_request/url_request_throttler_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/url_request/url_request_throttler_entry.h"
 
 #include <cmath>
 
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
@@ skipping 55 matching lines @@
 URLRequestThrottlerEntry::URLRequestThrottlerEntry(
     URLRequestThrottlerManager* manager,
     const std::string& url_id)
     : sliding_window_period_(
           base::TimeDelta::FromMilliseconds(kDefaultSlidingWindowPeriodMs)),
       max_send_threshold_(kDefaultMaxSendThreshold),
       is_backoff_disabled_(false),
       backoff_entry_(&backoff_policy_),
       manager_(manager),
       url_id_(url_id),
-      net_log_(BoundNetLog::Make(
-          manager->net_log(), NetLog::SOURCE_EXPONENTIAL_BACKOFF_THROTTLING)) {
+      net_log_(
+          BoundNetLog::Make(manager->net_log(),
+                            NetLog::SOURCE_EXPONENTIAL_BACKOFF_THROTTLING)) {
   DCHECK(manager_);
   Initialize();
 }
 
 URLRequestThrottlerEntry::URLRequestThrottlerEntry(
     URLRequestThrottlerManager* manager,
     const std::string& url_id,
     int sliding_window_period_ms,
     int max_send_threshold,
     int initial_backoff_ms,
@@ skipping 65 matching lines @@
     const URLRequest& request) const {
   bool reject_request = false;
   if (!is_backoff_disabled_ && !ExplicitUserRequest(request.load_flags()) &&
       (!request.context()->network_delegate() ||
        request.context()->network_delegate()->CanThrottleRequest(request)) &&
       GetBackoffEntry()->ShouldRejectRequest()) {
     int num_failures = GetBackoffEntry()->failure_count();
     int release_after_ms =
         GetBackoffEntry()->GetTimeUntilRelease().InMilliseconds();
 
-    net_log_.AddEvent(
-        NetLog::TYPE_THROTTLING_REJECTED_REQUEST,
-        base::Bind(&NetLogRejectedRequestCallback,
-                   &url_id_, num_failures, release_after_ms));
+    net_log_.AddEvent(NetLog::TYPE_THROTTLING_REJECTED_REQUEST,
+                      base::Bind(&NetLogRejectedRequestCallback,
+                                 &url_id_,
+                                 num_failures,
+                                 release_after_ms));
 
     reject_request = true;
   }
 
   int reject_count = reject_request ? 1 : 0;
-  UMA_HISTOGRAM_ENUMERATION(
-      "Throttling.RequestThrottled", reject_count, 2);
+  UMA_HISTOGRAM_ENUMERATION("Throttling.RequestThrottled", reject_count, 2);
 
   return reject_request;
 }
 
 int64 URLRequestThrottlerEntry::ReserveSendingTimeForNextRequest(
     const base::TimeTicks& earliest_time) {
   base::TimeTicks now = ImplGetTimeNow();
 
   // If a lot of requests were successfully made recently,
   // sliding_window_release_time_ may be greater than
   // exponential_backoff_release_time_.
   base::TimeTicks recommended_sending_time =
       std::max(std::max(now, earliest_time),
                std::max(GetBackoffEntry()->GetReleaseTime(),
                         sliding_window_release_time_));
 
-  DCHECK(send_log_.empty() ||
-         recommended_sending_time >= send_log_.back());
+  DCHECK(send_log_.empty() || recommended_sending_time >= send_log_.back());
   // Log the new send event.
   send_log_.push(recommended_sending_time);
 
   sliding_window_release_time_ = recommended_sending_time;
 
   // Drop the out-of-date events in the event list.
   // We don't need to worry that the queue may become empty during this
   // operation, since the last element is sliding_window_release_time_.
   while ((send_log_.front() + sliding_window_period_ <=
           sliding_window_release_time_) ||
          send_log_.size() > static_cast<unsigned>(max_send_threshold_)) {
     send_log_.pop();
   }
 
   // Check if there are too many send events in recent time.
   if (send_log_.size() == static_cast<unsigned>(max_send_threshold_))
     sliding_window_release_time_ = send_log_.front() + sliding_window_period_;
 
   return (recommended_sending_time - now).InMillisecondsRoundedUp();
 }
 
-base::TimeTicks
-    URLRequestThrottlerEntry::GetExponentialBackoffReleaseTime() const {
+base::TimeTicks URLRequestThrottlerEntry::GetExponentialBackoffReleaseTime()
+    const {
   // If a site opts out, it's likely because they have problems that trigger
   // the back-off mechanism when it shouldn't be triggered, in which case
   // returning the calculated back-off release time would probably be the
   // wrong thing to do (i.e. it would likely be too long).  Therefore, we
   // return "now" so that retries are not delayed.
   if (is_backoff_disabled_)
     return ImplGetTimeNow();
 
   return GetBackoffEntry()->GetReleaseTime();
 }
 
 void URLRequestThrottlerEntry::UpdateWithResponse(
     const std::string& host,
     const URLRequestThrottlerHeaderInterface* response) {
   if (IsConsideredError(response->GetResponseCode())) {
     GetBackoffEntry()->InformOfRequest(false);
   } else {
     GetBackoffEntry()->InformOfRequest(true);
 
-    std::string throttling_header = response->GetNormalizedValue(
-        kExponentialThrottlingHeader);
+    std::string throttling_header =
+        response->GetNormalizedValue(kExponentialThrottlingHeader);
     if (!throttling_header.empty())
       HandleThrottlingHeader(throttling_header, host);
   }
 }
 
 void URLRequestThrottlerEntry::ReceivedContentWasMalformed(int response_code) {
   // A malformed body can only occur when the request to fetch a resource
   // was successful.  Therefore, in such a situation, we will receive one
   // call to ReceivedContentWasMalformed() and one call to
   // UpdateWithResponse() with a response categorized as "good".  To end
@@ skipping 33 matching lines @@
   // 503 is explicitly documented as a temporary state where the server
   //     is either overloaded or down for maintenance.
   // 509 is the (non-standard but widely implemented) Bandwidth Limit Exceeded
   //     status code, which might indicate DDoS.
   //
   // We do not back off on 502 or 504, which are reported by gateways
   // (proxies) on timeouts or failures, because in many cases these requests
   // have not made it to the destination server and so we do not actually
   // know that it is down or busy.  One degenerate case could be a proxy on
   // localhost, where you are not actually connected to the network.
-  return (response_code == 500 ||
-          response_code == 503 ||
-          response_code == 509);
+  return (response_code == 500 || response_code == 503 || response_code == 509);
 }
 
 base::TimeTicks URLRequestThrottlerEntry::ImplGetTimeNow() const {
   return base::TimeTicks::Now();
 }
 
 void URLRequestThrottlerEntry::HandleThrottlingHeader(
     const std::string& header_value,
     const std::string& host) {
   if (header_value == kExponentialThrottlingDisableValue) {
@@ skipping 10 matching lines @@
 BackoffEntry* URLRequestThrottlerEntry::GetBackoffEntry() {
   return &backoff_entry_;
 }
 
 // static
 bool URLRequestThrottlerEntry::ExplicitUserRequest(const int load_flags) {
   return (load_flags & LOAD_MAYBE_USER_GESTURE) != 0;
 }
 
 }  // namespace net