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;
@@ skipping 38 matching lines @@
 }
 
 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_;
 }
 
 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) {
+    : platform_type_(platform_type),
+      threat_entry_type_(threat_entry_type),
+      threat_type_(threat_type) {
   DCHECK(PlatformType_IsValid(platform_type));
   DCHECK(ThreatEntryType_IsValid(threat_entry_type));
   DCHECK(ThreatType_IsValid(threat_type));
 }
 
 ListIdentifier::ListIdentifier(const ListUpdateResponse& response)
     : ListIdentifier(response.platform_type(),
                      response.threat_entry_type(),
                      response.threat_type()) {}
 
@@ skipping 337 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