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

components/drive/resource_metadata.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/resource_metadata.h"
 
+#include <stddef.h>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/guid.h"
 #include "base/location.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_info.h"
 #include "components/drive/drive.pb.h"
 #include "components/drive/file_cache.h"
 #include "components/drive/file_system_core_util.h"
 #include "components/drive/resource_metadata_storage.h"
 
 namespace drive {
 namespace internal {
 namespace {
 
 // Returns true if enough disk space is available for DB operation.
 // TODO(hashimoto): Merge this with FileCache's FreeDiskSpaceGetterInterface.
 bool EnoughDiskSpaceIsAvailableForDBOperation(const base::FilePath& path) {
-  const int64 kRequiredDiskSpaceInMB = 128;  // 128 MB seems to be large enough.
+  const int64_t kRequiredDiskSpaceInMB =
+      128;  // 128 MB seems to be large enough.
   return base::SysInfo::AmountOfFreeDiskSpace(path) >=
       kRequiredDiskSpaceInMB * (1 << 20);
 }
 
 // Returns a file name with a uniquifier appended. (e.g. "File (1).txt")
 std::string GetUniquifiedName(const std::string& name, int uniquifier) {
   base::FilePath name_path = base::FilePath::FromUTF8Unsafe(name);
   name_path = name_path.InsertBeforeExtensionASCII(
       base::StringPrintf(" (%d)", uniquifier));
   return name_path.AsUTF8Unsafe();
@@ skipping 162 matching lines @@
     return error;
   }
   return FILE_ERROR_OK;
 }
 
 void ResourceMetadata::DestroyOnBlockingPool() {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
   delete this;
 }
 
-FileError ResourceMetadata::GetLargestChangestamp(int64* out_value) {
+FileError ResourceMetadata::GetLargestChangestamp(int64_t* out_value) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
   return storage_->GetLargestChangestamp(out_value);
 }
 
-FileError ResourceMetadata::SetLargestChangestamp(int64 value) {
+FileError ResourceMetadata::SetLargestChangestamp(int64_t value) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
 
   if (!EnoughDiskSpaceIsAvailableForDBOperation(storage_->directory_path()))
     return FILE_ERROR_NO_LOCAL_SPACE;
 
   return storage_->SetLargestChangestamp(value);
 }
 
 FileError ResourceMetadata::AddEntry(const ResourceEntry& entry,
                                      std::string* out_id) {
@@ skipping 372 matching lines @@
 
   error = cache_->Remove(id);
   if (error != FILE_ERROR_OK)
     return error;
 
   return storage_->RemoveEntry(id);
 }
 
 }  // namespace internal
 }  // namespace drive