Adds backoff and Min Wait Duration compliance to Protocolmanager pver4 handlers.

chrome/browser/safe_browsing/protocol_manager.h

 // Copyright (c) 2012 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 CHROME_BROWSER_SAFE_BROWSING_PROTOCOL_MANAGER_H_
 #define CHROME_BROWSER_SAFE_BROWSING_PROTOCOL_MANAGER_H_
 
 // A class that implements Chrome's interface with the SafeBrowsing protocol.
 // See https://developers.google.com/safe-browsing/developers_guide_v2 for
 // protocol details.
@@ skipping 198 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(SafeBrowsingProtocolManagerTest,
                            TestParseV4HashResponse);
   FRIEND_TEST_ALL_PREFIXES(SafeBrowsingProtocolManagerTest,
                            TestParseV4HashResponseWrongThreatEntryType);
   FRIEND_TEST_ALL_PREFIXES(SafeBrowsingProtocolManagerTest,
                            TestParseV4HashResponseSocialEngineeringThreatType);
   FRIEND_TEST_ALL_PREFIXES(SafeBrowsingProtocolManagerTest,
                            TestParseV4HashResponseNonPermissionMetadata);
   FRIEND_TEST_ALL_PREFIXES(SafeBrowsingProtocolManagerTest,
                            TestGetHashBackOffTimes);
+  FRIEND_TEST_ALL_PREFIXES(SafeBrowsingProtocolManagerTest,
+                           TestGetV4HashBackOffTimes);
   FRIEND_TEST_ALL_PREFIXES(SafeBrowsingProtocolManagerTest, TestNextChunkUrl);
   FRIEND_TEST_ALL_PREFIXES(SafeBrowsingProtocolManagerTest, TestUpdateUrl);
   friend class SafeBrowsingServerTest;
   friend class SBProtocolManagerFactoryImpl;
 
   // Internal API for fetching information from the SafeBrowsing servers. The
   // GetHash requests are higher priority since they can block user requests
   // so are handled separately.
   enum SafeBrowsingRequestType {
     NO_REQUEST = 0,     // No requests in progress
@@ skipping 48 matching lines @@
   // the time returned will increment an error count and return the appriate
   // next time (see ScheduleNextUpdate below).
   base::TimeDelta GetNextUpdateInterval(bool back_off);
 
   // Worker function for calculating GetHash and Update backoff times (in
   // seconds). |multiplier| is doubled for each consecutive error between the
   // 2nd and 5th, and |error_count| is incremented with each call.
   base::TimeDelta GetNextBackOffInterval(size_t* error_count,
                                          size_t* multiplier) const;
 
+  // Worker function for calculating the V4 GetHash backoff times.
+  // |multiplier| is doubled for each consecutive error after the
+  // first, and |error_count| is incremented with each call.
+  static base::TimeDelta GetNextV4BackOffInterval(size_t* error_count,
+                                                  size_t* multiplier);
+
+  // Resets the V4 gethash error counter and multiplier.
+  void ResetGetHashV4Errors();
+
   // Manages our update with the next allowable update time. If 'back_off_' is
   // true, we must decrease the frequency of requests of the SafeBrowsing
   // service according to section 5 of the protocol specification.
   // When disable_auto_update_ is set, ScheduleNextUpdate will do nothing.
   // ForceScheduleNextUpdate has to be called to trigger the update.
   void ScheduleNextUpdate(bool back_off);
 
   // Sends a request for a list of chunks we should download to the SafeBrowsing
   // servers. In order to format this request, we need to send all the chunk
   // numbers for each list that we have to the server. Getting the chunk numbers
@@ skipping 14 matching lines @@
 
   // Runs the protocol parser on received data and update the
   // SafeBrowsingService with the new content. Returns 'true' on successful
   // parse, 'false' on error.
   bool HandleServiceResponse(const GURL& url, const char* data, size_t length);
 
   // Updates internal state for each GetHash response error, assuming that the
   // current time is |now|.
   void HandleGetHashError(const base::Time& now);
 
+  // Updates internal state for each GetHash V4 response error, assuming that
+  // the current time is |now|.
+  void HandleGetHashV4Error(const base::Time& now);
+
   // Helper function for update completion.
   void UpdateFinished(bool success);
   void UpdateFinished(bool success, bool back_off);
 
   // A callback that runs if we timeout waiting for a response to an update
   // request. We use this to properly set our update state.
   void UpdateResponseTimeout();
 
   // Called after the chunks are added to the database.
   void OnAddChunksComplete();
@@ skipping 18 matching lines @@
   SafeBrowsingProtocolManagerDelegate* delegate_;
 
   // Current active request (in case we need to cancel) for updates or chunks
   // from the SafeBrowsing service. We can only have one of these outstanding
   // at any given time unlike GetHash requests, which are tracked separately.
   scoped_ptr<net::URLFetcher> request_;
 
   // The kind of request that is currently in progress.
   SafeBrowsingRequestType request_type_;
 
-  // The number of HTTP response errors, used for request backoff timing.
+  // The number of HTTP response errors since the the last successful HTTP
+  // response, used for request backoff timing.
   size_t update_error_count_;
   size_t gethash_error_count_;
+  size_t gethash_v4_error_count_;
 
   // Multipliers which double (max == 8) for each error after the second.
   size_t update_back_off_mult_;
   size_t gethash_back_off_mult_;
+  size_t gethash_v4_back_off_mult_;
 
   // Multiplier between 0 and 1 to spread clients over an interval.
   float back_off_fuzz_;
 
   // The list for which we are make a request.
   std::string list_name_;
 
   // For managing the next earliest time to query the SafeBrowsing servers for
   // updates.
   base::TimeDelta next_update_interval_;
@@ skipping 11 matching lines @@
 
   // True if the service has been given an add/sub chunk but it hasn't been
   // added to the database yet.
   bool chunk_pending_to_write_;
 
   // The last time we successfully received an update.
   base::Time last_update_;
 
   // While in GetHash backoff, we can't make another GetHash until this time.
   base::Time next_gethash_time_;
+  // For v4, the next gethash time is set to the backoff time is the last
+  // response was an error, or the minimum wait time if the last response was
+  // successful.
+  base::Time next_gethash_v4_time_;
 
   // Current product version sent in each request.
   std::string version_;
 
   // Used for measuring chunk request latency.
   base::Time chunk_request_start_;
 
   // Tracks the size of each update (in bytes).
   size_t update_size_;
 
@@ skipping 82 matching lines @@
       AddChunksCallback callback) = 0;
 
   // Delete chunks from the database.
   virtual void DeleteChunks(
       scoped_ptr<std::vector<SBChunkDelete> > chunk_deletes) = 0;
 };
 
 }  // namespace safe_browsing
 
 #endif  // CHROME_BROWSER_SAFE_BROWSING_PROTOCOL_MANAGER_H_