Remove kuint32max.

chrome/browser/media_galleries/linux/mtp_device_task_helper.cc

 // Copyright 2013 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_task_helper.h"
 
 #include <algorithm>
+#include <limits>
 
 #include "base/logging.h"
 #include "chrome/browser/media_galleries/linux/mtp_device_object_enumerator.h"
 #include "chrome/browser/media_galleries/linux/mtp_read_file_worker.h"
 #include "chrome/browser/media_galleries/linux/snapshot_file_details.h"
 #include "components/storage_monitor/storage_monitor.h"
 #include "content/public/browser/browser_thread.h"
 #include "device/media_transfer_protocol/media_transfer_protocol_manager.h"
 #include "net/base/io_buffer.h"
 #include "storage/browser/fileapi/async_file_util.h"
@@ skipping 51 matching lines @@
   }
 
   const std::string mode =
       read_only ? mtpd::kReadOnlyMode : mtpd::kReadWriteMode;
   GetMediaTransferProtocolManager()->OpenStorage(
       storage_name, mode, base::Bind(&MTPDeviceTaskHelper::OnDidOpenStorage,
                                      weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void MTPDeviceTaskHelper::GetFileInfo(
-    uint32 file_id,
+    uint32_t file_id,
     const GetFileInfoSuccessCallback& success_callback,
     const ErrorCallback& error_callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (device_handle_.empty())
     return HandleDeviceError(error_callback, base::File::FILE_ERROR_FAILED);
 
   GetMediaTransferProtocolManager()->GetFileInfo(
       device_handle_, file_id,
       base::Bind(&MTPDeviceTaskHelper::OnGetFileInfo,
                  weak_ptr_factory_.GetWeakPtr(),
                  success_callback,
                  error_callback));
 }
 
 void MTPDeviceTaskHelper::CreateDirectory(
-    const uint32 parent_id,
+    const uint32_t parent_id,
     const std::string& directory_name,
     const CreateDirectorySuccessCallback& success_callback,
     const ErrorCallback& error_callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (device_handle_.empty())
     return HandleDeviceError(error_callback, base::File::FILE_ERROR_FAILED);
 
   GetMediaTransferProtocolManager()->CreateDirectory(
       device_handle_, parent_id, directory_name,
       base::Bind(&MTPDeviceTaskHelper::OnCreateDirectory,
                  weak_ptr_factory_.GetWeakPtr(), success_callback,
                  error_callback));
 }
 
 void MTPDeviceTaskHelper::ReadDirectory(
-    const uint32 directory_id,
+    const uint32_t directory_id,
     const size_t max_size,
     const ReadDirectorySuccessCallback& success_callback,
     const ErrorCallback& error_callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (device_handle_.empty())
     return HandleDeviceError(error_callback, base::File::FILE_ERROR_FAILED);
 
   GetMediaTransferProtocolManager()->ReadDirectory(
       device_handle_, directory_id, max_size,
       base::Bind(&MTPDeviceTaskHelper::OnDidReadDirectory,
@@ skipping 24 matching lines @@
                              base::File::FILE_ERROR_FAILED);
   }
 
   GetMediaTransferProtocolManager()->GetFileInfo(
       device_handle_, request.file_id,
       base::Bind(&MTPDeviceTaskHelper::OnGetFileInfoToReadBytes,
                  weak_ptr_factory_.GetWeakPtr(), request));
 }
 
 void MTPDeviceTaskHelper::RenameObject(
-    const uint32 object_id,
+    const uint32_t object_id,
     const std::string& new_name,
     const RenameObjectSuccessCallback& success_callback,
     const ErrorCallback& error_callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   GetMediaTransferProtocolManager()->RenameObject(
       device_handle_, object_id, new_name,
       base::Bind(&MTPDeviceTaskHelper::OnRenameObject,
                  weak_ptr_factory_.GetWeakPtr(), success_callback,
                  error_callback));
 }
 
 MTPDeviceTaskHelper::MTPEntry::MTPEntry() : file_id(0) {}
 
 // TODO(yawano) storage_name is not used, delete it.
 void MTPDeviceTaskHelper::CopyFileFromLocal(
     const std::string& storage_name,
     const int source_file_descriptor,
-    const uint32 parent_id,
+    const uint32_t parent_id,
     const std::string& file_name,
     const CopyFileFromLocalSuccessCallback& success_callback,
     const ErrorCallback& error_callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   GetMediaTransferProtocolManager()->CopyFileFromLocal(
       device_handle_, source_file_descriptor, parent_id, file_name,
       base::Bind(&MTPDeviceTaskHelper::OnCopyFileFromLocal,
                  weak_ptr_factory_.GetWeakPtr(), success_callback,
                  error_callback));
 }
 
 void MTPDeviceTaskHelper::DeleteObject(
-    const uint32 object_id,
+    const uint32_t object_id,
     const DeleteObjectSuccessCallback& success_callback,
     const ErrorCallback& error_callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   GetMediaTransferProtocolManager()->DeleteObject(
       device_handle_, object_id,
       base::Bind(&MTPDeviceTaskHelper::OnDeleteObject,
                  weak_ptr_factory_.GetWeakPtr(), success_callback,
                  error_callback));
 }
@@ skipping 89 matching lines @@
   DCHECK_GE(request.offset, 0);
   if (error) {
     return HandleDeviceError(request.error_callback,
                              base::File::FILE_ERROR_FAILED);
   }
 
   base::File::Info file_info = FileInfoFromMTPFileEntry(file_entry);
   if (file_info.is_directory) {
     return HandleDeviceError(request.error_callback,
                              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() ||
              request.offset > file_info.size) {
     return HandleDeviceError(request.error_callback,
                              base::File::FILE_ERROR_FAILED);
   } else if (request.offset == file_info.size) {
     content::BrowserThread::PostTask(content::BrowserThread::IO,
                                      FROM_HERE,
                                      base::Bind(request.success_callback,
                                                 file_info, 0u));
     return;
   }
 
-  uint32 bytes_to_read = std::min(
-      base::checked_cast<uint32>(request.buf_len),
-      base::saturated_cast<uint32>(file_info.size - request.offset));
+  uint32_t bytes_to_read =
+      std::min(base::checked_cast<uint32_t>(request.buf_len),
+               base::saturated_cast<uint32_t>(file_info.size - request.offset));
 
   GetMediaTransferProtocolManager()->ReadFileChunk(
-      device_handle_,
-      request.file_id,
-      base::checked_cast<uint32>(request.offset),
-      bytes_to_read,
+      device_handle_, request.file_id,
+      base::checked_cast<uint32_t>(request.offset), bytes_to_read,
       base::Bind(&MTPDeviceTaskHelper::OnDidReadBytes,
                  weak_ptr_factory_.GetWeakPtr(), request, file_info));
 }
 
 void MTPDeviceTaskHelper::OnDidReadBytes(
     const MTPDeviceAsyncDelegate::ReadBytesRequest& request,
     const base::File::Info& file_info,
     const std::string& data,
     bool error) const {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
@@ skipping 60 matching lines @@
 }
 
 void MTPDeviceTaskHelper::HandleDeviceError(
     const ErrorCallback& error_callback,
     base::File::Error error) const {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   content::BrowserThread::PostTask(content::BrowserThread::IO,
                                    FROM_HERE,
                                    base::Bind(error_callback, error));
 }