Switch to standard integer types in components/, part 1 of 4.

components/drive/file_cache.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 "components/drive/file_cache.h"
 
 #include <queue>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback_helpers.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_info.h"
+#include "build/build_config.h"
 #include "components/drive/drive.pb.h"
 #include "components/drive/drive_api_util.h"
 #include "components/drive/file_system_core_util.h"
 #include "components/drive/resource_metadata_storage.h"
 #include "google_apis/drive/task_util.h"
 #include "net/base/filename_util.h"
 #include "net/base/mime_sniffer.h"
 #include "net/base/mime_util.h"
 
 namespace drive {
@@ skipping 48 matching lines @@
 }
 
 void FileCache::AssertOnSequencedWorkerPool() {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
 }
 
 bool FileCache::IsUnderFileCacheDirectory(const base::FilePath& path) const {
   return cache_file_directory_.IsParent(path);
 }
 
-bool FileCache::FreeDiskSpaceIfNeededFor(int64 num_bytes) {
+bool FileCache::FreeDiskSpaceIfNeededFor(int64_t num_bytes) {
   AssertOnSequencedWorkerPool();
 
   // Do nothing and return if we have enough space.
   if (GetAvailableSpace() >= num_bytes)
     return true;
 
   // Otherwise, try to free up the disk space.
   DVLOG(1) << "Freeing up disk space for " << num_bytes;
 
   // Remove all files which have no corresponding cache entries.
   base::FileEnumerator enumerator(cache_file_directory_,
                                   false,  // not recursive
                                   base::FileEnumerator::FILES);
   ResourceEntry entry;
   for (base::FilePath current = enumerator.Next(); !current.empty();
        current = enumerator.Next()) {
     const std::string id = GetIdFromPath(current);
     const FileError error = storage_->GetEntry(id, &entry);
 
     if (error == FILE_ERROR_NOT_FOUND)
       base::DeleteFile(current, false /* recursive */);
     else if (error != FILE_ERROR_OK)
       return false;
   }
 
   // Check available space again. If we have enough space here, do nothing.
-  const int64 available_space = GetAvailableSpace();
+  const int64_t available_space = GetAvailableSpace();
   if (available_space >= num_bytes)
     return true;
 
-  const int64 requested_space = num_bytes - available_space;
+  const int64_t requested_space = num_bytes - available_space;
 
   // Put all entries in priority queue where latest entry becomes top.
   std::priority_queue<CacheInfo, std::vector<CacheInfo>, CacheInfoLatestCompare>
       cache_info_queue;
   scoped_ptr<ResourceMetadataStorage::Iterator> it = storage_->GetIterator();
   for (; !it->IsAtEnd(); it->Advance()) {
     if (IsEvictable(it->GetID(), it->GetValue())) {
       const ResourceEntry& entry = it->GetValue();
 
       const base::FilePath& cache_path = GetCacheFilePath(entry.local_id());
@@ skipping 20 matching lines @@
     return false;
 
   // Copy entries to the vector. This becomes last-accessed desc order.
   std::vector<CacheInfo> cache_info_list;
   while (!cache_info_queue.empty()) {
     cache_info_list.push_back(cache_info_queue.top());
     cache_info_queue.pop();
   }
 
   // Update DB and delete files with accessing to the vector in ascending order.
-  int64 evicted_cache_size = 0;
+  int64_t evicted_cache_size = 0;
   auto iter = cache_info_list.rbegin();
   while (evicted_cache_size < requested_space &&
          iter != cache_info_list.rend()) {
     const CacheInfo& cache_info = *iter;
 
     // Update DB.
     ResourceEntry entry = cache_info.second;
     entry.mutable_file_specific_info()->clear_cache_state();
     storage_->PutEntry(entry);
 
@@ skipping 51 matching lines @@
                            const std::string& md5,
                            const base::FilePath& source_path,
                            FileOperationType file_operation_type) {
   AssertOnSequencedWorkerPool();
 
   ResourceEntry entry;
   FileError error = storage_->GetEntry(id, &entry);
   if (error != FILE_ERROR_OK)
     return error;
 
-  int64 file_size = 0;
+  int64_t file_size = 0;
   if (file_operation_type == FILE_OPERATION_COPY) {
     if (!base::GetFileSize(source_path, &file_size)) {
       LOG(WARNING) << "Couldn't get file size for: " << source_path.value();
       return FILE_ERROR_FAILED;
     }
   }
   if (!FreeDiskSpaceIfNeededFor(file_size))
     return FILE_ERROR_NO_LOCAL_SPACE;
 
   // If file is mounted, return error.
@@ skipping 389 matching lines @@
     return error;
 
   std::set<std::string>::iterator it = mounted_files_.find(id);
   if (it == mounted_files_.end())
     return FILE_ERROR_INVALID_OPERATION;
 
   mounted_files_.erase(it);
   return FILE_ERROR_OK;
 }
 
-int64 FileCache::GetAvailableSpace() {
-  int64 free_space = 0;
+int64_t FileCache::GetAvailableSpace() {
+  int64_t free_space = 0;
   if (free_disk_space_getter_)
     free_space = free_disk_space_getter_->AmountOfFreeDiskSpace();
   else
     free_space = base::SysInfo::AmountOfFreeDiskSpace(cache_file_directory_);
 
   // Subtract this as if this portion does not exist.
   free_space -= drive::internal::kMinFreeSpaceInBytes;
   return free_space;
 }
 
@@ skipping 49 matching lines @@
 
 bool FileCache::IsEvictable(const std::string& id, const ResourceEntry& entry) {
   return entry.file_specific_info().has_cache_state() &&
          !entry.file_specific_info().cache_state().is_pinned() &&
          !entry.file_specific_info().cache_state().is_dirty() &&
          !mounted_files_.count(id);
 }
 
 }  // namespace internal
 }  // namespace drive