Switch to standard integer types in content/browser/.

content/browser/indexed_db/indexed_db_leveldb_coding_unittest.cc

 // Copyright (c) 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 "content/browser/indexed_db/indexed_db_leveldb_coding.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <limits>
 #include <vector>
 
-#include "base/basictypes.h"
+#include "base/macros.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/common/indexed_db/indexed_db_key.h"
 #include "content/common/indexed_db/indexed_db_key_path.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::ASCIIToUTF16;
 using base::StringPiece;
 using blink::WebIDBKeyTypeDate;
@@ skipping 141 matching lines @@
   EncodeIDBKey(IndexedDBKey(1000000, WebIDBKeyTypeDate), &date_key);
 
   EXPECT_LT(CompareKeys(min_key, max_key), 0);
   EXPECT_LT(CompareKeys(min_key, array_key), 0);
   EXPECT_LT(CompareKeys(min_key, binary_key), 0);
   EXPECT_LT(CompareKeys(min_key, string_key), 0);
   EXPECT_LT(CompareKeys(min_key, number_key), 0);
   EXPECT_LT(CompareKeys(min_key, date_key), 0);
 }
 
-static std::string WrappedEncodeInt(int64 value) {
+static std::string WrappedEncodeInt(int64_t value) {
   std::string buffer;
   EncodeInt(value, &buffer);
   return buffer;
 }
 
 TEST(IndexedDBLevelDBCodingTest, EncodeInt) {
   EXPECT_EQ(1u, WrappedEncodeInt(0).size());
   EXPECT_EQ(1u, WrappedEncodeInt(1).size());
   EXPECT_EQ(1u, WrappedEncodeInt(255).size());
   EXPECT_EQ(2u, WrappedEncodeInt(256).size());
@@ skipping 23 matching lines @@
     EXPECT_TRUE(slice.empty());
   }
   {
     StringPiece slice;
     bool value;
     EXPECT_FALSE(DecodeBool(&slice, &value));
   }
 }
 
 TEST(IndexedDBLevelDBCodingTest, DecodeInt) {
-  std::vector<int64> test_cases;
+  std::vector<int64_t> test_cases;
   test_cases.push_back(0);
   test_cases.push_back(1);
   test_cases.push_back(255);
   test_cases.push_back(256);
   test_cases.push_back(65535);
   test_cases.push_back(655536);
   test_cases.push_back(7711192431755665792ll);
   test_cases.push_back(0x7fffffffffffffffll);
 #ifdef NDEBUG
   test_cases.push_back(-3);
 #endif
 
   for (size_t i = 0; i < test_cases.size(); ++i) {
-    int64 n = test_cases[i];
+    int64_t n = test_cases[i];
     std::string v = WrappedEncodeInt(n);
     ASSERT_GT(v.size(), 0u);
     StringPiece slice(v);
-    int64 value;
+    int64_t value;
     EXPECT_TRUE(DecodeInt(&slice, &value));
     EXPECT_EQ(n, value);
     EXPECT_TRUE(slice.empty());
 
     // Verify decoding at an offset, to detect unaligned memory access.
     v.insert(v.begin(), 1u, static_cast<char>(0));
     slice = StringPiece(&*v.begin() + 1, v.size() - 1);
     EXPECT_TRUE(DecodeInt(&slice, &value));
     EXPECT_EQ(n, value);
     EXPECT_TRUE(slice.empty());
   }
   {
     StringPiece slice;
-    int64 value;
+    int64_t value;
     EXPECT_FALSE(DecodeInt(&slice, &value));
   }
 }
 
