Switch to standard integer types in chromeos/.

chromeos/network/network_sms_handler.cc

 // Copyright (c) 2012 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/network_sms_handler.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <algorithm>
 #include <deque>
 #include <vector>
 
 #include "base/bind.h"
+#include "base/macros.h"
 #include "base/values.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
+#include "chromeos/dbus/gsm_sms_client.h"
+#include "chromeos/dbus/modem_messaging_client.h"
 #include "chromeos/dbus/shill_device_client.h"
 #include "chromeos/dbus/shill_manager_client.h"
-#include "chromeos/dbus/gsm_sms_client.h"
-#include "chromeos/dbus/modem_messaging_client.h"
 #include "chromeos/dbus/sms_client.h"
 #include "dbus/object_path.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace {
 
 // Not exposed/exported:
 const char kIndexKey[] = "index";
 
 // Keys from ModemManager1
@@ skipping 25 matching lines @@
     : public NetworkSmsHandler::NetworkSmsDeviceHandler {
  public:
   ModemManagerNetworkSmsDeviceHandler(NetworkSmsHandler* host,
                                       const std::string& service_name,
                                       const dbus::ObjectPath& object_path);
 
   void RequestUpdate() override;
 
  private:
   void ListCallback(const base::ListValue& message_list);
-  void SmsReceivedCallback(uint32 index, bool complete);
-  void GetCallback(uint32 index, const base::DictionaryValue& dictionary);
+  void SmsReceivedCallback(uint32_t index, bool complete);
+  void GetCallback(uint32_t index, const base::DictionaryValue& dictionary);
   void DeleteMessages();
   void MessageReceived(const base::DictionaryValue& dictionary);
 
   NetworkSmsHandler* host_;
   std::string service_name_;
   dbus::ObjectPath object_path_;
   bool deleting_messages_;
-  std::vector<uint32> delete_queue_;
+  std::vector<uint32_t> delete_queue_;
   base::WeakPtrFactory<ModemManagerNetworkSmsDeviceHandler> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ModemManagerNetworkSmsDeviceHandler);
 };
 
 NetworkSmsHandler::
 ModemManagerNetworkSmsDeviceHandler::ModemManagerNetworkSmsDeviceHandler(
     NetworkSmsHandler* host,
     const std::string& service_name,
     const dbus::ObjectPath& object_path)
@@ skipping 26 matching lines @@
   // This receives all messages, so clear any pending deletes.
   delete_queue_.clear();
   for (base::ListValue::const_iterator iter = message_list.begin();
        iter != message_list.end(); ++iter) {
     base::DictionaryValue* message = NULL;
     if (!(*iter)->GetAsDictionary(&message))
       continue;
     MessageReceived(*message);
     double index = 0;
     if (message->GetDoubleWithoutPathExpansion(kIndexKey, &index))
-      delete_queue_.push_back(static_cast<uint32>(index));
+      delete_queue_.push_back(static_cast<uint32_t>(index));
   }
   DeleteMessages();
 }
 
 // Messages must be deleted one at a time, since we can not guarantee
 // the order the deletion will be executed in. Delete messages from
 // the back of the list so that the indices are valid.
 void NetworkSmsHandler::ModemManagerNetworkSmsDeviceHandler::DeleteMessages() {
   if (delete_queue_.empty()) {
     deleting_messages_ = false;
     return;
   }
   deleting_messages_ = true;
-  uint32 index = delete_queue_.back();
+  uint32_t index = delete_queue_.back();
   delete_queue_.pop_back();
   DBusThreadManager::Get()->GetGsmSMSClient()->Delete(
       service_name_, object_path_, index,
       base::Bind(&NetworkSmsHandler::
                  ModemManagerNetworkSmsDeviceHandler::DeleteMessages,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
-void NetworkSmsHandler::
-ModemManagerNetworkSmsDeviceHandler::SmsReceivedCallback(
-    uint32 index,
-    bool complete) {
+void NetworkSmsHandler::ModemManagerNetworkSmsDeviceHandler::
+    SmsReceivedCallback(uint32_t index, bool complete) {
   // Only handle complete messages.
   if (!complete)
     return;
   DBusThreadManager::Get()->GetGsmSMSClient()->Get(
       service_name_, object_path_, index,
       base::Bind(&NetworkSmsHandler::
                  ModemManagerNetworkSmsDeviceHandler::GetCallback,
                  weak_ptr_factory_.GetWeakPtr(), index));
 }
 
 void NetworkSmsHandler::ModemManagerNetworkSmsDeviceHandler::GetCallback(
-    uint32 index,
+    uint32_t index,
     const base::DictionaryValue& dictionary) {
   MessageReceived(dictionary);
   delete_queue_.push_back(index);
   if (!deleting_messages_)
     DeleteMessages();
 }
 
 void NetworkSmsHandler::
 ModemManagerNetworkSmsDeviceHandler::MessageReceived(
     const base::DictionaryValue& dictionary) {
@@ skipping 307 matching lines @@
         new ModemManager1NetworkSmsDeviceHandler(
             this, service_name, object_path));
   } else {
     device_handlers_.push_back(
         new ModemManagerNetworkSmsDeviceHandler(
             this, service_name, object_path));
   }
 }
 
 }  // namespace chromeos