Remove kuint32max.

chrome/browser/media_galleries/linux/mtp_device_delegate_impl_linux.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 "chrome/browser/media_galleries/linux/mtp_device_delegate_impl_linux.h"
 
 #include <errno.h>
 #include <fcntl.h>
+
 #include <algorithm>
+#include <limits>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "chrome/browser/media_galleries/linux/mtp_device_task_helper_map_service.h"
@@ skipping 75 matching lines @@
 // |storage_name| specifies the name of the storage device.
 // |read_only| specifies the mode of the storage device.
 // |parent_id| is an object id of the parent directory.
 // |directory_name| is name of the new directory.
 // |success_callback| is called when the directory is created successfully.
 // |error_callback| is called when it fails to create a directory.
 // |success_callback| and |error_callback| runs on the IO thread.
 void CreateDirectoryOnUIThread(
     const std::string& storage_name,
     const bool read_only,
-    const uint32 parent_id,
+    const uint32_t parent_id,
     const std::string& directory_name,
     const MTPDeviceTaskHelper::CreateDirectorySuccessCallback& success_callback,
     const MTPDeviceTaskHelper::ErrorCallback& error_callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   MTPDeviceTaskHelper* task_helper =
       GetDeviceTaskHelperForStorage(storage_name, read_only);
   if (!task_helper)
     return;
   task_helper->CreateDirectory(parent_id, directory_name, success_callback,
                                error_callback);
 }
 
 // Enumerates the |dir_id| directory file entries.
 //
 // Called on the UI thread to dispatch the request to the
 // MediaTransferProtocolManager.
 //
 // |storage_name| specifies the name of the storage device.
 // |read_only| specifies the mode of the storage device.
 // |directory_id| is an id of a directory to read.
 // |max_size| is a maximum size to read. Set 0 not to specify the maximum size.
 // |success_callback| is called when the ReadDirectory request succeeds.
 // |error_callback| is called when the ReadDirectory request fails.
 // |success_callback| and |error_callback| runs on the IO thread.
 void ReadDirectoryOnUIThread(
     const std::string& storage_name,
     const bool read_only,
-    const uint32 directory_id,
+    const uint32_t directory_id,
     const size_t max_size,
     const MTPDeviceTaskHelper::ReadDirectorySuccessCallback& success_callback,
     const MTPDeviceTaskHelper::ErrorCallback& error_callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   MTPDeviceTaskHelper* task_helper =
       GetDeviceTaskHelperForStorage(storage_name, read_only);
   if (!task_helper)
     return;
   task_helper->ReadDirectory(directory_id, max_size, success_callback,
                              error_callback);
 }
 
 // Gets the |file_path| details.
 //
 // Called on the UI thread to dispatch the request to the
 // MediaTransferProtocolManager.
 //
 // |storage_name| specifies the name of the storage device.
 // |read_only| specifies the mode of the storage device.
 // |success_callback| is called when the GetFileInfo request succeeds.
 // |error_callback| is called when the GetFileInfo request fails.
 // |success_callback| and |error_callback| runs on the IO thread.
 void GetFileInfoOnUIThread(
     const std::string& storage_name,
     const bool read_only,
-    uint32 file_id,
+    uint32_t file_id,
     const MTPDeviceTaskHelper::GetFileInfoSuccessCallback& success_callback,
     const MTPDeviceTaskHelper::ErrorCallback& error_callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   MTPDeviceTaskHelper* task_helper =
       GetDeviceTaskHelperForStorage(storage_name, read_only);
   if (!task_helper)
     return;
   task_helper->GetFileInfo(file_id, success_callback, error_callback);
 }
 
