Fix logic for handling reports of malformed bodies. To end up counting

net/base/backoff_entry.cc

 // Copyright (c) 2011 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 <algorithm>
 #include <cmath>
 
 #include "base/logging.h"
@@ skipping 11 matching lines @@
 }
 
 BackoffEntry::~BackoffEntry() {
   // TODO(joi): Remove this once our clients (e.g. URLRequestThrottlerManager)
   // always destroy from the I/O thread.
   DetachFromThread();
 }
 
 void BackoffEntry::InformOfRequest(bool succeeded) {
   if (!succeeded) {
-    failure_count_++;
-    exponential_backoff_release_time_ = CalculateReleaseTime();
+    ++failure_count_;
   } else {
-    failure_count_ = 0;
+    failure_count_ = std::max(0, --failure_count_);
+  }
 
-    // The reason why we are not just cutting the release time to GetTimeNow()
-    // is on the one hand, it would unset a release time set by
-    // SetCustomReleaseTime and on the other we would like to push every
-    // request up to our "horizon" when dealing with multiple in-flight
-    // requests. Ex: If we send three requests and we receive 2 failures and
-    // 1 success. The success that follows those failures will not reset the
-    // release time, further requests will then need to wait the delay caused
-    // by the 2 failures.
-    exponential_backoff_release_time_ = std::max(
-        GetTimeNow(), exponential_backoff_release_time_);
-  }
+  exponential_backoff_release_time_ = CalculateReleaseTime();

[sanjeevr, 2011/05/04 18:51:50]

I don't know the code well enough to tell if calling CalculateReleaseTime here
is the right thing to do. I am assuming it is :)

[Jói, 2011/05/04 20:04:29]

Nope, it's a small bug to call it in the success case. Thanks for asking.

 }
 
 bool BackoffEntry::ShouldRejectRequest() const {
   return exponential_backoff_release_time_ > GetTimeNow();
 }
 
 base::TimeTicks BackoffEntry::GetReleaseTime() const {
   return exponential_backoff_release_time_;
 }
 
@@ skipping 45 matching lines @@
   double delay = policy_->initial_backoff_ms;
   delay *= pow(policy_->multiply_factor, effective_failure_count - 1);
   delay -= base::RandDouble() * policy_->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>(policy_->maximum_backoff_ms));
 
   // Never reduce previously set release horizon, e.g. due to Retry-After
-  // header.
+  // header.  To clarify, the delay we are adding may have been reduced (if
+  // the failure count was decreased from its previous value) but the absolute
+  // time of the release horizon should not be moved forward.
   return std::max(GetTimeNow() + base::TimeDelta::FromMilliseconds(delay_int),
                   exponential_backoff_release_time_);
 }
 
 }  // namespace net