-static std::string WrappedEncodeVarInt(int64 value) {
+static std::string WrappedEncodeVarInt(int64_t value) {
   std::string buffer;
   EncodeVarInt(value, &buffer);
   return buffer;
 }
 
 TEST(IndexedDBLevelDBCodingTest, EncodeVarInt) {
   EXPECT_EQ(1u, WrappedEncodeVarInt(0).size());
   EXPECT_EQ(1u, WrappedEncodeVarInt(1).size());
   EXPECT_EQ(2u, WrappedEncodeVarInt(255).size());
   EXPECT_EQ(2u, WrappedEncodeVarInt(256).size());
   EXPECT_EQ(5u, WrappedEncodeVarInt(0xffffffff).size());
   EXPECT_EQ(8u, WrappedEncodeVarInt(0xfffffffffffffLL).size());
   EXPECT_EQ(9u, WrappedEncodeVarInt(0x7fffffffffffffffLL).size());
 #ifdef NDEBUG
   EXPECT_EQ(10u, WrappedEncodeVarInt(-100).size());
 #endif
 }
 
 TEST(IndexedDBLevelDBCodingTest, DecodeVarInt) {
-  std::vector<int64> test_cases;
+  std::vector<int64_t> test_cases;
   test_cases.push_back(0);
   test_cases.push_back(1);
   test_cases.push_back(255);
   test_cases.push_back(256);
   test_cases.push_back(65535);
   test_cases.push_back(655536);
   test_cases.push_back(7711192431755665792ll);
   test_cases.push_back(0x7fffffffffffffffll);
 #ifdef NDEBUG
   test_cases.push_back(-3);
 #endif
 
   for (size_t i = 0; i < test_cases.size(); ++i) {
-    int64 n = test_cases[i];
+    int64_t n = test_cases[i];
     std::string v = WrappedEncodeVarInt(n);
     ASSERT_GT(v.size(), 0u);
     StringPiece slice(v);
-    int64 res;
+    int64_t res;
     EXPECT_TRUE(DecodeVarInt(&slice, &res));
     EXPECT_EQ(n, res);
     EXPECT_TRUE(slice.empty());
 
     slice = StringPiece(&*v.begin(), v.size() - 1);
     EXPECT_FALSE(DecodeVarInt(&slice, &res));
 
     slice = StringPiece(&*v.begin(), static_cast<size_t>(0));
     EXPECT_FALSE(DecodeVarInt(&slice, &res));
 
@@ skipping 640 matching lines @@
   keys.push_back(IndexDataKey::Encode(1, 1, 30, MinIDBKey(), MinIDBKey(), 0));
   keys.push_back(IndexDataKey::Encode(1, 1, 30, MinIDBKey(), MinIDBKey(), 1));
   keys.push_back(IndexDataKey::Encode(1, 1, 30, MinIDBKey(), MaxIDBKey(), 0));
   keys.push_back(IndexDataKey::Encode(1, 1, 30, MinIDBKey(), MaxIDBKey(), 1));
   keys.push_back(IndexDataKey::Encode(1, 1, 30, MaxIDBKey(), MinIDBKey(), 0));
   keys.push_back(IndexDataKey::Encode(1, 1, 30, MaxIDBKey(), MinIDBKey(), 1));
   keys.push_back(IndexDataKey::Encode(1, 1, 30, MaxIDBKey(), MaxIDBKey(), 0));
   keys.push_back(IndexDataKey::Encode(1, 1, 30, MaxIDBKey(), MaxIDBKey(), 1));
   keys.push_back(IndexDataKey::Encode(1, 1, 31, MinIDBKey(), MinIDBKey(), 0));
   keys.push_back(IndexDataKey::Encode(1, 2, 30, MinIDBKey(), MinIDBKey(), 0));
-  keys.push_back(
-      IndexDataKey::EncodeMaxKey(1, 2, std::numeric_limits<int32>::max() - 1));
+  keys.push_back(IndexDataKey::EncodeMaxKey(
+      1, 2, std::numeric_limits<int32_t>::max() - 1));
 
   for (size_t i = 0; i < keys.size(); ++i) {
     EXPECT_EQ(Compare(keys[i], keys[i], false), 0);
 
     for (size_t j = i + 1; j < keys.size(); ++j) {
       EXPECT_LT(Compare(keys[i], keys[j], false), 0);
       EXPECT_GT(Compare(keys[j], keys[i], false), 0);
     }
   }
 }
 
 TEST(IndexedDBLevelDBCodingTest, EncodeVarIntVSEncodeByteTest) {
   std::vector<unsigned char> test_cases;
   test_cases.push_back(0);
   test_cases.push_back(1);
   test_cases.push_back(127);
 
   for (size_t i = 0; i < test_cases.size(); ++i) {
     unsigned char n = test_cases[i];
 
     std::string a = WrappedEncodeByte(n);
-    std::string b = WrappedEncodeVarInt(static_cast<int64>(n));
+    std::string b = WrappedEncodeVarInt(static_cast<int64_t>(n));
 
     EXPECT_EQ(a.size(), b.size());
     EXPECT_EQ(*a.begin(), *b.begin());
   }
 }
 
 }  // namespace
 
 }  // namespace content