Implement exponential back-off mechanism and enforce it at the URLRequestHttpJob level.

net/url_request/request_throttler_entry.h

+// 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.
+
+#ifndef NET_URL_REQUEST_REQUEST_THROTTLER_ENTRY_H_
+#define NET_URL_REQUEST_REQUEST_THROTTLER_ENTRY_H_
+
+#include "net/url_request/request_throttler_entry_interface.h"

[willchan no longer on Chromium, 2010/11/17 20:32:34]

http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml?showone=Names_...

Move this one below the system headers.

[yzshen, 2010/11/19 23:51:36]

Done.

+
+#include <queue>
+#include <string>
+
+#include "base/lock.h"
+
+// RequestThrottlerEntry represents an entry of RequestThrottlerManager.
+// It analyzes requests of a specific URL over some period of time, in order to
+// deduce the back-off time for every request.
+// The back-off algorithm consists of two parts. Firstly, exponential back-off
+// is used when receiving 5XX server errors or malformed response bodies.
+// The exponential back-off rule is enforced by URLRequestHttpJob. Any request
+// sent during the back-off period will be cancelled.
+// Secondly, a sliding window is used to count recent requests to a given
+// destination and provide guidance (to the application level only) on whether
+// too many requests have been sent and when a good time to send the next one
+// would be. This is never used to deny requests at the network level.
+class RequestThrottlerEntry : public RequestThrottlerEntryInterface {

[willchan no longer on Chromium, 2010/11/17 20:32:34]

Why is this in the global namespace?  In general, net code should be in the net
namespace.

[yzshen, 2010/11/19 23:51:36]

Since URLRequest/URLRequest.*Job are not in the net namespace, I thought it was
okay.
Please let me know if you think I need to change it.

+ public:
+  // Sliding window period.
+  static const int kDefaultSlidingWindowPeriodMs;
+
+  // Maximum number of requests allowed in sliding window period.
+  static const int kDefaultMaxSendThreshold;
+
+  // Initial delay for exponential back-off.
+  static const int kDefaultInitialBackoffMs;
+
+  // Additional constant to adjust back-off.
+  static const int kDefaultAdditionalConstantMs;
+
+  // Factor by which the waiting time will be multiplied.
+  static const double kDefaultMultiplyFactor;
+
+  // Fuzzing percentage. ex: 10% will spread requests randomly
+  // between 90%-100% of the calculated time.
+  static const double kDefaultJitterFactor;
+
+  // Maximum amount of time we are willing to delay our request.
+  static const int kDefaultMaximumBackoffMs;
+
+  // Time after which the entry is considered outdated.
+  static const int kDefaultEntryLifetimeMs;
+
+  // Name of the header that servers can use to ask clients to delay their next
+  // request.
+  static const char kRetryHeaderName[];
+
+  RequestThrottlerEntry();
+
+  // The life span of instances created with this constructor is set to
+  // infinite.
+  // It is only used by unit tests.
+  RequestThrottlerEntry(int sliding_window_period_ms,
+                        int max_send_threshold,
+                        int initial_backoff_ms,
+                        int additional_constant_ms,
+                        double multiply_factor,
+                        double jitter_factor,
+                        int maximum_backoff_ms);
+
+  // Implementation of RequestThrottlerEntryInterface.
+  virtual bool IsDuringExponentialBackoff() const;
+  virtual int64 GetRecommendedDelayForNextRequest();
+  virtual void UpdateWithResponse(
+      const RequestThrottlerHeaderInterface* response);
+  virtual void ReceivedContentWasMalformed();
+
+  // Used by the manager, returns true if the entry needs to be garbage
+  // collected.
+  bool IsEntryOutdated() const;
+
+ protected:
+  virtual ~RequestThrottlerEntry();
+
+  void Initialize();
+
+  // Calculates the release time for exponential back-off.
+  base::TimeTicks CalculateExponentialBackoffReleaseTime();
+
+  // Equivalent to TimeTicks::Now(), virtual to be mockable for testing purpose.
+  virtual base::TimeTicks GetTimeNow() const;
+
+  // Used internally to increase release time following a retry-after header.
+  void HandleCustomRetryAfter(const std::string& header_value);
+
+  // Handles 5XX server errors or malformed responses.
+  void HandleFailure();
+

[willchan no longer on Chromium, 2010/11/17 20:32:34]

All member variables should be private.  See
http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Access_Control.

[yzshen, 2010/11/19 23:51:36]

Thanks! Will keep in mind. :)

+  // Timestamp calculated by the exponential back-off algorithm at which we are
+  // allowed to start sending requests again.
+  base::TimeTicks exponential_backoff_release_time_;
+
+  // Number of times we encounter server errors or malformed response bodies.
+  int failure_count_;
+
+  // If true, the last request response was a failure.
+  // Note that this member can be false at the same time as failure_count_ can
+  // be greater than 0, since we gradually decrease failure_count_, instead of
+  // resetting it to 0 directly, when we receive successful responses.
+  bool latest_response_was_failure_;
+
+  // Timestamp calculated by the sliding window algorithm for when we advise
+  // clients the next request should be made, at the earliest. Advisory only,
+  // not used to deny requests.
+  base::TimeTicks sliding_window_release_time_;
+
+  // A list of the recent send events. We use them to decide whether there are
+  // too many requests sent in sliding window.
+  std::queue<base::TimeTicks> send_log_;
+
+  const base::TimeDelta sliding_window_period_;
+  const int max_send_threshold_;
+  const int initial_backoff_ms_;
+  const int additional_constant_ms_;
+  const double multiply_factor_;
+  const double jitter_factor_;
+  const int maximum_backoff_ms_;
+  // Set to -1 if the entry never expires.
+  const int entry_lifetime_ms_;
+
+  // Lock to protect the non-static data members.
+  mutable Lock lock_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(RequestThrottlerEntry);

[willchan no longer on Chromium, 2010/11/17 20:32:34]

You need basictypes.h for this macro.  You're transitively pulling it in from
somewhere else, but if someone refactors that header file to remove that
include, this will break.  You should include what you use.

[yzshen, 2010/11/19 23:51:36]

Done.

+};
+
+#endif  // NET_URL_REQUEST_REQUEST_THROTTLER_ENTRY_H_