Switch to standard integer types in device/.

device/media_transfer_protocol/media_transfer_protocol_manager.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_manager.h"
 
 #include <algorithm>
 #include <map>
 #include <queue>
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
+#include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/sequenced_task_runner.h"
 #include "base/stl_util.h"
 #include "base/threading/thread_checker.h"
+#include "build/build_config.h"
 #include "dbus/bus.h"
 #include "device/media_transfer_protocol/media_transfer_protocol_daemon_client.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"
 
 #if defined(OS_CHROMEOS)
 #include "chromeos/dbus/dbus_thread_manager.h"
 #endif
 
@@ skipping 143 matching lines @@
     close_storage_callbacks_.push(std::make_pair(callback, storage_handle));
     mtp_client_->CloseStorage(
         storage_handle,
         base::Bind(&MediaTransferProtocolManagerImpl::OnCloseStorage,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&MediaTransferProtocolManagerImpl::OnCloseStorageError,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   void CreateDirectory(const std::string& storage_handle,
-                       const uint32 parent_id,
+                       const uint32_t parent_id,
                        const std::string& directory_name,
                        const CreateDirectoryCallback& callback) override {
     DCHECK(thread_checker_.CalledOnValidThread());
     if (!ContainsKey(handles_, storage_handle) || !mtp_client_) {
       callback.Run(true /* error */);
       return;
     }
     create_directory_callbacks_.push(callback);
     mtp_client_->CreateDirectory(
         storage_handle, parent_id, directory_name,
         base::Bind(&MediaTransferProtocolManagerImpl::OnCreateDirectory,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&MediaTransferProtocolManagerImpl::OnCreateDirectoryError,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   // MediaTransferProtocolManager override.
   void ReadDirectory(const std::string& storage_handle,
-                     const uint32 file_id,
+                     const uint32_t file_id,
                      const size_t max_size,
                      const ReadDirectoryCallback& callback) override {
     DCHECK(thread_checker_.CalledOnValidThread());
     if (!ContainsKey(handles_, storage_handle) || !mtp_client_) {
       callback.Run(std::vector<MtpFileEntry>(),
                    false /* no more entries */,
                    true /* error */);
       return;
     }
     read_directory_callbacks_.push(callback);
     mtp_client_->ReadDirectoryEntryIds(
         storage_handle, file_id,
         base::Bind(&MediaTransferProtocolManagerImpl::
                        OnReadDirectoryEntryIdsToReadDirectory,
                    weak_ptr_factory_.GetWeakPtr(), storage_handle, max_size),
         base::Bind(&MediaTransferProtocolManagerImpl::OnReadDirectoryError,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   // MediaTransferProtocolManager override.
   void ReadFileChunk(const std::string& storage_handle,
-                     uint32 file_id,
-                     uint32 offset,
-                     uint32 count,
+                     uint32_t file_id,
+                     uint32_t offset,
+                     uint32_t count,
                      const ReadFileCallback& callback) override {
     DCHECK(thread_checker_.CalledOnValidThread());
     if (!ContainsKey(handles_, storage_handle) || !mtp_client_) {
       callback.Run(std::string(), true);
       return;
     }
     read_file_callbacks_.push(callback);
     mtp_client_->ReadFileChunk(
         storage_handle, file_id, offset, count,
         base::Bind(&MediaTransferProtocolManagerImpl::OnReadFile,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&MediaTransferProtocolManagerImpl::OnReadFileError,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   void GetFileInfo(const std::string& storage_handle,
-                   uint32 file_id,
+                   uint32_t file_id,
                    const GetFileInfoCallback& callback) override {
     DCHECK(thread_checker_.CalledOnValidThread());
     if (!ContainsKey(handles_, storage_handle) || !mtp_client_) {
       callback.Run(MtpFileEntry(), true);
       return;
     }
-    std::vector<uint32> file_ids;
+    std::vector<uint32_t> file_ids;
     file_ids.push_back(file_id);
     get_file_info_callbacks_.push(callback);
     mtp_client_->GetFileInfo(
         storage_handle,
         file_ids,
         kInitialOffset,
         file_ids.size(),
         base::Bind(&MediaTransferProtocolManagerImpl::OnGetFileInfo,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&MediaTransferProtocolManagerImpl::OnGetFileInfoError,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   void RenameObject(const std::string& storage_handle,
-                    const uint32 object_id,
+                    const uint32_t object_id,
                     const std::string& new_name,
                     const RenameObjectCallback& callback) override {
     DCHECK(thread_checker_.CalledOnValidThread());
     if (!ContainsKey(handles_, storage_handle) || !mtp_client_) {
       callback.Run(true /* error */);
       return;
     }
     rename_object_callbacks_.push(callback);
     mtp_client_->RenameObject(
         storage_handle, object_id, new_name,
         base::Bind(&MediaTransferProtocolManagerImpl::OnRenameObject,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&MediaTransferProtocolManagerImpl::OnRenameObjectError,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   void CopyFileFromLocal(const std::string& storage_handle,
                          const int source_file_descriptor,
-                         const uint32 parent_id,
+                         const uint32_t parent_id,
                          const std::string& file_name,
                          const CopyFileFromLocalCallback& callback) override {
     DCHECK(thread_checker_.CalledOnValidThread());
     if (!ContainsKey(handles_, storage_handle) || !mtp_client_) {
       callback.Run(true /* error */);
       return;
     }
     copy_file_from_local_callbacks_.push(callback);
     mtp_client_->CopyFileFromLocal(
         storage_handle, source_file_descriptor, parent_id, file_name,
         base::Bind(&MediaTransferProtocolManagerImpl::OnCopyFileFromLocal,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&MediaTransferProtocolManagerImpl::OnCopyFileFromLocalError,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   void DeleteObject(const std::string& storage_handle,
-                    const uint32 object_id,
+                    const uint32_t object_id,
                     const DeleteObjectCallback& callback) override {
     DCHECK(thread_checker_.CalledOnValidThread());
     if (!ContainsKey(handles_, storage_handle) || !mtp_client_) {
       callback.Run(true /* error */);
       return;
     }
     delete_object_callbacks_.push(callback);
     mtp_client_->DeleteObject(
         storage_handle, object_id,
         base::Bind(&MediaTransferProtocolManagerImpl::OnDeleteObject,
@@ skipping 142 matching lines @@
 
   void OnCreateDirectoryError() {
     DCHECK(thread_checker_.CalledOnValidThread());
     create_directory_callbacks_.front().Run(true /* error */);
     create_directory_callbacks_.pop();
   }
 
   void OnReadDirectoryEntryIdsToReadDirectory(
       const std::string& storage_handle,
       const size_t max_size,
-      const std::vector<uint32>& file_ids) {
+      const std::vector<uint32_t>& file_ids) {
     DCHECK(thread_checker_.CalledOnValidThread());
 
     if (file_ids.empty()) {
       OnGotDirectoryEntries(storage_handle, file_ids, kInitialOffset, max_size,
                             file_ids, std::vector<MtpFileEntry>());
       return;
     }
 
-    std::vector<uint32> sorted_file_ids = file_ids;
+    std::vector<uint32_t> sorted_file_ids = file_ids;
     std::sort(sorted_file_ids.begin(), sorted_file_ids.end());
 
     const size_t chunk_size =
         max_size == 0 ? kFileInfoToFetchChunkSize
                       : std::min(max_size, kFileInfoToFetchChunkSize);
 
     mtp_client_->GetFileInfo(
         storage_handle, file_ids, kInitialOffset, chunk_size,
         base::Bind(&MediaTransferProtocolManagerImpl::OnGotDirectoryEntries,
                    weak_ptr_factory_.GetWeakPtr(), storage_handle, file_ids,
                    kInitialOffset, max_size, sorted_file_ids),
         base::Bind(&MediaTransferProtocolManagerImpl::OnReadDirectoryError,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   void OnGotDirectoryEntries(const std::string& storage_handle,
-                             const std::vector<uint32>& file_ids,
+                             const std::vector<uint32_t>& file_ids,
                              const size_t offset,
                              const size_t max_size,
-                             const std::vector<uint32>& sorted_file_ids,
+                             const std::vector<uint32_t>& sorted_file_ids,
                              const std::vector<MtpFileEntry>& file_entries) {
     DCHECK(thread_checker_.CalledOnValidThread());
     DCHECK_EQ(file_ids.size(), sorted_file_ids.size());
 
     // Use |sorted_file_ids| to sanity check and make sure the results are a
     // subset of the requested file ids.
     for (size_t i = 0; i < file_entries.size(); ++i) {
-      std::vector<uint32>::const_iterator it =
-          std::lower_bound(sorted_file_ids.begin(),
-                           sorted_file_ids.end(),
+      std::vector<uint32_t>::const_iterator it =
+          std::lower_bound(sorted_file_ids.begin(), sorted_file_ids.end(),
                            file_entries[i].item_id());
       if (it == sorted_file_ids.end()) {
         OnReadDirectoryError();
         return;
       }
     }
 
     const size_t directory_size =
         max_size == 0 ? file_ids.size() : std::min(file_ids.size(), max_size);
     size_t next_offset = directory_size;
@@ skipping 194 matching lines @@
   DCHECK(!g_media_transfer_protocol_manager);
 
   g_media_transfer_protocol_manager =
       new MediaTransferProtocolManagerImpl(task_runner);
   VLOG(1) << "MediaTransferProtocolManager initialized";
 
   return g_media_transfer_protocol_manager;
 }
 
 }  // namespace device