Move full hash caching logic to v4_get_hash_protocol_manager

components/safe_browsing_db/v4_protocol_manager_util.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_protocol_manager_util.h"
 
 #include "base/base64.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/rand_util.h"
 #include "base/strings/string_util.h"
@@ skipping 50 matching lines @@
 
 }  // namespace
 
 std::ostream& operator<<(std::ostream& os, const UpdateListIdentifier& id) {
   os << "{hash: " << id.hash() << "; platform_type: " << id.platform_type
      << "; threat_entry_type: " << id.threat_entry_type
      << "; threat_type: " << id.threat_type << "}";
   return os;
 }
 
+PlatformType GetCurrentPlatformType() {
 #if defined(OS_WIN)
-#define PLATFORM_TYPE WINDOWS_PLATFORM
+  return WINDOWS_PLATFORM;
 #elif defined(OS_LINUX)
-#define PLATFORM_TYPE LINUX_PLATFORM
+  return LINUX_PLATFORM;
 #elif defined(OS_MACOSX)
-#define PLATFORM_TYPE OSX_PLATFORM
+  return OSX_PLATFORM;
 #else
 // This should ideally never compile but it is getting compiled on Android.
 // See: https://bugs.chromium.org/p/chromium/issues/detail?id=621647
 // TODO(vakh): Once that bug is fixed, this should be removed. If we leave
 // the platform_type empty, the server won't recognize the request and
 // return an error response which will pollute our UMA metrics.
-#define PLATFORM_TYPE LINUX_PLATFORM
+return LINUX_PLATFORM;
 #endif
+}
 
 const UpdateListIdentifier GetUrlMalwareId() {
-  return UpdateListIdentifier(PLATFORM_TYPE, URL, MALWARE_THREAT);
+  return UpdateListIdentifier(GetCurrentPlatformType(), URL, MALWARE_THREAT);
 }
 
 const UpdateListIdentifier GetUrlSocEngId() {
-  return UpdateListIdentifier(PLATFORM_TYPE, URL, SOCIAL_ENGINEERING_PUBLIC);
+  return UpdateListIdentifier(GetCurrentPlatformType(), URL,
+                              SOCIAL_ENGINEERING_PUBLIC);
+}
+
+const UpdateListIdentifier GetChromeUrlApiId() {
+  return UpdateListIdentifier(CHROME_PLATFORM, URL, API_ABUSE);
 }
 
 // The Safe Browsing V4 server URL prefix.
 const char kSbV4UrlPrefix[] = "https://safebrowsing.googleapis.com/v4";
 
+StoreAndHashPrefix::StoreAndHashPrefix(UpdateListIdentifier list_id,
+                                       HashPrefix hash_prefix)
+    : list_id(list_id), hash_prefix(hash_prefix) {}
+
+StoreAndHashPrefix::~StoreAndHashPrefix() {}
+
+bool StoreAndHashPrefix::operator==(const StoreAndHashPrefix& other) const {
+  return list_id == other.list_id && hash_prefix == other.hash_prefix;
+}
+
+bool StoreAndHashPrefix::operator!=(const StoreAndHashPrefix& other) const {
+  return !operator==(other);
+}
+
+size_t StoreAndHashPrefix::hash() const {
+  std::size_t first = list_id.hash();
+  std::size_t second = std::hash<std::string>()(hash_prefix);
+
+  return base::HashInts(first, second);
+}
+
 bool UpdateListIdentifier::operator==(const UpdateListIdentifier& other) const {
   return platform_type == other.platform_type &&
          threat_entry_type == other.threat_entry_type &&
          threat_type == other.threat_type;
 }
 
 bool UpdateListIdentifier::operator!=(const UpdateListIdentifier& other) const {
   return !operator==(other);
 }
 
@@ skipping 116 matching lines @@
   std::vector<std::string> paths;
   GeneratePathVariantsToCheck(canon_path, canon_query, &paths);
   for (const std::string& host : hosts) {
     for (const std::string& path : paths) {
       full_hashes->insert(crypto::SHA256HashString(host + path));
     }
   }
 }
 
 // static
+bool V4ProtocolManagerUtil::FullHashToHashPrefix(const FullHash& full_hash,
+                                                 PrefixSize prefix_size,
+                                                 HashPrefix* hash_prefix) {
+  if (full_hash.size() < prefix_size) {
+    return false;
+  }
+  *hash_prefix = full_hash.substr(prefix_size);
+  return true;
+}
+
+// static
+bool V4ProtocolManagerUtil::FullHashToSmallestHashPrefix(
+    const FullHash& full_hash,
+    HashPrefix* hash_prefix) {
+  return FullHashToHashPrefix(full_hash, kMinHashPrefixLength, hash_prefix);
+}
+
+// static
+bool V4ProtocolManagerUtil::FullHashMatchesHashPrefix(
+    const FullHash& full_hash,
+    const HashPrefix& hash_prefix) {
+  return full_hash.compare(0, hash_prefix.length(), hash_prefix) == 0;
+}
+
+// static
 void V4ProtocolManagerUtil::GenerateHostsToCheck(
     const GURL& url,
     std::vector<std::string>* hosts) {
   std::string canon_host;
   CanonicalizeUrl(url, &canon_host, NULL, NULL);
   GenerateHostVariantsToCheck(canon_host, hosts);
 }
 
 // static
 void V4ProtocolManagerUtil::GeneratePathsToCheck(
@@ skipping 194 matching lines @@
   }
 
   if (!paths->empty() && paths->back() != path)
     paths->push_back(path);
 
   if (!query.empty())
     paths->push_back(path + "?" + query);
 }
 
 }  // namespace safe_browsing