Remove kint64max.

content/browser/appcache/appcache_database_unittest.cc

 // Copyright 2014 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 <limits>
+
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/strings/stringprintf.h"
 #include "content/browser/appcache/appcache_database.h"
 #include "content/browser/appcache/appcache_entry.h"
 #include "sql/connection.h"
 #include "sql/meta_table.h"
 #include "sql/statement.h"
 #include "sql/test/scoped_error_ignorer.h"
@@ skipping 13 matching lines @@
 class AppCacheDatabaseTest {};
 
 TEST(AppCacheDatabaseTest, LazyOpen) {
   // Use an empty file path to use an in-memory sqlite database.
   const base::FilePath kEmptyPath;
   AppCacheDatabase db(kEmptyPath);
 
   EXPECT_FALSE(db.LazyOpen(false));
   EXPECT_TRUE(db.LazyOpen(true));
 
-  int64 group_id, cache_id, response_id, deleteable_response_rowid;
+  int64_t group_id, cache_id, response_id, deleteable_response_rowid;
   group_id = cache_id = response_id = deleteable_response_rowid = 0;
   EXPECT_TRUE(db.FindLastStorageIds(&group_id, &cache_id, &response_id,
                                     &deleteable_response_rowid));
   EXPECT_EQ(0, group_id);
   EXPECT_EQ(0, cache_id);
   EXPECT_EQ(0, response_id);
   EXPECT_EQ(0, deleteable_response_rowid);
 
   std::set<GURL> origins;
   EXPECT_TRUE(db.FindOriginsWithGroups(&origins));
@@ skipping 79 matching lines @@
   EXPECT_TRUE(base::PathExists(kDbFile));
   EXPECT_FALSE(db.was_corruption_detected());
 
   // Break it.
   ASSERT_TRUE(sql::test::CorruptSizeInHeader(kDbFile));
 
   // See the the corruption is detected and reported.
   {
     sql::ScopedErrorIgnorer ignore_errors;
     ignore_errors.IgnoreError(SQLITE_CORRUPT);
-    std::map<GURL, int64> usage_map;
+    std::map<GURL, int64_t> usage_map;
     EXPECT_FALSE(db.GetAllOriginUsage(&usage_map));
     EXPECT_TRUE(db.was_corruption_detected());
     EXPECT_TRUE(base::PathExists(kDbFile));
     EXPECT_TRUE(ignore_errors.CheckIgnoredErrors());
   }
 }
 
 TEST(AppCacheDatabaseTest, ExperimentalFlags) {
   const char kExperimentFlagsKey[] = "ExperimentFlags";
   std::string kInjectedFlags("exp1,exp2");
@@ skipping 524 matching lines @@
 
 TEST(AppCacheDatabaseTest, DeletableResponseIds) {
   const base::FilePath kEmptyPath;
   AppCacheDatabase db(kEmptyPath);
   EXPECT_TRUE(db.LazyOpen(true));
 
   sql::ScopedErrorIgnorer ignore_errors;
   // TODO(shess): See EntryRecords test.
   ignore_errors.IgnoreError(SQLITE_CONSTRAINT);
 
-  std::vector<int64> ids;
+  std::vector<int64_t> ids;
 
-  EXPECT_TRUE(db.GetDeletableResponseIds(&ids, kint64max, 100));
+  EXPECT_TRUE(db.GetDeletableResponseIds(
+      &ids, std::numeric_limits<int64_t>::max(), 100));
   EXPECT_TRUE(ids.empty());
   ids.push_back(0);
   EXPECT_TRUE(db.DeleteDeletableResponseIds(ids));
   EXPECT_TRUE(db.InsertDeletableResponseIds(ids));
 
   ids.clear();
-  EXPECT_TRUE(db.GetDeletableResponseIds(&ids, kint64max, 100));
+  EXPECT_TRUE(db.GetDeletableResponseIds(
+      &ids, std::numeric_limits<int64_t>::max(), 100));
   EXPECT_EQ(1U, ids.size());
   EXPECT_EQ(0, ids[0]);
 
-  int64 unused, deleteable_response_rowid;
+  int64_t unused, deleteable_response_rowid;
   unused = deleteable_response_rowid = 0;
   EXPECT_TRUE(db.FindLastStorageIds(&unused, &unused, &unused,
                                     &deleteable_response_rowid));
   EXPECT_EQ(1, deleteable_response_rowid);
 
 
   // Expected to fail due to the duplicate id, 0 is already in the table.
   ids.clear();
   ids.push_back(0);
   ids.push_back(1);
   EXPECT_FALSE(db.InsertDeletableResponseIds(ids));
 
   ids.clear();
   for (int i = 1; i < 10; ++i)
     ids.push_back(i);
   EXPECT_TRUE(db.InsertDeletableResponseIds(ids));
   EXPECT_TRUE(db.FindLastStorageIds(&unused, &unused, &unused,
                                     &deleteable_response_rowid));
   EXPECT_EQ(10, deleteable_response_rowid);
 
   ids.clear();
-  EXPECT_TRUE(db.GetDeletableResponseIds(&ids, kint64max, 100));
+  EXPECT_TRUE(db.GetDeletableResponseIds(
+      &ids, std::numeric_limits<int64_t>::max(), 100));
   EXPECT_EQ(10U, ids.size());
   for (int i = 0; i < 10; ++i)
     EXPECT_EQ(i, ids[i]);
 
   // Ensure the limit is respected.
   ids.clear();
-  EXPECT_TRUE(db.GetDeletableResponseIds(&ids, kint64max, 5));
+  EXPECT_TRUE(
+      db.GetDeletableResponseIds(&ids, std::numeric_limits<int64_t>::max(), 5));
   EXPECT_EQ(5U, ids.size());
   for (int i = 0; i < static_cast<int>(ids.size()); ++i)
     EXPECT_EQ(i, ids[i]);
 
   // Ensure the max_rowid is respected (the first rowid is 1).
   ids.clear();
   EXPECT_TRUE(db.GetDeletableResponseIds(&ids, 5, 100));
   EXPECT_EQ(5U, ids.size());
   for (int i = 0; i < static_cast<int>(ids.size()); ++i)
     EXPECT_EQ(i, ids[i]);
 
   // Ensure that we can delete from the table.
   EXPECT_TRUE(db.DeleteDeletableResponseIds(ids));
   ids.clear();
-  EXPECT_TRUE(db.GetDeletableResponseIds(&ids, kint64max, 100));
+  EXPECT_TRUE(db.GetDeletableResponseIds(
+      &ids, std::numeric_limits<int64_t>::max(), 100));
   EXPECT_EQ(5U, ids.size());
   for (int i = 0; i < static_cast<int>(ids.size()); ++i)
     EXPECT_EQ(i + 5, ids[i]);
 
   ASSERT_TRUE(ignore_errors.CheckIgnoredErrors());
 }
 
 TEST(AppCacheDatabaseTest, OriginUsage) {
   const GURL kManifestUrl("http://blah/manifest");
   const GURL kManifestUrl2("http://blah/manifest2");
@@ skipping 50 matching lines @@
   EXPECT_TRUE(db.InsertCache(&cache_record));
 
   EXPECT_EQ(5000, db.GetOriginUsage(kOtherOrigin));
 
   EXPECT_TRUE(db.FindCachesForOrigin(kOrigin, &cache_records));
   EXPECT_EQ(2U, cache_records.size());
   cache_records.clear();
   EXPECT_TRUE(db.FindCachesForOrigin(kOtherOrigin, &cache_records));
   EXPECT_EQ(1U, cache_records.size());
 
-  std::map<GURL, int64> usage_map;
+  std::map<GURL, int64_t> usage_map;
   EXPECT_TRUE(db.GetAllOriginUsage(&usage_map));
   EXPECT_EQ(2U, usage_map.size());
   EXPECT_EQ(1100, usage_map[kOrigin]);
   EXPECT_EQ(5000, usage_map[kOtherOrigin]);
 }
 
 #if defined(APPCACHE_USE_SIMPLE_CACHE)
 // There is no such upgrade path in this case.
 #else
 TEST(AppCacheDatabaseTest, UpgradeSchema4to7) {
@@ skipping 464 matching lines @@
   AppCacheDatabase::GroupRecord group;
   EXPECT_TRUE(db.FindGroup(1, &group));
   EXPECT_EQ(kMockTime, group.last_full_update_check_time);
   EXPECT_EQ(kZeroTime, group.first_evictable_error_time);
   EXPECT_TRUE(db.FindGroup(2, &group));
   EXPECT_EQ(kZeroTime, group.last_full_update_check_time);
   EXPECT_EQ(kZeroTime, group.first_evictable_error_time);
 }
 
 }  // namespace content