@@ skipping 49 matching lines @@
 // |storage_name| specifies the name of the storage device.
 // |read_only| specifies the mode of the storage device.
 // |object_id| is an id of object to be renamed.
 // |new_name| is new name of the object.
 // |success_callback| is called when the object is renamed successfully.
 // |error_callback| is called when it fails to rename the object.
 // |success_callback| and |error_callback| runs on the IO thread.
 void RenameObjectOnUIThread(
     const std::string& storage_name,
     const bool read_only,
-    const uint32 object_id,
+    const uint32_t object_id,
     const std::string& new_name,
     const MTPDeviceTaskHelper::RenameObjectSuccessCallback& success_callback,
     const MTPDeviceTaskHelper::ErrorCallback& error_callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   MTPDeviceTaskHelper* task_helper =
       GetDeviceTaskHelperForStorage(storage_name, read_only);
   if (!task_helper)
     return;
   task_helper->RenameObject(object_id, new_name, success_callback,
                             error_callback);
 }
 
 // Copies the file |source_file_descriptor| to |file_name| in |parent_id|.
 //
 // |storage_name| specifies the name of the storage device.
 // |read_only| specifies the mode of the storage device.
 // |source_file_descriptor| file descriptor of source file.
 // |parent_id| object id of a target directory.
 // |file_name| file name of a target file.
 // |success_callback| is called when the file is copied successfully.
 // |error_callback| is called when it fails to copy file.
 // Since this method does not close the file descriptor, callbacks are
 // responsible for closing it.
 void CopyFileFromLocalOnUIThread(
     const std::string& storage_name,
     const bool read_only,
     const int source_file_descriptor,
-    const uint32 parent_id,
+    const uint32_t parent_id,
     const std::string& file_name,
     const MTPDeviceTaskHelper::CopyFileFromLocalSuccessCallback&
         success_callback,
     const MTPDeviceTaskHelper::ErrorCallback& error_callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   MTPDeviceTaskHelper* task_helper =
       GetDeviceTaskHelperForStorage(storage_name, read_only);
   if (!task_helper)
     return;
   task_helper->CopyFileFromLocal(storage_name, source_file_descriptor,
                                  parent_id, file_name, success_callback,
                                  error_callback);
 }
 
 // Deletes |object_id|.
 //
 // Called on the UI thread to dispatch the request to the
 // MediaTransferProtocolManager.
 //
 // |storage_name| specifies the name of the storage device.
 // |read_only| specifies the mode of the storage device.
 // |object_id| is the object to be deleted.
 // |success_callback| is called when the object is deleted successfully.
 // |error_callback| is called when it fails to delete the object.
 // |success_callback| and |error_callback| runs on the IO thread.
 void DeleteObjectOnUIThread(
     const std::string storage_name,
     const bool read_only,
-    const uint32 object_id,
+    const uint32_t object_id,
     const MTPDeviceTaskHelper::DeleteObjectSuccessCallback success_callback,
     const MTPDeviceTaskHelper::ErrorCallback error_callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   MTPDeviceTaskHelper* task_helper =
       GetDeviceTaskHelperForStorage(storage_name, read_only);
   if (!task_helper)
     return;
   task_helper->DeleteObject(object_id, success_callback, error_callback);
 }
 
@@ skipping 44 matching lines @@
 }
 
 // Deletes a temporary file |file_path|.
 void DeleteTemporaryFile(const base::FilePath& file_path) {
   content::BrowserThread::PostBlockingPoolTask(
       FROM_HERE, base::Bind(base::IgnoreResult(base::DeleteFile), file_path,
                             false /* not recursive*/));
 }
 
 // A fake callback to be passed as CopyFileProgressCallback.
