Switch to standard integer types in chromeos/.

chromeos/network/shill_property_util.cc

 // Copyright 2013 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 "chromeos/network/shill_property_util.h"
 
+#include <stdint.h>
+
 #include <set>
 
 #include "base/i18n/icu_encoding_detection.h"
 #include "base/i18n/icu_string_conversions.h"
 #include "base/json/json_writer.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversion_utils.h"
 #include "base/values.h"
 #include "chromeos/network/network_ui_data.h"
 #include "chromeos/network/onc/onc_utils.h"
 #include "components/device_event_log/device_event_log.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 namespace shill_property_util {
 
 namespace {
 
 // Replace non UTF8 characters in |str| with a replacement character.
 std::string ValidateUTF8(const std::string& str) {
   std::string result;
-  for (int32 index = 0; index < static_cast<int32>(str.size()); ++index) {
-    uint32 code_point_out;
+  for (int32_t index = 0; index < static_cast<int32_t>(str.size()); ++index) {
+    uint32_t code_point_out;
     bool is_unicode_char = base::ReadUnicodeCharacter(
         str.c_str(), str.size(), &index, &code_point_out);
-    const uint32 kFirstNonControlChar = 0x20;
+    const uint32_t kFirstNonControlChar = 0x20;
     if (is_unicode_char && (code_point_out >= kFirstNonControlChar)) {
       base::WriteUnicodeCharacter(code_point_out, &result);
     } else {
-      const uint32 kReplacementChar = 0xFFFD;
+      const uint32_t kReplacementChar = 0xFFFD;
       // Puts kReplacementChar if character is a control character [0,0x20)
       // or is not readable UTF8.
       base::WriteUnicodeCharacter(kReplacementChar, &result);
     }
   }
   return result;
 }
 
 // If existent and non-empty, copies the string at |key| from |source| to
 // |dest|. Returns true if the string was copied.
@@ skipping 29 matching lines @@
   std::string hex_ssid;
   properties.GetStringWithoutPathExpansion(shill::kWifiHexSsid, &hex_ssid);
 
   if (hex_ssid.empty()) {
     if (verbose_logging)
       NET_LOG(DEBUG) << "GetSSIDFromProperties: No HexSSID set: " << name;
     return std::string();
   }
 
   std::string ssid;
-  std::vector<uint8> raw_ssid_bytes;
+  std::vector<uint8_t> raw_ssid_bytes;
   if (base::HexStringToBytes(hex_ssid, &raw_ssid_bytes)) {
     ssid = std::string(raw_ssid_bytes.begin(), raw_ssid_bytes.end());
     VLOG(2) << "GetSSIDFromProperties: " << name << " HexSsid=" << hex_ssid
             << " SSID=" << ssid;
   } else {
     NET_LOG(ERROR) << "GetSSIDFromProperties: " << name
                    << " Error processing HexSsid: " << hex_ssid;
     return std::string();
   }
 
@@ skipping 272 matching lines @@
     LOG(WARNING)
         << "Provider name and country not defined, using code instead: "
         << *home_provider_id;
   }
   return true;
 }
 
 }  // namespace shill_property_util
 
 }  // namespace chromeos