Switch to standard integer types in device/.

device/media_transfer_protocol/media_transfer_protocol_daemon_client.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 "device/media_transfer_protocol/media_transfer_protocol_daemon_client.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
+#include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
 #include "dbus/object_proxy.h"
 #include "device/media_transfer_protocol/mtp_file_entry.pb.h"
 #include "device/media_transfer_protocol/mtp_storage_info.pb.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace device {
 
 namespace {
 
 const char kInvalidResponseMsg[] = "Invalid Response: ";
-uint32 kMaxChunkSize = 1024*1024;  // D-Bus has message size limits.
+uint32_t kMaxChunkSize = 1024 * 1024;  // D-Bus has message size limits.
 
 // The MediaTransferProtocolDaemonClient implementation.
 class MediaTransferProtocolDaemonClientImpl
     : public MediaTransferProtocolDaemonClient {
  public:
   explicit MediaTransferProtocolDaemonClientImpl(dbus::Bus* bus)
       : proxy_(bus->GetObjectProxy(
           mtpd::kMtpdServiceName,
           dbus::ObjectPath(mtpd::kMtpdServicePath))),
         listen_for_changes_called_(false),
@@ skipping 70 matching lines @@
     writer.AppendString(handle);
     proxy_->CallMethod(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&MediaTransferProtocolDaemonClientImpl::OnCloseStorage,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback,
                    error_callback));
   }
 
   void CreateDirectory(const std::string& handle,
-                       const uint32 parent_id,
+                       const uint32_t parent_id,
                        const std::string& directory_name,
                        const CreateDirectoryCallback& callback,
                        const ErrorCallback& error_callback) override {
     dbus::MethodCall method_call(mtpd::kMtpdInterface, mtpd::kCreateDirectory);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(handle);
     writer.AppendUint32(parent_id);
     writer.AppendString(directory_name);
     proxy_->CallMethod(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&MediaTransferProtocolDaemonClientImpl::OnCreateDirectory,
                    weak_ptr_factory_.GetWeakPtr(), callback, error_callback));
   }
 
   // MediaTransferProtocolDaemonClient override.
   void ReadDirectoryEntryIds(const std::string& handle,
-                             uint32 file_id,
+                             uint32_t file_id,
                              const ReadDirectoryEntryIdsCallback& callback,
                              const ErrorCallback& error_callback) override {
     dbus::MethodCall method_call(mtpd::kMtpdInterface,
                                  mtpd::kReadDirectoryEntryIds);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(handle);
     writer.AppendUint32(file_id);
     proxy_->CallMethod(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&MediaTransferProtocolDaemonClientImpl::OnReadDirectoryIds,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback,
                    error_callback));
   }
 
   void GetFileInfo(const std::string& handle,
-                   const std::vector<uint32>& file_ids,
+                   const std::vector<uint32_t>& file_ids,
                    size_t offset,
                    size_t entries_to_read,
                    const GetFileInfoCallback& callback,
                    const ErrorCallback& error_callback) override {
     if (offset >= file_ids.size()) {
       error_callback.Run();
       return;
     }
 
     dbus::MethodCall method_call(mtpd::kMtpdInterface, mtpd::kGetFileInfo);
@@ skipping 14 matching lines @@
     proxy_->CallMethod(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&MediaTransferProtocolDaemonClientImpl::OnGetFileInfo,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback,
                    error_callback));
   }
 
   // MediaTransferProtocolDaemonClient override.
   void ReadFileChunk(const std::string& handle,
-                     uint32 file_id,
-                     uint32 offset,
-                     uint32 bytes_to_read,
+                     uint32_t file_id,
+                     uint32_t offset,
+                     uint32_t bytes_to_read,
                      const ReadFileCallback& callback,
                      const ErrorCallback& error_callback) override {
     DCHECK_LE(bytes_to_read, kMaxChunkSize);
     dbus::MethodCall method_call(mtpd::kMtpdInterface, mtpd::kReadFileChunk);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(handle);
     writer.AppendUint32(file_id);
     writer.AppendUint32(offset);
     writer.AppendUint32(bytes_to_read);
     proxy_->CallMethod(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&MediaTransferProtocolDaemonClientImpl::OnReadFile,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback,
                    error_callback));
   }
 
   void RenameObject(const std::string& handle,
-                    const uint32 object_id,
+                    const uint32_t object_id,
                     const std::string& new_name,
                     const RenameObjectCallback& callback,
                     const ErrorCallback& error_callback) override {
     dbus::MethodCall method_call(mtpd::kMtpdInterface, mtpd::kRenameObject);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(handle);
     writer.AppendUint32(object_id);
     writer.AppendString(new_name);
     proxy_->CallMethod(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&MediaTransferProtocolDaemonClientImpl::OnRenameObject,
                    weak_ptr_factory_.GetWeakPtr(), callback, error_callback));
   }
 
   void CopyFileFromLocal(const std::string& handle,
                          const int source_file_descriptor,
-                         const uint32 parent_id,
+                         const uint32_t parent_id,
                          const std::string& file_name,
                          const CopyFileFromLocalCallback& callback,
                          const ErrorCallback& error_callback) override {
     dbus::FileDescriptor file_descriptor(source_file_descriptor);
     file_descriptor.CheckValidity();
 
     dbus::MethodCall method_call(mtpd::kMtpdInterface,
                                  mtpd::kCopyFileFromLocal);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(handle);
     writer.AppendFileDescriptor(file_descriptor);
     writer.AppendUint32(parent_id);
     writer.AppendString(file_name);
     proxy_->CallMethod(
         &method_call, dbus::ObjectProxy::TIMEOUT_INFINITE,
         base::Bind(&MediaTransferProtocolDaemonClientImpl::OnCopyFileFromLocal,
                    weak_ptr_factory_.GetWeakPtr(), callback, error_callback));
   }
 
   void DeleteObject(const std::string& handle,
-                    const uint32 object_id,
+                    const uint32_t object_id,
                     const DeleteObjectCallback& callback,
                     const ErrorCallback& error_callback) override {
     dbus::MethodCall method_call(mtpd::kMtpdInterface, mtpd::kDeleteObject);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(handle);
     writer.AppendUint32(object_id);
     proxy_->CallMethod(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&MediaTransferProtocolDaemonClientImpl::OnDeleteObject,
                    weak_ptr_factory_.GetWeakPtr(), callback, error_callback));
