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_++;
+    ++failure_count_;
     exponential_backoff_release_time_ = CalculateReleaseTime();
   } else {
-    failure_count_ = 0;
+    // We slowly decay the number of times delayed instead of resetting it to 0
+    // in order to stay stable if we receive successes interleaved between lots
+    // of failures.
+    failure_count_ = std::max(0, --failure_count_);

[sanjeevr, 2011/05/04 20:23:09]

I think we need to think of a better fix in the long term for the malformed
case. Ideally you do want to reset the failure count to 0, but also remember the
last value so we revert to that + 1 if the upper layer reports a malformed body.
But I think this is OK for now.

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

Added a TODO to revisit this.

 
     // 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(
@@ skipping 63 matching lines @@
   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.
   return std::max(GetTimeNow() + base::TimeDelta::FromMilliseconds(delay_int),
                   exponential_backoff_release_time_);
 }
 
 }  // namespace net