-void FakeCopyFileProgressCallback(int64 size) {
-}
+void FakeCopyFileProgressCallback(int64_t size) {}
 
 }  // namespace
 
 MTPDeviceDelegateImplLinux::PendingTaskInfo::PendingTaskInfo(
     const base::FilePath& path,
     content::BrowserThread::ID thread_id,
     const tracked_objects::Location& location,
     const base::Closure& task)
     : path(path),
       thread_id(thread_id),
       location(location),
       task(task) {
 }
 
 MTPDeviceDelegateImplLinux::PendingTaskInfo::~PendingTaskInfo() {
 }
 
 // Represents a file on the MTP device.
 // Lives on the IO thread.
 class MTPDeviceDelegateImplLinux::MTPFileNode {
  public:
-  MTPFileNode(uint32 file_id,
+  MTPFileNode(uint32_t file_id,
               const std::string& file_name,
               MTPFileNode* parent,
               FileIdToMTPFileNodeMap* file_id_to_node_map);
   ~MTPFileNode();
 
   const MTPFileNode* GetChild(const std::string& name) const;
 
-  void EnsureChildExists(const std::string& name, uint32 id);
+  void EnsureChildExists(const std::string& name, uint32_t id);
 
   // Clears all the children, except those in |children_to_keep|.
   void ClearNonexistentChildren(
       const std::set<std::string>& children_to_keep);
 
-  bool DeleteChild(uint32 file_id);
+  bool DeleteChild(uint32_t file_id);
 
   bool HasChildren() const;
 
-  uint32 file_id() const { return file_id_; }
+  uint32_t file_id() const { return file_id_; }
   const std::string& file_name() const { return file_name_; }
   MTPFileNode* parent() { return parent_; }
 
  private:
   // Container for holding a node's children.
   typedef base::ScopedPtrHashMap<std::string, scoped_ptr<MTPFileNode>>
       ChildNodes;
 
-  const uint32 file_id_;
+  const uint32_t file_id_;
   const std::string file_name_;
 
   ChildNodes children_;
   MTPFileNode* const parent_;
   FileIdToMTPFileNodeMap* file_id_to_node_map_;
 
   DISALLOW_COPY_AND_ASSIGN(MTPFileNode);
 };
 
 MTPDeviceDelegateImplLinux::MTPFileNode::MTPFileNode(
-    uint32 file_id,
+    uint32_t file_id,
     const std::string& file_name,
     MTPFileNode* parent,
     FileIdToMTPFileNodeMap* file_id_to_node_map)
     : file_id_(file_id),
       file_name_(file_name),
       parent_(parent),
       file_id_to_node_map_(file_id_to_node_map) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   DCHECK(file_id_to_node_map_);
   DCHECK(!ContainsKey(*file_id_to_node_map_, file_id_));
   (*file_id_to_node_map_)[file_id_] = this;
 }
 
 MTPDeviceDelegateImplLinux::MTPFileNode::~MTPFileNode() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   size_t erased = file_id_to_node_map_->erase(file_id_);
   DCHECK_EQ(1U, erased);
 }
 
 const MTPDeviceDelegateImplLinux::MTPFileNode*
 MTPDeviceDelegateImplLinux::MTPFileNode::GetChild(
     const std::string& name) const {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   return children_.get(name);
 }
 
 void MTPDeviceDelegateImplLinux::MTPFileNode::EnsureChildExists(
     const std::string& name,
-    uint32 id) {
+    uint32_t id) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   const MTPFileNode* child = GetChild(name);
   if (child && child->file_id() == id)
     return;
 
   children_.set(
       name,
       make_scoped_ptr(new MTPFileNode(id, name, this, file_id_to_node_map_)));
 }
 
 void MTPDeviceDelegateImplLinux::MTPFileNode::ClearNonexistentChildren(
     const std::set<std::string>& children_to_keep) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   std::set<std::string> children_to_erase;
   for (ChildNodes::const_iterator it = children_.begin();
        it != children_.end(); ++it) {
     if (ContainsKey(children_to_keep, it->first))
       continue;
     children_to_erase.insert(it->first);
   }
   for (std::set<std::string>::iterator it = children_to_erase.begin();
        it != children_to_erase.end(); ++it) {
     children_.take_and_erase(*it);
   }
 }
 
