Remove kint64max.

content/browser/appcache/appcache_database.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_database.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
@@ skipping 200 matching lines @@
 AppCacheDatabase::~AppCacheDatabase() {
   CommitLazyLastAccessTimes();
 }
 
 void AppCacheDatabase::Disable() {
   VLOG(1) << "Disabling appcache database.";
   is_disabled_ = true;
   ResetConnectionAndTables();
 }
 
-int64 AppCacheDatabase::GetOriginUsage(const GURL& origin) {
+int64_t AppCacheDatabase::GetOriginUsage(const GURL& origin) {
   std::vector<CacheRecord> records;
   if (!FindCachesForOrigin(origin, &records))
     return 0;
 
-  int64 origin_usage = 0;
+  int64_t origin_usage = 0;
   std::vector<CacheRecord>::const_iterator iter = records.begin();
   while (iter != records.end()) {
     origin_usage += iter->cache_size;
     ++iter;
   }
   return origin_usage;
 }
 
-bool AppCacheDatabase::GetAllOriginUsage(std::map<GURL, int64>* usage_map) {
+bool AppCacheDatabase::GetAllOriginUsage(std::map<GURL, int64_t>* usage_map) {
   std::set<GURL> origins;
   if (!FindOriginsWithGroups(&origins))
     return false;
   for (std::set<GURL>::const_iterator origin = origins.begin();
        origin != origins.end(); ++origin) {
     (*usage_map)[*origin] = GetOriginUsage(*origin);
   }
   return true;
 }
 
 bool AppCacheDatabase::FindOriginsWithGroups(std::set<GURL>* origins) {
   DCHECK(origins && origins->empty());
   if (!LazyOpen(kDontCreate))
     return false;
 
   const char kSql[] =
       "SELECT DISTINCT(origin) FROM Groups";
 
   sql::Statement statement(db_->GetUniqueStatement(kSql));
 
   while (statement.Step())
     origins->insert(GURL(statement.ColumnString(0)));
 
   return statement.Succeeded();
 }
 
 bool AppCacheDatabase::FindLastStorageIds(
-    int64* last_group_id, int64* last_cache_id, int64* last_response_id,
-    int64* last_deletable_response_rowid) {
+    int64_t* last_group_id,
+    int64_t* last_cache_id,
+    int64_t* last_response_id,
+    int64_t* last_deletable_response_rowid) {
   DCHECK(last_group_id && last_cache_id && last_response_id &&
          last_deletable_response_rowid);
 
   *last_group_id = 0;
   *last_cache_id = 0;
   *last_response_id = 0;
   *last_deletable_response_rowid = 0;
 
   if (!LazyOpen(kDontCreate))
     return false;
 
   const char* kMaxGroupIdSql = "SELECT MAX(group_id) FROM Groups";
   const char* kMaxCacheIdSql = "SELECT MAX(cache_id) FROM Caches";
   const char* kMaxResponseIdFromEntriesSql =
       "SELECT MAX(response_id) FROM Entries";
   const char* kMaxResponseIdFromDeletablesSql =
       "SELECT MAX(response_id) FROM DeletableResponseIds";
   const char* kMaxDeletableResponseRowIdSql =
       "SELECT MAX(rowid) FROM DeletableResponseIds";
-  int64 max_group_id;
-  int64 max_cache_id;
-  int64 max_response_id_from_entries;
-  int64 max_response_id_from_deletables;
-  int64 max_deletable_response_rowid;
+  int64_t max_group_id;
+  int64_t max_cache_id;
+  int64_t max_response_id_from_entries;
+  int64_t max_response_id_from_deletables;
+  int64_t max_deletable_response_rowid;
   if (!RunUniqueStatementWithInt64Result(kMaxGroupIdSql, &max_group_id) ||
       !RunUniqueStatementWithInt64Result(kMaxCacheIdSql, &max_cache_id) ||
       !RunUniqueStatementWithInt64Result(kMaxResponseIdFromEntriesSql,
                                          &max_response_id_from_entries) ||
       !RunUniqueStatementWithInt64Result(kMaxResponseIdFromDeletablesSql,
                                          &max_response_id_from_deletables) ||
       !RunUniqueStatementWithInt64Result(kMaxDeletableResponseRowIdSql,
                                          &max_deletable_response_rowid)) {
     return false;
   }
 
   *last_group_id = max_group_id;
   *last_cache_id = max_cache_id;
   *last_response_id = std::max(max_response_id_from_entries,
                                max_response_id_from_deletables);
   *last_deletable_response_rowid = max_deletable_response_rowid;
   return true;
 }
 
-bool AppCacheDatabase::FindGroup(int64 group_id, GroupRecord* record) {
+bool AppCacheDatabase::FindGroup(int64_t group_id, GroupRecord* record) {
   DCHECK(record);
   if (!LazyOpen(kDontCreate))
     return false;
 
   const char kSql[] =
       "SELECT group_id, origin, manifest_url,"
       "       creation_time, last_access_time,"
       "       last_full_update_check_time,"
       "       first_evictable_error_time"
       "  FROM Groups WHERE group_id = ?";
@@ skipping 51 matching lines @@
 
   while (statement.Step()) {
     records->push_back(GroupRecord());
     ReadGroupRecord(statement, &records->back());
     DCHECK(records->back().origin == origin);
   }
 
   return statement.Succeeded();
 }
 
-bool AppCacheDatabase::FindGroupForCache(int64 cache_id, GroupRecord* record) {
+bool AppCacheDatabase::FindGroupForCache(int64_t cache_id,
+                                         GroupRecord* record) {
   DCHECK(record);
   if (!LazyOpen(kDontCreate))
     return false;
 
   const char kSql[] =
       "SELECT g.group_id, g.origin, g.manifest_url,"
       "       g.creation_time, g.last_access_time,"
       "       g.last_full_update_check_time,"
       "       g.first_evictable_error_time"
       "  FROM Groups g, Caches c"
@@ skipping 22 matching lines @@
   statement.BindInt64(0, record->group_id);
   statement.BindString(1, record->origin.spec());
   statement.BindString(2, record->manifest_url.spec());
   statement.BindInt64(3, record->creation_time.ToInternalValue());
   statement.BindInt64(4, record->last_access_time.ToInternalValue());
   statement.BindInt64(5, record->last_full_update_check_time.ToInternalValue());
   statement.BindInt64(6, record->first_evictable_error_time.ToInternalValue());
   return statement.Run();
 }
 
-bool AppCacheDatabase::DeleteGroup(int64 group_id) {
+bool AppCacheDatabase::DeleteGroup(int64_t group_id) {
   if (!LazyOpen(kDontCreate))
     return false;
 
   const char kSql[] =
       "DELETE FROM Groups WHERE group_id = ?";
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, group_id);
   return statement.Run();
 }
 
-bool AppCacheDatabase::UpdateLastAccessTime(
-    int64 group_id, base::Time time) {
+bool AppCacheDatabase::UpdateLastAccessTime(int64_t group_id, base::Time time) {
   if (!LazyUpdateLastAccessTime(group_id, time))
     return false;
   return CommitLazyLastAccessTimes();
 }
 
-bool AppCacheDatabase::LazyUpdateLastAccessTime(
-    int64 group_id, base::Time time) {
+bool AppCacheDatabase::LazyUpdateLastAccessTime(int64_t group_id,
+                                                base::Time time) {
   if (!LazyOpen(kCreateIfNeeded))
     return false;
   lazy_last_access_times_[group_id] = time;
   return true;
 }
 
 bool AppCacheDatabase::CommitLazyLastAccessTimes() {
   if (lazy_last_access_times_.empty())
     return true;
   if (!LazyOpen(kDontCreate))
     return false;
 
   sql::Transaction transaction(db_.get());
   if (!transaction.Begin())
     return false;
   for (const auto& pair : lazy_last_access_times_) {
     const char kSql[] =
         "UPDATE Groups SET last_access_time = ? WHERE group_id = ?";
     sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
     statement.BindInt64(0, pair.second.ToInternalValue());  // time
     statement.BindInt64(1, pair.first);  // group_id
     statement.Run();
   }
   lazy_last_access_times_.clear();
   return transaction.Commit();
 }
 
 bool AppCacheDatabase::UpdateEvictionTimes(
-    int64 group_id,
+    int64_t group_id,
     base::Time last_full_update_check_time,
     base::Time first_evictable_error_time) {
   if (!LazyOpen(kCreateIfNeeded))
     return false;
 
   const char kSql[] =
       "UPDATE Groups"
       " SET last_full_update_check_time = ?, first_evictable_error_time = ?"
       " WHERE group_id = ?";
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, last_full_update_check_time.ToInternalValue());
   statement.BindInt64(1, first_evictable_error_time.ToInternalValue());
   statement.BindInt64(2, group_id);
   return statement.Run();  // Will succeed even if group_id is invalid.
 }
 
-bool AppCacheDatabase::FindCache(int64 cache_id, CacheRecord* record) {
+bool AppCacheDatabase::FindCache(int64_t cache_id, CacheRecord* record) {
   DCHECK(record);
   if (!LazyOpen(kDontCreate))
     return false;
 
   const char kSql[] =
       "SELECT cache_id, group_id, online_wildcard, update_time, cache_size"
       " FROM Caches WHERE cache_id = ?";
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, cache_id);
 
   if (!statement.Step())
     return false;
 
   ReadCacheRecord(statement, record);
   return true;
 }
 
-bool AppCacheDatabase::FindCacheForGroup(int64 group_id, CacheRecord* record) {
+bool AppCacheDatabase::FindCacheForGroup(int64_t group_id,
+                                         CacheRecord* record) {
   DCHECK(record);
   if (!LazyOpen(kDontCreate))
     return false;
 
   const char kSql[] =
       "SELECT cache_id, group_id, online_wildcard, update_time, cache_size"
       "  FROM Caches WHERE group_id = ?";
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, group_id);
@@ skipping 34 matching lines @@
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, record->cache_id);
   statement.BindInt64(1, record->group_id);
   statement.BindBool(2, record->online_wildcard);
   statement.BindInt64(3, record->update_time.ToInternalValue());
   statement.BindInt64(4, record->cache_size);
 
   return statement.Run();
 }
 
-bool AppCacheDatabase::DeleteCache(int64 cache_id) {
+bool AppCacheDatabase::DeleteCache(int64_t cache_id) {
   if (!LazyOpen(kDontCreate))
     return false;
 
   const char kSql[] =
       "DELETE FROM Caches WHERE cache_id = ?";
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, cache_id);
 
   return statement.Run();
 }
 
-bool AppCacheDatabase::FindEntriesForCache(
-    int64 cache_id, std::vector<EntryRecord>* records) {
+bool AppCacheDatabase::FindEntriesForCache(int64_t cache_id,
+                                           std::vector<EntryRecord>* records) {
   DCHECK(records && records->empty());
   if (!LazyOpen(kDontCreate))
     return false;
 
   const char kSql[] =
       "SELECT cache_id, url, flags, response_id, response_size FROM Entries"
       "  WHERE cache_id = ?";
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, cache_id);
@@ skipping 22 matching lines @@
 
   while (statement.Step()) {
     records->push_back(EntryRecord());
     ReadEntryRecord(statement, &records->back());
     DCHECK(records->back().url == url);
   }
 
   return statement.Succeeded();
 }
 
-bool AppCacheDatabase::FindEntry(
-    int64 cache_id, const GURL& url, EntryRecord* record) {
+bool AppCacheDatabase::FindEntry(int64_t cache_id,
+                                 const GURL& url,
+                                 EntryRecord* record) {
   DCHECK(record);
   if (!LazyOpen(kDontCreate))
     return false;
 
   const char kSql[] =
       "SELECT cache_id, url, flags, response_id, response_size FROM Entries"
       "  WHERE cache_id = ? AND url = ?";
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, cache_id);
@@ skipping 35 matching lines @@
     return false;
   std::vector<EntryRecord>::const_iterator iter = records.begin();
   while (iter != records.end()) {
     if (!InsertEntry(&(*iter)))
       return false;
     ++iter;
   }
   return transaction.Commit();
 }
 
-bool AppCacheDatabase::DeleteEntriesForCache(int64 cache_id) {
+bool AppCacheDatabase::DeleteEntriesForCache(int64_t cache_id) {
   if (!LazyOpen(kDontCreate))
     return false;
 
   const char kSql[] =
       "DELETE FROM Entries WHERE cache_id = ?";
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, cache_id);
 
   return statement.Run();
 }
 
-bool AppCacheDatabase::AddEntryFlags(
-    const GURL& entry_url, int64 cache_id, int additional_flags) {
+bool AppCacheDatabase::AddEntryFlags(const GURL& entry_url,
+                                     int64_t cache_id,
+                                     int additional_flags) {
   if (!LazyOpen(kDontCreate))
     return false;
 
   const char kSql[] =
       "UPDATE Entries SET flags = flags | ? WHERE cache_id = ? AND url = ?";
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt(0, additional_flags);
   statement.BindInt64(1, cache_id);
   statement.BindString(2, entry_url.spec());
@@ skipping 16 matching lines @@
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindString(0, origin.spec());
 
   ReadNamespaceRecords(&statement, intercepts, fallbacks);
 
   return statement.Succeeded();
 }
 
 bool AppCacheDatabase::FindNamespacesForCache(
-    int64 cache_id,
+    int64_t cache_id,
     std::vector<NamespaceRecord>* intercepts,
     std::vector<NamespaceRecord>* fallbacks) {
   DCHECK(intercepts && intercepts->empty());
   DCHECK(fallbacks && fallbacks->empty());
   if (!LazyOpen(kDontCreate))
     return false;
 
   const char kSql[] =
       "SELECT cache_id, origin, type, namespace_url, target_url, is_pattern"
       "  FROM Namespaces WHERE cache_id = ?";
@@ skipping 44 matching lines @@
     return false;
   std::vector<NamespaceRecord>::const_iterator iter = records.begin();
   while (iter != records.end()) {
     if (!InsertNamespace(&(*iter)))
       return false;
     ++iter;
   }
   return transaction.Commit();
 }
 
-bool AppCacheDatabase::DeleteNamespacesForCache(int64 cache_id) {
+bool AppCacheDatabase::DeleteNamespacesForCache(int64_t cache_id) {
   if (!LazyOpen(kDontCreate))
     return false;
 
   const char kSql[] =
       "DELETE FROM Namespaces WHERE cache_id = ?";
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, cache_id);
 
   return statement.Run();
 }
 
 bool AppCacheDatabase::FindOnlineWhiteListForCache(
-    int64 cache_id, std::vector<OnlineWhiteListRecord>* records) {
+    int64_t cache_id,
+    std::vector<OnlineWhiteListRecord>* records) {
   DCHECK(records && records->empty());
   if (!LazyOpen(kDontCreate))
     return false;
 
   const char kSql[] =
       "SELECT cache_id, namespace_url, is_pattern FROM OnlineWhiteLists"
       "  WHERE cache_id = ?";
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, cache_id);
@@ skipping 32 matching lines @@
     return false;
   std::vector<OnlineWhiteListRecord>::const_iterator iter = records.begin();
   while (iter != records.end()) {
     if (!InsertOnlineWhiteList(&(*iter)))
       return false;
     ++iter;
   }
   return transaction.Commit();
 }
 
-bool AppCacheDatabase::DeleteOnlineWhiteListForCache(int64 cache_id) {
+bool AppCacheDatabase::DeleteOnlineWhiteListForCache(int64_t cache_id) {
   if (!LazyOpen(kDontCreate))
     return false;
 
   const char kSql[] =
       "DELETE FROM OnlineWhiteLists WHERE cache_id = ?";
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, cache_id);
 
   return statement.Run();
 }
 
 bool AppCacheDatabase::GetDeletableResponseIds(
-    std::vector<int64>* response_ids, int64 max_rowid, int limit) {
+    std::vector<int64_t>* response_ids,
+    int64_t max_rowid,
+    int limit) {
   if (!LazyOpen(kDontCreate))
     return false;
 
   const char kSql[] =
       "SELECT response_id FROM DeletableResponseIds "
       "  WHERE rowid <= ?"
       "  LIMIT ?";
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, max_rowid);
   statement.BindInt64(1, limit);
 
   while (statement.Step())
     response_ids->push_back(statement.ColumnInt64(0));
   return statement.Succeeded();
 }
 
 bool AppCacheDatabase::InsertDeletableResponseIds(
-    const std::vector<int64>& response_ids) {
+    const std::vector<int64_t>& response_ids) {
   const char kSql[] =
       "INSERT INTO DeletableResponseIds (response_id) VALUES (?)";
   return RunCachedStatementWithIds(SQL_FROM_HERE, kSql, response_ids);
 }
 
 bool AppCacheDatabase::DeleteDeletableResponseIds(
-    const std::vector<int64>& response_ids) {
+    const std::vector<int64_t>& response_ids) {
   const char kSql[] =
       "DELETE FROM DeletableResponseIds WHERE response_id = ?";
   return RunCachedStatementWithIds(SQL_FROM_HERE, kSql, response_ids);
 }
 
 bool AppCacheDatabase::RunCachedStatementWithIds(
-    const sql::StatementID& statement_id, const char* sql,
-    const std::vector<int64>& ids) {
+    const sql::StatementID& statement_id,
+    const char* sql,
+    const std::vector<int64_t>& ids) {
   DCHECK(sql);
   if (!LazyOpen(kCreateIfNeeded))
     return false;
 
   sql::Transaction transaction(db_.get());
   if (!transaction.Begin())
     return false;
 
   sql::Statement statement(db_->GetCachedStatement(statement_id, sql));
 
-  std::vector<int64>::const_iterator iter = ids.begin();
+  std::vector<int64_t>::const_iterator iter = ids.begin();
   while (iter != ids.end()) {
     statement.BindInt64(0, *iter);
     if (!statement.Run())
       return false;
     statement.Reset(true);
     ++iter;
   }
 
   return transaction.Commit();
 }
 
-bool AppCacheDatabase::RunUniqueStatementWithInt64Result(
-    const char* sql, int64* result) {
+bool AppCacheDatabase::RunUniqueStatementWithInt64Result(const char* sql,
+                                                         int64_t* result) {
   DCHECK(sql);
   sql::Statement statement(db_->GetUniqueStatement(sql));
   if (!statement.Step()) {
     return false;
   }
   *result = statement.ColumnInt64(0);
   return true;
 }
 
 bool AppCacheDatabase::FindResponseIdsForCacheHelper(
-    int64 cache_id, std::vector<int64>* ids_vector,
-    std::set<int64>* ids_set) {
+    int64_t cache_id,
+    std::vector<int64_t>* ids_vector,
+    std::set<int64_t>* ids_set) {
   DCHECK(ids_vector || ids_set);
   DCHECK(!(ids_vector && ids_set));
   if (!LazyOpen(kDontCreate))
     return false;
 
   const char kSql[] =
       "SELECT response_id FROM Entries WHERE cache_id = ?";
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
 
   statement.BindInt64(0, cache_id);
   while (statement.Step()) {
-    int64 id = statement.ColumnInt64(0);
+    int64_t id = statement.ColumnInt64(0);
     if (ids_set)
       ids_set->insert(id);
     else
       ids_vector->push_back(id);
   }
 
   return statement.Succeeded();
 }
 
 void AppCacheDatabase::ReadGroupRecord(
@@ skipping 340 matching lines @@
 }
 
 void AppCacheDatabase::OnDatabaseError(int err, sql::Statement* stmt) {
   was_corruption_detected_ |= sql::IsErrorCatastrophic(err);
   if (!db_->ShouldIgnoreSqliteError(err))
     DLOG(ERROR) << db_->GetErrorMessage();
   // TODO: Maybe use non-catostrophic errors to trigger a full integrity check?
 }
 
 }  // namespace content