Store list information in ListInfo (was: StoreIdAndFIleName)

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 44 matching lines @@
       escaped_str += c;
     }
   }
 
   return escaped_str;
 }
 
 }  // namespace
 
 std::ostream& operator<<(std::ostream& os, const ListIdentifier& id) {
-  os << "{hash: " << id.hash() << "; platform_type: " << id.platform_type
-     << "; threat_entry_type: " << id.threat_entry_type
-     << "; threat_type: " << id.threat_type << "}";
+  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)
   return WINDOWS_PLATFORM;
 #elif defined(OS_LINUX)
   return LINUX_PLATFORM;
 #elif defined(OS_MACOSX)
   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.
 return LINUX_PLATFORM;
 #endif
 }
 
 const ListIdentifier GetChromeUrlApiId() {
-  return ListIdentifier(CHROME_PLATFORM, URL, API_ABUSE);
+  return ListIdentifier(CHROME_PLATFORM, URL, API_ABUSE,
+                        SB_THREAT_TYPE_API_ABUSE);
 }
 
 const ListIdentifier GetUrlMalwareId() {
-  return ListIdentifier(GetCurrentPlatformType(), URL, MALWARE_THREAT);
+  return ListIdentifier(GetCurrentPlatformType(), URL, MALWARE_THREAT,
+                        SB_THREAT_TYPE_URL_MALWARE);
 }
 
 const ListIdentifier GetUrlSocEngId() {
   return ListIdentifier(GetCurrentPlatformType(), URL,
-                        SOCIAL_ENGINEERING_PUBLIC);
+                        SOCIAL_ENGINEERING_PUBLIC, SB_THREAT_TYPE_URL_PHISHING);
 }
 
 // The Safe Browsing V4 server URL prefix.
 const char kSbV4UrlPrefix[] = "https://safebrowsing.googleapis.com/v4";
 
 StoreAndHashPrefix::StoreAndHashPrefix(ListIdentifier 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 ListIdentifier::operator==(const ListIdentifier& other) const {
-  return platform_type == other.platform_type &&
-         threat_entry_type == other.threat_entry_type &&
-         threat_type == other.threat_type;
+  return platform_type_ == other.platform_type_ &&
+         threat_entry_type_ == other.threat_entry_type_ &&
+         threat_type_ == other.threat_type_;

[Nathan Parker, 2016/09/21 19:02:57]

Why not compare SBThreatType as well?  And in the hash below.

[vakh (use Gerrit instead), 2016/09/22 00:10:36]

This triad is sufficient to identify a list.
Anyway, I've reverted the change to ListIdentifier.

 }
 
 bool ListIdentifier::operator!=(const ListIdentifier& other) const {
   return !operator==(other);
 }
 
 size_t ListIdentifier::hash() const {
-  std::size_t first = std::hash<unsigned int>()(platform_type);
-  std::size_t second = std::hash<unsigned int>()(threat_entry_type);
-  std::size_t third = std::hash<unsigned int>()(threat_type);
+  std::size_t first = std::hash<unsigned int>()(platform_type_);
+  std::size_t second = std::hash<unsigned int>()(threat_entry_type_);
+  std::size_t third = std::hash<unsigned int>()(threat_type_);
 
   std::size_t interim = base::HashInts(first, second);
   return base::HashInts(interim, third);
 }
 
 ListIdentifier::ListIdentifier() {}
 
 ListIdentifier::ListIdentifier(PlatformType platform_type,
                                ThreatEntryType threat_entry_type,
-                               ThreatType threat_type)
-    : platform_type(platform_type),
-      threat_entry_type(threat_entry_type),
-      threat_type(threat_type) {
+                               ThreatType threat_type,
+                               SBThreatType sb_threat_type)
+    : platform_type_(platform_type),
+      threat_entry_type_(threat_entry_type),
+      threat_type_(threat_type),
+      sb_threat_type_(sb_threat_type) {
   DCHECK(PlatformType_IsValid(platform_type));
   DCHECK(ThreatEntryType_IsValid(threat_entry_type));
   DCHECK(ThreatType_IsValid(threat_type));
 }
+ListIdentifier::ListIdentifier(PlatformType platform_type,
+                               ThreatEntryType threat_entry_type,
+                               ThreatType threat_type)
+    : ListIdentifier(platform_type,
+                     threat_entry_type,
+                     threat_type,
+                     SB_THREAT_TYPE_SAFE) {}
 
 ListIdentifier::ListIdentifier(const ListUpdateResponse& response)
     : ListIdentifier(response.platform_type(),
                      response.threat_entry_type(),
                      response.threat_type()) {}
 
 V4ProtocolConfig::V4ProtocolConfig() : disable_auto_update(false) {}
 
 V4ProtocolConfig::V4ProtocolConfig(const V4ProtocolConfig& other) = default;
 
@@ skipping 333 matching lines @@
 // static
 void V4ProtocolManagerUtil::SetClientInfoFromConfig(
     ClientInfo* client_info,
     const V4ProtocolConfig& config) {
   DCHECK(client_info);
   client_info->set_client_id(config.client_name);
   client_info->set_client_version(config.version);
 }
 
 }  // namespace safe_browsing