Switch to standard integer types in content/browser/.

content/browser/indexed_db/indexed_db_leveldb_coding.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 <iterator>
 #include <limits>
 
 #include "base/logging.h"
@@ skipping 205 matching lines @@
 static const unsigned char kObjectStoreFreeListTypeByte = 150;
 static const unsigned char kIndexFreeListTypeByte = 151;
 static const unsigned char kObjectStoreNamesTypeByte = 200;
 static const unsigned char kIndexNamesKeyTypeByte = 201;
 
 static const unsigned char kObjectMetaDataTypeMaximum = 255;
 static const unsigned char kIndexMetaDataTypeMaximum = 255;
 
 const unsigned char kMinimumIndexId = 30;
 
-inline void EncodeIntSafely(int64 value, int64 max, std::string* into) {
+inline void EncodeIntSafely(int64_t value, int64_t max, std::string* into) {
   DCHECK_LE(value, max);
   return EncodeInt(value, into);
 }
 
 std::string MaxIDBKey() {
   std::string ret;
   EncodeByte(kIndexedDBKeyNullTypeByte, &ret);
   return ret;
 }
 
 std::string MinIDBKey() {
   std::string ret;
   EncodeByte(kIndexedDBKeyMinKeyTypeByte, &ret);
   return ret;
 }
 
 void EncodeByte(unsigned char value, std::string* into) {
   into->push_back(value);
 }
 
 void EncodeBool(bool value, std::string* into) {
   into->push_back(value ? 1 : 0);
 }
 
-void EncodeInt(int64 value, std::string* into) {
+void EncodeInt(int64_t value, std::string* into) {
 #ifndef NDEBUG
   // Exercised by unit tests in debug only.
   DCHECK_GE(value, 0);
 #endif
-  uint64 n = static_cast<uint64>(value);
+  uint64_t n = static_cast<uint64_t>(value);
 
   do {
     unsigned char c = n;
     into->push_back(c);
     n >>= 8;
   } while (n);
 }
 
-void EncodeVarInt(int64 value, std::string* into) {
+void EncodeVarInt(int64_t value, std::string* into) {
 #ifndef NDEBUG
   // Exercised by unit tests in debug only.
   DCHECK_GE(value, 0);
 #endif
-  uint64 n = static_cast<uint64>(value);
+  uint64_t n = static_cast<uint64_t>(value);
 
   do {
     unsigned char c = n & 0x7f;
     n >>= 7;
     if (n)
       c |= 0x80;
     into->push_back(c);
   } while (n);
 }
 
@@ skipping 116 matching lines @@
 
 bool DecodeBool(StringPiece* slice, bool* value) {
   if (slice->empty())
     return false;
 
   *value = !!(*slice)[0];
   slice->remove_prefix(1);
   return true;
 }
 
-bool DecodeInt(StringPiece* slice, int64* value) {
+bool DecodeInt(StringPiece* slice, int64_t* value) {
   if (slice->empty())
     return false;
 
   StringPiece::const_iterator it = slice->begin();
   int shift = 0;
-  int64 ret = 0;
+  int64_t ret = 0;
   while (it != slice->end()) {
     unsigned char c = *it++;
-    ret |= static_cast<int64>(c) << shift;
+    ret |= static_cast<int64_t>(c) << shift;
     shift += 8;
   }
   *value = ret;
   slice->remove_prefix(it - slice->begin());
   return true;
 }
 
-bool DecodeVarInt(StringPiece* slice, int64* value) {
+bool DecodeVarInt(StringPiece* slice, int64_t* value) {
   if (slice->empty())
     return false;
 
   StringPiece::const_iterator it = slice->begin();
   int shift = 0;
-  int64 ret = 0;
+  int64_t ret = 0;
   do {
     if (it == slice->end())
       return false;
 
     unsigned char c = *it;
-    ret |= static_cast<int64>(c & 0x7f) << shift;
+    ret |= static_cast<int64_t>(c & 0x7f) << shift;
     shift += 7;
   } while (*it++ & 0x80);
   *value = ret;
   slice->remove_prefix(it - slice->begin());
   return true;
 }
 
 bool DecodeString(StringPiece* slice, base::string16* value) {
   if (slice->empty()) {
     value->clear();
@@ skipping 12 matching lines @@
 
   *value = decoded;
   slice->remove_prefix(length * sizeof(base::char16));
   return true;
 }
 
 bool DecodeStringWithLength(StringPiece* slice, base::string16* value) {
   if (slice->empty())
     return false;
 
-  int64 length = 0;
+  int64_t length = 0;
   if (!DecodeVarInt(slice, &length) || length < 0)
     return false;
   size_t bytes = length * sizeof(base::char16);
   if (slice->size() < bytes)
     return false;
 
   StringPiece subpiece(slice->begin(), bytes);
   slice->remove_prefix(bytes);
   if (!DecodeString(&subpiece, value))
     return false;
 
   return true;
 }
 
 bool DecodeBinary(StringPiece* slice, std::string* value) {
   if (slice->empty())
     return false;
 
-  int64 length = 0;
+  int64_t length = 0;
   if (!DecodeVarInt(slice, &length) || length < 0)
     return false;
   size_t size = length;
   if (slice->size() < size)
     return false;
 
   value->assign(slice->begin(), size);
   slice->remove_prefix(size);
   return true;
 }
 
 bool DecodeIDBKey(StringPiece* slice, scoped_ptr<IndexedDBKey>* value) {
   if (slice->empty())
     return false;
 
   unsigned char type = (*slice)[0];
   slice->remove_prefix(1);
 
   switch (type) {
     case kIndexedDBKeyNullTypeByte:
       *value = make_scoped_ptr(new IndexedDBKey());
       return true;
 
     case kIndexedDBKeyArrayTypeByte: {
-      int64 length = 0;
+      int64_t length = 0;
       if (!DecodeVarInt(slice, &length) || length < 0)
         return false;
       IndexedDBKey::KeyArray array;
       while (length--) {
         scoped_ptr<IndexedDBKey> key;
         if (!DecodeIDBKey(slice, &key))
           return false;
         array.push_back(*key);
       }
       *value = make_scoped_ptr(new IndexedDBKey(array));
@@ skipping 68 matching lines @@
     case WebIDBKeyPathTypeString: {
       base::string16 string;
       if (!DecodeStringWithLength(slice, &string))
         return false;
       DCHECK(slice->empty());
       *value = IndexedDBKeyPath(string);
       return true;
     }
     case WebIDBKeyPathTypeArray: {
       std::vector<base::string16> array;
-      int64 count;
+      int64_t count;
       if (!DecodeVarInt(slice, &count))
         return false;
       DCHECK_GE(count, 0);
       while (count--) {
         base::string16 string;
         if (!DecodeStringWithLength(slice, &string))
           return false;
         array.push_back(string);
       }
       DCHECK(slice->empty());
       *value = IndexedDBKeyPath(array);
       return true;
     }
   }
   NOTREACHED();
   return false;
 }
 
 bool DecodeBlobJournal(StringPiece* slice, BlobJournalType* journal) {
   BlobJournalType output;
   while (!slice->empty()) {
-    int64 database_id = -1;
-    int64 blob_key = -1;
+    int64_t database_id = -1;
+    int64_t blob_key = -1;
     if (!DecodeVarInt(slice, &database_id))
       return false;
     if (!KeyPrefix::IsValidDatabaseId(database_id))
       return false;
     if (!DecodeVarInt(slice, &blob_key))
       return false;
     if (!DatabaseMetaDataKey::IsValidBlobKey(blob_key) &&
         (blob_key != DatabaseMetaDataKey::kAllBlobsKey)) {
       return false;
     }
     output.push_back(std::make_pair(database_id, blob_key));
   }
   journal->swap(output);
   return true;
 }
 
 bool ConsumeEncodedIDBKey(StringPiece* slice) {
   unsigned char type = (*slice)[0];
   slice->remove_prefix(1);
 
   switch (type) {
     case kIndexedDBKeyNullTypeByte:
     case kIndexedDBKeyMinKeyTypeByte:
       return true;
     case kIndexedDBKeyArrayTypeByte: {
-      int64 length;
+      int64_t length;
       if (!DecodeVarInt(slice, &length))
         return false;
       while (length--) {
         if (!ConsumeEncodedIDBKey(slice))
           return false;
       }
       return true;
     }
     case kIndexedDBKeyBinaryTypeByte: {
-      int64 length = 0;
+      int64_t length = 0;
       if (!DecodeVarInt(slice, &length) || length < 0)
         return false;
       if (slice->size() < static_cast<size_t>(length))
         return false;
       slice->remove_prefix(length);
       return true;
     }
     case kIndexedDBKeyStringTypeByte: {
-      int64 length = 0;
+      int64_t length = 0;
       if (!DecodeVarInt(slice, &length) || length < 0)
         return false;
       if (slice->size() < static_cast<size_t>(length) * sizeof(base::char16))
         return false;
       slice->remove_prefix(length * sizeof(base::char16));
       return true;
     }
     case kIndexedDBKeyDateTypeByte:
     case kIndexedDBKeyNumberTypeByte:
       if (slice->size() < sizeof(double))
@@ skipping 33 matching lines @@
       return WebIDBKeyTypeMin;
   }
 
   NOTREACHED();
   return WebIDBKeyTypeInvalid;
 }
 
 int CompareEncodedStringsWithLength(StringPiece* slice1,
                                     StringPiece* slice2,
                                     bool* ok) {
-  int64 len1, len2;
+  int64_t len1, len2;
   if (!DecodeVarInt(slice1, &len1) || !DecodeVarInt(slice2, &len2)) {
     *ok = false;
     return 0;
   }
   DCHECK_GE(len1, 0);
   DCHECK_GE(len2, 0);
   if (len1 < 0 || len2 < 0) {
     *ok = false;
     return 0;
   }
@@ skipping 12 matching lines @@
   slice2->remove_prefix(len2 * sizeof(base::char16));
 
   *ok = true;
   // Strings are UTF-16BE encoded, so a simple memcmp is sufficient.
   return string1.compare(string2);
 }
 
 int CompareEncodedBinary(StringPiece* slice1,
                          StringPiece* slice2,
                          bool* ok) {
-  int64 len1, len2;
+  int64_t len1, len2;
   if (!DecodeVarInt(slice1, &len1) || !DecodeVarInt(slice2, &len2)) {
     *ok = false;
     return 0;
   }
   DCHECK_GE(len1, 0);
   DCHECK_GE(len2, 0);
   if (len1 < 0 || len2 < 0) {
     *ok = false;
     return 0;
   }
@@ skipping 11 matching lines @@
   StringPiece binary1(slice1->begin(), size1);
   StringPiece binary2(slice2->begin(), size2);
   slice1->remove_prefix(size1);
   slice2->remove_prefix(size2);
 
   *ok = true;
   // This is the same as a memcmp()
   return binary1.compare(binary2);
 }
 
-static int CompareInts(int64 a, int64 b) {
+static int CompareInts(int64_t a, int64_t b) {
 #ifndef NDEBUG
   // Exercised by unit tests in debug only.
   DCHECK_GE(a, 0);
   DCHECK_GE(b, 0);
 #endif
-  int64 diff = a - b;
+  int64_t diff = a - b;
   if (diff < 0)
     return -1;
   if (diff > 0)
     return 1;
   return 0;
 }
 
 static inline int CompareSizes(size_t a, size_t b) {
   if (a > b)
     return 1;
@@ skipping 18 matching lines @@
   if (int x = CompareTypes(KeyTypeByteToKeyType(type_a),
                            KeyTypeByteToKeyType(type_b)))
     return x;
 
   switch (type_a) {
     case kIndexedDBKeyNullTypeByte:
     case kIndexedDBKeyMinKeyTypeByte:
       // Null type or max type; no payload to compare.
       return 0;
     case kIndexedDBKeyArrayTypeByte: {
-      int64 length_a, length_b;
+      int64_t length_a, length_b;
       if (!DecodeVarInt(slice_a, &length_a) ||
           !DecodeVarInt(slice_b, &length_b)) {
         *ok = false;
         return 0;
       }
-      for (int64 i = 0; i < length_a && i < length_b; ++i) {
+      for (int64_t i = 0; i < length_a && i < length_b; ++i) {
         int result = CompareEncodedIDBKeys(slice_a, slice_b, ok);
         if (!*ok || result)
           return result;
       }
       return length_a - length_b;
     }
     case kIndexedDBKeyBinaryTypeByte:
       return CompareEncodedBinary(slice_a, slice_b, ok);
     case kIndexedDBKeyStringTypeByte:
       return CompareEncodedStringsWithLength(slice_a, slice_b, ok);
@@ skipping 82 matching lines @@
                                 bool only_compare_index_keys,
                                 bool* ok) {
   // index key
   int result = CompareEncodedIDBKeys(slice_a, slice_b, ok);
   if (!*ok || result)
     return result;
   if (only_compare_index_keys)
     return 0;
 
   // sequence number [optional]
-  int64 sequence_number_a = -1;
-  int64 sequence_number_b = -1;
+  int64_t sequence_number_a = -1;
+  int64_t sequence_number_b = -1;
   if (!slice_a->empty() && !DecodeVarInt(slice_a, &sequence_number_a))
       return 0;
   if (!slice_b->empty() && !DecodeVarInt(slice_b, &sequence_number_b))
       return 0;
 
   if (slice_a->empty() || slice_b->empty())
     return CompareSizes(slice_a->size(), slice_b->size());
 
   // primary key [optional]
   result = CompareEncodedIDBKeys(slice_a, slice_b, ok);
@@ skipping 171 matching lines @@
   if (!ok)
     return 0;
   return result;
 }
 
 KeyPrefix::KeyPrefix()
     : database_id_(INVALID_TYPE),
       object_store_id_(INVALID_TYPE),
       index_id_(INVALID_TYPE) {}
 
-KeyPrefix::KeyPrefix(int64 database_id)
+KeyPrefix::KeyPrefix(int64_t database_id)
     : database_id_(database_id), object_store_id_(0), index_id_(0) {
   DCHECK(KeyPrefix::IsValidDatabaseId(database_id));
 }
 
-KeyPrefix::KeyPrefix(int64 database_id, int64 object_store_id)
+KeyPrefix::KeyPrefix(int64_t database_id, int64_t object_store_id)
     : database_id_(database_id),
       object_store_id_(object_store_id),
       index_id_(0) {
   DCHECK(KeyPrefix::IsValidDatabaseId(database_id));
   DCHECK(KeyPrefix::IsValidObjectStoreId(object_store_id));
 }
 
-KeyPrefix::KeyPrefix(int64 database_id, int64 object_store_id, int64 index_id)
+KeyPrefix::KeyPrefix(int64_t database_id,
+                     int64_t object_store_id,
+                     int64_t index_id)
     : database_id_(database_id),
       object_store_id_(object_store_id),
       index_id_(index_id) {
   DCHECK(KeyPrefix::IsValidDatabaseId(database_id));
   DCHECK(KeyPrefix::IsValidObjectStoreId(object_store_id));
   DCHECK(KeyPrefix::IsValidIndexId(index_id));
 }
 
 KeyPrefix::KeyPrefix(enum Type type,
-                     int64 database_id,
-                     int64 object_store_id,
-                     int64 index_id)
+                     int64_t database_id,
+                     int64_t object_store_id,
+                     int64_t index_id)
     : database_id_(database_id),
       object_store_id_(object_store_id),
       index_id_(index_id) {
   DCHECK_EQ(type, INVALID_TYPE);
   DCHECK(KeyPrefix::IsValidDatabaseId(database_id));
   DCHECK(KeyPrefix::IsValidObjectStoreId(object_store_id));
 }
 
-KeyPrefix KeyPrefix::CreateWithSpecialIndex(int64 database_id,
-                                            int64 object_store_id,
-                                            int64 index_id) {
+KeyPrefix KeyPrefix::CreateWithSpecialIndex(int64_t database_id,
+                                            int64_t object_store_id,
+                                            int64_t index_id) {
   DCHECK(KeyPrefix::IsValidDatabaseId(database_id));
   DCHECK(KeyPrefix::IsValidObjectStoreId(object_store_id));
   DCHECK(index_id);
   return KeyPrefix(INVALID_TYPE, database_id, object_store_id, index_id);
 }
 
-bool KeyPrefix::IsValidDatabaseId(int64 database_id) {
+bool KeyPrefix::IsValidDatabaseId(int64_t database_id) {
   return (database_id > 0) && (database_id < KeyPrefix::kMaxDatabaseId);
 }
 
-bool KeyPrefix::IsValidObjectStoreId(int64 object_store_id) {
+bool KeyPrefix::IsValidObjectStoreId(int64_t object_store_id) {
   return (object_store_id > 0) &&
          (object_store_id < KeyPrefix::kMaxObjectStoreId);
 }
 
-bool KeyPrefix::IsValidIndexId(int64 index_id) {
+bool KeyPrefix::IsValidIndexId(int64_t index_id) {
   return (index_id >= kMinimumIndexId) && (index_id < KeyPrefix::kMaxIndexId);
 }
 
 bool KeyPrefix::Decode(StringPiece* slice, KeyPrefix* result) {
   unsigned char first_byte;
   if (!DecodeByte(slice, &first_byte))
     return false;
 
   size_t database_id_bytes = ((first_byte >> 5) & 0x7) + 1;
   size_t object_store_id_bytes = ((first_byte >> 2) & 0x7) + 1;
@@ skipping 30 matching lines @@
   return result;
 }
 
 std::string KeyPrefix::Encode() const {
   DCHECK(database_id_ != kInvalidId);
   DCHECK(object_store_id_ != kInvalidId);
   DCHECK(index_id_ != kInvalidId);
   return EncodeInternal(database_id_, object_store_id_, index_id_);
 }
 
-std::string KeyPrefix::EncodeInternal(int64 database_id,
-                                      int64 object_store_id,
-                                      int64 index_id) {
+std::string KeyPrefix::EncodeInternal(int64_t database_id,
+                                      int64_t object_store_id,
+                                      int64_t index_id) {
   std::string database_id_string;
   std::string object_store_id_string;
   std::string index_id_string;
 
   EncodeIntSafely(database_id, kMaxDatabaseId, &database_id_string);
   EncodeIntSafely(object_store_id, kMaxObjectStoreId, &object_store_id_string);
   EncodeIntSafely(index_id, kMaxIndexId, &index_id_string);
 
   DCHECK(database_id_string.size() <= kMaxDatabaseIdSizeBytes);
   DCHECK(object_store_id_string.size() <= kMaxObjectStoreIdSizeBytes);
@@ skipping 97 matching lines @@
   DCHECK(!prefix.index_id_);
   unsigned char type_byte = 0;
   if (!DecodeByte(slice, &type_byte))
     return false;
   DCHECK_EQ(type_byte, kDatabaseFreeListTypeByte);
   if (!DecodeVarInt(slice, &result->database_id_))
     return false;
   return true;
 }
 
-std::string DatabaseFreeListKey::Encode(int64 database_id) {
+std::string DatabaseFreeListKey::Encode(int64_t database_id) {
   std::string ret = KeyPrefix::EncodeEmpty();
   ret.push_back(kDatabaseFreeListTypeByte);
   EncodeVarInt(database_id, &ret);
   return ret;
 }
 
 std::string DatabaseFreeListKey::EncodeMaxKey() {
-  return Encode(std::numeric_limits<int64>::max());
+  return Encode(std::numeric_limits<int64_t>::max());
 }
 
-int64 DatabaseFreeListKey::DatabaseId() const {
+int64_t DatabaseFreeListKey::DatabaseId() const {
   DCHECK_GE(database_id_, 0);
   return database_id_;
 }
 
 int DatabaseFreeListKey::Compare(const DatabaseFreeListKey& other) const {
   DCHECK_GE(database_id_, 0);
   return CompareInts(database_id_, other.database_id_);
 }
 
 bool DatabaseNameKey::Decode(StringPiece* slice, DatabaseNameKey* result) {
@@ skipping 33 matching lines @@
   // just after origin in collation order
   return EncodeMinKeyForOrigin(origin_identifier + '\x01');
 }
 
 int DatabaseNameKey::Compare(const DatabaseNameKey& other) {
   if (int x = origin_.compare(other.origin_))
     return x;
   return database_name_.compare(other.database_name_);
 }
 
-bool DatabaseMetaDataKey::IsValidBlobKey(int64 blob_key) {
+bool DatabaseMetaDataKey::IsValidBlobKey(int64_t blob_key) {
   return blob_key >= kBlobKeyGeneratorInitialNumber;
 }
 
-const int64 DatabaseMetaDataKey::kAllBlobsKey = 1;
-const int64 DatabaseMetaDataKey::kBlobKeyGeneratorInitialNumber = 2;
-const int64 DatabaseMetaDataKey::kInvalidBlobKey = -1;
+const int64_t DatabaseMetaDataKey::kAllBlobsKey = 1;
+const int64_t DatabaseMetaDataKey::kBlobKeyGeneratorInitialNumber = 2;
+const int64_t DatabaseMetaDataKey::kInvalidBlobKey = -1;
 
-std::string DatabaseMetaDataKey::Encode(int64 database_id,
+std::string DatabaseMetaDataKey::Encode(int64_t database_id,
                                         MetaDataType meta_data_type) {
   KeyPrefix prefix(database_id);
   std::string ret = prefix.Encode();
   ret.push_back(meta_data_type);
   return ret;
 }
 
 ObjectStoreMetaDataKey::ObjectStoreMetaDataKey()
     : object_store_id_(-1), meta_data_type_(0xFF) {}
 
@@ skipping 10 matching lines @@
     return false;
   DCHECK_EQ(type_byte, kObjectStoreMetaDataTypeByte);
   if (!DecodeVarInt(slice, &result->object_store_id_))
     return false;
   DCHECK(result->object_store_id_);
   if (!DecodeByte(slice, &result->meta_data_type_))
     return false;
   return true;
 }
 
-std::string ObjectStoreMetaDataKey::Encode(int64 database_id,
-                                           int64 object_store_id,
+std::string ObjectStoreMetaDataKey::Encode(int64_t database_id,
+                                           int64_t object_store_id,
                                            unsigned char meta_data_type) {
   KeyPrefix prefix(database_id);
   std::string ret = prefix.Encode();
   ret.push_back(kObjectStoreMetaDataTypeByte);
   EncodeVarInt(object_store_id, &ret);
   ret.push_back(meta_data_type);
   return ret;
 }
 
-std::string ObjectStoreMetaDataKey::EncodeMaxKey(int64 database_id) {
-  return Encode(database_id,
-                std::numeric_limits<int64>::max(),
+std::string ObjectStoreMetaDataKey::EncodeMaxKey(int64_t database_id) {
+  return Encode(database_id, std::numeric_limits<int64_t>::max(),
                 kObjectMetaDataTypeMaximum);
 }
 
-std::string ObjectStoreMetaDataKey::EncodeMaxKey(int64 database_id,
-                                                 int64 object_store_id) {
+std::string ObjectStoreMetaDataKey::EncodeMaxKey(int64_t database_id,
+                                                 int64_t object_store_id) {
   return Encode(database_id, object_store_id, kObjectMetaDataTypeMaximum);
 }
 
-int64 ObjectStoreMetaDataKey::ObjectStoreId() const {
+int64_t ObjectStoreMetaDataKey::ObjectStoreId() const {
   DCHECK_GE(object_store_id_, 0);
   return object_store_id_;
 }
 unsigned char ObjectStoreMetaDataKey::MetaDataType() const {
   return meta_data_type_;
 }
 
 int ObjectStoreMetaDataKey::Compare(const ObjectStoreMetaDataKey& other) {
   DCHECK_GE(object_store_id_, 0);
   if (int x = CompareInts(object_store_id_, other.object_store_id_))
@@ skipping 17 matching lines @@
   DCHECK_EQ(type_byte, kIndexMetaDataTypeByte);
   if (!DecodeVarInt(slice, &result->object_store_id_))
     return false;
   if (!DecodeVarInt(slice, &result->index_id_))
     return false;
   if (!DecodeByte(slice, &result->meta_data_type_))
     return false;
   return true;
 }
 
-std::string IndexMetaDataKey::Encode(int64 database_id,
-                                     int64 object_store_id,
-                                     int64 index_id,
+std::string IndexMetaDataKey::Encode(int64_t database_id,
+                                     int64_t object_store_id,
+                                     int64_t index_id,
                                      unsigned char meta_data_type) {
   KeyPrefix prefix(database_id);
   std::string ret = prefix.Encode();
   ret.push_back(kIndexMetaDataTypeByte);
   EncodeVarInt(object_store_id, &ret);
   EncodeVarInt(index_id, &ret);
   EncodeByte(meta_data_type, &ret);
   return ret;
 }
 
-std::string IndexMetaDataKey::EncodeMaxKey(int64 database_id,
-                                           int64 object_store_id) {
-  return Encode(database_id,
-                object_store_id,
-                std::numeric_limits<int64>::max(),
-                kIndexMetaDataTypeMaximum);
+std::string IndexMetaDataKey::EncodeMaxKey(int64_t database_id,
+                                           int64_t object_store_id) {
+  return Encode(database_id, object_store_id,
+                std::numeric_limits<int64_t>::max(), kIndexMetaDataTypeMaximum);
 }
 
-std::string IndexMetaDataKey::EncodeMaxKey(int64 database_id,
-                                           int64 object_store_id,
-                                           int64 index_id) {
+std::string IndexMetaDataKey::EncodeMaxKey(int64_t database_id,
+                                           int64_t object_store_id,
+                                           int64_t index_id) {
   return Encode(
       database_id, object_store_id, index_id, kIndexMetaDataTypeMaximum);
 }
 
 int IndexMetaDataKey::Compare(const IndexMetaDataKey& other) {
   DCHECK_GE(object_store_id_, 0);
   DCHECK_GE(index_id_, 0);
 
   if (int x = CompareInts(object_store_id_, other.object_store_id_))
     return x;
   if (int x = CompareInts(index_id_, other.index_id_))
     return x;
   return meta_data_type_ - other.meta_data_type_;
 }
 
-int64 IndexMetaDataKey::IndexId() const {
+int64_t IndexMetaDataKey::IndexId() const {
   DCHECK_GE(index_id_, 0);
   return index_id_;
 }
 
 ObjectStoreFreeListKey::ObjectStoreFreeListKey() : object_store_id_(-1) {}
 
 bool ObjectStoreFreeListKey::Decode(StringPiece* slice,
                                     ObjectStoreFreeListKey* result) {
   KeyPrefix prefix;
   if (!KeyPrefix::Decode(slice, &prefix))
     return false;
   DCHECK(prefix.database_id_);
   DCHECK(!prefix.object_store_id_);
   DCHECK(!prefix.index_id_);
   unsigned char type_byte = 0;
   if (!DecodeByte(slice, &type_byte))
     return false;
   DCHECK_EQ(type_byte, kObjectStoreFreeListTypeByte);
   if (!DecodeVarInt(slice, &result->object_store_id_))
     return false;
   return true;
 }
 
-std::string ObjectStoreFreeListKey::Encode(int64 database_id,
-                                           int64 object_store_id) {
+std::string ObjectStoreFreeListKey::Encode(int64_t database_id,
+                                           int64_t object_store_id) {
   KeyPrefix prefix(database_id);
   std::string ret = prefix.Encode();
   ret.push_back(kObjectStoreFreeListTypeByte);
   EncodeVarInt(object_store_id, &ret);
   return ret;
 }
 
-std::string ObjectStoreFreeListKey::EncodeMaxKey(int64 database_id) {
-  return Encode(database_id, std::numeric_limits<int64>::max());
+std::string ObjectStoreFreeListKey::EncodeMaxKey(int64_t database_id) {
+  return Encode(database_id, std::numeric_limits<int64_t>::max());
 }
 
-int64 ObjectStoreFreeListKey::ObjectStoreId() const {
+int64_t ObjectStoreFreeListKey::ObjectStoreId() const {
   DCHECK_GE(object_store_id_, 0);
   return object_store_id_;
 }
 
 int ObjectStoreFreeListKey::Compare(const ObjectStoreFreeListKey& other) {
   // TODO(jsbell): It may seem strange that we're not comparing database id's,
   // but that comparison will have been made earlier.
   // We should probably make this more clear, though...
   DCHECK_GE(object_store_id_, 0);
   return CompareInts(object_store_id_, other.object_store_id_);
@@ skipping 12 matching lines @@
   if (!DecodeByte(slice, &type_byte))
     return false;
   DCHECK_EQ(type_byte, kIndexFreeListTypeByte);
   if (!DecodeVarInt(slice, &result->object_store_id_))
     return false;
   if (!DecodeVarInt(slice, &result->index_id_))
     return false;
   return true;
 }
 
-std::string IndexFreeListKey::Encode(int64 database_id,
-                                     int64 object_store_id,
-                                     int64 index_id) {
+std::string IndexFreeListKey::Encode(int64_t database_id,
+                                     int64_t object_store_id,
+                                     int64_t index_id) {
   KeyPrefix prefix(database_id);
   std::string ret = prefix.Encode();
   ret.push_back(kIndexFreeListTypeByte);
   EncodeVarInt(object_store_id, &ret);
   EncodeVarInt(index_id, &ret);
   return ret;
 }
 
-std::string IndexFreeListKey::EncodeMaxKey(int64 database_id,
-                                           int64 object_store_id) {
-  return Encode(
-      database_id, object_store_id, std::numeric_limits<int64>::max());
+std::string IndexFreeListKey::EncodeMaxKey(int64_t database_id,
+                                           int64_t object_store_id) {
+  return Encode(database_id, object_store_id,
+                std::numeric_limits<int64_t>::max());
 }
 
 int IndexFreeListKey::Compare(const IndexFreeListKey& other) {
   DCHECK_GE(object_store_id_, 0);
   DCHECK_GE(index_id_, 0);
   if (int x = CompareInts(object_store_id_, other.object_store_id_))
     return x;
   return CompareInts(index_id_, other.index_id_);
 }
 
-int64 IndexFreeListKey::ObjectStoreId() const {
+int64_t IndexFreeListKey::ObjectStoreId() const {
   DCHECK_GE(object_store_id_, 0);
   return object_store_id_;
 }
 
-int64 IndexFreeListKey::IndexId() const {
+int64_t IndexFreeListKey::IndexId() const {
   DCHECK_GE(index_id_, 0);
   return index_id_;
 }
 
 // TODO(jsbell): We never use this to look up object store ids,
 // because a mapping is kept in the IndexedDBDatabase. Can the
 // mapping become unreliable?  Can we remove this?
 bool ObjectStoreNamesKey::Decode(StringPiece* slice,
                                  ObjectStoreNamesKey* result) {
   KeyPrefix prefix;
   if (!KeyPrefix::Decode(slice, &prefix))
     return false;
   DCHECK(prefix.database_id_);
   DCHECK(!prefix.object_store_id_);
   DCHECK(!prefix.index_id_);
   unsigned char type_byte = 0;
   if (!DecodeByte(slice, &type_byte))
     return false;
   DCHECK_EQ(type_byte, kObjectStoreNamesTypeByte);
   if (!DecodeStringWithLength(slice, &result->object_store_name_))
     return false;
   return true;
 }
 
 std::string ObjectStoreNamesKey::Encode(
-    int64 database_id,
+    int64_t database_id,
     const base::string16& object_store_name) {
   KeyPrefix prefix(database_id);
   std::string ret = prefix.Encode();
   ret.push_back(kObjectStoreNamesTypeByte);
   EncodeStringWithLength(object_store_name, &ret);
   return ret;
 }
 
 int ObjectStoreNamesKey::Compare(const ObjectStoreNamesKey& other) {
   return object_store_name_.compare(other.object_store_name_);
@@ skipping 14 matching lines @@
   if (!DecodeByte(slice, &type_byte))
     return false;
   DCHECK_EQ(type_byte, kIndexNamesKeyTypeByte);
   if (!DecodeVarInt(slice, &result->object_store_id_))
     return false;
   if (!DecodeStringWithLength(slice, &result->index_name_))
     return false;
   return true;
 }
 
-std::string IndexNamesKey::Encode(int64 database_id,
-                                  int64 object_store_id,
+std::string IndexNamesKey::Encode(int64_t database_id,
+                                  int64_t object_store_id,
                                   const base::string16& index_name) {
   KeyPrefix prefix(database_id);
   std::string ret = prefix.Encode();
   ret.push_back(kIndexNamesKeyTypeByte);
   EncodeVarInt(object_store_id, &ret);
   EncodeStringWithLength(index_name, &ret);
   return ret;
 }
 
 int IndexNamesKey::Compare(const IndexNamesKey& other) {
@@ skipping 12 matching lines @@
   if (!KeyPrefix::Decode(slice, &prefix))
     return false;
   DCHECK(prefix.database_id_);
   DCHECK(prefix.object_store_id_);
   DCHECK_EQ(prefix.index_id_, kSpecialIndexNumber);
   if (!ExtractEncodedIDBKey(slice, &result->encoded_user_key_))
     return false;
   return true;
 }
 
-std::string ObjectStoreDataKey::Encode(int64 database_id,
-                                       int64 object_store_id,
+std::string ObjectStoreDataKey::Encode(int64_t database_id,
+                                       int64_t object_store_id,
                                        const std::string encoded_user_key) {
   KeyPrefix prefix(KeyPrefix::CreateWithSpecialIndex(
       database_id, object_store_id, kSpecialIndexNumber));
   std::string ret = prefix.Encode();
   ret.append(encoded_user_key);
 
   return ret;
 }
 
-std::string ObjectStoreDataKey::Encode(int64 database_id,
-                                       int64 object_store_id,
+std::string ObjectStoreDataKey::Encode(int64_t database_id,
+                                       int64_t object_store_id,
                                        const IndexedDBKey& user_key) {
   std::string encoded_key;
   EncodeIDBKey(user_key, &encoded_key);
   return Encode(database_id, object_store_id, encoded_key);
 }
 
 scoped_ptr<IndexedDBKey> ObjectStoreDataKey::user_key() const {
   scoped_ptr<IndexedDBKey> key;
   StringPiece slice(encoded_user_key_);
   if (!DecodeIDBKey(&slice, &key)) {
     // TODO(jsbell): Return error.
   }
   return key.Pass();
 }
 
-const int64 ObjectStoreDataKey::kSpecialIndexNumber = kObjectStoreDataIndexId;
+const int64_t ObjectStoreDataKey::kSpecialIndexNumber = kObjectStoreDataIndexId;
 
 ExistsEntryKey::ExistsEntryKey() {}
 ExistsEntryKey::~ExistsEntryKey() {}
 
 bool ExistsEntryKey::Decode(StringPiece* slice, ExistsEntryKey* result) {
   KeyPrefix prefix;
   if (!KeyPrefix::Decode(slice, &prefix))
     return false;
   DCHECK(prefix.database_id_);
   DCHECK(prefix.object_store_id_);
   DCHECK_EQ(prefix.index_id_, kSpecialIndexNumber);
   if (!ExtractEncodedIDBKey(slice, &result->encoded_user_key_))
     return false;
   return true;
 }
 
-std::string ExistsEntryKey::Encode(int64 database_id,
-                                   int64 object_store_id,
+std::string ExistsEntryKey::Encode(int64_t database_id,
+                                   int64_t object_store_id,
                                    const std::string& encoded_key) {
   KeyPrefix prefix(KeyPrefix::CreateWithSpecialIndex(
       database_id, object_store_id, kSpecialIndexNumber));
   std::string ret = prefix.Encode();
   ret.append(encoded_key);
   return ret;
 }
 
-std::string ExistsEntryKey::Encode(int64 database_id,
-                                   int64 object_store_id,
+std::string ExistsEntryKey::Encode(int64_t database_id,
+                                   int64_t object_store_id,
                                    const IndexedDBKey& user_key) {
   std::string encoded_key;
   EncodeIDBKey(user_key, &encoded_key);
   return Encode(database_id, object_store_id, encoded_key);
 }
 
 scoped_ptr<IndexedDBKey> ExistsEntryKey::user_key() const {
   scoped_ptr<IndexedDBKey> key;
   StringPiece slice(encoded_user_key_);
   if (!DecodeIDBKey(&slice, &key)) {
     // TODO(jsbell): Return error.
   }
   return key.Pass();
 }
 
-const int64 ExistsEntryKey::kSpecialIndexNumber = kExistsEntryIndexId;
+const int64_t ExistsEntryKey::kSpecialIndexNumber = kExistsEntryIndexId;
 
 bool BlobEntryKey::Decode(StringPiece* slice, BlobEntryKey* result) {
   KeyPrefix prefix;
   if (!KeyPrefix::Decode(slice, &prefix))
     return false;
   DCHECK(prefix.database_id_);
   DCHECK(prefix.object_store_id_);
   DCHECK_EQ(prefix.index_id_, kSpecialIndexNumber);
 
   if (!ExtractEncodedIDBKey(slice, &result->encoded_user_key_))
@@ skipping 23 matching lines @@
 std::string BlobEntryKey::ReencodeToObjectStoreDataKey(StringPiece* slice) {
   // TODO(ericu): We could be more efficient here, since the suffix is the same.
   BlobEntryKey key;
   if (!Decode(slice, &key))
     return std::string();
 
   return ObjectStoreDataKey::Encode(
       key.database_id_, key.object_store_id_, key.encoded_user_key_);
 }
 
-std::string BlobEntryKey::EncodeMinKeyForObjectStore(int64 database_id,
-                                                     int64 object_store_id) {
+std::string BlobEntryKey::EncodeMinKeyForObjectStore(int64_t database_id,
+                                                     int64_t object_store_id) {
   // Our implied encoded_user_key_ here is empty, the lowest possible key.
   return Encode(database_id, object_store_id, std::string());
 }
 
-std::string BlobEntryKey::EncodeStopKeyForObjectStore(int64 database_id,
-                                                      int64 object_store_id) {
+std::string BlobEntryKey::EncodeStopKeyForObjectStore(int64_t database_id,
+                                                      int64_t object_store_id) {
   DCHECK(KeyPrefix::ValidIds(database_id, object_store_id));
   KeyPrefix prefix(KeyPrefix::CreateWithSpecialIndex(
       database_id, object_store_id, kSpecialIndexNumber + 1));
   return prefix.Encode();
 }
 
 std::string BlobEntryKey::Encode() const {
   DCHECK(!encoded_user_key_.empty());
   return Encode(database_id_, object_store_id_, encoded_user_key_);
 }
 
-std::string BlobEntryKey::Encode(int64 database_id,
-                                 int64 object_store_id,
+std::string BlobEntryKey::Encode(int64_t database_id,
+                                 int64_t object_store_id,
                                  const IndexedDBKey& user_key) {
   std::string encoded_key;
   EncodeIDBKey(user_key, &encoded_key);
   return Encode(database_id, object_store_id, encoded_key);
 }
 
-std::string BlobEntryKey::Encode(int64 database_id,
-                                 int64 object_store_id,
+std::string BlobEntryKey::Encode(int64_t database_id,
+                                 int64_t object_store_id,
                                  const std::string& encoded_user_key) {
   DCHECK(KeyPrefix::ValidIds(database_id, object_store_id));
   KeyPrefix prefix(KeyPrefix::CreateWithSpecialIndex(
       database_id, object_store_id, kSpecialIndexNumber));
   return prefix.Encode() + encoded_user_key;
 }
 
-const int64 BlobEntryKey::kSpecialIndexNumber = kBlobEntryIndexId;
+const int64_t BlobEntryKey::kSpecialIndexNumber = kBlobEntryIndexId;
 
 IndexDataKey::IndexDataKey()
     : database_id_(-1),
       object_store_id_(-1),
       index_id_(-1),
       sequence_number_(-1) {}
 
 IndexDataKey::~IndexDataKey() {}
 
 bool IndexDataKey::Decode(StringPiece* slice, IndexDataKey* result) {
@@ skipping 19 matching lines @@
     return false;
 
   // [optional] primary key
   if (slice->empty())
     return true;
   if (!ExtractEncodedIDBKey(slice, &result->encoded_primary_key_))
     return false;
   return true;
 }
 
-std::string IndexDataKey::Encode(int64 database_id,
-                                 int64 object_store_id,
-                                 int64 index_id,
+std::string IndexDataKey::Encode(int64_t database_id,
+                                 int64_t object_store_id,
+                                 int64_t index_id,
                                  const std::string& encoded_user_key,
                                  const std::string& encoded_primary_key,
-                                 int64 sequence_number) {
+                                 int64_t sequence_number) {
   KeyPrefix prefix(database_id, object_store_id, index_id);
   std::string ret = prefix.Encode();
   ret.append(encoded_user_key);
   EncodeVarInt(sequence_number, &ret);
   ret.append(encoded_primary_key);
   return ret;
 }
 
-std::string IndexDataKey::Encode(int64 database_id,
-                                 int64 object_store_id,
-                                 int64 index_id,
+std::string IndexDataKey::Encode(int64_t database_id,
+                                 int64_t object_store_id,
+                                 int64_t index_id,
                                  const IndexedDBKey& user_key) {
   std::string encoded_key;
   EncodeIDBKey(user_key, &encoded_key);
   return Encode(
       database_id, object_store_id, index_id, encoded_key, MinIDBKey(), 0);
 }
 
-std::string IndexDataKey::Encode(int64 database_id,
-                                 int64 object_store_id,
-                                 int64 index_id,
+std::string IndexDataKey::Encode(int64_t database_id,
+                                 int64_t object_store_id,
+                                 int64_t index_id,
                                  const IndexedDBKey& user_key,
                                  const IndexedDBKey& user_primary_key) {
   std::string encoded_key;
   EncodeIDBKey(user_key, &encoded_key);
   std::string encoded_primary_key;
   EncodeIDBKey(user_primary_key, &encoded_primary_key);
   return Encode(database_id,
                 object_store_id,
                 index_id,
                 encoded_key,
                 encoded_primary_key,
                 0);
 }
 
-std::string IndexDataKey::EncodeMinKey(int64 database_id,
-                                       int64 object_store_id,
-                                       int64 index_id) {
+std::string IndexDataKey::EncodeMinKey(int64_t database_id,
+                                       int64_t object_store_id,
+                                       int64_t index_id) {
   return Encode(
       database_id, object_store_id, index_id, MinIDBKey(), MinIDBKey(), 0);
 }
 
-std::string IndexDataKey::EncodeMaxKey(int64 database_id,
-                                       int64 object_store_id,
-                                       int64 index_id) {
-  return Encode(database_id,
-                object_store_id,
-                index_id,
-                MaxIDBKey(),
-                MaxIDBKey(),
-                std::numeric_limits<int64>::max());
+std::string IndexDataKey::EncodeMaxKey(int64_t database_id,
+                                       int64_t object_store_id,
+                                       int64_t index_id) {
+  return Encode(database_id, object_store_id, index_id, MaxIDBKey(),
+                MaxIDBKey(), std::numeric_limits<int64_t>::max());
 }
 
-int64 IndexDataKey::DatabaseId() const {
+int64_t IndexDataKey::DatabaseId() const {
   DCHECK_GE(database_id_, 0);
   return database_id_;
 }
 
-int64 IndexDataKey::ObjectStoreId() const {
+int64_t IndexDataKey::ObjectStoreId() const {
   DCHECK_GE(object_store_id_, 0);
   return object_store_id_;
 }
 
-int64 IndexDataKey::IndexId() const {
+int64_t IndexDataKey::IndexId() const {
   DCHECK_GE(index_id_, 0);
   return index_id_;
 }
 
 scoped_ptr<IndexedDBKey> IndexDataKey::user_key() const {
   scoped_ptr<IndexedDBKey> key;
   StringPiece slice(encoded_user_key_);
   if (!DecodeIDBKey(&slice, &key)) {
     // TODO(jsbell): Return error.
   }
   return key.Pass();
 }
 
 scoped_ptr<IndexedDBKey> IndexDataKey::primary_key() const {
   scoped_ptr<IndexedDBKey> key;
   StringPiece slice(encoded_primary_key_);
   if (!DecodeIDBKey(&slice, &key)) {
     // TODO(jsbell): Return error.
   }
   return key.Pass();
 }
 
 }  // namespace content