Add a GetFullHashWithApis method to Protocol Manager.

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 "base/base64.h"
 #include "base/environment.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/timer/timer.h"
 #include "chrome/browser/safe_browsing/protocol_parser.h"
 #include "chrome/common/env_vars.h"
+#include "components/safe_browsing_db/safebrowsing.pb.h"
 #include "components/safe_browsing_db/util.h"
 #include "components/variations/variations_associated_data.h"
 #include "google_apis/google_api_keys.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_context_getter.h"
@@ skipping 156 matching lines @@
 
 bool SafeBrowsingProtocolManager::IsUpdateScheduled() const {
   return update_timer_.IsRunning();
 }
 
 SafeBrowsingProtocolManager::~SafeBrowsingProtocolManager() {
   // Delete in-progress SafeBrowsing requests.
   STLDeleteContainerPairFirstPointers(hash_requests_.begin(),
                                       hash_requests_.end());
   hash_requests_.clear();
+
+  STLDeleteContainerPairFirstPointers(hash_api_requests_.begin(),
+                                      hash_api_requests_.end());
+  hash_api_requests_.clear();
 }
 
 // We can only have one update or chunk request outstanding, but there may be
 // multiple GetHash requests pending since we don't want to serialize them and
 // slow down the user.
 void SafeBrowsingProtocolManager::GetFullHash(
     const std::vector<SBPrefix>& prefixes,
     FullHashCallback callback,
     bool is_download,
     bool is_extended_reporting) {
@@ skipping 15 matching lines @@
   hash_requests_[fetcher] = FullHashDetails(callback, is_download);
 
   const std::string get_hash = FormatGetHash(prefixes);
 
   fetcher->SetLoadFlags(net::LOAD_DISABLE_CACHE);
   fetcher->SetRequestContext(request_context_getter_.get());
   fetcher->SetUploadData("text/plain", get_hash);
   fetcher->Start();
 }
 
+std::string SafeBrowsingProtocolManager::GetHashWithApisRequest(

[Nathan Parker, 2015/12/27 01:10:17]

This could be non-"Apis
-specific by passing the threat types as a param, and then calling it
GetV4HashRequest(..)

[kcarattini, 2015/12/28 00:05:46]

Done.

+    const std::vector<SBPrefix>& prefixes) {
+  // Build the request. Client info and client states are not added to the
+  // request protocol buffer. Client info is passed as params in the url.
+  FindFullHashesRequest req;
+  ThreatInfo* info = req.mutable_threat_info();
+  info->add_threat_types(API_ABUSE);
+  info->add_platform_types(CHROME_PLATFORM);
+  info->add_threat_entry_types(URL_EXPRESSION);
+  for (const SBPrefix& prefix : prefixes) {
+    std::string hash;
+    hash.append(reinterpret_cast<const char*>(&prefix), sizeof(SBPrefix));
+    info->add_threat_entries()->set_hash(hash);
+  }
+
+  // Serialize and Base64 encode.
+  std::string req_data, req_base64;
+  req.SerializeToString(&req_data);
+  base::Base64Encode(req_data, &req_base64);
+
+  return req_base64;
+}
+
+void SafeBrowsingProtocolManager::GetFullHashWithApis(

[Nathan Parker, 2015/12/27 01:10:17]

Same here.  This function could call a generic Pver4 version, with the API_ABUSE
threat type so the caller doesn't need to know about the proto.

[kcarattini, 2015/12/28 00:05:46]

Done.

+    const std::vector<SBPrefix>& prefixes,
+    FullHashCallback callback) {
+  DCHECK(CalledOnValidThread());
+  // TODO(kcarattini): Implement backoff behavior.
+
+  std::string req_base64 = GetHashWithApisRequest(prefixes);
+  GURL gethash_url = GetHashWithApisUrl(req_base64);
+
+  net::URLFetcher* fetcher =
+      net::URLFetcher::Create(url_fetcher_id_++, gethash_url,
+                              net::URLFetcher::POST, this)
+          .release();
+  hash_api_requests_[fetcher] = FullHashDetails(callback,
+                                                false  /* is_download */);
+
+  fetcher->SetLoadFlags(net::LOAD_DISABLE_CACHE);
+  fetcher->SetRequestContext(request_context_getter_.get());
+  fetcher->Start();
+}
+
 void SafeBrowsingProtocolManager::GetNextUpdate() {
   DCHECK(CalledOnValidThread());
   if (request_.get() || request_type_ != NO_REQUEST)
     return;
 
   IssueUpdateRequest();
 }
 
 // net::URLFetcherDelegate implementation ----------------------------------
 
@@ skipping 510 matching lines @@
   return GURL(url);
 }
 
 GURL SafeBrowsingProtocolManager::GetHashUrl(bool is_extended_reporting) const {
   std::string url = SafeBrowsingProtocolManagerHelper::ComposeUrl(
       url_prefix_, "gethash", client_name_, version_, additional_query_,
       is_extended_reporting);
   return GURL(url);
 }
 
+// The API hash call uses the pver4 Safe Browsing server.
+GURL SafeBrowsingProtocolManager::GetHashWithApisUrl(

[Nathan Parker, 2015/12/27 01:10:17]

This is not "Apis" specific -- we could call it GetV4HashUrl()

[kcarattini, 2015/12/28 00:05:46]

Done.

+    const std::string& request_base64) const {
+  std::string url = SafeBrowsingProtocolManagerHelper::ComposePver4Url(
+      "https://safebrowsing.googleapis.com/v4", "encodedFullHashes",
+      request_base64, client_name_, version_);
+  return GURL(url);
+}
+
 GURL SafeBrowsingProtocolManager::NextChunkUrl(const std::string& url) const {
   DCHECK(CalledOnValidThread());
   std::string next_url;
   if (!base::StartsWith(url, "http://", base::CompareCase::INSENSITIVE_ASCII) &&
       !base::StartsWith(url, "https://",
                         base::CompareCase::INSENSITIVE_ASCII)) {
     // Use https if we updated via https, otherwise http (useful for testing).
     if (base::StartsWith(url_prefix_, "https://",
                          base::CompareCase::INSENSITIVE_ASCII))
       next_url.append("https://");
@@ skipping 20 matching lines @@
 SafeBrowsingProtocolManager::FullHashDetails::FullHashDetails(
     FullHashCallback callback,
     bool is_download)
     : callback(callback), is_download(is_download) {}
 
 SafeBrowsingProtocolManager::FullHashDetails::~FullHashDetails() {}
 
 SafeBrowsingProtocolManagerDelegate::~SafeBrowsingProtocolManagerDelegate() {}
 
 }  // namespace safe_browsing