Remove kint64max.

content/browser/appcache/appcache_storage_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/appcache/appcache_storage_impl.h"
 
 #include <algorithm>
 #include <functional>
+#include <limits>
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 24 matching lines @@
 static const int kDefaultQuota = 5 * 1024 * 1024;
 
 static const int kMaxDiskCacheSize = 250 * 1024 * 1024;
 static const int kMaxMemDiskCacheSize = 10 * 1024 * 1024;
 static const base::FilePath::CharType kDiskCacheDirectoryName[] =
     FILE_PATH_LITERAL("Cache");
 
 namespace {
 
 // Helpers for clearing data from the AppCacheDatabase.
-bool DeleteGroupAndRelatedRecords(AppCacheDatabase* database,
-                                  int64 group_id,
-                                  std::vector<int64>* deletable_response_ids) {
+bool DeleteGroupAndRelatedRecords(
+    AppCacheDatabase* database,
+    int64_t group_id,
+    std::vector<int64_t>* deletable_response_ids) {
   AppCacheDatabase::CacheRecord cache_record;
   bool success = false;
   if (database->FindCacheForGroup(group_id, &cache_record)) {
     database->FindResponseIdsForCacheAsVector(cache_record.cache_id,
                                               deletable_response_ids);
     success =
         database->DeleteGroup(group_id) &&
         database->DeleteCache(cache_record.cache_id) &&
         database->DeleteEntriesForCache(cache_record.cache_id) &&
         database->DeleteNamespacesForCache(cache_record.cache_id) &&
@@ skipping 47 matching lines @@
 
     std::vector<AppCacheDatabase::GroupRecord> groups;
     database->FindGroupsForOrigin(*origin, &groups);
     std::vector<AppCacheDatabase::GroupRecord>::const_iterator group;
     for (group = groups.begin(); group != groups.end(); ++group) {
       sql::Transaction transaction(connection);
       if (!transaction.Begin()) {
         NOTREACHED() << "Failed to start transaction";
         return;
       }
-      std::vector<int64> deletable_response_ids;
+      std::vector<int64_t> deletable_response_ids;
       bool success = DeleteGroupAndRelatedRecords(database,
                                                   group->group_id,
                                                   &deletable_response_ids);
       success = success && transaction.Commit();
       DCHECK(success);
     }  // for each group
   }  // for each origin
 }
 
 }  // namespace
@@ skipping 140 matching lines @@
   // DatabaseTask:
   void Run() override;
   void RunCompleted() override;
 
  protected:
   ~InitTask() override {}
 
  private:
   base::FilePath db_file_path_;
   base::FilePath disk_cache_directory_;
-  int64 last_group_id_;
-  int64 last_cache_id_;
-  int64 last_response_id_;
-  int64 last_deletable_response_rowid_;
-  std::map<GURL, int64> usage_map_;
+  int64_t last_group_id_;
+  int64_t last_cache_id_;
+  int64_t last_response_id_;
+  int64_t last_deletable_response_rowid_;
+  std::map<GURL, int64_t> usage_map_;
 };
 
 void AppCacheStorageImpl::InitTask::Run() {
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION("AppCacheStorageImpl::InitTask"));
   // If there is no sql database, ensure there is no disk cache either.
   if (!db_file_path_.empty() &&
       !base::PathExists(db_file_path_) &&
       base::DirectoryExists(disk_cache_directory_)) {
     base::DeleteFile(disk_cache_directory_, true);
@@ skipping 97 matching lines @@
 }
 
 // StoreOrLoadTask -------
 
 class AppCacheStorageImpl::StoreOrLoadTask : public DatabaseTask {
  protected:
   explicit StoreOrLoadTask(AppCacheStorageImpl* storage)
       : DatabaseTask(storage) {}
   ~StoreOrLoadTask() override {}
 
-  bool FindRelatedCacheRecords(int64 cache_id);
+  bool FindRelatedCacheRecords(int64_t cache_id);
   void CreateCacheAndGroupFromRecords(
       scoped_refptr<AppCache>* cache, scoped_refptr<AppCacheGroup>* group);
 
   AppCacheDatabase::GroupRecord group_record_;
   AppCacheDatabase::CacheRecord cache_record_;
   std::vector<AppCacheDatabase::EntryRecord> entry_records_;
   std::vector<AppCacheDatabase::NamespaceRecord>
       intercept_namespace_records_;
   std::vector<AppCacheDatabase::NamespaceRecord>
       fallback_namespace_records_;
   std::vector<AppCacheDatabase::OnlineWhiteListRecord>
       online_whitelist_records_;
 };
 
 bool AppCacheStorageImpl::StoreOrLoadTask::FindRelatedCacheRecords(
-    int64 cache_id) {
+    int64_t cache_id) {
   return database_->FindEntriesForCache(cache_id, &entry_records_) &&
          database_->FindNamespacesForCache(
              cache_id, &intercept_namespace_records_,
              &fallback_namespace_records_) &&
          database_->FindOnlineWhiteListForCache(
              cache_id, &online_whitelist_records_);
 }
 
 void AppCacheStorageImpl::StoreOrLoadTask::CreateCacheAndGroupFromRecords(
     scoped_refptr<AppCache>* cache, scoped_refptr<AppCacheGroup>* group) {
@@ skipping 65 matching lines @@
   storage_->NotifyStorageAccessed(group_record_.origin);
 
   // TODO(michaeln): Maybe verify that the responses we expect to exist
   // do actually exist in the disk_cache (and if not then what?)
 }
 
 // CacheLoadTask -------
 
 class AppCacheStorageImpl::CacheLoadTask : public StoreOrLoadTask {
  public:
-  CacheLoadTask(int64 cache_id, AppCacheStorageImpl* storage)
-      : StoreOrLoadTask(storage), cache_id_(cache_id),
-        success_(false) {}
+  CacheLoadTask(int64_t cache_id, AppCacheStorageImpl* storage)
+      : StoreOrLoadTask(storage), cache_id_(cache_id), success_(false) {}
 
   // DatabaseTask:
   void Run() override;
   void RunCompleted() override;
 
  protected:
   ~CacheLoadTask() override {}
 
  private:
-  int64 cache_id_;
+  int64_t cache_id_;
   bool success_;
 };
 
 void AppCacheStorageImpl::CacheLoadTask::Run() {
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION("AppCacheStorageImpl::CacheLoadTask"));
   success_ =
       database_->FindCache(cache_id_, &cache_record_) &&
       database_->FindGroup(cache_record_.group_id, &group_record_) &&
       FindRelatedCacheRecords(cache_id_);
