Replace the old URL format for PVer4 requests with the new format.

components/safe_browsing_db/v4_get_hash_protocol_manager.cc

 // Copyright 2016 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 "components/safe_browsing_db/v4_get_hash_protocol_manager.h"
 
 #include <utility>
 
 #include "base/base64.h"
 #include "base/macros.h"
@@ skipping 98 matching lines @@
 
 V4GetHashProtocolManager::V4GetHashProtocolManager(
     net::URLRequestContextGetter* request_context_getter,
     const V4ProtocolConfig& config)
     : gethash_error_count_(0),
       gethash_back_off_mult_(1),
       next_gethash_time_(Time::FromDoubleT(0)),
       config_(config),
       request_context_getter_(request_context_getter),
       url_fetcher_id_(0),
-      clock_(new base::DefaultClock()) {
-}
+      clock_(new base::DefaultClock()) {}
 
 V4GetHashProtocolManager::~V4GetHashProtocolManager() {
   // Delete in-progress SafeBrowsing requests.
   STLDeleteContainerPairFirstPointers(hash_requests_.begin(),
                                       hash_requests_.end());
   hash_requests_.clear();
 }
 
 // static
 void V4GetHashProtocolManager::RegisterFactory(
@@ skipping 36 matching lines @@
   FindFullHashesResponse response;
 
   if (!response.ParseFromString(data)) {
     RecordParseGetHashResult(PARSE_FROM_STRING_ERROR);
     return false;
   }
 
   // negative_cache_duration should always be set.
   DCHECK(response.has_negative_cache_duration());
   // Seconds resolution is good enough so we ignore the nanos field.
-  *negative_cache_expire = clock_->Now() + base::TimeDelta::FromSeconds(
-      response.negative_cache_duration().seconds());
+  *negative_cache_expire =
+      clock_->Now() + 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_time_ =
         clock_->Now() + base::TimeDelta::FromSeconds(
-                          response.minimum_wait_duration().seconds());
+                            response.minimum_wait_duration().seconds());
   }
 
   // We only expect one threat type per request, so we make sure
   // the threat types are consistent between matches.
   ThreatType expected_threat_type = THREAT_TYPE_UNSPECIFIED;
 
   // 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 && match.has_threat())) {
+    if (!(match.has_threat_entry_type() && match.threat_entry_type() == URL &&
+          match.has_threat())) {
       RecordParseGetHashResult(UNEXPECTED_THREAT_ENTRY_TYPE_ERROR);
       return false;
     }
 
     if (!match.has_threat_type()) {
       RecordParseGetHashResult(UNEXPECTED_THREAT_TYPE_ERROR);
       return false;
     }
 
     if (expected_threat_type == THREAT_TYPE_UNSPECIFIED) {
       expected_threat_type = match.threat_type();
     } else if (match.threat_type() != expected_threat_type) {
       RecordParseGetHashResult(INCONSISTENT_THREAT_TYPE_ERROR);
       return false;
     }
 
     // Fill in the full hash.
     SBFullHashResult result;
     result.hash = StringToSBFullHash(match.threat().hash());
 
     if (match.has_cache_duration()) {
       // Seconds resolution is good enough so we ignore the nanos field.
-      result.cache_expire_after = clock_->Now() +
+      result.cache_expire_after =
+          clock_->Now() +
           base::TimeDelta::FromSeconds(match.cache_duration().seconds());
     } else {
       result.cache_expire_after = clock_->Now();
     }
 
     // Different threat types will handle the metadata differently.
     if (match.threat_type() == API_ABUSE) {
       if (match.has_platform_type() &&
           match.platform_type() == CHROME_PLATFORM) {
         if (match.has_threat_entry_metadata()) {
@@ skipping 82 matching lines @@
       RecordGetHashResult(V4OperationResult::BACKOFF_ERROR);
     } else {
       RecordGetHashResult(V4OperationResult::MIN_WAIT_DURATION_ERROR);
     }
     std::vector<SBFullHashResult> full_hashes;
     callback.Run(full_hashes, base::Time());
     return;
   }
 
   std::string req_base64 = GetHashRequest(prefixes, platforms, threat_type);
-  GURL gethash_url = GetHashUrl(req_base64);
+  GURL gethash_url;
+  net::HttpRequestHeaders headers;
+  GetHashUrlAndHeaders(req_base64, &gethash_url, &headers);
 
   net::URLFetcher* fetcher =
       net::URLFetcher::Create(url_fetcher_id_++, gethash_url,
                               net::URLFetcher::GET, this)
           .release();
+  fetcher->SetExtraRequestHeaders(headers.ToString());
   hash_requests_[fetcher] = callback;
 
   fetcher->SetLoadFlags(net::LOAD_DISABLE_CACHE);
   fetcher->SetRequestContext(request_context_getter_.get());
   fetcher->Start();
 }
 
 void V4GetHashProtocolManager::GetFullHashesWithApis(
     const std::vector<SBPrefix>& prefixes,
     FullHashCallback callback) {
@@ skipping 59 matching lines @@
   hash_requests_.erase(it);
 }
 
 void V4GetHashProtocolManager::HandleGetHashError(const Time& now) {
   DCHECK(CalledOnValidThread());
   base::TimeDelta next = V4ProtocolManagerUtil::GetNextBackOffInterval(
       &gethash_error_count_, &gethash_back_off_mult_);
   next_gethash_time_ = now + next;
 }
 
-GURL V4GetHashProtocolManager::GetHashUrl(const std::string& req_base64) const {
-  return V4ProtocolManagerUtil::GetRequestUrl(req_base64, "encodedFullHashes",
-                                              config_);
+void V4GetHashProtocolManager::GetHashUrlAndHeaders(
+    const std::string& req_base64,
+    GURL* gurl,
+    net::HttpRequestHeaders* headers) const {
+  V4ProtocolManagerUtil::GetRequestUrlAndHeaders(req_base64, "fullHashes:find",
+                                                 config_, gurl, headers);
 }
 
-
 }  // namespace safe_browsing