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 123 matching lines @@
 }
 
 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::Now()),
       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 113 matching lines @@
 
   if (!response.ParseFromString(data))
     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 24 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 86 matching lines @@
 
     hash_requests_.erase(it);
   } else if (v4_it != v4_hash_requests_.end()) {
     // V4 FindFullHashes response.
     fetcher.reset(v4_it->first);
     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.
+      gethash_v4_error_count_ = 0;
+      gethash_v4_back_off_mult_ = 1;
       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.
       if (status.status() == net::URLRequestStatus::FAILED) {
         DVLOG(1) << "SafeBrowsing GetEncodedFullHashes request for: " <<
             source->GetURL() << " failed with error: " << status.error();
       } else {
         DVLOG(1) << "SafeBrowsing GetEncodedFullHashes request for: " <<
             source->GetURL() << " failed with error: " << response_code;
       }
     }
 
@@ skipping 249 matching lines @@
     *multiplier *= 2;
     if (*multiplier > kSbMaxBackOff)
       *multiplier = kSbMaxBackOff;
     return next;
   }
   if (*error_count >= 6)
     return base::TimeDelta::FromHours(8);
   return base::TimeDelta::FromMinutes(1);
 }
 
+// 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(

[Nathan Parker, 2016/01/07 06:06:58]

This could be static, if you remove the CalledOnValidThread.

[kcarattini, 2016/01/07 06:48:53]

Done.

+    size_t* error_count,
+    size_t* multiplier) const {
+  DCHECK(CalledOnValidThread());
+  DCHECK(multiplier && error_count);
+  (*error_count)++;
+  if (*error_count > 1) {
+    *multiplier *= 2;

[Nathan Parker, 2016/01/07 06:06:58]

What happens on integer overflow?  Probably want to keep it at the clipped 24hrs
value rather than having multiplier go to zero.  I guess it'd be after ~64 days,
but still.

[kcarattini, 2016/01/07 06:48:53]

Done.

+  }
+  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;
+}
+
 // This request requires getting a list of all the chunks for each list from the
 // database asynchronously. The request will be issued when we're called back in
 // OnGetChunksComplete.
 // TODO(paulg): We should get this at start up and maintain a ChunkRange cache
 //              to avoid hitting the database with each update request. On the
 //              otherhand, this request will only occur ~20-30 minutes so there
 //              isn't that much overhead. Measure!
 void SafeBrowsingProtocolManager::IssueUpdateRequest() {
   DCHECK(CalledOnValidThread());
   request_type_ = UPDATE_REQUEST;
@@ skipping 134 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