Switch to standard integer types in content/browser/.

content/browser/indexed_db/indexed_db_context_impl.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 "content/browser/indexed_db/indexed_db_context_impl.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 269 matching lines @@
   base::FileEnumerator file_enumerator(
       GetBlobPath(storage::GetIdentifierFromOrigin(origin_url)), true,
       base::FileEnumerator::FILES);
   for (base::FilePath file_path = file_enumerator.Next(); !file_path.empty();
        file_path = file_enumerator.Next()) {
     count++;
   }
   return count;
 }
 
-int64 IndexedDBContextImpl::GetOriginDiskUsage(const GURL& origin_url) {
+int64_t IndexedDBContextImpl::GetOriginDiskUsage(const GURL& origin_url) {
   DCHECK(TaskRunner()->RunsTasksOnCurrentThread());
   if (data_path_.empty() || !IsInOriginSet(origin_url))
     return 0;
   EnsureDiskUsageCacheInitialized(origin_url);
   return origin_size_map_[origin_url];
 }
 
 base::Time IndexedDBContextImpl::GetOriginLastModified(const GURL& origin_url) {
   DCHECK(TaskRunner()->RunsTasksOnCurrentThread());
   if (data_path_.empty() || !IsInOriginSet(origin_url))
@@ skipping 156 matching lines @@
   QueryAvailableQuota(origin_url);
 }
 
 void IndexedDBContextImpl::DatabaseDeleted(const GURL& origin_url) {
   AddToOriginSet(origin_url);
   QueryDiskAndUpdateQuotaUsage(origin_url);
   QueryAvailableQuota(origin_url);
 }
 
 bool IndexedDBContextImpl::WouldBeOverQuota(const GURL& origin_url,
-                                            int64 additional_bytes) {
+                                            int64_t additional_bytes) {
   if (space_available_map_.find(origin_url) == space_available_map_.end()) {
     // We haven't heard back from the QuotaManager yet, just let it through.
     return false;
   }
   bool over_quota = additional_bytes > space_available_map_[origin_url];
   return over_quota;
 }
 
 bool IndexedDBContextImpl::IsOverQuota(const GURL& origin_url) {
   const int kOneAdditionalByte = 1;
@@ skipping 38 matching lines @@
       .AddExtension(kBlobExtension);
 }
 
 base::FilePath IndexedDBContextImpl::GetLevelDBPath(
     const std::string& origin_id) const {
   DCHECK(!data_path_.empty());
   return data_path_.AppendASCII(origin_id).AddExtension(kIndexedDBExtension)
       .AddExtension(kLevelDBExtension);
 }
 
-int64 IndexedDBContextImpl::ReadUsageFromDisk(const GURL& origin_url) const {
+int64_t IndexedDBContextImpl::ReadUsageFromDisk(const GURL& origin_url) const {
   if (data_path_.empty())
     return 0;
-  int64 total_size = 0;
+  int64_t total_size = 0;
   for (const base::FilePath& path : GetStoragePaths(origin_url))
     total_size += base::ComputeDirectorySize(path);
   return total_size;
 }
 
 void IndexedDBContextImpl::EnsureDiskUsageCacheInitialized(
     const GURL& origin_url) {
   if (origin_size_map_.find(origin_url) == origin_size_map_.end())
     origin_size_map_[origin_url] = ReadUsageFromDisk(origin_url);
 }
 
 void IndexedDBContextImpl::QueryDiskAndUpdateQuotaUsage(
     const GURL& origin_url) {
-  int64 former_disk_usage = origin_size_map_[origin_url];
-  int64 current_disk_usage = ReadUsageFromDisk(origin_url);
-  int64 difference = current_disk_usage - former_disk_usage;
+  int64_t former_disk_usage = origin_size_map_[origin_url];
+  int64_t current_disk_usage = ReadUsageFromDisk(origin_url);
+  int64_t difference = current_disk_usage - former_disk_usage;
   if (difference) {
     origin_size_map_[origin_url] = current_disk_usage;
     // quota_manager_proxy() is NULL in unit tests.
     if (quota_manager_proxy()) {
       quota_manager_proxy()->NotifyStorageModified(
           storage::QuotaClient::kIndexedDatabase,
           origin_url,
           storage::kStorageTypeTemporary,
           difference);
     }
   }
 }
 
 void IndexedDBContextImpl::GotUsageAndQuota(const GURL& origin_url,
                                             storage::QuotaStatusCode status,
-                                            int64 usage,
-                                            int64 quota) {
+                                            int64_t usage,
+                                            int64_t quota) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(status == storage::kQuotaStatusOk ||
          status == storage::kQuotaErrorAbort)
       << "status was " << status;
   if (status == storage::kQuotaErrorAbort) {
     // We seem to no longer care to wait around for the answer.
     return;
   }
   TaskRunner()->PostTask(FROM_HERE,
                          base::Bind(&IndexedDBContextImpl::GotUpdatedQuota,
                                     this,
                                     origin_url,
                                     usage,
                                     quota));
 }
 
 void IndexedDBContextImpl::GotUpdatedQuota(const GURL& origin_url,
-                                           int64 usage,
-                                           int64 quota) {
+                                           int64_t usage,
+                                           int64_t quota) {
   DCHECK(TaskRunner()->RunsTasksOnCurrentThread());
   space_available_map_[origin_url] = quota - usage;
 }
 
 void IndexedDBContextImpl::QueryAvailableQuota(const GURL& origin_url) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     DCHECK(TaskRunner()->RunsTasksOnCurrentThread());
     if (quota_manager_proxy()) {
       BrowserThread::PostTask(
           BrowserThread::IO,
@@ skipping 29 matching lines @@
   origin_set_.reset();
   origin_size_map_.clear();
   space_available_map_.clear();
 }
 
 base::SequencedTaskRunner* IndexedDBContextImpl::TaskRunner() const {
   return task_runner_.get();
 }
 
 }  // namespace content