Reorder the methods in net/url_request/.

net/url_request/url_request_throttler_entry.cc

 // Copyright (c) 2010 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/rand_util.h"
@@ skipping 47 matching lines @@
   DCHECK_GE(initial_backoff_ms_, 0);
   DCHECK_GE(additional_constant_ms_, 0);
   DCHECK_GT(multiply_factor_, 0);
   DCHECK_GE(jitter_factor_, 0);
   DCHECK_LT(jitter_factor_, 1);
   DCHECK_GE(maximum_backoff_ms_, 0);
 
   Initialize();
 }
 
-URLRequestThrottlerEntry::~URLRequestThrottlerEntry() {
-}
+bool URLRequestThrottlerEntry::IsEntryOutdated() const {
+  if (entry_lifetime_ms_ == -1)
+    return false;
 
-void URLRequestThrottlerEntry::Initialize() {
-  // Since this method is called by the constructors, GetTimeNow() (a virtual
-  // method) is not used.
-  exponential_backoff_release_time_ = base::TimeTicks::Now();
-  failure_count_ = 0;
-  latest_response_was_failure_ = false;
+  base::TimeTicks now = GetTimeNow();
 
-  sliding_window_release_time_ = base::TimeTicks::Now();
+  // If there are send events in the sliding window period, we still need this
+  // entry.
+  if (send_log_.size() > 0 &&
+      send_log_.back() + sliding_window_period_ > now) {
+    return false;
+  }
+
+  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;
+
+  // latest_response_was_failure_ is true indicates that the latest one or
+  // more requests encountered server errors or had malformed response bodies.
+  // In that case, we don't want to collect the entry unless it hasn't been used
+  // for longer than the maximum allowed back-off.
+  if (latest_response_was_failure_)
+    return unused_since_ms > std::max(maximum_backoff_ms_, entry_lifetime_ms_);
+
+  // Otherwise, consider the entry is outdated if it hasn't been used for the
+  // specified lifetime period.
+  return unused_since_ms > entry_lifetime_ms_;
 }
 
 bool URLRequestThrottlerEntry::IsDuringExponentialBackoff() const {
   return exponential_backoff_release_time_ > GetTimeNow();
 }
 
 int64 URLRequestThrottlerEntry::ReserveSendingTimeForNextRequest(
     const base::TimeTicks& earliest_time) {
   base::TimeTicks now = GetTimeNow();
   // If a lot of requests were successfully made recently,
@@ skipping 57 matching lines @@
     // will then need to wait the delay caused by the 2 failures.
     exponential_backoff_release_time_ = std::max(
         GetTimeNow(), exponential_backoff_release_time_);
 
     std::string retry_header = response->GetNormalizedValue(kRetryHeaderName);
     if (!retry_header.empty())
       HandleCustomRetryAfter(retry_header);
   }
 }
 
-bool URLRequestThrottlerEntry::IsEntryOutdated() const {
-  if (entry_lifetime_ms_ == -1)
-    return false;
-
-  base::TimeTicks now = GetTimeNow();
-
-  // If there are send events in the sliding window period, we still need this
-  // entry.
-  if (send_log_.size() > 0 &&
-      send_log_.back() + sliding_window_period_ > now) {
-    return false;
-  }
-
-  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;
-
-  // latest_response_was_failure_ is true indicates that the latest one or
-  // more requests encountered server errors or had malformed response bodies.
-  // In that case, we don't want to collect the entry unless it hasn't been used
-  // for longer than the maximum allowed back-off.
-  if (latest_response_was_failure_)
-    return unused_since_ms > std::max(maximum_backoff_ms_, entry_lifetime_ms_);
-
-  // Otherwise, consider the entry is outdated if it hasn't been used for the
-  // specified lifetime period.
-  return unused_since_ms > entry_lifetime_ms_;
-}
-
 void URLRequestThrottlerEntry::ReceivedContentWasMalformed() {
   // For any response that is marked as malformed now, we have probably
   // considered it as a success when receiving it and decreased the failure
   // count by 1. As a result, we increase the failure count by 2 here to undo
   // the effect and record a failure.
   //
   // Please note that this may lead to a larger failure count than expected,
   // because we don't decrease the failure count for successful responses when
   // it has already reached 0.
   failure_count_ += 2;
   latest_response_was_failure_ = true;
   exponential_backoff_release_time_ = CalculateExponentialBackoffReleaseTime();
 }
 
+URLRequestThrottlerEntry::~URLRequestThrottlerEntry() {
+}
+
+void URLRequestThrottlerEntry::Initialize() {
+  // Since this method is called by the constructors, GetTimeNow() (a virtual
+  // method) is not used.
+  exponential_backoff_release_time_ = base::TimeTicks::Now();
+  failure_count_ = 0;
+  latest_response_was_failure_ = false;
+
+  sliding_window_release_time_ = base::TimeTicks::Now();
+}
+
 base::TimeTicks
     URLRequestThrottlerEntry::CalculateExponentialBackoffReleaseTime() {
   double delay = initial_backoff_ms_;
   delay *= pow(multiply_factor_, failure_count_);
   delay += additional_constant_ms_;
   delay -= base::RandDouble() * jitter_factor_ * delay;
 
   // Ensure that we do not exceed maximum delay.
   int64 delay_int = static_cast<int64>(delay + 0.5);
   delay_int = std::min(delay_int, static_cast<int64>(maximum_backoff_ms_));
@@ skipping 21 matching lines @@
 
   if (maximum_backoff_ms_ < value_ms || value_ms < 0)
     return;
 
   exponential_backoff_release_time_ = std::max(
       (GetTimeNow() + base::TimeDelta::FromMilliseconds(value_ms)),
       exponential_backoff_release_time_);
 }
 
 }  // namespace net