Switch to standard integer types in extensions/browser/.

extensions/browser/api/networking_private/networking_private_linux.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 "extensions/browser/api/networking_private/networking_private_linux.h"
 
+#include <stddef.h>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_split.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "components/onc/onc_constants.h"
 #include "content/public/browser/browser_context.h"
@@ skipping 364 matching lines @@
   dict_writer.OpenArray("{sv}", &wifi_array);
 
   dbus::MessageWriter wifi_dict_writer(&method_call);
   wifi_array.OpenDictEntry(&wifi_dict_writer);
   wifi_dict_writer.AppendString(
       networking_private::kNetworkManagerConnectionConfigSsid);
 
   dbus::MessageWriter variant_writer(&method_call);
   wifi_dict_writer.OpenVariant("ay", &variant_writer);
   variant_writer.AppendArrayOfBytes(
-      reinterpret_cast<const uint8*>(ssid.c_str()), ssid.size());
+      reinterpret_cast<const uint8_t*>(ssid.c_str()), ssid.size());
 
   // Close all the arrays and dicts.
   wifi_dict_writer.CloseContainer(&variant_writer);
   wifi_array.CloseContainer(&wifi_dict_writer);
   dict_writer.CloseContainer(&wifi_array);
   array_writer.CloseContainer(&dict_writer);
   builder.CloseContainer(&array_writer);
 
   builder.AppendObjectPath(device_path);
   builder.AppendObjectPath(access_point_path);
@@ skipping 283 matching lines @@
   scoped_ptr<dbus::Response> response(device_proxy->CallMethodAndBlock(
       &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
 
   if (!response) {
     LOG(ERROR) << "Failed to get the device type for device "
                << device_path.value();
     return NetworkingPrivateLinux::NM_DEVICE_TYPE_UNKNOWN;
   }
 
   dbus::MessageReader reader(response.get());
-  uint32 device_type = 0;
+  uint32_t device_type = 0;
   if (!reader.PopVariantOfUint32(&device_type)) {
     LOG(ERROR) << "Unexpected response for device " << device_type << ": "
                << response->ToString();
     return NM_DEVICE_TYPE_UNKNOWN;
   }
 
   return static_cast<NetworkingPrivateLinux::DeviceType>(device_type);
 }
 
 void NetworkingPrivateLinux::GetAllWiFiAccessPoints(bool configured_only,
@@ skipping 60 matching lines @@
 
     // The response should contain a variant that contains an array of bytes.
     dbus::MessageReader reader(response.get());
     dbus::MessageReader variant_reader(response.get());
     if (!reader.PopVariant(&variant_reader)) {
       LOG(ERROR) << "Unexpected response for " << access_point_path.value()
                  << ": " << response->ToString();
       return false;
     }
 
-    const uint8* ssid_bytes = NULL;
+    const uint8_t* ssid_bytes = NULL;
     size_t ssid_length = 0;
     if (!variant_reader.PopArrayOfBytes(&ssid_bytes, &ssid_length)) {
       LOG(ERROR) << "Unexpected response for " << access_point_path.value()
                  << ": " << response->ToString();
       return false;
     }
 
     std::string ssidUTF8(ssid_bytes, ssid_bytes + ssid_length);
     base::string16 ssid = base::UTF8ToUTF16(ssidUTF8);
 
     access_point_info->SetString(kAccessPointInfoName, ssid);
   }
 
   // Read signal strength.
   {
     scoped_ptr<dbus::Response> response(GetAccessPointProperty(
         access_point_proxy,
         networking_private::kNetworkManagerStrengthProperty));
     if (!response) {
       return false;
     }
 
     dbus::MessageReader reader(response.get());
-    uint8 strength = 0;
+    uint8_t strength = 0;
     if (!reader.PopVariantOfByte(&strength)) {
       LOG(ERROR) << "Unexpected response for " << access_point_path.value()
                  << ": " << response->ToString();
       return false;
     }
 
     access_point_info->SetInteger(kAccessPointInfoWifiSignalStrengthDotted,
                                   strength);
   }
 
   // Read the security type. This is from the WpaFlags and RsnFlags property
   // which are of the same type and can be OR'd together to find all supported
   // security modes.
 
-  uint32 wpa_security_flags = 0;
+  uint32_t wpa_security_flags = 0;
   {
     scoped_ptr<dbus::Response> response(GetAccessPointProperty(
         access_point_proxy,
         networking_private::kNetworkManagerWpaFlagsProperty));
     if (!response) {
       return false;
     }
 
     dbus::MessageReader reader(response.get());
 
     if (!reader.PopVariantOfUint32(&wpa_security_flags)) {
       LOG(ERROR) << "Unexpected response for " << access_point_path.value()
                  << ": " << response->ToString();
       return false;
     }
   }
 
-  uint32 rsn_security_flags = 0;
+  uint32_t rsn_security_flags = 0;
   {
     scoped_ptr<dbus::Response> response(GetAccessPointProperty(
         access_point_proxy,
         networking_private::kNetworkManagerRsnFlagsProperty));
     if (!response) {
       return false;
     }
 
     dbus::MessageReader reader(response.get());
 
@@ skipping 110 matching lines @@
          signal_strength > existing_signal_strength)) {
       existing_access_point->SetString(kAccessPointInfoConnectionState,
                                        connection_state);
       existing_access_point->SetInteger(
           kAccessPointInfoWifiSignalStrengthDotted, signal_strength);
       existing_access_point->SetString(kAccessPointInfoGuid, network_guid);
     }
   }
 }
 
-void NetworkingPrivateLinux::MapSecurityFlagsToString(uint32 security_flags,
+void NetworkingPrivateLinux::MapSecurityFlagsToString(uint32_t security_flags,
                                                       std::string* security) {
   // Valid values are None, WEP-PSK, WEP-8021X, WPA-PSK, WPA-EAP
   if (security_flags == NetworkingPrivateLinux::NM_802_11_AP_SEC_NONE) {
     *security = kAccessPointSecurityNone;
   } else if (security_flags &
              NetworkingPrivateLinux::NM_802_11_AP_SEC_KEY_MGMT_PSK) {
     *security = kAccessPointSecurityWpaPsk;
   } else if (security_flags &
              NetworkingPrivateLinux::NM_802_11_AP_SEC_KEY_MGMT_802_1X) {
     *security = kAccessPointSecurity9021X;
@@ skipping 221 matching lines @@
                  base::Unretained(this), base::Passed(&guid_list)));
 }
 
 void NetworkingPrivateLinux::OnNetworksChangedEventTask(
     scoped_ptr<GuidList> guid_list) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   OnNetworksChangedEventOnUIThread(*guid_list);
 }
 
 }  // namespace extensions