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

chrome/browser/safe_browsing/protocol_manager.cc

 // 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.
 
 #include "chrome/browser/safe_browsing/protocol_manager.h"
 
 #include <utility>
 
 #include "base/base64.h"
 #include "base/environment.h"
@@ skipping 116 matching lines @@
   // TODO(cbentzel): Remove ScopedTracker below once crbug.com/483689 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "483689 SafeBrowsingProtocolManager::Create"));
   if (!factory_)
     factory_ = new SBProtocolManagerFactoryImpl();
   return factory_->CreateProtocolManager(delegate, request_context_getter,
                                          config);
 }
 
+// static
+// Backoff interval is MIN(((2^(n-1))*15 minutes) * (RAND + 1), 24 hours) where
+// n is the number of consecutive errors.
+base::TimeDelta SafeBrowsingProtocolManager::GetNextV4BackOffInterval(
+    size_t* error_count,
+    size_t* multiplier) {
+  DCHECK(multiplier && error_count);
+  (*error_count)++;
+  if (*error_count > 1 && *error_count < 9) {
+    // With error count 9 and above we will hit the 24 hour max interval.
+    // Cap the multiplier here to prevent integer overflow errors.
+    *multiplier *= 2;
+  }
+  base::TimeDelta next = base::TimeDelta::FromMinutes(
+      *multiplier * (1 + base::RandDouble()) * 15);
+
+  base::TimeDelta day = base::TimeDelta::FromHours(24);
+
+  if (next < day)
+    return next;
+  else
+    return day;
+}
+
+void SafeBrowsingProtocolManager::ResetGetHashV4Errors() {
+  gethash_v4_error_count_ = 0;
+  gethash_v4_back_off_mult_ = 1;
+}
+
 SafeBrowsingProtocolManager::SafeBrowsingProtocolManager(
     SafeBrowsingProtocolManagerDelegate* delegate,
     net::URLRequestContextGetter* request_context_getter,
     const SafeBrowsingProtocolConfig& config)
     : delegate_(delegate),
       request_type_(NO_REQUEST),
       update_error_count_(0),
       gethash_error_count_(0),
+      gethash_v4_error_count_(0),
       update_back_off_mult_(1),
       gethash_back_off_mult_(1),
+      gethash_v4_back_off_mult_(1),
       next_update_interval_(base::TimeDelta::FromSeconds(
           base::RandInt(kSbTimerStartIntervalSecMin,
                         kSbTimerStartIntervalSecMax))),
       chunk_pending_to_write_(false),
+      next_gethash_v4_time_(Time::FromDoubleT(0)),
       version_(config.version),
       update_size_(0),
       client_name_(config.client_name),
       request_context_getter_(request_context_getter),
       url_prefix_(config.url_prefix),
       backup_update_reason_(BACKUP_UPDATE_REASON_MAX),
       disable_auto_update_(config.disable_auto_update),
       url_fetcher_id_(0),
       app_in_foreground_(true) {
   DCHECK(!url_prefix_.empty());
@@ skipping 115 matching lines @@
     // TODO(kcarattini): Add UMA.
     return false;
   }
 
   if (response.has_negative_cache_duration()) {
     // Seconds resolution is good enough so we ignore the nanos field.
     *negative_cache_duration = base::TimeDelta::FromSeconds(
         response.negative_cache_duration().seconds());
   }
 