@@ skipping 114 matching lines @@
   // Handles the result of ReadDirectoryEntryIds and calls |callback| or
   // |error_callback|.
   void OnReadDirectoryIds(const ReadDirectoryEntryIdsCallback& callback,
                           const ErrorCallback& error_callback,
                           dbus::Response* response) {
     if (!response) {
       error_callback.Run();
       return;
     }
 
-    std::vector<uint32> file_ids;
+    std::vector<uint32_t> file_ids;
     dbus::MessageReader reader(response);
     dbus::MessageReader array_reader(NULL);
     if (!reader.PopArray(&array_reader) || reader.HasMoreData()) {
       LOG(ERROR) << kInvalidResponseMsg << response->ToString();
       error_callback.Run();
       return;
     }
 
     while (array_reader.HasMoreData()) {
-      uint32 file_id;
+      uint32_t file_id;
       if (array_reader.PopUint32(&file_id)) {
         file_ids.push_back(file_id);
       } else {
         LOG(ERROR) << kInvalidResponseMsg << response->ToString();
         error_callback.Run();
         return;
       }
     }
     callback.Run(file_ids);
   }
@@ skipping 24 matching lines @@
   // Handles the result of ReadFileChunk and calls |callback| or
   // |error_callback|.
   void OnReadFile(const ReadFileCallback& callback,
                   const ErrorCallback& error_callback,
                   dbus::Response* response) {
     if (!response) {
       error_callback.Run();
       return;
     }
 
-    const uint8* data_bytes = NULL;
+    const uint8_t* data_bytes = NULL;
     size_t data_length = 0;
     dbus::MessageReader reader(response);
     if (!reader.PopArrayOfBytes(&data_bytes, &data_length)) {
       error_callback.Run();
       return;
     }
     std::string data(reinterpret_cast<const char*>(data_bytes), data_length);
     callback.Run(data);
   }
 
@@ skipping 73 matching lines @@
 
 MediaTransferProtocolDaemonClient::~MediaTransferProtocolDaemonClient() {}
 
 // static
 MediaTransferProtocolDaemonClient* MediaTransferProtocolDaemonClient::Create(
     dbus::Bus* bus) {
   return new MediaTransferProtocolDaemonClientImpl(bus);
 }
 
 }  // namespace device