-bool MTPDeviceDelegateImplLinux::MTPFileNode::DeleteChild(uint32 file_id) {
+bool MTPDeviceDelegateImplLinux::MTPFileNode::DeleteChild(uint32_t file_id) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   for (ChildNodes::iterator it = children_.begin();
        it != children_.end(); ++it) {
     if (it->second->file_id() == file_id) {
       DCHECK(!it->second->HasChildren());
       children_.erase(it);
       return true;
     }
   }
   return false;
@@ skipping 129 matching lines @@
                                        closure));
 }
 
 bool MTPDeviceDelegateImplLinux::IsStreaming() {
   return true;
 }
 
 void MTPDeviceDelegateImplLinux::ReadBytes(
     const base::FilePath& device_file_path,
     const scoped_refptr<net::IOBuffer>& buf,
-    int64 offset,
+    int64_t offset,
     int buf_len,
     const ReadBytesSuccessCallback& success_callback,
     const ErrorCallback& error_callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   DCHECK(!device_file_path.empty());
   base::Closure closure =
       base::Bind(&MTPDeviceDelegateImplLinux::ReadBytesInternal,
                  weak_ptr_factory_.GetWeakPtr(),
                  device_file_path,
                  buf,
@@ skipping 199 matching lines @@
                  read_only_));
   delete this;
 }
 
 void MTPDeviceDelegateImplLinux::GetFileInfoInternal(
     const base::FilePath& file_path,
     const GetFileInfoSuccessCallback& success_callback,
     const ErrorCallback& error_callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
-  uint32 file_id;
+  uint32_t file_id;
   if (CachedPathToId(file_path, &file_id)) {
     GetFileInfoSuccessCallback success_callback_wrapper =
         base::Bind(&MTPDeviceDelegateImplLinux::OnDidGetFileInfo,
                    weak_ptr_factory_.GetWeakPtr(),
                    success_callback);
     ErrorCallback error_callback_wrapper =
         base::Bind(&MTPDeviceDelegateImplLinux::HandleDeviceFileError,
                    weak_ptr_factory_.GetWeakPtr(),
                    error_callback,
                    file_id);
@@ skipping 22 matching lines @@
     const ErrorCallback& error_callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   const base::FilePath current_component = components.back();
   std::vector<base::FilePath> other_components = components;
   other_components.pop_back();
 
   if (other_components.empty()) {
     // Either we reached the last component in the recursive case, or this is
     // the non-recursive case.
-    uint32 parent_id;
+    uint32_t parent_id;
     if (CachedPathToId(current_component.DirName(), &parent_id)) {
       const base::Closure closure =
           base::Bind(&MTPDeviceDelegateImplLinux::CreateSingleDirectory,
                      weak_ptr_factory_.GetWeakPtr(), current_component,
                      exclusive, success_callback, error_callback);
       EnsureInitAndRunTask(PendingTaskInfo(
           base::FilePath(), content::BrowserThread::IO, FROM_HERE, closure));
     } else {
       error_callback.Run(base::File::FILE_ERROR_NOT_FOUND);
     }
   } else {
     // Ensures that parent directories are created for recursive case.
-    uint32 directory_id;
+    uint32_t directory_id;
     if (CachedPathToId(current_component, &directory_id)) {
       // Parent directory |current_component| already exists, continue creating
       // directories.
       const base::Closure closure =
           base::Bind(&MTPDeviceDelegateImplLinux::CreateDirectoryInternal,
                      weak_ptr_factory_.GetWeakPtr(), other_components,
                      exclusive, success_callback, error_callback);
       EnsureInitAndRunTask(PendingTaskInfo(
           base::FilePath(), content::BrowserThread::IO, FROM_HERE, closure));
     } else {
@@ skipping 22 matching lines @@
 
   PendingRequestDone();
 }
 
 void MTPDeviceDelegateImplLinux::ReadDirectoryInternal(
     const base::FilePath& root,
     const ReadDirectorySuccessCallback& success_callback,
     const ErrorCallback& error_callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
-  uint32 dir_id;
+  uint32_t dir_id;
   if (CachedPathToId(root, &dir_id)) {
     GetFileInfoSuccessCallback success_callback_wrapper =
         base::Bind(&MTPDeviceDelegateImplLinux::OnDidGetFileInfoToReadDirectory,
                    weak_ptr_factory_.GetWeakPtr(),
                    dir_id,
                    success_callback,
                    error_callback);
     ErrorCallback error_callback_wrapper =
         base::Bind(&MTPDeviceDelegateImplLinux::HandleDeviceFileError,
                    weak_ptr_factory_.GetWeakPtr(),
@@ skipping 15 matching lines @@
   PendingRequestDone();
 }
 
 void MTPDeviceDelegateImplLinux::CreateSnapshotFileInternal(
     const base::FilePath& device_file_path,
     const base::FilePath& local_path,
     const CreateSnapshotFileSuccessCallback& success_callback,
     const ErrorCallback& error_callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
-  uint32 file_id;
+  uint32_t file_id;
   if (CachedPathToId(device_file_path, &file_id)) {
     scoped_ptr<SnapshotRequestInfo> request_info(
         new SnapshotRequestInfo(file_id,
                                 local_path,
                                 success_callback,
                                 error_callback));
     GetFileInfoSuccessCallback success_callback_wrapper =
         base::Bind(
             &MTPDeviceDelegateImplLinux::OnDidGetFileInfoToCreateSnapshotFile,
             weak_ptr_factory_.GetWeakPtr(),
@@ skipping 14 matching lines @@
                                          FROM_HERE,
                                          closure));
   } else {
     error_callback.Run(base::File::FILE_ERROR_NOT_FOUND);
   }
   PendingRequestDone();
 }
 
 void MTPDeviceDelegateImplLinux::ReadBytesInternal(
     const base::FilePath& device_file_path,
-    net::IOBuffer* buf, int64 offset, int buf_len,
+    net::IOBuffer* buf,
+    int64_t offset,
+    int buf_len,
     const ReadBytesSuccessCallback& success_callback,
     const ErrorCallback& error_callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
-  uint32 file_id;
+  uint32_t file_id;
   if (CachedPathToId(device_file_path, &file_id)) {
     ReadBytesRequest request(
         file_id, buf, offset, buf_len,
         base::Bind(&MTPDeviceDelegateImplLinux::OnDidReadBytes,
                    weak_ptr_factory_.GetWeakPtr(),
                    success_callback),
         base::Bind(&MTPDeviceDelegateImplLinux::HandleDeviceFileError,
                    weak_ptr_factory_.GetWeakPtr(),
                    error_callback,
                    file_id));
@@ skipping 19 matching lines @@
     const base::File::Info& source_file_info) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   if (source_file_info.is_directory) {
     error_callback.Run(base::File::FILE_ERROR_NOT_A_FILE);
     return;
   }
 
   if (source_file_path.DirName() == device_file_path.DirName()) {
     // If a file is moved in a same directory, rename the file.
-    uint32 file_id;
+    uint32_t file_id;
     if (CachedPathToId(source_file_path, &file_id)) {
       const MTPDeviceTaskHelper::RenameObjectSuccessCallback
           success_callback_wrapper = base::Bind(
               &MTPDeviceDelegateImplLinux::OnDidMoveFileLocalWithRename,
               weak_ptr_factory_.GetWeakPtr(), success_callback,
               source_file_path, file_id);
       const MTPDeviceTaskHelper::ErrorCallback error_callback_wrapper =
           base::Bind(&MTPDeviceDelegateImplLinux::HandleDeviceFileError,
                      weak_ptr_factory_.GetWeakPtr(), error_callback, file_id);
       const base::Closure closure =
@@ skipping 26 matching lines @@
     const ErrorCallback& error_callback,
     const std::pair<int, base::File::Error>& open_fd_result) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   if (open_fd_result.second != base::File::FILE_OK) {
     error_callback.Run(open_fd_result.second);
     return;
   }
 
   const int source_file_descriptor = open_fd_result.first;
-  uint32 parent_id;
+  uint32_t parent_id;
   if (CachedPathToId(device_file_path.DirName(), &parent_id)) {
     CopyFileFromLocalSuccessCallback success_callback_wrapper =
         base::Bind(&MTPDeviceDelegateImplLinux::OnDidCopyFileFromLocal,
                    weak_ptr_factory_.GetWeakPtr(), success_callback,
                    device_file_path, source_file_descriptor);
 
     ErrorCallback error_callback_wrapper = base::Bind(
         &MTPDeviceDelegateImplLinux::HandleCopyFileFromLocalError,
         weak_ptr_factory_.GetWeakPtr(), error_callback, source_file_descriptor);
 
@@ skipping 17 matching lines @@
 void MTPDeviceDelegateImplLinux::DeleteFileInternal(
     const base::FilePath& file_path,
     const DeleteFileSuccessCallback& success_callback,
     const ErrorCallback& error_callback,
     const base::File::Info& file_info) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   if (file_info.is_directory) {
     error_callback.Run(base::File::FILE_ERROR_NOT_A_FILE);
   } else {
-    uint32 file_id;
+    uint32_t file_id;
     if (CachedPathToId(file_path, &file_id))
       RunDeleteObjectOnUIThread(file_path, file_id, success_callback,
                                 error_callback);
     else
       error_callback.Run(base::File::FILE_ERROR_NOT_FOUND);
   }
 }
 
 void MTPDeviceDelegateImplLinux::DeleteDirectoryInternal(
     const base::FilePath& file_path,
     const DeleteDirectorySuccessCallback& success_callback,
     const ErrorCallback& error_callback,
     const base::File::Info& file_info) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   if (!file_info.is_directory) {
     error_callback.Run(base::File::FILE_ERROR_NOT_A_DIRECTORY);
     return;
   }
 
-  uint32 directory_id;
+  uint32_t directory_id;
   if (!CachedPathToId(file_path, &directory_id)) {
     error_callback.Run(base::File::FILE_ERROR_NOT_FOUND);
     return;
   }
 
   // Checks the cache first. If it has children in cache, the directory cannot
   // be empty.
   FileIdToMTPFileNodeMap::const_iterator it =
       file_id_to_node_map_.find(directory_id);
   if (it != file_id_to_node_map_.end() && it->second->HasChildren()) {
@@ skipping 57 matching lines @@
   const base::Closure closure =
       base::Bind(&MTPDeviceDelegateImplLinux::CreateDirectoryInternal,
                  weak_ptr_factory_.GetWeakPtr(), components, exclusive,
                  success_callback, error_callback);
   EnsureInitAndRunTask(PendingTaskInfo(
       base::FilePath(), content::BrowserThread::IO, FROM_HERE, closure));
 }
 
 void MTPDeviceDelegateImplLinux::OnDidReadDirectoryToDeleteDirectory(
     const base::FilePath& directory_path,
-    const uint32 directory_id,
+    const uint32_t directory_id,
     const DeleteDirectorySuccessCallback& success_callback,
     const ErrorCallback& error_callback,
     const MTPDeviceTaskHelper::MTPEntries& entries,
     const bool has_more) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   DCHECK(!has_more);
 
   if (entries.size() > 0) {
     error_callback.Run(base::File::FILE_ERROR_NOT_EMPTY);
   } else {
     RunDeleteObjectOnUIThread(directory_path, directory_id, success_callback,
                               error_callback);
   }
 
   PendingRequestDone();
 }
 
 void MTPDeviceDelegateImplLinux::RunDeleteObjectOnUIThread(
     const base::FilePath& object_path,
-    const uint32 object_id,
+    const uint32_t object_id,
     const DeleteObjectSuccessCallback& success_callback,
     const ErrorCallback& error_callback) {
   const MTPDeviceTaskHelper::DeleteObjectSuccessCallback
       success_callback_wrapper =
           base::Bind(&MTPDeviceDelegateImplLinux::OnDidDeleteObject,
                      weak_ptr_factory_.GetWeakPtr(), object_path, object_id,
                      success_callback);
 
   const MTPDeviceTaskHelper::ErrorCallback error_callback_wrapper =
       base::Bind(&MTPDeviceDelegateImplLinux::HandleDeleteFileOrDirectoryError,
@@ skipping 131 matching lines @@
     const CreateDirectorySuccessCallback& success_callback,
     const ErrorCallback& error_callback,
     const base::File::Error error) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   if (error != base::File::FILE_ERROR_NOT_FOUND) {
     error_callback.Run(base::File::FILE_ERROR_NOT_FOUND);
     return;
   }
 
-  uint32 parent_id;
+  uint32_t parent_id;
   if (!CachedPathToId(directory_path.DirName(), &parent_id)) {
     error_callback.Run(base::File::FILE_ERROR_NOT_FOUND);
     return;
   }
 
   const MTPDeviceTaskHelper::CreateDirectorySuccessCallback
       success_callback_wrapper = base::Bind(
           &MTPDeviceDelegateImplLinux::OnDidCreateSingleDirectory,
           weak_ptr_factory_.GetWeakPtr(), directory_path, success_callback);
   const MTPDeviceTaskHelper::ErrorCallback error_callback_wrapper =
       base::Bind(&MTPDeviceDelegateImplLinux::HandleDeviceFileError,
                  weak_ptr_factory_.GetWeakPtr(), error_callback, parent_id);
   const base::Closure closure =
       base::Bind(&CreateDirectoryOnUIThread, storage_name_, read_only_,
                  parent_id, directory_path.BaseName().value(),
                  success_callback_wrapper, error_callback_wrapper);
   EnsureInitAndRunTask(PendingTaskInfo(
       base::FilePath(), content::BrowserThread::UI, FROM_HERE, closure));
 }
 
 void MTPDeviceDelegateImplLinux::OnDidGetFileInfoToReadDirectory(
-    uint32 dir_id,
+    uint32_t dir_id,
     const ReadDirectorySuccessCallback& success_callback,
     const ErrorCallback& error_callback,
     const base::File::Info& file_info) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   DCHECK(task_in_progress_);
   if (!file_info.is_directory) {
     return HandleDeviceFileError(error_callback,
                                  dir_id,
                                  base::File::FILE_ERROR_NOT_A_DIRECTORY);
   }
@@ skipping 13 matching lines @@
 void MTPDeviceDelegateImplLinux::OnDidGetFileInfoToCreateSnapshotFile(
     scoped_ptr<SnapshotRequestInfo> snapshot_request_info,
     const base::File::Info& file_info) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   DCHECK(!current_snapshot_request_info_.get());
   DCHECK(snapshot_request_info.get());
   DCHECK(task_in_progress_);
   base::File::Error error = base::File::FILE_OK;
   if (file_info.is_directory)
     error = base::File::FILE_ERROR_NOT_A_FILE;
-  else if (file_info.size < 0 || file_info.size > kuint32max)
+  else if (file_info.size < 0 ||
+           file_info.size > std::numeric_limits<uint32_t>::max())
     error = base::File::FILE_ERROR_FAILED;
 
   if (error != base::File::FILE_OK)
     return HandleDeviceFileError(snapshot_request_info->error_callback,
                                  snapshot_request_info->file_id,
                                  error);
 
   base::File::Info snapshot_file_info(file_info);
   // Modify the last modified time to null. This prevents the time stamp
   // verfication in LocalFileStreamReader.
@@ skipping 77 matching lines @@
 
 void MTPDeviceDelegateImplLinux::OnCreateParentDirectoryErrorToCreateDirectory(
     const ErrorCallback& callback,
     const base::File::Error error) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   callback.Run(base::File::FILE_ERROR_FAILED);
 }
 
 void MTPDeviceDelegateImplLinux::OnDidReadDirectory(
-    uint32 dir_id,
+    uint32_t dir_id,
     const ReadDirectorySuccessCallback& success_callback,
     const MTPDeviceTaskHelper::MTPEntries& mtp_entries,
     bool has_more) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   FileIdToMTPFileNodeMap::iterator it = file_id_to_node_map_.find(dir_id);
   DCHECK(it != file_id_to_node_map_.end());
   MTPFileNode* dir_node = it->second;
 
   // Traverse the MTPFileNode tree to reconstuct the full path for |dir_id|.
@@ skipping 136 matching lines @@
     const base::FilePath& temporary_file_path) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   DeleteTemporaryFile(temporary_file_path);
   success_callback.Run();
 }
 
 void MTPDeviceDelegateImplLinux::OnDidMoveFileLocalWithRename(
     const MoveFileLocalSuccessCallback& success_callback,
     const base::FilePath& source_file_path,
-    const uint32 file_id) {
+    const uint32_t file_id) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   EvictCachedPathToId(file_id);
   success_callback.Run();
   NotifyFileChange(source_file_path,
                    storage::WatcherManager::ChangeType::DELETED);
   NotifyFileChange(source_file_path.DirName(),
                    storage::WatcherManager::ChangeType::CHANGED);
   PendingRequestDone();
 }
@@ skipping 37 matching lines @@
 
   content::BrowserThread::PostTask(content::BrowserThread::FILE, FROM_HERE,
                                    closure);
 
   error_callback.Run(error);
   PendingRequestDone();
 }
 
 void MTPDeviceDelegateImplLinux::OnDidDeleteObject(
     const base::FilePath& object_path,
-    const uint32 object_id,
+    const uint32_t object_id,
     const DeleteObjectSuccessCallback success_callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   EvictCachedPathToId(object_id);
   success_callback.Run();
   NotifyFileChange(object_path, storage::WatcherManager::ChangeType::DELETED);
   NotifyFileChange(object_path.DirName(),
                    storage::WatcherManager::ChangeType::CHANGED);
   PendingRequestDone();
 }
 
 void MTPDeviceDelegateImplLinux::HandleDeleteFileOrDirectoryError(
     const ErrorCallback& error_callback,
     base::File::Error error) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   error_callback.Run(error);
   PendingRequestDone();
 }
 
 void MTPDeviceDelegateImplLinux::HandleDeviceFileError(
     const ErrorCallback& error_callback,
-    uint32 file_id,
+    uint32_t file_id,
     base::File::Error error) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   EvictCachedPathToId(file_id);
   error_callback.Run(error);
   PendingRequestDone();
 }
 
 base::FilePath MTPDeviceDelegateImplLinux::NextUncachedPathComponent(
     const base::FilePath& path,
@@ skipping 36 matching lines @@
   ReadDirectorySuccessCallback success_callback =
       base::Bind(&MTPDeviceDelegateImplLinux::OnDidFillFileCache,
                  weak_ptr_factory_.GetWeakPtr(),
                  uncached_path);
   ErrorCallback error_callback =
       base::Bind(&MTPDeviceDelegateImplLinux::OnFillFileCacheFailed,
                  weak_ptr_factory_.GetWeakPtr());
   ReadDirectoryInternal(uncached_path, success_callback, error_callback);
 }
 
