Switch to standard integer types in net/.

net/http/http_server_properties_manager.cc

 // Copyright 2014 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 "net/http/http_server_properties_manager.h"
 
 #include "base/bind.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/prefs/pref_service.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "net/base/ip_address_number.h"
 #include "net/base/port_util.h"
 
 namespace net {
 
 namespace {
 
 // Time to wait before starting an update the http_server_properties_impl_ cache
 // from preferences. Scheduling another update during this period will reset the
 // timer.
-const int64 kUpdateCacheDelayMs = 1000;
+const int64_t kUpdateCacheDelayMs = 1000;
 
 // Time to wait before starting an update the preferences from the
 // http_server_properties_impl_ cache. Scheduling another update during this
 // period will reset the timer.
-const int64 kUpdatePrefsDelayMs = 60000;
+const int64_t kUpdatePrefsDelayMs = 60000;
 
 // "version" 0 indicates, http_server_properties doesn't have "version"
 // property.
 const int kMissingVersion = 0;
 
 // The version number of persisted http_server_properties.
 const int kVersionNumber = 3;
 
 typedef std::vector<std::string> StringVector;
 
@@ skipping 261 matching lines @@
 const SettingsMap& HttpServerPropertiesManager::GetSpdySettings(
     const HostPortPair& host_port_pair) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   return http_server_properties_impl_->GetSpdySettings(host_port_pair);
 }
 
 bool HttpServerPropertiesManager::SetSpdySetting(
     const HostPortPair& host_port_pair,
     SpdySettingsIds id,
     SpdySettingsFlags flags,
-    uint32 value) {
+    uint32_t value) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   bool persist = http_server_properties_impl_->SetSpdySetting(
       host_port_pair, id, flags, value);
   if (persist)
     ScheduleUpdatePrefsOnNetworkThread(SET_SPDY_SETTING);
   return persist;
 }
 
 void HttpServerPropertiesManager::ClearSpdySettings(
     const HostPortPair& host_port_pair) {
@@ skipping 263 matching lines @@
   }
 
   // Port is mandatory.
   int port = 0;
   if (!alternative_service_dict.GetInteger(kPortKey, &port) ||
       !IsPortValid(port)) {
     DVLOG(1) << "Malformed alternative service port for server: " << server_str;
     return false;
   }
   alternative_service_info->alternative_service.port =
-      static_cast<uint32>(port);
+      static_cast<uint32_t>(port);
 
   // Probability is optional, defaults to 1.0.
   alternative_service_info->probability = 1.0;
   if (alternative_service_dict.HasKey(kProbabilityKey) &&
       !alternative_service_dict.GetDoubleWithoutPathExpansion(
           kProbabilityKey, &(alternative_service_info->probability))) {
     DVLOG(1) << "Malformed alternative service probability for server: "
              << server_str;
     return false;
   }
 
   // Expiration is optional, defaults to one day.
   base::Time expiration;
   if (!alternative_service_dict.HasKey(kExpirationKey)) {
     alternative_service_info->expiration =
         base::Time::Now() + base::TimeDelta::FromDays(1);
     return true;
   }
 
   std::string expiration_string;
   if (alternative_service_dict.GetStringWithoutPathExpansion(
           kExpirationKey, &expiration_string)) {
-    int64 expiration_int64 = 0;
+    int64_t expiration_int64 = 0;
     if (!base::StringToInt64(expiration_string, &expiration_int64)) {
       DVLOG(1) << "Malformed alternative service expiration for server: "
                << server_str;
       return false;
     }
     alternative_service_info->expiration =
         base::Time::FromInternalValue(expiration_int64);
     return true;
   }
 
@@ skipping 431 matching lines @@
 void HttpServerPropertiesManager::SaveSpdySettingsToServerPrefs(
     const SettingsMap* settings_map,
     base::DictionaryValue* server_pref_dict) {
   if (!settings_map) {
     return;
   }
   base::DictionaryValue* spdy_settings_dict = new base::DictionaryValue;
   for (SettingsMap::const_iterator it = settings_map->begin();
        it != settings_map->end(); ++it) {
     SpdySettingsIds id = it->first;
-    uint32 value = it->second.second;
+    uint32_t value = it->second.second;
     std::string key = base::StringPrintf("%u", id);
     spdy_settings_dict->SetInteger(key, value);
   }
   server_pref_dict->SetWithoutPathExpansion(kSettingsKey, spdy_settings_dict);
 }
 
 void HttpServerPropertiesManager::SaveAlternativeServiceToServerPrefs(
     const AlternativeServiceInfoVector* alternative_service_info_vector,
     base::DictionaryValue* server_pref_dict) {
   if (!alternative_service_info_vector ||
       alternative_service_info_vector->empty()) {
     return;
   }
   scoped_ptr<base::ListValue> alternative_service_list(new base::ListValue);
   for (const AlternativeServiceInfo& alternative_service_info :
        *alternative_service_info_vector) {
     const AlternativeService alternative_service =
         alternative_service_info.alternative_service;
     DCHECK(IsAlternateProtocolValid(alternative_service.protocol));
     base::DictionaryValue* alternative_service_dict = new base::DictionaryValue;
     alternative_service_dict->SetInteger(kPortKey, alternative_service.port);
     if (!alternative_service.host.empty()) {
       alternative_service_dict->SetString(kHostKey, alternative_service.host);
     }
     alternative_service_dict->SetString(
         kProtocolKey, AlternateProtocolToString(alternative_service.protocol));
     alternative_service_dict->SetDouble(kProbabilityKey,
                                         alternative_service_info.probability);
-    // JSON cannot store int64, so expiration is converted to a string.
+    // JSON cannot store int64_t, so expiration is converted to a string.
     alternative_service_dict->SetString(
         kExpirationKey,
         base::Int64ToString(
             alternative_service_info.expiration.ToInternalValue()));
     alternative_service_list->Append(alternative_service_dict);
   }
   if (alternative_service_list->GetSize() == 0)
     return;
   server_pref_dict->SetWithoutPathExpansion(kAlternativeServiceKey,
                                             alternative_service_list.release());
@@ skipping 13 matching lines @@
                                                        supports_quic_dict);
 }
 
 void HttpServerPropertiesManager::SaveNetworkStatsToServerPrefs(
     const ServerNetworkStats* server_network_stats,
     base::DictionaryValue* server_pref_dict) {
   if (!server_network_stats)
     return;
 
   base::DictionaryValue* server_network_stats_dict = new base::DictionaryValue;
-  // Becasue JSON doesn't support int64, persist int64 as a string.
+  // Becasue JSON doesn't support int64_t, persist int64_t as a string.
   server_network_stats_dict->SetInteger(
       kSrttKey, static_cast<int>(server_network_stats->srtt.ToInternalValue()));
   // TODO(rtenneti): When QUIC starts using bandwidth_estimate, then persist
   // bandwidth_estimate.
   server_pref_dict->SetWithoutPathExpansion(kNetworkStatsKey,
                                             server_network_stats_dict);
 }
 
 void HttpServerPropertiesManager::SaveQuicServerInfoMapToServerPrefs(
     QuicServerInfoMap* quic_server_info_map,
@@ skipping 15 matching lines @@
                                                        quic_servers_dict);
 }
 
 void HttpServerPropertiesManager::OnHttpServerPropertiesChanged() {
   DCHECK(pref_task_runner_->RunsTasksOnCurrentThread());
   if (!setting_prefs_)
     ScheduleUpdateCacheOnPrefThread();
 }
 
 }  // namespace net