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

components/drive/file_system.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_system.h"
 
+#include <stddef.h>
+
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/prefs/pref_service.h"
 #include "components/drive/change_list_loader.h"
 #include "components/drive/directory_loader.h"
 #include "components/drive/drive.pb.h"
 #include "components/drive/drive_pref_names.h"
 #include "components/drive/file_cache.h"
 #include "components/drive/file_change.h"
 #include "components/drive/file_system/copy_operation.h"
@@ skipping 127 matching lines @@
 // Runs the callback with arguments.
 void RunMarkMountedCallback(const MarkMountedCallback& callback,
                             base::FilePath* cache_file_path,
                             FileError error) {
   DCHECK(!callback.is_null());
   callback.Run(error, *cache_file_path);
 }
 
 // Callback for ResourceMetadata::GetLargestChangestamp.
 // |callback| must not be null.
-void OnGetLargestChangestamp(
-    FileSystemMetadata metadata,  // Will be modified.
-    const GetFilesystemMetadataCallback& callback,
-    const int64* largest_changestamp,
-    FileError error) {
+void OnGetLargestChangestamp(FileSystemMetadata metadata,  // Will be modified.
+                             const GetFilesystemMetadataCallback& callback,
+                             const int64_t* largest_changestamp,
+                             FileError error) {
   DCHECK(!callback.is_null());
 
   metadata.largest_changestamp = *largest_changestamp;
   callback.Run(metadata);
 }
 
 // Thin adapter to map GetFileCallback to FileOperationCallback.
 void GetFileCallbackToFileOperationCallbackAdapter(
     const FileOperationCallback& callback,
     FileError error,
@@ skipping 28 matching lines @@
 
 // Part of GetPathFromResourceId().
 // Called when GetPathFromResourceIdInBlockingPool is complete.
 void GetPathFromResourceIdAfterGetPath(base::FilePath* file_path,
                                        const GetFilePathCallback& callback,
                                        FileError error) {
   callback.Run(error, *file_path);
 }
 
 bool FreeDiskSpaceIfNeededForOnBlockingPool(internal::FileCache* cache,
-                                            int64 num_bytes) {
+                                            int64_t num_bytes) {
   return cache->FreeDiskSpaceIfNeededFor(num_bytes);
 }
 
 uint64_t CalculateEvictableCacheSizeOnBlockingPool(internal::FileCache* cache) {
   return cache->CalculateEvictableCacheSize();
 }
 
 // Excludes hosted documents from the given entries.
 // Used to implement ReadDirectory().
 void FilterHostedDocuments(const ReadDirectoryEntriesCallback& callback,
@@ skipping 295 matching lines @@
                            const base::Time& last_access_time,
                            const base::Time& last_modified_time,
                            const FileOperationCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
   touch_operation_->TouchFile(
       file_path, last_access_time, last_modified_time, callback);
 }
 
 void FileSystem::TruncateFile(const base::FilePath& file_path,
-                              int64 length,
+                              int64_t length,
                               const FileOperationCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
   truncate_operation_->Truncate(file_path, length, callback);
 }
 
 void FileSystem::Pin(const base::FilePath& file_path,
                      const FileOperationCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
@@ skipping 360 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   FileSystemMetadata metadata;
   metadata.refreshing = change_list_loader_->IsRefreshing();
 
   // Metadata related to delta update.
   metadata.last_update_check_time = last_update_check_time_;
   metadata.last_update_check_error = last_update_check_error_;
 
-  int64* largest_changestamp = new int64(0);
+  int64_t* largest_changestamp = new int64_t(0);
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&internal::ResourceMetadata::GetLargestChangestamp,
                  base::Unretained(resource_metadata_),
                  largest_changestamp),
       base::Bind(&OnGetLargestChangestamp,
                  metadata,
                  callback,
                  base::Owned(largest_changestamp)));
@@ skipping 117 matching lines @@
       base::Bind(&GetPathFromResourceIdOnBlockingPool,
                  resource_metadata_,
                  resource_id,
                  file_path),
       base::Bind(&GetPathFromResourceIdAfterGetPath,
                  base::Owned(file_path),
                  callback));
 }
 
 void FileSystem::FreeDiskSpaceIfNeededFor(
-    int64 num_bytes,
+    int64_t num_bytes,
     const FreeDiskSpaceCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_.get(), FROM_HERE,
       base::Bind(&FreeDiskSpaceIfNeededForOnBlockingPool, cache_, num_bytes),
       callback);
 }
 
 void FileSystem::CalculateEvictableCacheSize(
     const EvictableCacheSizeCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_.get(), FROM_HERE,
       base::Bind(&CalculateEvictableCacheSizeOnBlockingPool, cache_), callback);
 }
 }  // namespace drive