Request Throttler : Exponential back-off

net/request_throttler/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_REQUEST_THROTTLER_REQUEST_THROTTLER_ENTRY_H_
+#define NET_REQUEST_THROTTLER_REQUEST_THROTTLER_ENTRY_H_
+
+#include "net/request_throttler/request_throttler_entry_interface.h"
+
+#include <string>
+
+#include "base/ref_counted.h"
+#include "base/time.h"
+
+// Represents an entry of the Request Throttler Manager.
+class RequestThrottlerEntry : public RequestThrottlerEntryInterface {
+ public:
+  // Additional constant to adjust back-off.
+  static const int kAdditionalConstantMs;
+
+  // Time after which the entry is considered outdated.
+  static const int kEntryLifetimeSec;
+
+  // Fuzzing percentage. ex: 10% will spread requests randomly
+  // between 90%-100% of the calculated time.
+  static const double kJitterFactor;
+
+  // Initial delay.
+  static const int kInitialBackoffMs;
+
+  // Maximum amount of time we are willing to delay our request.
+  static const int kMaximumBackoffMs;
+
+  // Factor by which the waiting time will be multiplied.
+  static const double kMultiplyFactor;
+
+  // Name of the header that servers can use to ask clients to delay their next
+  // request. ex: "X-Retry-After"
+  static const char kRetryHeaderName[];
+
+  RequestThrottlerEntry();
+
+  ////// Implementation of the Request throttler Interface. ///////
+
+  // This method needs to be called prior to every request; if it returns
+  // false, the calling module must cancel its current request.
+  virtual bool IsRequestAllowed() const;
+
+  // This method needs to be called each time a response is received.
+  virtual void UpdateWithResponse(
+      const RequestThrottlerHeaderInterface* response);
+
+  ////////// Specific method of Request throttler Entry ////////////////
+
+  // Used by the manager, returns if the entry needs to be garbage collected.
+  bool IsEntryOutdated() const;
+
+  // Used by the manager, enables the manager to flag the last successful
+  // request as a failure.
+  void ReceivedContentWasMalformed();
+
+ protected:
+
+  // This struct is used to save the state of the entry each time we are updated
+  // with a response header so we can regenerate it if we are informed that one
+  // of our bodies was malformed.
+  struct OldValues {
+    base::TimeTicks release_time;
+    int number_of_failed_requests;
+  };
+
+  virtual ~RequestThrottlerEntry();
+
+  // Calculates when we should start sending requests again. Follows a failure
+  // response.
+  base::TimeTicks CalculateReleaseTime();
+
+  // Equivalent to TimeTicks::Now(), virtual to be mockable for testing purpose.
+  virtual base::TimeTicks GetTimeNow() const;
+
+  // Is used internally to increase release time following a retry-after header.
+  void HandleCustomRetryAfter(const std::string& header_value);
+
+  // Saves the state of the object to be able to regenerate it.
+  // Must be informed of the state of the response.
+  void SaveState();
+
+  // This contains the timestamp at which we are allowed to start sending
+  // requests again.
+  base::TimeTicks release_time_;
+
+  // Number of times we were delayed.
+  int num_times_delayed_;
+
+  // Are we currently managing this request.
+  bool is_managed_;
+
+  OldValues old_values_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(RequestThrottlerEntry);
+};
+
+#endif  // NET_REQUEST_THROTTLER_REQUEST_THROTTLER_ENTRY_H_