Remove kint64max.

storage/browser/quota/quota_manager.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/quota/quota_manager.h"
 
 #include <algorithm>
 #include <functional>
+#include <limits>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/metrics/histogram.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 11 matching lines @@
 
 #define UMA_HISTOGRAM_MBYTES(name, sample)          \
   UMA_HISTOGRAM_CUSTOM_COUNTS(                      \
       (name), static_cast<int>((sample) / kMBytes), \
       1, 10 * 1024 * 1024 /* 10TB */, 100)
 
 namespace storage {
 
 namespace {
 
-const int64 kMBytes = 1024 * 1024;
+const int64_t kMBytes = 1024 * 1024;
 const int kMinutesInMilliSeconds = 60 * 1000;
 
-const int64 kReportHistogramInterval = 60 * 60 * 1000;  // 1 hour
+const int64_t kReportHistogramInterval = 60 * 60 * 1000;  // 1 hour
 const double kTemporaryQuotaRatioToAvail = 1.0 / 3.0;  // 33%
 
 }  // namespace
 
 // Arbitrary for now, but must be reasonably small so that
 // in-memory databases can fit.
 // TODO(kinuko): Refer SysInfo::AmountOfPhysicalMemory() to determine this.
-const int64 QuotaManager::kIncognitoDefaultQuotaLimit = 100 * kMBytes;
+const int64_t QuotaManager::kIncognitoDefaultQuotaLimit = 100 * kMBytes;
 
-const int64 QuotaManager::kNoLimit = kint64max;
+const int64_t QuotaManager::kNoLimit = INT64_MAX;
 
 const int QuotaManager::kPerHostTemporaryPortion = 5;  // 20%
 
 // Cap size for per-host persistent quota determined by the histogram.
 // This is a bit lax value because the histogram says nothing about per-host
 // persistent storage usage and we determined by global persistent storage
 // usage that is less than 10GB for almost all users.
-const int64 QuotaManager::kPerHostPersistentQuotaLimit = 10 * 1024 * kMBytes;
+const int64_t QuotaManager::kPerHostPersistentQuotaLimit = 10 * 1024 * kMBytes;
 
 const char QuotaManager::kDatabaseName[] = "QuotaManager";
 
 const int QuotaManager::kThresholdOfErrorsToBeBlacklisted = 3;
 
 // Preserve kMinimumPreserveForSystem disk space for system book-keeping
 // when returning the quota to unlimited apps/extensions.
 // TODO(kinuko): This should be like 10% of the actual disk space.
 // For now we simply use a constant as getting the disk size needs
 // platform-dependent code. (http://crbug.com/178976)
-int64 QuotaManager::kMinimumPreserveForSystem = 1024 * kMBytes;
+int64_t QuotaManager::kMinimumPreserveForSystem = 1024 * kMBytes;
 
 const int QuotaManager::kEvictionIntervalInMilliSeconds =
     30 * kMinutesInMilliSeconds;
 
 const char QuotaManager::kTimeBetweenRepeatedOriginEvictionsHistogram[] =
     "Quota.TimeBetweenRepeatedOriginEvictions";
 const char QuotaManager::kEvictedOriginAccessedCountHistogram[] =
     "Quota.EvictedOriginAccessCount";
 const char QuotaManager::kEvictedOriginTimeSinceAccessHistogram[] =
     "Quota.EvictedOriginTimeSinceAccess";
 
 // Heuristics: assuming average cloud server allows a few Gigs storage
 // on the server side and the storage needs to be shared for user data
 // and by multiple apps.
-int64 QuotaManager::kSyncableStorageDefaultHostQuota = 500 * kMBytes;
+int64_t QuotaManager::kSyncableStorageDefaultHostQuota = 500 * kMBytes;
 
 namespace {
 
 void CountOriginType(const std::set<GURL>& origins,
                      SpecialStoragePolicy* policy,
                      size_t* protected_origins,
                      size_t* unlimited_origins) {
   DCHECK(protected_origins);
   DCHECK(unlimited_origins);
   *protected_origins = 0;
   *unlimited_origins = 0;
   if (!policy)
     return;
   for (std::set<GURL>::const_iterator itr = origins.begin();
        itr != origins.end();
        ++itr) {
     if (policy->IsStorageProtected(*itr))
       ++*protected_origins;
     if (policy->IsStorageUnlimited(*itr))
       ++*unlimited_origins;
   }
 }
 
-bool SetTemporaryGlobalOverrideQuotaOnDBThread(int64* new_quota,
+bool SetTemporaryGlobalOverrideQuotaOnDBThread(int64_t* new_quota,
                                                QuotaDatabase* database) {
   DCHECK(database);
   if (!database->SetQuotaConfigValue(
           QuotaDatabase::kTemporaryQuotaOverrideKey, *new_quota)) {
     *new_quota = -1;
     return false;
   }
   return true;
 }
 
 bool GetPersistentHostQuotaOnDBThread(const std::string& host,
-                                      int64* quota,
+                                      int64_t* quota,
                                       QuotaDatabase* database) {
   DCHECK(database);
   database->GetHostQuota(host, kStorageTypePersistent, quota);
   return true;
 }
 
 bool SetPersistentHostQuotaOnDBThread(const std::string& host,
-                                      int64* new_quota,
+                                      int64_t* new_quota,
                                       QuotaDatabase* database) {
   DCHECK(database);
   if (database->SetHostQuota(host, kStorageTypePersistent, *new_quota))
     return true;
   *new_quota = 0;
   return false;
 }
 
-bool InitializeOnDBThread(int64* temporary_quota_override,
-                          int64* desired_available_space,
+bool InitializeOnDBThread(int64_t* temporary_quota_override,
+                          int64_t* desired_available_space,
                           QuotaDatabase* database) {
   DCHECK(database);
   database->GetQuotaConfigValue(QuotaDatabase::kTemporaryQuotaOverrideKey,
                                 temporary_quota_override);
   database->GetQuotaConfigValue(QuotaDatabase::kDesiredAvailableSpaceKey,
                                 desired_available_space);
   return true;
 }
 
 bool GetLRUOriginOnDBThread(StorageType type,
@@ skipping 67 matching lines @@
 }
 
 bool UpdateModifiedTimeOnDBThread(const GURL& origin,
                                   StorageType type,
                                   base::Time modified_time,
                                   QuotaDatabase* database) {
   DCHECK(database);
   return database->SetOriginLastModifiedTime(origin, type, modified_time);
 }
 
-int64 CallSystemGetAmountOfFreeDiskSpace(const base::FilePath& profile_path) {
+int64_t CallSystemGetAmountOfFreeDiskSpace(const base::FilePath& profile_path) {
   // crbug.com/349708
   TRACE_EVENT0("io", "CallSystemGetAmountOfFreeDiskSpace");
 
   // Ensure the profile path exists.
   if (!base::CreateDirectory(profile_path)) {
     LOG(WARNING) << "Create directory failed for path" << profile_path.value();
     return 0;
   }
   return base::SysInfo::AmountOfFreeDiskSpace(profile_path);
 }
 
-int64 CalculateTemporaryGlobalQuota(int64 global_limited_usage,
-                                    int64 available_space) {
+int64_t CalculateTemporaryGlobalQuota(int64_t global_limited_usage,
+                                      int64_t available_space) {
   DCHECK_GE(global_limited_usage, 0);
-  int64 avail_space = available_space;
-  if (avail_space < kint64max - global_limited_usage) {
+  int64_t avail_space = available_space;
+  if (avail_space <
+      std::numeric_limits<int64_t>::max() - global_limited_usage) {
     // We basically calculate the temporary quota by
     // [available_space + space_used_for_temp] * kTempQuotaRatio,
     // but make sure we'll have no overflow.
     avail_space += global_limited_usage;
   }
   return avail_space * kTemporaryQuotaRatioToAvail;
 }
 
 void DispatchTemporaryGlobalQuotaCallback(
     const QuotaCallback& callback,
     QuotaStatusCode status,
     const UsageAndQuota& usage_and_quota) {
   if (status != kQuotaStatusOk) {
     callback.Run(status, 0);
     return;
   }
 
   callback.Run(status, CalculateTemporaryGlobalQuota(
       usage_and_quota.global_limited_usage,
       usage_and_quota.available_disk_space));
 }
 
-int64 CalculateQuotaWithDiskSpace(
-    int64 available_disk_space, int64 usage, int64 quota) {
+int64_t CalculateQuotaWithDiskSpace(int64_t available_disk_space,
+                                    int64_t usage,
+                                    int64_t quota) {
   if (available_disk_space < QuotaManager::kMinimumPreserveForSystem) {
     LOG(WARNING)
         << "Running out of disk space for profile."
         << " QuotaManager starts forbidding further quota consumption.";
     return usage;
   }
 
   if (quota < usage) {
     // No more space; cap the quota to the current usage.
     return usage;
   }
 
   available_disk_space -= QuotaManager::kMinimumPreserveForSystem;
   if (available_disk_space < quota - usage)
     return available_disk_space + usage;
 
   return quota;
 }
 
-int64 CalculateTemporaryHostQuota(int64 host_usage,
-                                  int64 global_quota,
-                                  int64 global_limited_usage) {
+int64_t CalculateTemporaryHostQuota(int64_t host_usage,
+                                    int64_t global_quota,
+                                    int64_t global_limited_usage) {
   DCHECK_GE(global_limited_usage, 0);
-  int64 host_quota = global_quota / QuotaManager::kPerHostTemporaryPortion;
+  int64_t host_quota = global_quota / QuotaManager::kPerHostTemporaryPortion;
   if (global_limited_usage > global_quota)
     host_quota = std::min(host_quota, host_usage);
   return host_quota;
 }
 
 void DispatchUsageAndQuotaForWebApps(
     StorageType type,
     bool is_incognito,
     bool is_unlimited,
     bool can_query_disk_size,
     const QuotaManager::GetUsageAndQuotaCallback& callback,
     QuotaStatusCode status,
     const UsageAndQuota& usage_and_quota) {
   if (status != kQuotaStatusOk) {
     callback.Run(status, 0, 0);
     return;
   }
 
-  int64 usage = usage_and_quota.usage;
-  int64 quota = usage_and_quota.quota;
+  int64_t usage = usage_and_quota.usage;
+  int64_t quota = usage_and_quota.quota;
 
   if (type == kStorageTypeTemporary && !is_unlimited) {
     quota = CalculateTemporaryHostQuota(
         usage, quota, usage_and_quota.global_limited_usage);
   }
 
   if (is_incognito) {
     quota = std::min(quota, QuotaManager::kIncognitoDefaultQuotaLimit);
     callback.Run(status, usage, quota);
     return;
@@ skipping 17 matching lines @@
 
 }  // namespace
 
 UsageAndQuota::UsageAndQuota()
     : usage(0),
       global_limited_usage(0),
       quota(0),
       available_disk_space(0) {
 }
 
-UsageAndQuota::UsageAndQuota(
-    int64 usage,
-    int64 global_limited_usage,
-    int64 quota,
-    int64 available_disk_space)
+UsageAndQuota::UsageAndQuota(int64_t usage,
+                             int64_t global_limited_usage,
+                             int64_t quota,
+                             int64_t available_disk_space)
     : usage(usage),
       global_limited_usage(global_limited_usage),
       quota(quota),
-      available_disk_space(available_disk_space) {
-}
+      available_disk_space(available_disk_space) {}
 
 class UsageAndQuotaCallbackDispatcher
     : public QuotaTask,
       public base::SupportsWeakPtr<UsageAndQuotaCallbackDispatcher> {
  public:
   explicit UsageAndQuotaCallbackDispatcher(QuotaManager* manager)
       : QuotaTask(manager),
         has_usage_(false),
         has_global_limited_usage_(false),
         has_quota_(false),
         has_available_disk_space_(false),
         status_(kQuotaStatusUnknown),
         usage_and_quota_(-1, -1, -1, -1),
         waiting_callbacks_(1) {}
 
   ~UsageAndQuotaCallbackDispatcher() override {}
 
   void WaitForResults(const QuotaManager::UsageAndQuotaCallback& callback) {
     callback_ = callback;
     Start();
   }
 
-  void set_usage(int64 usage) {
+  void set_usage(int64_t usage) {
     usage_and_quota_.usage = usage;
     has_usage_ = true;
   }
 
-  void set_global_limited_usage(int64 global_limited_usage) {
+  void set_global_limited_usage(int64_t global_limited_usage) {
     usage_and_quota_.global_limited_usage = global_limited_usage;
     has_global_limited_usage_ = true;
   }
 
-  void set_quota(int64 quota) {
+  void set_quota(int64_t quota) {
     usage_and_quota_.quota = quota;
     has_quota_ = true;
   }
 
-  void set_available_disk_space(int64 available_disk_space) {
+  void set_available_disk_space(int64_t available_disk_space) {
     usage_and_quota_.available_disk_space = available_disk_space;
     has_available_disk_space_ = true;
   }
 
   UsageCallback GetHostUsageCallback() {
     ++waiting_callbacks_;
     has_usage_ = true;
     return base::Bind(&UsageAndQuotaCallbackDispatcher::DidGetHostUsage,
                       AsWeakPtr());
   }
@@ skipping 14 matching lines @@
   }
 
   QuotaCallback GetAvailableSpaceCallback() {
     ++waiting_callbacks_;
     has_available_disk_space_ = true;
     return base::Bind(&UsageAndQuotaCallbackDispatcher::DidGetAvailableSpace,
                       AsWeakPtr());
   }
 
  private:
-  void DidGetHostUsage(int64 usage) {
+  void DidGetHostUsage(int64_t usage) {
     if (status_ == kQuotaStatusUnknown)
       status_ = kQuotaStatusOk;
     usage_and_quota_.usage = usage;
     CheckCompleted();
   }
 
-  void DidGetGlobalLimitedUsage(int64 limited_usage) {
+  void DidGetGlobalLimitedUsage(int64_t limited_usage) {
     if (status_ == kQuotaStatusUnknown)
       status_ = kQuotaStatusOk;
     usage_and_quota_.global_limited_usage = limited_usage;
     CheckCompleted();
   }
 
-  void DidGetQuota(QuotaStatusCode status, int64 quota) {
+  void DidGetQuota(QuotaStatusCode status, int64_t quota) {
     if (status_ == kQuotaStatusUnknown || status_ == kQuotaStatusOk)
       status_ = status;
     usage_and_quota_.quota = quota;
     CheckCompleted();
   }
 
-  void DidGetAvailableSpace(QuotaStatusCode status, int64 space) {
+  void DidGetAvailableSpace(QuotaStatusCode status, int64_t space) {
     // crbug.com/349708
     TRACE_EVENT0(
         "io", "UsageAndQuotaCallbackDispatcher::DidGetAvailableSpace");
 
     DCHECK_GE(space, 0);
     if (status_ == kQuotaStatusUnknown || status_ == kQuotaStatusOk)
       status_ = status;
     usage_and_quota_.available_disk_space = space;
     CheckCompleted();
   }
@@ skipping 83 matching lines @@
     DeleteSoon();
   }
 
   void Aborted() override {
     callback_.Run(UsageInfoEntries());
     DeleteSoon();
   }
 
  private:
   void AddEntries(StorageType type, UsageTracker* tracker) {
-    std::map<std::string, int64> host_usage;
+    std::map<std::string, int64_t> host_usage;
     tracker->GetCachedHostsUsage(&host_usage);
-    for (std::map<std::string, int64>::const_iterator iter = host_usage.begin();
-         iter != host_usage.end();
-         ++iter) {
+    for (std::map<std::string, int64_t>::const_iterator iter =
+             host_usage.begin();
+         iter != host_usage.end(); ++iter) {
       entries_.push_back(UsageInfo(iter->first, type, iter->second));
     }
     if (--remaining_trackers_ == 0)
       CallCompleted();
   }
 
-  void DidGetGlobalUsage(StorageType type, int64, int64) {
+  void DidGetGlobalUsage(StorageType type, int64_t, int64_t) {
     DCHECK(manager()->GetUsageTracker(type));
     AddEntries(type, manager()->GetUsageTracker(type));
   }
 
   QuotaManager* manager() const {
     return static_cast<QuotaManager*>(observer());
   }
 
   GetUsageInfoCallback callback_;
   UsageInfoEntries entries_;
@@ skipping 377 matching lines @@
   GetUsageAndQuotaForWebApps(origin, type, callback);
 }
 
 void QuotaManager::NotifyStorageAccessed(
     QuotaClient::ID client_id,
     const GURL& origin, StorageType type) {
   DCHECK(origin == origin.GetOrigin());
   NotifyStorageAccessedInternal(client_id, origin, type, base::Time::Now());
 }
 
-void QuotaManager::NotifyStorageModified(
-    QuotaClient::ID client_id,
-    const GURL& origin, StorageType type, int64 delta) {
+void QuotaManager::NotifyStorageModified(QuotaClient::ID client_id,
+                                         const GURL& origin,
+                                         StorageType type,
+                                         int64_t delta) {
   DCHECK(origin == origin.GetOrigin());
   NotifyStorageModifiedInternal(client_id, origin, type, delta,
                                 base::Time::Now());
 }
 
 void QuotaManager::NotifyOriginInUse(const GURL& origin) {
   DCHECK(io_thread_->BelongsToCurrentThread());
   origins_in_use_[origin]++;
 }
 
@@ skipping 72 matching lines @@
   UsageAndQuotaCallbackDispatcher* dispatcher =
       new UsageAndQuotaCallbackDispatcher(this);
   GetUsageTracker(kStorageTypeTemporary)->
       GetGlobalLimitedUsage(dispatcher->GetGlobalLimitedUsageCallback());
   GetAvailableSpace(dispatcher->GetAvailableSpaceCallback());
   dispatcher->WaitForResults(
       base::Bind(&DispatchTemporaryGlobalQuotaCallback, callback));
 }
 
 void QuotaManager::SetTemporaryGlobalOverrideQuota(
-    int64 new_quota, const QuotaCallback& callback) {
+    int64_t new_quota,
+    const QuotaCallback& callback) {
   LazyInitialize();
 
   if (new_quota < 0) {
     if (!callback.is_null())
       callback.Run(kQuotaErrorInvalidModification, -1);
     return;
   }
 
   if (db_disabled_) {
     if (!callback.is_null())
       callback.Run(kQuotaErrorInvalidAccess, -1);
     return;
   }
 
-  int64* new_quota_ptr = new int64(new_quota);
+  int64_t* new_quota_ptr = new int64_t(new_quota);
   PostTaskAndReplyWithResultForDBThread(
       FROM_HERE,
       base::Bind(&SetTemporaryGlobalOverrideQuotaOnDBThread,
                  base::Unretained(new_quota_ptr)),
       base::Bind(&QuotaManager::DidSetTemporaryGlobalOverrideQuota,
                  weak_factory_.GetWeakPtr(),
                  callback,
                  base::Owned(new_quota_ptr)));
 }
 
 void QuotaManager::GetPersistentHostQuota(const std::string& host,
                                           const QuotaCallback& callback) {
   LazyInitialize();
   if (host.empty()) {
     // This could happen if we are called on file:///.
     // TODO(kinuko) We may want to respect --allow-file-access-from-files
     // command line switch.
     callback.Run(kQuotaStatusOk, 0);
     return;
   }
 
   if (!persistent_host_quota_callbacks_.Add(host, callback))
     return;
 
-  int64* quota_ptr = new int64(0);
+  int64_t* quota_ptr = new int64_t(0);
   PostTaskAndReplyWithResultForDBThread(
       FROM_HERE,
       base::Bind(&GetPersistentHostQuotaOnDBThread,
                  host,
                  base::Unretained(quota_ptr)),
       base::Bind(&QuotaManager::DidGetPersistentHostQuota,
                  weak_factory_.GetWeakPtr(),
                  host,
                  base::Owned(quota_ptr)));
 }
 
 void QuotaManager::SetPersistentHostQuota(const std::string& host,
-                                          int64 new_quota,
+                                          int64_t new_quota,
                                           const QuotaCallback& callback) {
   LazyInitialize();
   if (host.empty()) {
     // This could happen if we are called on file:///.
     callback.Run(kQuotaErrorNotSupported, 0);
     return;
   }
 
   if (new_quota < 0) {
     callback.Run(kQuotaErrorInvalidModification, -1);
     return;
   }
 
   if (kPerHostPersistentQuotaLimit < new_quota) {
     // Cap the requested size at the per-host quota limit.
     new_quota = kPerHostPersistentQuotaLimit;
   }
 
   if (db_disabled_) {
     callback.Run(kQuotaErrorInvalidAccess, -1);
     return;
   }
 
-  int64* new_quota_ptr = new int64(new_quota);
+  int64_t* new_quota_ptr = new int64_t(new_quota);
   PostTaskAndReplyWithResultForDBThread(
       FROM_HERE,
       base::Bind(&SetPersistentHostQuotaOnDBThread,
                  host,
                  base::Unretained(new_quota_ptr)),
       base::Bind(&QuotaManager::DidSetPersistentHostQuota,
                  weak_factory_.GetWeakPtr(),
                  host,
                  callback,
                  base::Owned(new_quota_ptr)));
@@ skipping 32 matching lines @@
 bool QuotaManager::IsTrackingHostUsage(StorageType type,
                                        QuotaClient::ID client_id) const {
   UsageTracker* tracker = GetUsageTracker(type);
   return tracker && tracker->GetClientTracker(client_id);
 }
 
 void QuotaManager::GetStatistics(
     std::map<std::string, std::string>* statistics) {
   DCHECK(statistics);
   if (temporary_storage_evictor_) {
-    std::map<std::string, int64> stats;
+    std::map<std::string, int64_t> stats;
     temporary_storage_evictor_->GetStatistics(&stats);
-    for (std::map<std::string, int64>::iterator p = stats.begin();
-         p != stats.end();
-         ++p)
+    for (std::map<std::string, int64_t>::iterator p = stats.begin();
+         p != stats.end(); ++p) {
       (*statistics)[p->first] = base::Int64ToString(p->second);
+    }
   }
 }
 
 bool QuotaManager::IsStorageUnlimited(const GURL& origin,
                                       StorageType type) const {
   // For syncable storage we should always enforce quota (since the
   // quota must be capped by the server limit).
   if (type == kStorageTypeSyncable)
     return false;
   if (type == kStorageTypeQuotaNotManaged)
@@ skipping 92 matching lines @@
   temporary_usage_tracker_.reset(new UsageTracker(
       clients_, kStorageTypeTemporary, special_storage_policy_.get(),
       storage_monitor_.get()));
   persistent_usage_tracker_.reset(new UsageTracker(
       clients_, kStorageTypePersistent, special_storage_policy_.get(),
       storage_monitor_.get()));
   syncable_usage_tracker_.reset(new UsageTracker(
       clients_, kStorageTypeSyncable, special_storage_policy_.get(),
       storage_monitor_.get()));
 
-  int64* temporary_quota_override = new int64(-1);
-  int64* desired_available_space = new int64(-1);
+  int64_t* temporary_quota_override = new int64_t(-1);
+  int64_t* desired_available_space = new int64_t(-1);
   PostTaskAndReplyWithResultForDBThread(
       FROM_HERE,
       base::Bind(&InitializeOnDBThread,
                  base::Unretained(temporary_quota_override),
                  base::Unretained(desired_available_space)),
       base::Bind(&QuotaManager::DidInitialize,
                  weak_factory_.GetWeakPtr(),
                  base::Owned(temporary_quota_override),
                  base::Owned(desired_available_space)));
 }
@@ skipping 40 matching lines @@
 
   if (db_disabled_)
     return;
   PostTaskAndReplyWithResultForDBThread(
       FROM_HERE,
       base::Bind(&UpdateAccessTimeOnDBThread, origin, type, accessed_time),
       base::Bind(&QuotaManager::DidDatabaseWork,
                  weak_factory_.GetWeakPtr()));
 }
 
-void QuotaManager::NotifyStorageModifiedInternal(
-    QuotaClient::ID client_id,
-    const GURL& origin,
-    StorageType type,
-    int64 delta,
-    base::Time modified_time) {
+void QuotaManager::NotifyStorageModifiedInternal(QuotaClient::ID client_id,
+                                                 const GURL& origin,
+                                                 StorageType type,
+                                                 int64_t delta,
+                                                 base::Time modified_time) {
   LazyInitialize();
   DCHECK(GetUsageTracker(type));
   GetUsageTracker(type)->UpdateUsageCache(client_id, origin, delta);
 
   PostTaskAndReplyWithResultForDBThread(
       FROM_HERE,
       base::Bind(&UpdateModifiedTimeOnDBThread, origin, type, modified_time),
       base::Bind(&QuotaManager::DidDatabaseWork,
                  weak_factory_.GetWeakPtr()));
 }
@@ skipping 83 matching lines @@
                  base::Bind(
                      &QuotaManager::DidGetTemporaryGlobalUsageForHistogram,
                      weak_factory_.GetWeakPtr()));
   GetGlobalUsage(kStorageTypePersistent,
                  base::Bind(
                      &QuotaManager::DidGetPersistentGlobalUsageForHistogram,
                      weak_factory_.GetWeakPtr()));
 }
 
 void QuotaManager::DidGetTemporaryGlobalUsageForHistogram(
-    int64 usage,
-    int64 unlimited_usage) {
+    int64_t usage,
+    int64_t unlimited_usage) {
   UMA_HISTOGRAM_MBYTES("Quota.GlobalUsageOfTemporaryStorage", usage);
 
   std::set<GURL> origins;
   GetCachedOrigins(kStorageTypeTemporary, &origins);
 
   size_t num_origins = origins.size();
   size_t protected_origins = 0;
   size_t unlimited_origins = 0;
   CountOriginType(origins,
                   special_storage_policy_.get(),
                   &protected_origins,
                   &unlimited_origins);
 
   UMA_HISTOGRAM_COUNTS("Quota.NumberOfTemporaryStorageOrigins",
                        num_origins);
   UMA_HISTOGRAM_COUNTS("Quota.NumberOfProtectedTemporaryStorageOrigins",
                        protected_origins);
   UMA_HISTOGRAM_COUNTS("Quota.NumberOfUnlimitedTemporaryStorageOrigins",
                        unlimited_origins);
 }
 
 void QuotaManager::DidGetPersistentGlobalUsageForHistogram(
-    int64 usage,
-    int64 unlimited_usage) {
+    int64_t usage,
+    int64_t unlimited_usage) {
   UMA_HISTOGRAM_MBYTES("Quota.GlobalUsageOfPersistentStorage", usage);
 
   std::set<GURL> origins;
   GetCachedOrigins(kStorageTypePersistent, &origins);
 
   size_t num_origins = origins.size();
   size_t protected_origins = 0;
   size_t unlimited_origins = 0;
   CountOriginType(origins,
                   special_storage_policy_.get(),
@@ skipping 34 matching lines @@
   } else {
     callback.Run(origin);
   }
   access_notified_origins_.clear();
 
   is_getting_eviction_origin_ = false;
 }
 
 void QuotaManager::GetEvictionOrigin(StorageType type,
                                      const std::set<GURL>& extra_exceptions,
-                                     int64 global_quota,
+                                     int64_t global_quota,
                                      const GetOriginCallback& callback) {
   LazyInitialize();
   // This must not be called while there's an in-flight task.
   DCHECK(!is_getting_eviction_origin_);
   is_getting_eviction_origin_ = true;
 
   GetOriginCallback did_get_origin_callback =
       base::Bind(&QuotaManager::DidGetEvictionOrigin,
                  weak_factory_.GetWeakPtr(), callback);
 
   if (type == kStorageTypeTemporary && temporary_storage_eviction_policy_) {
-    std::map<GURL, int64> usage_map;
+    std::map<GURL, int64_t> usage_map;
     // The cached origins are populated by the prior call to
     // GetUsageAndQuotaForEviction().
     GetUsageTracker(kStorageTypeTemporary)->GetCachedOriginsUsage(&usage_map);
 
     temporary_storage_eviction_policy_->GetEvictionOrigin(
         special_storage_policy_, GetEvictionOriginExceptions(extra_exceptions),
         usage_map, global_quota, did_get_origin_callback);
 
     return;
   }
@@ skipping 50 matching lines @@
   PostTaskAndReplyWithResultForDBThread(
       FROM_HERE, base::Bind(&GetLRUOriginOnDBThread, type,
                             GetEvictionOriginExceptions(std::set<GURL>()),
                             special_storage_policy_, base::Unretained(url)),
       base::Bind(&QuotaManager::DidGetLRUOrigin, weak_factory_.GetWeakPtr(),
                  base::Owned(url)));
 }
 
 void QuotaManager::DidSetTemporaryGlobalOverrideQuota(
     const QuotaCallback& callback,
-    const int64* new_quota,
+    const int64_t* new_quota,
     bool success) {
   QuotaStatusCode status = kQuotaErrorInvalidAccess;
   DidDatabaseWork(success);
   if (success) {
     temporary_quota_override_ = *new_quota;
     status = kQuotaStatusOk;
   }
 
   if (callback.is_null())
     return;
 
   callback.Run(status, *new_quota);
 }
 
 void QuotaManager::DidGetPersistentHostQuota(const std::string& host,
-                                             const int64* quota,
+                                             const int64_t* quota,
                                              bool success) {
   DidDatabaseWork(success);
   persistent_host_quota_callbacks_.Run(host, kQuotaStatusOk, *quota);
 }
 
 void QuotaManager::DidSetPersistentHostQuota(const std::string& host,
                                              const QuotaCallback& callback,
-                                             const int64* new_quota,
+                                             const int64_t* new_quota,
                                              bool success) {
   DidDatabaseWork(success);
   callback.Run(success ? kQuotaStatusOk : kQuotaErrorInvalidAccess, *new_quota);
 }
 
-void QuotaManager::DidInitialize(int64* temporary_quota_override,
-                                 int64* desired_available_space,
+void QuotaManager::DidInitialize(int64_t* temporary_quota_override,
+                                 int64_t* desired_available_space,
                                  bool success) {
   temporary_quota_override_ = *temporary_quota_override;
   desired_available_space_ = *desired_available_space;
   temporary_quota_initialized_ = true;
   DidDatabaseWork(success);
 
   histogram_timer_.Start(FROM_HERE,
                          base::TimeDelta::FromMilliseconds(
                              kReportHistogramInterval),
                          this, &QuotaManager::ReportHistogram);
 
   db_initialization_callbacks_.Run();
   GetTemporaryGlobalQuota(
       base::Bind(&QuotaManager::DidGetInitialTemporaryGlobalQuota,
                  weak_factory_.GetWeakPtr()));
 }
 
 void QuotaManager::DidGetLRUOrigin(const GURL* origin,
                                    bool success) {
   DidDatabaseWork(success);
 
   lru_origin_callback_.Run(*origin);
   lru_origin_callback_.Reset();
 }
 
-void QuotaManager::DidGetInitialTemporaryGlobalQuota(
-    QuotaStatusCode status, int64 quota_unused) {
+void QuotaManager::DidGetInitialTemporaryGlobalQuota(QuotaStatusCode status,
+                                                     int64_t quota_unused) {
   if (eviction_disabled_)
     return;
 
   std::set<GURL>* origins = new std::set<GURL>;
   temporary_usage_tracker_->GetCachedOrigins(origins);
   // This will call the StartEviction() when initial origin registration
   // is completed.
   PostTaskAndReplyWithResultForDBThread(
       FROM_HERE,
       base::Bind(&InitializeTemporaryOriginsInfoOnDBThread,
                  base::Owned(origins)),
       base::Bind(&QuotaManager::DidInitializeTemporaryOriginsInfo,
                  weak_factory_.GetWeakPtr()));
 }
 
 void QuotaManager::DidInitializeTemporaryOriginsInfo(bool success) {
   DidDatabaseWork(success);
   if (success)
     StartEviction();
 }
 
-void QuotaManager::DidGetAvailableSpace(int64 space) {
+void QuotaManager::DidGetAvailableSpace(int64_t space) {
   // crbug.com/349708
   TRACE_EVENT1("io", "QuotaManager::DidGetAvailableSpace",
                "n_callbacks", available_space_callbacks_.size());
 
   available_space_callbacks_.Run(kQuotaStatusOk, space);
 }
 
 void QuotaManager::DidDatabaseWork(bool success) {
   db_disabled_ = !success;
 }
@@ skipping 14 matching lines @@
   // |database_|, therefore we can be sure that database_ is alive when this
   // task runs.
   base::PostTaskAndReplyWithResult(
       db_thread_.get(),
       from_here,
       base::Bind(task, base::Unretained(database_.get())),
       reply);
 }
 
 }  // namespace storage