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

chrome/browser/chromeos/file_manager/snapshot_manager.cc

 // Copyright 2014 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/file_manager/snapshot_manager.h"
 
 #include "base/bind.h"
 #include "base/sys_info.h"
 #include "chrome/browser/chromeos/file_manager/app_id.h"
 #include "chrome/browser/chromeos/file_manager/fileapi_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/browser_thread.h"
 #include "google_apis/drive/task_util.h"
 #include "storage/browser/blob/shareable_file_reference.h"
 #include "storage/browser/fileapi/file_system_context.h"
 #include "third_party/cros_system_api/constants/cryptohome.h"
 
 namespace file_manager {
 namespace {
 
-typedef base::Callback<void(int64)> GetNecessaryFreeSpaceCallback;
+typedef base::Callback<void(int64_t)> GetNecessaryFreeSpaceCallback;
 
 // Part of ComputeSpaceNeedToBeFreed.
-int64 ComputeSpaceNeedToBeFreedAfterGetMetadataOnBlockingPool(
+int64_t ComputeSpaceNeedToBeFreedAfterGetMetadataOnBlockingPool(
     const base::FilePath& path,
-    int64 snapshot_size) {
-  int64 free_size = base::SysInfo::AmountOfFreeDiskSpace(path);
+    int64_t snapshot_size) {
+  int64_t free_size = base::SysInfo::AmountOfFreeDiskSpace(path);
   if (free_size < 0)
     return -1;
 
   // We need to keep cryptohome::kMinFreeSpaceInBytes free space even after
   // |snapshot_size| is occupied.
   free_size -= snapshot_size + cryptohome::kMinFreeSpaceInBytes;
   return (free_size < 0 ? -free_size : 0);
 }
 
 // Part of ComputeSpaceNeedToBeFreed.
@@ skipping 57 matching lines @@
 // Bind callback should destruct the bound argument.
 void FreeReferenceOnIOThread(
     const std::deque<SnapshotManager::FileReferenceWithSizeInfo>& file_refs) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 }
 
 }  // namespace
 
 SnapshotManager::FileReferenceWithSizeInfo::FileReferenceWithSizeInfo(
     scoped_refptr<storage::ShareableFileReference> ref,
-    int64 size)
-    : file_ref(ref), file_size(size) {
-}
+    int64_t size)
+    : file_ref(ref), file_size(size) {}
 
 SnapshotManager::FileReferenceWithSizeInfo::~FileReferenceWithSizeInfo() {
 }
 
 SnapshotManager::SnapshotManager(Profile* profile)
     : profile_(profile), weak_ptr_factory_(this) {
 }
 
 SnapshotManager::~SnapshotManager() {
   if (!file_refs_.empty()) {
@@ skipping 23 matching lines @@
   ComputeSpaceNeedToBeFreed(profile_, context, filesystem_url,
       base::Bind(&SnapshotManager::CreateManagedSnapshotAfterSpaceComputed,
                  weak_ptr_factory_.GetWeakPtr(),
                  filesystem_url,
                  callback));
 }
 
 void SnapshotManager::CreateManagedSnapshotAfterSpaceComputed(
     const storage::FileSystemURL& filesystem_url,
     const LocalPathCallback& callback,
-    int64 needed_space) {
+    int64_t needed_space) {
   scoped_refptr<storage::FileSystemContext> context(
       util::GetFileSystemContextForExtensionId(profile_, kFileManagerAppId));
   DCHECK(context.get());
 
   if (needed_space < 0) {
     callback.Run(base::FilePath());
     return;
   }
 
   // Free up to the required size.
@@ skipping 41 matching lines @@
   if (result != base::File::FILE_OK) {
     callback.Run(base::FilePath());
     return;
   }
 
   file_refs_.push_back(FileReferenceWithSizeInfo(file_ref, file_info.size));
   callback.Run(platform_path);
 }
 
 }  // namespace file_manager