+  if (response.has_minimum_wait_duration()) {
+    // Seconds resolution is good enough so we ignore the nanos field.
+    next_gethash_v4_time_ = Time::Now() + base::TimeDelta::FromSeconds(
+        response.minimum_wait_duration().seconds());
+  }
+
   // Loop over the threat matches and fill in full_hashes.
   for (const ThreatMatch& match : response.matches()) {
     // Make sure the platform and threat entry type match.
     if (!(match.has_threat_entry_type() &&
           match.threat_entry_type() == URL_EXPRESSION &&
           match.has_threat())) {
       continue;
     }
 
     // Fill in the full hash.
@@ skipping 27 matching lines @@
   }
   return true;
 }
 
 void SafeBrowsingProtocolManager::GetV4FullHashes(
     const std::vector<SBPrefix>& prefixes,
     const std::vector<PlatformType>& platforms,
     ThreatType threat_type,
     FullHashCallback callback) {
   DCHECK(CalledOnValidThread());
-  // TODO(kcarattini): Implement backoff behavior.
+  // We need to wait the minimum waiting duration, and if we are in backoff,
+  // we need to check if we're past the next allowed time. If we are, we can
+  // proceed with the request. If not, we are required to return empty results
+  // (i.e. treat the page as safe).
+  if (Time::Now() <= next_gethash_v4_time_) {
+    // TODO(kcarattini): Add UMA recording.
+    std::vector<SBFullHashResult> full_hashes;
+    callback.Run(full_hashes, base::TimeDelta());
+    return;
+  }
 
   std::string req_base64 = GetV4HashRequest(prefixes, platforms, threat_type);
   GURL gethash_url = GetV4HashUrl(req_base64);
 
   net::URLFetcher* fetcher =
       net::URLFetcher::Create(url_fetcher_id_++, gethash_url,
                               net::URLFetcher::GET, this)
           .release();
   v4_hash_requests_[fetcher] = FullHashDetails(callback,
                                                false  /* is_download */);
@@ skipping 84 matching lines @@
     details.callback.Run(full_hashes, cache_lifetime);
 
     hash_requests_.erase(it);
   } else if (v4_it != v4_hash_requests_.end()) {
     // V4 FindFullHashes response.
     const FullHashDetails& details = v4_it->second;
     std::vector<SBFullHashResult> full_hashes;
     base::TimeDelta negative_cache_duration;
     if (status.is_success() && response_code == net::HTTP_OK) {
       // TODO(kcarattini): Add UMA reporting.
-      // TODO(kcarattini): Implement backoff and minimum waiting duration
-      // compliance.
+      ResetGetHashV4Errors();
       std::string data;
       source->GetResponseAsString(&data);
       if (!ParseV4HashResponse(data, &full_hashes, &negative_cache_duration)) {
         full_hashes.clear();
         // TODO(kcarattini): Add UMA reporting.
       }
     } else {
-      // TODO(kcarattini): Handle error by setting backoff interval.
+      HandleGetHashV4Error(Time::Now());
       // TODO(kcarattini): Add UMA reporting.
       DVLOG(1) << "SafeBrowsing GetEncodedFullHashes request for: " <<
           source->GetURL() << " failed with error: " << status.error() <<
           " and response code: " << response_code;
     }
 
     // Invoke the callback with full_hashes, even if there was a parse error or
     // an error response code (in which case full_hashes will be empty). The
     // caller can't be blocked indefinitely.
     details.callback.Run(full_hashes, negative_cache_duration);
@@ skipping 401 matching lines @@
   }
 }
 
 void SafeBrowsingProtocolManager::HandleGetHashError(const Time& now) {
   DCHECK(CalledOnValidThread());
   base::TimeDelta next =
       GetNextBackOffInterval(&gethash_error_count_, &gethash_back_off_mult_);
   next_gethash_time_ = now + next;
 }
 
+void SafeBrowsingProtocolManager::HandleGetHashV4Error(const Time& now) {
+  DCHECK(CalledOnValidThread());
+  base::TimeDelta next = GetNextV4BackOffInterval(
+      &gethash_v4_error_count_, &gethash_v4_back_off_mult_);
+  next_gethash_v4_time_ = now + next;
+}
+
 void SafeBrowsingProtocolManager::UpdateFinished(bool success) {
   UpdateFinished(success, !success);
 }
 
 void SafeBrowsingProtocolManager::UpdateFinished(bool success, bool back_off) {
   DCHECK(CalledOnValidThread());
   UMA_HISTOGRAM_COUNTS("SB2.UpdateSize", update_size_);
   update_size_ = 0;
   bool update_success = success || request_type_ == CHUNK_REQUEST;
   if (backup_update_reason_ == BACKUP_UPDATE_REASON_MAX) {
@@ skipping 79 matching lines @@
 SafeBrowsingProtocolManager::FullHashDetails::FullHashDetails(
     FullHashCallback callback,
     bool is_download)
     : callback(callback), is_download(is_download) {}
 
 SafeBrowsingProtocolManager::FullHashDetails::~FullHashDetails() {}
 
 SafeBrowsingProtocolManagerDelegate::~SafeBrowsingProtocolManagerDelegate() {}
 
 }  // namespace safe_browsing