Remove kint64max.

storage/browser/fileapi/file_system_operation_impl.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 "storage/browser/fileapi/file_system_operation_impl.h"
 
+#include <limits>
+
 #include "base/bind.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "net/base/escape.h"
 #include "net/url_request/url_request.h"
 #include "storage/browser/blob/shareable_file_reference.h"
 #include "storage/browser/fileapi/async_file_util.h"
 #include "storage/browser/fileapi/copy_or_move_operation_delegate.h"
@@ skipping 174 matching lines @@
     scoped_ptr<net::URLRequest> blob_request,
     const WriteCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationWrite));
   file_writer_delegate_ = writer_delegate.Pass();
   file_writer_delegate_->Start(
       blob_request.Pass(),
       base::Bind(&FileSystemOperationImpl::DidWrite,
                  weak_factory_.GetWeakPtr(), url, callback));
 }
 
-void FileSystemOperationImpl::Truncate(const FileSystemURL& url, int64 length,
+void FileSystemOperationImpl::Truncate(const FileSystemURL& url,
+                                       int64_t length,
                                        const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationTruncate));
 
   // crbug.com/349708
   TRACE_EVENT0("io", "FileSystemOperationImpl::Truncate");
 
   GetUsageAndQuotaThenRunTask(
       url,
       base::Bind(&FileSystemOperationImpl::DoTruncate,
                  weak_factory_.GetWeakPtr(), url, callback, length),
@@ skipping 174 matching lines @@
 void FileSystemOperationImpl::GetUsageAndQuotaThenRunTask(
     const FileSystemURL& url,
     const base::Closure& task,
     const base::Closure& error_callback) {
   storage::QuotaManagerProxy* quota_manager_proxy =
       file_system_context()->quota_manager_proxy();
   if (!quota_manager_proxy ||
       !file_system_context()->GetQuotaUtil(url.type())) {
     // If we don't have the quota manager or the requested filesystem type
     // does not support quota, we should be able to let it go.
-    operation_context_->set_allowed_bytes_growth(kint64max);
+    operation_context_->set_allowed_bytes_growth(
+        std::numeric_limits<int64_t>::max());
     task.Run();
     return;
   }
 
   DCHECK(quota_manager_proxy);
   DCHECK(quota_manager_proxy->quota_manager());
   quota_manager_proxy->quota_manager()->GetUsageAndQuota(
       url.origin(),
       FileSystemTypeToQuotaStorageType(url.type()),
       base::Bind(&FileSystemOperationImpl::DidGetUsageAndQuotaAndRunTask,
                  weak_factory_.GetWeakPtr(), task, error_callback));
 }
 
 void FileSystemOperationImpl::DidGetUsageAndQuotaAndRunTask(
     const base::Closure& task,
     const base::Closure& error_callback,
     storage::QuotaStatusCode status,
-    int64 usage,
-    int64 quota) {
+    int64_t usage,
+    int64_t quota) {
   if (status != storage::kQuotaStatusOk) {
     LOG(WARNING) << "Got unexpected quota error : " << status;
     error_callback.Run();
     return;
   }
 
   operation_context_->set_allowed_bytes_growth(quota - usage);
   task.Run();
 }
 
@@ skipping 50 matching lines @@
     const StatusCallback& callback) {
   async_file_util_->CopyInForeignFile(
       operation_context_.Pass(),
       src_local_disk_file_path, dest_url,
       base::Bind(&FileSystemOperationImpl::DidFinishOperation,
                  weak_factory_.GetWeakPtr(), callback));
 }
 
 void FileSystemOperationImpl::DoTruncate(const FileSystemURL& url,
                                          const StatusCallback& callback,
-                                         int64 length) {
+                                         int64_t length) {
   async_file_util_->Truncate(
       operation_context_.Pass(), url, length,
       base::Bind(&FileSystemOperationImpl::DidFinishOperation,
                  weak_factory_.GetWeakPtr(), callback));
 }
 
 void FileSystemOperationImpl::DoOpenFile(const FileSystemURL& url,
                                          const OpenFileCallback& callback,
                                          int file_flags) {
   async_file_util_->CreateOrOpen(
@@ skipping 68 matching lines @@
     return;
   }
 
   callback.Run(rv);
 }
 
 void FileSystemOperationImpl::DidWrite(
     const FileSystemURL& url,
     const WriteCallback& write_callback,
     base::File::Error rv,
-    int64 bytes,
+    int64_t bytes,
     FileWriterDelegate::WriteProgressStatus write_status) {
   const bool complete = (
       write_status != FileWriterDelegate::SUCCESS_IO_PENDING);
   if (complete && write_status != FileWriterDelegate::ERROR_WRITE_NOT_STARTED) {
     DCHECK(operation_context_);
     operation_context_->change_observers()->Notify(
         &FileChangeObserver::OnModifyFile, base::MakeTuple(url));
   }
 
   StatusCallback cancel_callback = cancel_callback_;
   write_callback.Run(rv, bytes, complete);
   if (!cancel_callback.is_null())
     cancel_callback.Run(base::File::FILE_OK);
 }
 
 bool FileSystemOperationImpl::SetPendingOperationType(OperationType type) {
   if (pending_operation_ != kOperationNone)
     return false;
   pending_operation_ = type;
   return true;
 }
 
 }  // namespace storage