-
 bool MTPDeviceDelegateImplLinux::CachedPathToId(const base::FilePath& path,
-                                                uint32* id) const {
+                                                uint32_t* id) const {
   DCHECK(id);
 
   std::string device_relpath = GetDeviceRelativePath(device_path_, path);
   if (device_relpath.empty())
     return false;
   std::vector<std::string> device_relpath_components;
   if (device_relpath != kRootPath) {
     device_relpath_components = base::SplitString(
         device_relpath, "/", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   }
   const MTPFileNode* current_node = root_node_.get();
   for (size_t i = 0; i < device_relpath_components.size(); ++i) {
     current_node = current_node->GetChild(device_relpath_components[i]);
     if (!current_node)
       return false;
   }
   *id = current_node->file_id();
   return true;
 }
 
-void MTPDeviceDelegateImplLinux::EvictCachedPathToId(const uint32 id) {
+void MTPDeviceDelegateImplLinux::EvictCachedPathToId(const uint32_t id) {
   FileIdToMTPFileNodeMap::iterator it = file_id_to_node_map_.find(id);
   if (it != file_id_to_node_map_.end()) {
     DCHECK(!it->second->HasChildren());
     MTPFileNode* parent = it->second->parent();
     if (parent) {
       const bool ret = parent->DeleteChild(id);
       DCHECK(ret);
     }
   }
 }
 
 void CreateMTPDeviceAsyncDelegate(
     const std::string& device_location,
     const bool read_only,
     const CreateMTPDeviceAsyncDelegateCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   callback.Run(new MTPDeviceDelegateImplLinux(device_location, read_only));
 }