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

components/drive/file_system/truncate_operation.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 "components/drive/file_system/truncate_operation.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
@@ skipping 11 matching lines @@
 namespace drive {
 namespace file_system {
 namespace {
 
 // Truncates the local file at |local_cache_path| to the |length| bytes,
 // then marks the resource is dirty on |cache|.
 FileError TruncateOnBlockingPool(internal::ResourceMetadata* metadata,
                                  internal::FileCache* cache,
                                  const std::string& local_id,
                                  const base::FilePath& local_cache_path,
-                                 int64 length) {
+                                 int64_t length) {
   DCHECK(metadata);
   DCHECK(cache);
 
   scoped_ptr<base::ScopedClosureRunner> file_closer;
   FileError error = cache->OpenForWrite(local_id, &file_closer);
   if (error != FILE_ERROR_OK)
     return error;
 
   base::File file(local_cache_path,
                   base::File::FLAG_OPEN | base::File::FLAG_WRITE);
@@ skipping 25 matching lines @@
                                                 metadata,
                                                 cache,
                                                 temporary_file_directory)),
       weak_ptr_factory_(this) {
 }
 
 TruncateOperation::~TruncateOperation() {
 }
 
 void TruncateOperation::Truncate(const base::FilePath& file_path,
-                                 int64 length,
+                                 int64_t length,
                                  const FileOperationCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   if (length < 0) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback, FILE_ERROR_INVALID_OPERATION));
     return;
   }
 
   // TODO(kinaba): http://crbug.com/132780.
   // Optimize the cases for small |length|, at least for |length| == 0.
   download_operation_->EnsureFileDownloadedByPath(
       file_path,
       ClientContext(USER_INITIATED),
       GetFileContentInitializedCallback(),
       google_apis::GetContentCallback(),
       base::Bind(&TruncateOperation::TruncateAfterEnsureFileDownloadedByPath,
                  weak_ptr_factory_.GetWeakPtr(), length, callback));
 }
 
 void TruncateOperation::TruncateAfterEnsureFileDownloadedByPath(
-    int64 length,
+    int64_t length,
     const FileOperationCallback& callback,
     FileError error,
     const base::FilePath& local_file_path,
     scoped_ptr<ResourceEntry> entry) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   if (error != FILE_ERROR_OK) {
     callback.Run(error);
     return;
@@ skipping 23 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   delegate_->OnEntryUpdatedByOperation(ClientContext(USER_INITIATED), local_id);
 
   callback.Run(error);
 }
 
 }  // namespace file_system
 }  // namespace drive