@@ skipping 70 matching lines @@
 
 // StoreGroupAndCacheTask -------
 
 class AppCacheStorageImpl::StoreGroupAndCacheTask : public StoreOrLoadTask {
  public:
   StoreGroupAndCacheTask(AppCacheStorageImpl* storage, AppCacheGroup* group,
                          AppCache* newest_cache);
 
   void GetQuotaThenSchedule();
   void OnQuotaCallback(storage::QuotaStatusCode status,
-                       int64 usage,
-                       int64 quota);
+                       int64_t usage,
+                       int64_t quota);
 
   // DatabaseTask:
   void Run() override;
   void RunCompleted() override;
   void CancelCompletion() override;
 
  protected:
   ~StoreGroupAndCacheTask() override {}
 
  private:
   scoped_refptr<AppCacheGroup> group_;
   scoped_refptr<AppCache> cache_;
   bool success_;
   bool would_exceed_quota_;
-  int64 space_available_;
-  int64 new_origin_usage_;
-  std::vector<int64> newly_deletable_response_ids_;
+  int64_t space_available_;
+  int64_t new_origin_usage_;
+  std::vector<int64_t> newly_deletable_response_ids_;
 };
 
 AppCacheStorageImpl::StoreGroupAndCacheTask::StoreGroupAndCacheTask(
     AppCacheStorageImpl* storage, AppCacheGroup* group, AppCache* newest_cache)
     : StoreOrLoadTask(storage), group_(group), cache_(newest_cache),
       success_(false), would_exceed_quota_(false),
       space_available_(-1), new_origin_usage_(-1) {
   group_record_.group_id = group->group_id();
   group_record_.manifest_url = group->manifest_url();
   group_record_.origin = group_record_.manifest_url.GetOrigin();
@@ skipping 13 matching lines @@
   storage::QuotaManager* quota_manager = NULL;
   if (storage_->service()->quota_manager_proxy()) {
     quota_manager =
         storage_->service()->quota_manager_proxy()->quota_manager();
   }
 
   if (!quota_manager) {
     if (storage_->service()->special_storage_policy() &&
         storage_->service()->special_storage_policy()->IsStorageUnlimited(
             group_record_.origin))
-      space_available_ = kint64max;
+      space_available_ = std::numeric_limits<int64_t>::max();
     Schedule();
     return;
   }
 
   // crbug.com/349708
   TRACE_EVENT0(
       "io",
       "AppCacheStorageImpl::StoreGroupAndCacheTask::GetQuotaThenSchedule");
 
   // We have to ask the quota manager for the value.
   storage_->pending_quota_queries_.insert(this);
   quota_manager->GetUsageAndQuota(
       group_record_.origin,
       storage::kStorageTypeTemporary,
       base::Bind(&StoreGroupAndCacheTask::OnQuotaCallback, this));
 }
 
 void AppCacheStorageImpl::StoreGroupAndCacheTask::OnQuotaCallback(
     storage::QuotaStatusCode status,
-    int64 usage,
-    int64 quota) {
+    int64_t usage,
+    int64_t quota) {
   if (storage_) {
     if (status == storage::kQuotaStatusOk)
-      space_available_ = std::max(static_cast<int64>(0), quota - usage);
+      space_available_ = std::max(static_cast<int64_t>(0), quota - usage);
     else
       space_available_ = 0;
     storage_->pending_quota_queries_.erase(this);
     Schedule();
   }
 }
 
 void AppCacheStorageImpl::StoreGroupAndCacheTask::Run() {
   DCHECK(!success_);
   sql::Connection* connection = database_->db_connection();
   if (!connection)
     return;
 
   sql::Transaction transaction(connection);
   if (!transaction.Begin())
     return;
 
-  int64 old_origin_usage = database_->GetOriginUsage(group_record_.origin);
+  int64_t old_origin_usage = database_->GetOriginUsage(group_record_.origin);
 
   AppCacheDatabase::GroupRecord existing_group;
   success_ = database_->FindGroup(group_record_.group_id, &existing_group);
   if (!success_) {
     group_record_.creation_time = base::Time::Now();
     group_record_.last_access_time = base::Time::Now();
     success_ = database_->InsertGroup(&group_record_);
   } else {
     DCHECK(group_record_.group_id == existing_group.group_id);
     DCHECK(group_record_.manifest_url == existing_group.manifest_url);
     DCHECK(group_record_.origin == existing_group.origin);
 
     database_->UpdateLastAccessTime(group_record_.group_id,
                                     base::Time::Now());
 
     database_->UpdateEvictionTimes(
         group_record_.group_id,
         group_record_.last_full_update_check_time,
         group_record_.first_evictable_error_time);
 
     AppCacheDatabase::CacheRecord cache;
     if (database_->FindCacheForGroup(group_record_.group_id, &cache)) {
       // Get the set of response ids in the old cache.
-      std::set<int64> existing_response_ids;
+      std::set<int64_t> existing_response_ids;
       database_->FindResponseIdsForCacheAsSet(cache.cache_id,
                                               &existing_response_ids);
 
       // Remove those that remain in the new cache.
       std::vector<AppCacheDatabase::EntryRecord>::const_iterator entry_iter =
           entry_records_.begin();
       while (entry_iter != entry_records_.end()) {
         existing_response_ids.erase(entry_iter->response_id);
         ++entry_iter;
       }
 
       // The rest are deletable.
-      std::set<int64>::const_iterator id_iter = existing_response_ids.begin();
+      std::set<int64_t>::const_iterator id_iter = existing_response_ids.begin();
       while (id_iter != existing_response_ids.end()) {
         newly_deletable_response_ids_.push_back(*id_iter);
         ++id_iter;
       }
 
       success_ =
           database_->DeleteCache(cache.cache_id) &&
           database_->DeleteEntriesForCache(cache.cache_id) &&
           database_->DeleteNamespacesForCache(cache.cache_id) &&
           database_->DeleteOnlineWhiteListForCache(cache.cache_id) &&
@@ skipping 29 matching lines @@
       would_exceed_quota_ = true;
       success_ = false;
       return;
     }
     success_ = transaction.Commit();
     return;
   }
 
   // Check limits based on the space availbable given to us via the
   // quota system.
-  int64 delta = new_origin_usage_ - old_origin_usage;
+  int64_t delta = new_origin_usage_ - old_origin_usage;
   if (delta > space_available_) {
     would_exceed_quota_ = true;
     success_ = false;
     return;
   }
 
   success_ = transaction.Commit();
 }
 
 void AppCacheStorageImpl::StoreGroupAndCacheTask::RunCompleted() {
@@ skipping 30 matching lines @@
 // FindMainResponseTask -------
 
 // Helpers for FindMainResponseTask::Run()
 namespace {
 class SortByCachePreference
     : public std::binary_function<
         AppCacheDatabase::EntryRecord,
         AppCacheDatabase::EntryRecord,
         bool> {
  public:
-  SortByCachePreference(int64 preferred_id, const std::set<int64>& in_use_ids)
-      : preferred_id_(preferred_id), in_use_ids_(in_use_ids) {
-  }
+  SortByCachePreference(int64_t preferred_id,
+                        const std::set<int64_t>& in_use_ids)
+      : preferred_id_(preferred_id), in_use_ids_(in_use_ids) {}
   bool operator()(
       const AppCacheDatabase::EntryRecord& lhs,
       const AppCacheDatabase::EntryRecord& rhs) {
     return compute_value(lhs) > compute_value(rhs);
   }
  private:
   int compute_value(const AppCacheDatabase::EntryRecord& entry) {
     if (entry.cache_id == preferred_id_)
       return 100;
     else if (in_use_ids_.find(entry.cache_id) != in_use_ids_.end())
       return 50;
     return 0;
   }
-  int64 preferred_id_;
-  const std::set<int64>& in_use_ids_;
+  int64_t preferred_id_;
+  const std::set<int64_t>& in_use_ids_;
 };
 
 bool SortByLength(
     const AppCacheDatabase::NamespaceRecord& lhs,
     const AppCacheDatabase::NamespaceRecord& rhs) {
   return lhs.namespace_.namespace_url.spec().length() >
          rhs.namespace_.namespace_url.spec().length();
 }
 
 class NetworkNamespaceHelper {
  public:
   explicit NetworkNamespaceHelper(AppCacheDatabase* database)
       : database_(database) {
   }
 
-  bool IsInNetworkNamespace(const GURL& url, int64 cache_id) {
+  bool IsInNetworkNamespace(const GURL& url, int64_t cache_id) {
     typedef std::pair<WhiteListMap::iterator, bool> InsertResult;
     InsertResult result = namespaces_map_.insert(
         WhiteListMap::value_type(cache_id, AppCacheNamespaceVector()));
     if (result.second)
       GetOnlineWhiteListForCache(cache_id, &result.first->second);
     return AppCache::FindNamespace(result.first->second, url) != NULL;
   }
 
  private:
-  void GetOnlineWhiteListForCache(
-      int64 cache_id, AppCacheNamespaceVector* namespaces) {
+  void GetOnlineWhiteListForCache(int64_t cache_id,
+                                  AppCacheNamespaceVector* namespaces) {
     DCHECK(namespaces && namespaces->empty());
     typedef std::vector<AppCacheDatabase::OnlineWhiteListRecord>
         WhiteListVector;
     WhiteListVector records;
     if (!database_->FindOnlineWhiteListForCache(cache_id, &records))
       return;
     WhiteListVector::const_iterator iter = records.begin();
     while (iter != records.end()) {
       namespaces->push_back(
             AppCacheNamespace(APPCACHE_NETWORK_NAMESPACE, iter->namespace_url,
                 GURL(), iter->is_pattern));
       ++iter;
     }
   }
 
   // Key is cache id
-  typedef std::map<int64, AppCacheNamespaceVector> WhiteListMap;
+  typedef std::map<int64_t, AppCacheNamespaceVector> WhiteListMap;
   WhiteListMap namespaces_map_;
   AppCacheDatabase* database_;
 };
 
 }  // namespace
 
 class AppCacheStorageImpl::FindMainResponseTask : public DatabaseTask {
  public:
   FindMainResponseTask(AppCacheStorageImpl* storage,
                        const GURL& url,
@@ skipping 19 matching lines @@
   void Run() override;
   void RunCompleted() override;
 
  protected:
   ~FindMainResponseTask() override {}
 
  private:
   typedef std::vector<AppCacheDatabase::NamespaceRecord*>
       NamespaceRecordPtrVector;
 
-  bool FindExactMatch(int64 preferred_id);
-  bool FindNamespaceMatch(int64 preferred_id);
-  bool FindNamespaceHelper(
-      int64 preferred_cache_id,
-      AppCacheDatabase::NamespaceRecordVector* namespaces,
-      NetworkNamespaceHelper* network_namespace_helper);
+  bool FindExactMatch(int64_t preferred_id);
+  bool FindNamespaceMatch(int64_t preferred_id);
+  bool FindNamespaceHelper(int64_t preferred_cache_id,
+                           AppCacheDatabase::NamespaceRecordVector* namespaces,
+                           NetworkNamespaceHelper* network_namespace_helper);
   bool FindFirstValidNamespace(const NamespaceRecordPtrVector& namespaces);
 
   GURL url_;
   GURL preferred_manifest_url_;
-  std::set<int64> cache_ids_in_use_;
+  std::set<int64_t> cache_ids_in_use_;
   AppCacheEntry entry_;
   AppCacheEntry fallback_entry_;
   GURL namespace_entry_url_;
-  int64 cache_id_;
-  int64 group_id_;
+  int64_t cache_id_;
+  int64_t group_id_;
   GURL manifest_url_;
 };
 
 void AppCacheStorageImpl::FindMainResponseTask::Run() {
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "AppCacheStorageImpl::FindMainResponseTask"));
   // NOTE: The heuristics around choosing amoungst multiple candidates
   // is underspecified, and just plain not fully understood. This needs
   // to be refined.
 
   // The 'preferred_manifest_url' is the url of the manifest associated
   // with the page that opened or embedded the page being loaded now.
   // We have a strong preference to use resources from that cache.
   // We also have a lesser bias to use resources from caches that are currently
   // being used by other unrelated pages.
   // TODO(michaeln): come up with a 'preferred_manifest_url' in more cases
   // - when navigating a frame whose current contents are from an appcache
   // - when clicking an href in a frame that is appcached
-  int64 preferred_cache_id = kAppCacheNoCacheId;
+  int64_t preferred_cache_id = kAppCacheNoCacheId;
   if (!preferred_manifest_url_.is_empty()) {
     AppCacheDatabase::GroupRecord preferred_group;
     AppCacheDatabase::CacheRecord preferred_cache;
     if (database_->FindGroupForManifestUrl(
             preferred_manifest_url_, &preferred_group) &&
         database_->FindCacheForGroup(
             preferred_group.group_id, &preferred_cache)) {
       preferred_cache_id = preferred_cache.cache_id;
     }
   }
 
   if (FindExactMatch(preferred_cache_id) ||
       FindNamespaceMatch(preferred_cache_id)) {
     // We found something.
     DCHECK(cache_id_ != kAppCacheNoCacheId && !manifest_url_.is_empty() &&
            group_id_ != 0);
     return;
   }
 
   // We didn't find anything.
   DCHECK(cache_id_ == kAppCacheNoCacheId && manifest_url_.is_empty() &&
          group_id_ == 0);
 }
 
-bool AppCacheStorageImpl::
-FindMainResponseTask::FindExactMatch(int64 preferred_cache_id) {
+bool AppCacheStorageImpl::FindMainResponseTask::FindExactMatch(
+    int64_t preferred_cache_id) {
   std::vector<AppCacheDatabase::EntryRecord> entries;
   if (database_->FindEntriesForUrl(url_, &entries) && !entries.empty()) {
     // Sort them in order of preference, from the preferred_cache first,
     // followed by hits from caches that are 'in use', then the rest.
     std::sort(entries.begin(), entries.end(),
               SortByCachePreference(preferred_cache_id, cache_ids_in_use_));
 
     // Take the first with a valid, non-foreign entry.
     std::vector<AppCacheDatabase::EntryRecord>::iterator iter;
     for (iter = entries.begin(); iter < entries.end(); ++iter) {
       AppCacheDatabase::GroupRecord group_record;
       if ((iter->flags & AppCacheEntry::FOREIGN) ||
           !database_->FindGroupForCache(iter->cache_id, &group_record)) {
         continue;
       }
       manifest_url_ = group_record.manifest_url;
       group_id_ = group_record.group_id;
       entry_ = AppCacheEntry(iter->flags, iter->response_id);
       cache_id_ = iter->cache_id;
       return true;  // We found an exact match.
     }
   }
   return false;
 }
 
-bool AppCacheStorageImpl::
-FindMainResponseTask::FindNamespaceMatch(int64 preferred_cache_id) {
+bool AppCacheStorageImpl::FindMainResponseTask::FindNamespaceMatch(
+    int64_t preferred_cache_id) {
   AppCacheDatabase::NamespaceRecordVector all_intercepts;
   AppCacheDatabase::NamespaceRecordVector all_fallbacks;
   if (!database_->FindNamespacesForOrigin(
           url_.GetOrigin(), &all_intercepts, &all_fallbacks)
       || (all_intercepts.empty() && all_fallbacks.empty())) {
     return false;
   }
 
   NetworkNamespaceHelper network_namespace_helper(database_);
   if (FindNamespaceHelper(preferred_cache_id,
                           &all_intercepts,
                           &network_namespace_helper) ||
       FindNamespaceHelper(preferred_cache_id,
                           &all_fallbacks,
                           &network_namespace_helper)) {
     return true;
   }
   return false;
 }
 
-bool AppCacheStorageImpl::
-FindMainResponseTask::FindNamespaceHelper(
-    int64 preferred_cache_id,
+bool AppCacheStorageImpl::FindMainResponseTask::FindNamespaceHelper(
+    int64_t preferred_cache_id,
     AppCacheDatabase::NamespaceRecordVector* namespaces,
     NetworkNamespaceHelper* network_namespace_helper) {
   // Sort them by length, longer matches within the same cache/bucket take
   // precedence.
   std::sort(namespaces->begin(), namespaces->end(), SortByLength);
 
   NamespaceRecordPtrVector preferred_namespaces;
   NamespaceRecordPtrVector inuse_namespaces;
   NamespaceRecordPtrVector other_namespaces;
   std::vector<AppCacheDatabase::NamespaceRecord>::iterator iter;
@@ skipping 57 matching lines @@
 void AppCacheStorageImpl::FindMainResponseTask::RunCompleted() {
   storage_->CallOnMainResponseFound(
       &delegates_, url_, entry_, namespace_entry_url_, fallback_entry_,
       cache_id_, group_id_, manifest_url_);
 }
 
 // MarkEntryAsForeignTask -------
 
 class AppCacheStorageImpl::MarkEntryAsForeignTask : public DatabaseTask {
  public:
-  MarkEntryAsForeignTask(
-      AppCacheStorageImpl* storage, const GURL& url, int64 cache_id)
+  MarkEntryAsForeignTask(AppCacheStorageImpl* storage,
+                         const GURL& url,
+                         int64_t cache_id)
       : DatabaseTask(storage), cache_id_(cache_id), entry_url_(url) {}
 
   // DatabaseTask:
   void Run() override;
   void RunCompleted() override;
 
  protected:
   ~MarkEntryAsForeignTask() override {}
 
  private:
-  int64 cache_id_;
+  int64_t cache_id_;
   GURL entry_url_;
 };
 
 void AppCacheStorageImpl::MarkEntryAsForeignTask::Run() {
   database_->AddEntryFlags(entry_url_, cache_id_, AppCacheEntry::FOREIGN);
 }
 
 void AppCacheStorageImpl::MarkEntryAsForeignTask::RunCompleted() {
   DCHECK(storage_->pending_foreign_markings_.front().first == entry_url_ &&
          storage_->pending_foreign_markings_.front().second == cache_id_);
@@ skipping 11 matching lines @@
   // DatabaseTask:
   void Run() override;
   void RunCompleted() override;
   void CancelCompletion() override;
 
  protected:
   ~MakeGroupObsoleteTask() override {}
 
  private:
   scoped_refptr<AppCacheGroup> group_;
-  int64 group_id_;
+  int64_t group_id_;
   GURL origin_;
   bool success_;
   int response_code_;
-  int64 new_origin_usage_;
-  std::vector<int64> newly_deletable_response_ids_;
+  int64_t new_origin_usage_;
+  std::vector<int64_t> newly_deletable_response_ids_;
 };
 
 AppCacheStorageImpl::MakeGroupObsoleteTask::MakeGroupObsoleteTask(
     AppCacheStorageImpl* storage,
     AppCacheGroup* group,
     int response_code)
     : DatabaseTask(storage),
       group_(group),
       group_id_(group->group_id()),
       origin_(group->manifest_url().GetOrigin()),
@@ skipping 50 matching lines @@
   // Overriden to safely drop our reference to the group
   // which is not thread safe refcounted.
   DatabaseTask::CancelCompletion();
   group_ = NULL;
 }
 
 // GetDeletableResponseIdsTask -------
 
 class AppCacheStorageImpl::GetDeletableResponseIdsTask : public DatabaseTask {
  public:
-  GetDeletableResponseIdsTask(AppCacheStorageImpl* storage, int64 max_rowid)
+  GetDeletableResponseIdsTask(AppCacheStorageImpl* storage, int64_t max_rowid)
       : DatabaseTask(storage), max_rowid_(max_rowid) {}
 
   // DatabaseTask:
   void Run() override;
   void RunCompleted() override;
 
  protected:
   ~GetDeletableResponseIdsTask() override {}
 
  private:
-  int64 max_rowid_;
-  std::vector<int64> response_ids_;
+  int64_t max_rowid_;
+  std::vector<int64_t> response_ids_;
 };
 
 void AppCacheStorageImpl::GetDeletableResponseIdsTask::Run() {
   const int kSqlLimit = 1000;
   database_->GetDeletableResponseIds(&response_ids_, max_rowid_, kSqlLimit);
   // TODO(michaeln): retrieve group_ids too
 }
 
 void AppCacheStorageImpl::GetDeletableResponseIdsTask::RunCompleted() {
   if (!response_ids_.empty())
     storage_->StartDeletingResponses(response_ids_);
 }
 
 // InsertDeletableResponseIdsTask -------
 
 class AppCacheStorageImpl::InsertDeletableResponseIdsTask
     : public DatabaseTask {
  public:
   explicit InsertDeletableResponseIdsTask(AppCacheStorageImpl* storage)
       : DatabaseTask(storage) {}
 
   // DatabaseTask:
   void Run() override;
 
-  std::vector<int64> response_ids_;
+  std::vector<int64_t> response_ids_;
 
  protected:
   ~InsertDeletableResponseIdsTask() override {}
 };
 
 void AppCacheStorageImpl::InsertDeletableResponseIdsTask::Run() {
   database_->InsertDeletableResponseIds(response_ids_);
   // TODO(michaeln): store group_ids too
 }
 
 // DeleteDeletableResponseIdsTask -------
 
 class AppCacheStorageImpl::DeleteDeletableResponseIdsTask
     : public DatabaseTask {
  public:
   explicit DeleteDeletableResponseIdsTask(AppCacheStorageImpl* storage)
       : DatabaseTask(storage) {}
 
   // DatabaseTask:
   void Run() override;
 
-  std::vector<int64> response_ids_;
+  std::vector<int64_t> response_ids_;
 
  protected:
   ~DeleteDeletableResponseIdsTask() override {}
 };
 
 void AppCacheStorageImpl::DeleteDeletableResponseIdsTask::Run() {
   database_->DeleteDeletableResponseIds(response_ids_);
 }
 
 // LazyUpdateLastAccessTimeTask -------
 
 class AppCacheStorageImpl::LazyUpdateLastAccessTimeTask
     : public DatabaseTask {
  public:
   LazyUpdateLastAccessTimeTask(
       AppCacheStorageImpl* storage, AppCacheGroup* group, base::Time time)
       : DatabaseTask(storage), group_id_(group->group_id()),
         last_access_time_(time) {
     storage->NotifyStorageAccessed(group->manifest_url().GetOrigin());
   }
 
   // DatabaseTask:
   void Run() override;
   void RunCompleted() override;
 
  protected:
   ~LazyUpdateLastAccessTimeTask() override {}
 
  private:
-  int64 group_id_;
+  int64_t group_id_;
   base::Time last_access_time_;
 };
 
 void AppCacheStorageImpl::LazyUpdateLastAccessTimeTask::Run() {
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "AppCacheStorageImpl::LazyUpdateLastAccessTimeTask"));
   database_->LazyUpdateLastAccessTime(group_id_, last_access_time_);
 }
 
@@ skipping 33 matching lines @@
         first_evictable_error_time_(group->first_evictable_error_time()) {
   }
 
   // DatabaseTask:
   void Run() override;
 
  protected:
   ~UpdateEvictionTimesTask() override {}
 
  private:
-  int64 group_id_;
+  int64_t group_id_;
   base::Time last_full_update_check_time_;
   base::Time first_evictable_error_time_;
 };
 
 void AppCacheStorageImpl::UpdateEvictionTimesTask::Run() {
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "AppCacheStorageImpl::UpdateEvictionTimes"));
   database_->UpdateEvictionTimes(group_id_,
                                  last_full_update_check_time_,
@@ skipping 67 matching lines @@
   task->Schedule();
 }
 
 void AppCacheStorageImpl::GetAllInfo(Delegate* delegate) {
   DCHECK(delegate);
   scoped_refptr<GetAllInfoTask> task(new GetAllInfoTask(this));
   task->AddDelegate(GetOrCreateDelegateReference(delegate));
   task->Schedule();
 }
 
-void AppCacheStorageImpl::LoadCache(int64 id, Delegate* delegate) {
+void AppCacheStorageImpl::LoadCache(int64_t id, Delegate* delegate) {
   DCHECK(delegate);
   if (is_disabled_) {
     delegate->OnCacheLoaded(NULL, id);
     return;
   }
 
   AppCache* cache = working_set_.GetCache(id);
   if (cache) {
     delegate->OnCacheLoaded(cache, id);
     if (cache->owning_group()) {
@@ skipping 165 matching lines @@
         &delegates, url, found_entry,
         GURL(), AppCacheEntry(),
         cache.get() ? cache->cache_id() : kAppCacheNoCacheId,
         group.get() ? group->group_id() : kAppCacheNoCacheId,
         group.get() ? group->manifest_url() : GURL());
   }
 }
 
 void AppCacheStorageImpl::CallOnMainResponseFound(
     DelegateReferenceVector* delegates,
-    const GURL& url, const AppCacheEntry& entry,
-    const GURL& namespace_entry_url, const AppCacheEntry& fallback_entry,
-    int64 cache_id, int64 group_id, const GURL& manifest_url) {
+    const GURL& url,
+    const AppCacheEntry& entry,
+    const GURL& namespace_entry_url,
+    const AppCacheEntry& fallback_entry,
+    int64_t cache_id,
+    int64_t group_id,
+    const GURL& manifest_url) {
   FOR_EACH_DELEGATE(
       (*delegates),
       OnMainResponseFound(url, entry,
                           namespace_entry_url, fallback_entry,
                           cache_id, group_id, manifest_url));
 }
 
 void AppCacheStorageImpl::FindResponseForSubRequest(
     AppCache* cache, const GURL& url,
     AppCacheEntry* found_entry, AppCacheEntry* found_fallback_entry,
@@ skipping 11 matching lines @@
   }
 
   GURL fallback_namespace_not_used;
   GURL intercept_namespace_not_used;
   cache->FindResponseForRequest(
       url, found_entry, &intercept_namespace_not_used,
       found_fallback_entry, &fallback_namespace_not_used,
       found_network_namespace);
 }
 
-void AppCacheStorageImpl::MarkEntryAsForeign(
-    const GURL& entry_url, int64 cache_id) {
+void AppCacheStorageImpl::MarkEntryAsForeign(const GURL& entry_url,
+                                             int64_t cache_id) {
   AppCache* cache = working_set_.GetCache(cache_id);
   if (cache) {
     AppCacheEntry* entry = cache->GetEntry(entry_url);
     DCHECK(entry);
     if (entry)
       entry->add_types(AppCacheEntry::FOREIGN);
   }
   scoped_refptr<MarkEntryAsForeignTask> task(
       new MarkEntryAsForeignTask(this, entry_url, cache_id));
   task->Schedule();
@@ skipping 10 matching lines @@
   task->Schedule();
 }
 
 void AppCacheStorageImpl::StoreEvictionTimes(AppCacheGroup* group) {
   scoped_refptr<UpdateEvictionTimesTask> task(
       new UpdateEvictionTimesTask(this, group));
   task->Schedule();
 }
 
 AppCacheResponseReader* AppCacheStorageImpl::CreateResponseReader(
-    const GURL& manifest_url, int64 group_id, int64 response_id) {
+    const GURL& manifest_url,
+    int64_t group_id,
+    int64_t response_id) {
   return new AppCacheResponseReader(response_id, group_id, disk_cache());
 }
 
 AppCacheResponseWriter* AppCacheStorageImpl::CreateResponseWriter(
-    const GURL& manifest_url, int64 group_id) {
+    const GURL& manifest_url,
+    int64_t group_id) {
   return new AppCacheResponseWriter(NewResponseId(), group_id, disk_cache());
 }
 
 AppCacheResponseMetadataWriter*
-AppCacheStorageImpl::CreateResponseMetadataWriter(int64 group_id,
-                                                  int64 response_id) {
+AppCacheStorageImpl::CreateResponseMetadataWriter(int64_t group_id,
+                                                  int64_t response_id) {
   return new AppCacheResponseMetadataWriter(response_id, group_id,
                                             disk_cache());
 }
 
 void AppCacheStorageImpl::DoomResponses(
-    const GURL& manifest_url, const std::vector<int64>& response_ids) {
+    const GURL& manifest_url,
+    const std::vector<int64_t>& response_ids) {
   if (response_ids.empty())
     return;
 
   // Start deleting them from the disk cache lazily.
   StartDeletingResponses(response_ids);
 
   // Also schedule a database task to record these ids in the
   // deletable responses table.
   // TODO(michaeln): There is a race here. If the browser crashes
   // prior to committing these rows to the database and prior to us
   // having deleted them from the disk cache, we'll never delete them.
   scoped_refptr<InsertDeletableResponseIdsTask> task(
       new InsertDeletableResponseIdsTask(this));
   task->response_ids_ = response_ids;
   task->Schedule();
 }
 
 void AppCacheStorageImpl::DeleteResponses(
-    const GURL& manifest_url, const std::vector<int64>& response_ids) {
+    const GURL& manifest_url,
+    const std::vector<int64_t>& response_ids) {
   if (response_ids.empty())
     return;
   StartDeletingResponses(response_ids);
 }
 
 void AppCacheStorageImpl::DelayedStartDeletingUnusedResponses() {
   // Only if we haven't already begun.
   if (!did_start_deleting_responses_) {
     scoped_refptr<GetDeletableResponseIdsTask> task(
         new GetDeletableResponseIdsTask(this, last_deletable_response_rowid_));
     task->Schedule();
   }
 }
 
 void AppCacheStorageImpl::StartDeletingResponses(
-    const std::vector<int64>& response_ids) {
+    const std::vector<int64_t>& response_ids) {
   DCHECK(!response_ids.empty());
   did_start_deleting_responses_ = true;
   deletable_response_ids_.insert(
       deletable_response_ids_.end(),
       response_ids.begin(), response_ids.end());
   if (!is_response_deletion_scheduled_)
     ScheduleDeleteOneResponse();
 }
 
 void AppCacheStorageImpl::ScheduleDeleteOneResponse() {
@@ skipping 12 matching lines @@
 
   if (!disk_cache()) {
     DCHECK(is_disabled_);
     deletable_response_ids_.clear();
     deleted_response_ids_.clear();
     is_response_deletion_scheduled_ = false;
     return;
   }
 
   // TODO(michaeln): add group_id to DoomEntry args
-  int64 id = deletable_response_ids_.front();
+  int64_t id = deletable_response_ids_.front();
   int rv = disk_cache_->DoomEntry(
       id, base::Bind(&AppCacheStorageImpl::OnDeletedOneResponse,
                      base::Unretained(this)));
   if (rv != net::ERR_IO_PENDING)
     OnDeletedOneResponse(rv);
 }
 
 void AppCacheStorageImpl::OnDeletedOneResponse(int rv) {
   is_response_deletion_scheduled_ = false;
   if (is_disabled_)
     return;
 
-  int64 id = deletable_response_ids_.front();
+  int64_t id = deletable_response_ids_.front();
   deletable_response_ids_.pop_front();
   if (rv != net::ERR_ABORTED)
     deleted_response_ids_.push_back(id);
 
   const size_t kBatchSize = 50U;
   if (deleted_response_ids_.size() >= kBatchSize ||
       deletable_response_ids_.empty()) {
     scoped_refptr<DeleteDeletableResponseIdsTask> task(
         new DeleteDeletableResponseIdsTask(this));
     task->response_ids_.swap(deleted_response_ids_);
     task->Schedule();
   }
 
   if (deletable_response_ids_.empty()) {
     scoped_refptr<GetDeletableResponseIdsTask> task(
         new GetDeletableResponseIdsTask(this, last_deletable_response_rowid_));
     task->Schedule();
     return;
   }
 
   ScheduleDeleteOneResponse();
 }
 
 AppCacheStorageImpl::CacheLoadTask*
-AppCacheStorageImpl::GetPendingCacheLoadTask(int64 cache_id) {
+AppCacheStorageImpl::GetPendingCacheLoadTask(int64_t cache_id) {
   PendingCacheLoads::iterator found = pending_cache_loads_.find(cache_id);
   if (found != pending_cache_loads_.end())
     return found->second;
   return NULL;
 }
 
 AppCacheStorageImpl::GroupLoadTask*
 AppCacheStorageImpl::GetPendingGroupLoadTask(const GURL& manifest_url) {
   PendingGroupLoads::iterator found = pending_group_loads_.find(manifest_url);
   if (found != pending_group_loads_.end())
     return found->second;
   return NULL;
 }
 
 void AppCacheStorageImpl::GetPendingForeignMarkingsForCache(
-    int64 cache_id, std::vector<GURL>* urls) {
+    int64_t cache_id,
+    std::vector<GURL>* urls) {
   PendingForeignMarkings::iterator iter = pending_foreign_markings_.begin();
   while (iter != pending_foreign_markings_.end()) {
     if (iter->second == cache_id)
       urls->push_back(iter->first);
     ++iter;
   }
 }
 
 void AppCacheStorageImpl::ScheduleSimpleTask(const base::Closure& task) {
   pending_simple_tasks_.push_back(task);
@@ skipping 93 matching lines @@
 
 void AppCacheStorageImpl::OnLazyCommitTimer() {
   lazy_commit_timer_.Stop();
   if (is_disabled())
     return;
   scoped_refptr<DatabaseTask> task(new CommitLastAccessTimesTask(this));
   task->Schedule();
 }
 
 }  // namespace content