Switch to standard integer types in chrome/browser/chromeos/.

chrome/browser/chromeos/extensions/file_manager/private_api_file_system.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/chromeos/extensions/file_manager/private_api_file_system.h"
 
 #include <sys/statvfs.h>
 #include <set>
 
 #include "base/memory/weak_ptr.h"
@@ skipping 50 matching lines @@
 using file_manager::util::FileDefinition;
 using storage::FileSystemURL;
 
 namespace extensions {
 namespace {
 
 const char kRootPath[] = "/";
 
 // Retrieves total and remaining available size on |mount_path|.
 void GetSizeStatsOnBlockingPool(const std::string& mount_path,
-                                uint64* total_size,
-                                uint64* remaining_size) {
+                                uint64_t* total_size,
+                                uint64_t* remaining_size) {
   struct statvfs stat = {};  // Zero-clear
   if (HANDLE_EINTR(statvfs(mount_path.c_str(), &stat)) == 0) {
-    *total_size = static_cast<uint64>(stat.f_blocks) * stat.f_frsize;
-    *remaining_size = static_cast<uint64>(stat.f_bavail) * stat.f_frsize;
+    *total_size = static_cast<uint64_t>(stat.f_blocks) * stat.f_frsize;
+    *remaining_size = static_cast<uint64_t>(stat.f_bavail) * stat.f_frsize;
   }
 }
 
 // Used for OnCalculateEvictableCacheSize.
 typedef base::Callback<void(const uint64_t* total_size,
                             const uint64_t* remaining_space)>
     GetSizeStatsCallback;
 
 // Calculates the real remaining size of Download volume and pass it to
 // GetSizeStatsCallback.
@@ skipping 39 matching lines @@
   return file_manager::EventRouterFactory::GetForProfile(profile);
 }
 
 // Notifies the copy progress to extensions via event router.
 void NotifyCopyProgress(
     void* profile_id,
     storage::FileSystemOperationRunner::OperationID operation_id,
     storage::FileSystemOperation::CopyProgressType type,
     const FileSystemURL& source_url,
     const FileSystemURL& destination_url,
-    int64 size) {
+    int64_t size) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   file_manager::EventRouter* event_router =
       GetEventRouterByProfileId(profile_id);
   if (event_router) {
     event_router->OnCopyProgress(
         operation_id, type,
         source_url.ToGURL(), destination_url.ToGURL(), size);
   }
 }
 
 // Callback invoked periodically on progress update of Copy().
 void OnCopyProgress(
     void* profile_id,
     storage::FileSystemOperationRunner::OperationID* operation_id,
     storage::FileSystemOperation::CopyProgressType type,
     const FileSystemURL& source_url,
     const FileSystemURL& destination_url,
-    int64 size) {
+    int64_t size) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&NotifyCopyProgress,
                  profile_id, *operation_id, type,
                  source_url, destination_url, size));
 }
 
 // Notifies the copy completion to extensions via event router.
@@ skipping 324 matching lines @@
   // We need to add evictable cache size to the remaining size of Downloads
   // volume if drive is available.
   file_system->CalculateEvictableCacheSize(base::Bind(
       &OnCalculateEvictableCacheSize,
       base::Bind(&FileManagerPrivateGetSizeStatsFunction::OnGetSizeStats, this),
       *total_size, *remaining_size));
 }
 
 void FileManagerPrivateGetSizeStatsFunction::OnGetDriveAvailableSpace(
     drive::FileError error,
-    int64 bytes_total,
-    int64 bytes_used) {
+    int64_t bytes_total,
+    int64_t bytes_used) {
   if (error == drive::FILE_ERROR_OK) {
-    const uint64 bytes_total_unsigned = bytes_total;
+    const uint64_t bytes_total_unsigned = bytes_total;
     // bytes_used can be larger than bytes_total (over quota).
-    const uint64 bytes_remaining_unsigned =
-        std::max(bytes_total - bytes_used, int64(0));
+    const uint64_t bytes_remaining_unsigned =
+        std::max(bytes_total - bytes_used, int64_t(0));
     OnGetSizeStats(&bytes_total_unsigned, &bytes_remaining_unsigned);
   } else {
     // If stats couldn't be gotten for drive, result should be left undefined.
     SendResponse(true);
   }
 }
 
 void FileManagerPrivateGetSizeStatsFunction::OnGetMtpAvailableSpace(
     const MtpStorageInfo& mtp_storage_info,
     const bool error) {
   if (error) {
     // If stats couldn't be gotten from MTP volume, result should be left
     // undefined same as we do for Drive.
     SendResponse(true);
     return;
   }
 
-  const uint64 max_capacity = mtp_storage_info.max_capacity();
-  const uint64 free_space_in_bytes = mtp_storage_info.free_space_in_bytes();
+  const uint64_t max_capacity = mtp_storage_info.max_capacity();
+  const uint64_t free_space_in_bytes = mtp_storage_info.free_space_in_bytes();
   OnGetSizeStats(&max_capacity, &free_space_in_bytes);
 }
 
 void FileManagerPrivateGetSizeStatsFunction::OnGetSizeStats(
-    const uint64* total_size,
-    const uint64* remaining_size) {
+    const uint64_t* total_size,
+    const uint64_t* remaining_size) {
   base::DictionaryValue* sizes = new base::DictionaryValue();
   SetResult(sizes);
 
   sizes->SetDouble("totalSize", static_cast<double>(*total_size));
   sizes->SetDouble("remainingSize", static_cast<double>(*remaining_size));
 
   SendResponse(true);
 }
 
 bool FileManagerPrivateInternalValidatePathNameLengthFunction::RunAsync() {
@@ skipping 61 matching lines @@
     scoped_refptr<storage::FileSystemContext> file_system_context,
     const FileSystemURL& url,
     int fields,
     const storage::FileSystemOperation::GetMetadataCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   file_system_context->operation_runner()->GetMetadata(
       url, fields, base::Bind(&GetFileMetadataRespondOnUIThread, callback));
 }
 
 // Checks if the available space of the |path| is enough for required |bytes|.
-bool CheckLocalDiskSpaceOnIOThread(const base::FilePath& path, int64 bytes) {
+bool CheckLocalDiskSpaceOnIOThread(const base::FilePath& path, int64_t bytes) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return bytes <= base::SysInfo::AmountOfFreeDiskSpace(path) -
                       cryptohome::kMinFreeSpaceInBytes;
 }
 
 bool FileManagerPrivateInternalStartCopyFunction::RunAsync() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   using extensions::api::file_manager_private_internal::StartCopy::Params;
   const scoped_ptr<Params> params(Params::Create(*args_));
@@ skipping 365 matching lines @@
   return RespondLater();
 }
 
 void FileManagerPrivateInternalSetEntryTagFunction::OnSetEntryPropertyCompleted(
     drive::FileError result) {
   Respond(result == drive::FILE_ERROR_OK ? NoArguments()
                                          : Error("Failed to set a tag."));
 }
 
 }  // namespace extensions