Switch to standard integer types in content/browser/.

content/browser/indexed_db/indexed_db_backing_store.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_backing_store.h"
 
 #include <algorithm>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/format_macros.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
+#include "build/build_config.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/indexed_db/indexed_db_blob_info.h"
 #include "content/browser/indexed_db/indexed_db_class_factory.h"
 #include "content/browser/indexed_db/indexed_db_database_error.h"
 #include "content/browser/indexed_db/indexed_db_leveldb_coding.h"
 #include "content/browser/indexed_db/indexed_db_metadata.h"
 #include "content/browser/indexed_db/indexed_db_tracing.h"
 #include "content/browser/indexed_db/indexed_db_value.h"
 #include "content/browser/indexed_db/leveldb/leveldb_comparator.h"
 #include "content/browser/indexed_db/leveldb/leveldb_database.h"
@@ skipping 17 matching lines @@
 
 using base::FilePath;
 using base::StringPiece;
 using std::string;
 using storage::FileWriterDelegate;
 
 namespace content {
 
 namespace {
 
-FilePath GetBlobDirectoryName(const FilePath& path_base, int64 database_id) {
+FilePath GetBlobDirectoryName(const FilePath& path_base, int64_t database_id) {
   return path_base.AppendASCII(base::StringPrintf("%" PRIx64, database_id));
 }
 
 FilePath GetBlobDirectoryNameForKey(const FilePath& path_base,
-                                    int64 database_id,
-                                    int64 key) {
+                                    int64_t database_id,
+                                    int64_t key) {
   FilePath path = GetBlobDirectoryName(path_base, database_id);
   path = path.AppendASCII(base::StringPrintf(
       "%02x", static_cast<int>(key & 0x000000000000ff00) >> 8));
   return path;
 }
 
 FilePath GetBlobFileNameForKey(const FilePath& path_base,
-                               int64 database_id,
-                               int64 key) {
+                               int64_t database_id,
+                               int64_t key) {
   FilePath path = GetBlobDirectoryNameForKey(path_base, database_id, key);
   path = path.AppendASCII(base::StringPrintf("%" PRIx64, key));
   return path;
 }
 
 bool MakeIDBBlobDirectory(const FilePath& path_base,
-                          int64 database_id,
-                          int64 key) {
+                          int64_t database_id,
+                          int64_t key) {
   FilePath path = GetBlobDirectoryNameForKey(path_base, database_id, key);
   return base::CreateDirectory(path);
 }
 
 static std::string ComputeOriginIdentifier(const GURL& origin_url) {
   return storage::GetIdentifierFromOrigin(origin_url) + "@1";
 }
 
 static base::FilePath ComputeFileName(const GURL& origin_url) {
   return base::FilePath()
       .AppendASCII(storage::GetIdentifierFromOrigin(origin_url))
       .AddExtension(FILE_PATH_LITERAL(".indexeddb.leveldb"));
 }
 
 static base::FilePath ComputeBlobPath(const GURL& origin_url) {
   return base::FilePath()
       .AppendASCII(storage::GetIdentifierFromOrigin(origin_url))
       .AddExtension(FILE_PATH_LITERAL(".indexeddb.blob"));
 }
 
 static base::FilePath ComputeCorruptionFileName(const GURL& origin_url) {
   return ComputeFileName(origin_url)
       .Append(FILE_PATH_LITERAL("corruption_info.json"));
 }
 
 }  // namespace
 
-static const int64 kKeyGeneratorInitialNumber =
+static const int64_t kKeyGeneratorInitialNumber =
     1;  // From the IndexedDB specification.
 
 enum IndexedDBBackingStoreErrorSource {
   // 0 - 2 are no longer used.
   FIND_KEY_IN_INDEX = 3,
   GET_IDBDATABASE_METADATA,
   GET_INDEXES,
   GET_KEY_GENERATOR_CURRENT_NUMBER,
   GET_OBJECT_STORES,
   GET_RECORD,
@@ skipping 84 matching lines @@
   return leveldb::Status::InvalidArgument("Invalid database key ID");
 }
 
 static leveldb::Status IOErrorStatus() {
   return leveldb::Status::IOError("IO Error");
 }
 
 template <typename DBOrTransaction>
 static leveldb::Status GetInt(DBOrTransaction* db,
                               const StringPiece& key,
-                              int64* found_int,
+                              int64_t* found_int,
                               bool* found) {
   std::string result;
   leveldb::Status s = db->Get(key, &result, found);
   if (!s.ok())
     return s;
   if (!*found)
     return leveldb::Status::OK();
   StringPiece slice(result);
   if (DecodeInt(&slice, found_int) && slice.empty())
     return s;
   return InternalInconsistencyStatus();
 }
 
 static void PutInt(LevelDBTransaction* transaction,
                    const StringPiece& key,
-                   int64 value) {
+                   int64_t value) {
   DCHECK_GE(value, 0);
   std::string buffer;
   EncodeInt(value, &buffer);
   transaction->Put(key, &buffer);
 }
 
 template <typename DBOrTransaction>
 WARN_UNUSED_RESULT static leveldb::Status GetVarInt(DBOrTransaction* db,
                                                     const StringPiece& key,
-                                                    int64* found_int,
+                                                    int64_t* found_int,
                                                     bool* found) {
   std::string result;
   leveldb::Status s = db->Get(key, &result, found);
   if (!s.ok())
     return s;
   if (!*found)
     return leveldb::Status::OK();
   StringPiece slice(result);
   if (DecodeVarInt(&slice, found_int) && slice.empty())
     return s;
   return InternalInconsistencyStatus();
 }
 
 static void PutVarInt(LevelDBTransaction* transaction,
                       const StringPiece& key,
-                      int64 value) {
+                      int64_t value) {
   std::string buffer;
   EncodeVarInt(value, &buffer);
   transaction->Put(key, &buffer);
 }
 
 template <typename DBOrTransaction>
 WARN_UNUSED_RESULT static leveldb::Status GetString(
     DBOrTransaction* db,
     const StringPiece& key,
     base::string16* found_string,
@@ skipping 41 matching lines @@
 }
 
 const char* IndexedDBBackingStore::Comparator::Name() const {
   return "idb_cmp1";
 }
 
 // 0 - Initial version.
 // 1 - Adds UserIntVersion to DatabaseMetaData.
 // 2 - Adds DataVersion to to global metadata.
 // 3 - Adds metadata needed for blob support.
-static const int64 kLatestKnownSchemaVersion = 3;
+static const int64_t kLatestKnownSchemaVersion = 3;
 WARN_UNUSED_RESULT static bool IsSchemaKnown(LevelDBDatabase* db, bool* known) {
-  int64 db_schema_version = 0;
+  int64_t db_schema_version = 0;
   bool found = false;
   leveldb::Status s =
       GetInt(db, SchemaVersionKey::Encode(), &db_schema_version, &found);
   if (!s.ok())
     return false;
   if (!found) {
     *known = true;
     return true;
   }
   if (db_schema_version < 0)
     return false;  // Only corruption should cause this.
   if (db_schema_version > kLatestKnownSchemaVersion) {
     *known = false;
     return true;
   }
 
-  const uint32 latest_known_data_version =
+  const uint32_t latest_known_data_version =
       blink::kSerializedScriptValueVersion;
-  int64 db_data_version = 0;
+  int64_t db_data_version = 0;
   s = GetInt(db, DataVersionKey::Encode(), &db_data_version, &found);
   if (!s.ok())
     return false;
   if (!found) {
     *known = true;
     return true;
   }
   if (db_data_version < 0)
     return false;  // Only corruption should cause this.
   if (db_data_version > latest_known_data_version) {
     *known = false;
     return true;
   }
 
   *known = true;
   return true;
 }
 
 // TODO(ericu): Move this down into the member section of this file.  I'm
 // leaving it here for this CL as it's easier to see the diffs in place.
 WARN_UNUSED_RESULT leveldb::Status IndexedDBBackingStore::SetUpMetadata() {
-  const uint32 latest_known_data_version =
+  const uint32_t latest_known_data_version =
       blink::kSerializedScriptValueVersion;
   const std::string schema_version_key = SchemaVersionKey::Encode();
   const std::string data_version_key = DataVersionKey::Encode();
 
   scoped_refptr<LevelDBTransaction> transaction =
       IndexedDBClassFactory::Get()->CreateLevelDBTransaction(db_.get());
 
-  int64 db_schema_version = 0;
-  int64 db_data_version = 0;
+  int64_t db_schema_version = 0;
+  int64_t db_data_version = 0;
   bool found = false;
   leveldb::Status s =
       GetInt(transaction.get(), schema_version_key, &db_schema_version, &found);
   if (!s.ok()) {
     INTERNAL_READ_ERROR_UNTESTED(SET_UP_METADATA);
     return s;
   }
   if (!found) {
     // Initialize new backing store.
     db_schema_version = kLatestKnownSchemaVersion;
@@ skipping 13 matching lines @@
       db_schema_version = 1;
       PutInt(transaction.get(), schema_version_key, db_schema_version);
       const std::string start_key =
           DatabaseNameKey::EncodeMinKeyForOrigin(origin_identifier_);
       const std::string stop_key =
           DatabaseNameKey::EncodeStopKeyForOrigin(origin_identifier_);
       scoped_ptr<LevelDBIterator> it = db_->CreateIterator();
       for (s = it->Seek(start_key);
            s.ok() && it->IsValid() && CompareKeys(it->Key(), stop_key) < 0;
            s = it->Next()) {
-        int64 database_id = 0;
+        int64_t database_id = 0;
         found = false;
         s = GetInt(transaction.get(), it->Key(), &database_id, &found);
         if (!s.ok()) {
           INTERNAL_READ_ERROR_UNTESTED(SET_UP_METADATA);
           return s;
         }
         if (!found) {
           INTERNAL_CONSISTENCY_ERROR_UNTESTED(SET_UP_METADATA);
           return InternalInconsistencyStatus();
         }
@@ skipping 45 matching lines @@
 
   s = transaction->Commit();
   if (!s.ok())
     INTERNAL_WRITE_ERROR_UNTESTED(SET_UP_METADATA);
   return s;
 }
 
 template <typename DBOrTransaction>
 WARN_UNUSED_RESULT static leveldb::Status GetMaxObjectStoreId(
     DBOrTransaction* db,
-    int64 database_id,
-    int64* max_object_store_id) {
+    int64_t database_id,
+    int64_t* max_object_store_id) {
   const std::string max_object_store_id_key = DatabaseMetaDataKey::Encode(
       database_id, DatabaseMetaDataKey::MAX_OBJECT_STORE_ID);
   return GetMaxObjectStoreId(db, max_object_store_id_key, max_object_store_id);
 }
 
 template <typename DBOrTransaction>
 WARN_UNUSED_RESULT static leveldb::Status GetMaxObjectStoreId(
     DBOrTransaction* db,
     const std::string& max_object_store_id_key,
-    int64* max_object_store_id) {
+    int64_t* max_object_store_id) {
   *max_object_store_id = -1;
   bool found = false;
   leveldb::Status s =
       GetInt(db, max_object_store_id_key, max_object_store_id, &found);
   if (!s.ok())
     return s;
   if (!found)
     *max_object_store_id = 0;
 
   DCHECK_GE(*max_object_store_id, 0);
@@ skipping 12 matching lines @@
   leveldb::Status DestroyLevelDB(const base::FilePath& file_name) override {
     return LevelDBDatabase::Destroy(file_name);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DefaultLevelDBFactory);
 };
 
 static bool GetBlobKeyGeneratorCurrentNumber(
     LevelDBTransaction* leveldb_transaction,
-    int64 database_id,
-    int64* blob_key_generator_current_number) {
+    int64_t database_id,
+    int64_t* blob_key_generator_current_number) {
   const std::string key_gen_key = DatabaseMetaDataKey::Encode(
       database_id, DatabaseMetaDataKey::BLOB_KEY_GENERATOR_CURRENT_NUMBER);
 
   // Default to initial number if not found.
-  int64 cur_number = DatabaseMetaDataKey::kBlobKeyGeneratorInitialNumber;
+  int64_t cur_number = DatabaseMetaDataKey::kBlobKeyGeneratorInitialNumber;
   std::string data;
 
   bool found = false;
   bool ok = leveldb_transaction->Get(key_gen_key, &data, &found).ok();
   if (!ok) {
     INTERNAL_READ_ERROR_UNTESTED(GET_BLOB_KEY_GENERATOR_CURRENT_NUMBER);
     return false;
   }
   if (found) {
     StringPiece slice(data);
     if (!DecodeVarInt(&slice, &cur_number) || !slice.empty() ||
         !DatabaseMetaDataKey::IsValidBlobKey(cur_number)) {
       INTERNAL_READ_ERROR_UNTESTED(GET_BLOB_KEY_GENERATOR_CURRENT_NUMBER);
       return false;
     }
   }
   *blob_key_generator_current_number = cur_number;
   return true;
 }
 
 static bool UpdateBlobKeyGeneratorCurrentNumber(
     LevelDBTransaction* leveldb_transaction,
-    int64 database_id,
-    int64 blob_key_generator_current_number) {
+    int64_t database_id,
+    int64_t blob_key_generator_current_number) {
 #ifndef NDEBUG
-  int64 old_number;
+  int64_t old_number;
   if (!GetBlobKeyGeneratorCurrentNumber(
           leveldb_transaction, database_id, &old_number))
     return false;
   DCHECK_LT(old_number, blob_key_generator_current_number);
 #endif
   DCHECK(
       DatabaseMetaDataKey::IsValidBlobKey(blob_key_generator_current_number));
   const std::string key = DatabaseMetaDataKey::Encode(
       database_id, DatabaseMetaDataKey::BLOB_KEY_GENERATOR_CURRENT_NUMBER);
 
@@ skipping 107 matching lines @@
     const BlobJournalType& journal) {
   return AppendBlobsToBlobJournal(transaction, LiveBlobJournalKey::Encode(),
                                   journal);
 }
 
 // Append a database to the specified blob journal via the supplied transaction.
 // The key must be either the primary journal key or live journal key.
 static leveldb::Status MergeDatabaseIntoBlobJournal(
     LevelDBDirectTransaction* transaction,
     const std::string& key,
-    int64 database_id) {
+    int64_t database_id) {
   IDB_TRACE("IndexedDBBackingStore::MergeDatabaseIntoBlobJournal");
   BlobJournalType journal;
   leveldb::Status s = GetBlobJournal(key, transaction, &journal);
   if (!s.ok())
     return s;
   journal.push_back(
       std::make_pair(database_id, DatabaseMetaDataKey::kAllBlobsKey));
   UpdateBlobJournal(transaction, key, journal);
   return leveldb::Status::OK();
 }
 
 static leveldb::Status MergeDatabaseIntoPrimaryBlobJournal(
     LevelDBDirectTransaction* leveldb_transaction,
-    int64 database_id) {
+    int64_t database_id) {
   return MergeDatabaseIntoBlobJournal(leveldb_transaction,
                                       BlobJournalKey::Encode(), database_id);
 }
 
 static leveldb::Status MergeDatabaseIntoLiveBlobJournal(
     LevelDBDirectTransaction* leveldb_transaction,
-    int64 database_id) {
+    int64_t database_id) {
   return MergeDatabaseIntoBlobJournal(
       leveldb_transaction, LiveBlobJournalKey::Encode(), database_id);
 }
 
 // Blob Data is encoded as a series of:
-//   { is_file [bool], key [int64 as varInt],
+//   { is_file [bool], key [int64_t as varInt],
 //     type [string-with-length, may be empty],
-//     (for Blobs only) size [int64 as varInt]
+//     (for Blobs only) size [int64_t as varInt]
 //     (for Files only) fileName [string-with-length]
 //   }
 // There is no length field; just read until you run out of data.
 static std::string EncodeBlobData(
     const std::vector<IndexedDBBlobInfo*>& blob_info) {
   std::string ret;
   for (const auto* info : blob_info) {
     EncodeBool(info->is_file(), &ret);
     EncodeVarInt(info->key(), &ret);
     EncodeStringWithLength(info->type(), &ret);
     if (info->is_file())
       EncodeStringWithLength(info->file_name(), &ret);
     else
       EncodeVarInt(info->size(), &ret);
   }
   return ret;
 }
 
 static bool DecodeBlobData(const std::string& data,
                            std::vector<IndexedDBBlobInfo>* output) {
   std::vector<IndexedDBBlobInfo> ret;
   output->clear();
   StringPiece slice(data);
   while (!slice.empty()) {
     bool is_file;
-    int64 key;
+    int64_t key;
     base::string16 type;
-    int64 size;
+    int64_t size;
     base::string16 file_name;
 
     if (!DecodeBool(&slice, &is_file))
       return false;
     if (!DecodeVarInt(&slice, &key) ||
         !DatabaseMetaDataKey::IsValidBlobKey(key))
       return false;
     if (!DecodeStringWithLength(&slice, &type))
       return false;
     if (is_file) {
       if (!DecodeStringWithLength(&slice, &file_name))
         return false;
       ret.push_back(IndexedDBBlobInfo(key, type, file_name));
     } else {
       if (!DecodeVarInt(&slice, &size) || size < 0)
         return false;
-      ret.push_back(IndexedDBBlobInfo(type, static_cast<uint64>(size), key));
+      ret.push_back(IndexedDBBlobInfo(type, static_cast<uint64_t>(size), key));
     }
   }
   output->swap(ret);
 
   return true;
 }
 
 IndexedDBBackingStore::IndexedDBBackingStore(
     IndexedDBFactory* indexed_db_factory,
     const GURL& origin_url,
@@ skipping 23 matching lines @@
   }
   STLDeleteContainerPairSecondPointers(incognito_blob_map_.begin(),
                                        incognito_blob_map_.end());
   // db_'s destructor uses comparator_. The order of destruction is important.
   db_.reset();
   comparator_.reset();
 }
 
 IndexedDBBackingStore::RecordIdentifier::RecordIdentifier(
     const std::string& primary_key,
-    int64 version)
+    int64_t version)
     : primary_key_(primary_key), version_(version) {
   DCHECK(!primary_key.empty());
 }
 IndexedDBBackingStore::RecordIdentifier::RecordIdentifier()
     : primary_key_(), version_(-1) {}
 IndexedDBBackingStore::RecordIdentifier::~RecordIdentifier() {}
 
 IndexedDBBackingStore::Cursor::CursorOptions::CursorOptions() {}
 IndexedDBBackingStore::Cursor::CursorOptions::~CursorOptions() {}
 
@@ skipping 112 matching lines @@
 
 bool IndexedDBBackingStore::ReadCorruptionInfo(const base::FilePath& path_base,
                                                const GURL& origin_url,
                                                std::string* message) {
   const base::FilePath info_path =
       path_base.Append(ComputeCorruptionFileName(origin_url));
 
   if (IsPathTooLong(info_path))
     return false;
 
-  const int64 max_json_len = 4096;
-  int64 file_size(0);
+  const int64_t max_json_len = 4096;
+  int64_t file_size(0);
   if (!GetFileSize(info_path, &file_size) || file_size > max_json_len)
     return false;
   if (!file_size) {
     NOTREACHED();
     return false;
   }
 
   base::File file(info_path, base::File::FLAG_OPEN | base::File::FLAG_READ);
   bool success = false;
   if (file.IsValid()) {
@@ skipping 281 matching lines @@
     // Decode database name (in iterator key).
     StringPiece slice(it->Key());
     DatabaseNameKey database_name_key;
     if (!DatabaseNameKey::Decode(&slice, &database_name_key) ||
         !slice.empty()) {
       INTERNAL_CONSISTENCY_ERROR_UNTESTED(GET_DATABASE_NAMES);
       continue;
     }
 
     // Decode database id (in iterator value).
-    int64 database_id = 0;
+    int64_t database_id = 0;
     StringPiece value_slice(it->Value());
     if (!DecodeInt(&value_slice, &database_id) || !value_slice.empty()) {
       INTERNAL_CONSISTENCY_ERROR_UNTESTED(GET_DATABASE_NAMES);
       continue;
     }
 
     // Look up version by id.
     bool found = false;
-    int64 database_version = IndexedDBDatabaseMetadata::DEFAULT_INT_VERSION;
+    int64_t database_version = IndexedDBDatabaseMetadata::DEFAULT_INT_VERSION;
     *s = GetVarInt(db_.get(),
                    DatabaseMetaDataKey::Encode(
                        database_id, DatabaseMetaDataKey::USER_INT_VERSION),
                    &database_version,
                    &found);
     if (!s->ok() || !found) {
       INTERNAL_READ_ERROR_UNTESTED(GET_DATABASE_NAMES);
       continue;
     }
 
@@ skipping 54 matching lines @@
   if (metadata->int_version == IndexedDBDatabaseMetadata::DEFAULT_INT_VERSION)
     metadata->int_version = IndexedDBDatabaseMetadata::NO_INT_VERSION;
 
   s = GetMaxObjectStoreId(
       db_.get(), metadata->id, &metadata->max_object_store_id);
   if (!s.ok()) {
     INTERNAL_READ_ERROR_UNTESTED(GET_IDBDATABASE_METADATA);
   }
 
   // We don't cache this, we just check it if it's there.
-  int64 blob_key_generator_current_number =
+  int64_t blob_key_generator_current_number =
       DatabaseMetaDataKey::kInvalidBlobKey;
 
   s = GetVarInt(
       db_.get(),
       DatabaseMetaDataKey::Encode(
           metadata->id, DatabaseMetaDataKey::BLOB_KEY_GENERATOR_CURRENT_NUMBER),
       &blob_key_generator_current_number,
       found);
   if (!s.ok()) {
     INTERNAL_READ_ERROR_UNTESTED(GET_IDBDATABASE_METADATA);
     return s;
   }
   if (!*found) {
     // This database predates blob support.
     *found = true;
   } else if (!DatabaseMetaDataKey::IsValidBlobKey(
                  blob_key_generator_current_number)) {
     INTERNAL_CONSISTENCY_ERROR_UNTESTED(GET_IDBDATABASE_METADATA);
     return InternalInconsistencyStatus();
   }
 
   return s;
 }
 
 WARN_UNUSED_RESULT static leveldb::Status GetNewDatabaseId(
     LevelDBTransaction* transaction,
-    int64* new_id) {
+    int64_t* new_id) {
   *new_id = -1;
-  int64 max_database_id = -1;
+  int64_t max_database_id = -1;
   bool found = false;
   leveldb::Status s =
       GetInt(transaction, MaxDatabaseIdKey::Encode(), &max_database_id, &found);
   if (!s.ok()) {
     INTERNAL_READ_ERROR_UNTESTED(GET_NEW_DATABASE_ID);
     return s;
   }
   if (!found)
     max_database_id = 0;
 
   DCHECK_GE(max_database_id, 0);
 
-  int64 database_id = max_database_id + 1;
+  int64_t database_id = max_database_id + 1;
   PutInt(transaction, MaxDatabaseIdKey::Encode(), database_id);
   *new_id = database_id;
   return leveldb::Status::OK();
 }
 
 leveldb::Status IndexedDBBackingStore::CreateIDBDatabaseMetaData(
     const base::string16& name,
     const base::string16& version,
-    int64 int_version,
-    int64* row_id) {
+    int64_t int_version,
+    int64_t* row_id) {
   // TODO(jsbell): Don't persist metadata if open fails. http://crbug.com/395472
   scoped_refptr<LevelDBTransaction> transaction =
       IndexedDBClassFactory::Get()->CreateLevelDBTransaction(db_.get());
 
   leveldb::Status s = GetNewDatabaseId(transaction.get(), row_id);
   if (!s.ok())
     return s;
   DCHECK_GE(*row_id, 0);
 
   if (int_version == IndexedDBDatabaseMetadata::NO_INT_VERSION)
@@ skipping 17 matching lines @@
       DatabaseMetaDataKey::kBlobKeyGeneratorInitialNumber);
 
   s = transaction->Commit();
   if (!s.ok())
     INTERNAL_WRITE_ERROR_UNTESTED(CREATE_IDBDATABASE_METADATA);
   return s;
 }
 
 bool IndexedDBBackingStore::UpdateIDBDatabaseIntVersion(
     IndexedDBBackingStore::Transaction* transaction,
-    int64 row_id,
-    int64 int_version) {
+    int64_t row_id,
+    int64_t int_version) {
   if (int_version == IndexedDBDatabaseMetadata::NO_INT_VERSION)
     int_version = IndexedDBDatabaseMetadata::DEFAULT_INT_VERSION;
   DCHECK_GE(int_version, 0) << "int_version was " << int_version;
   PutVarInt(transaction->transaction(),
             DatabaseMetaDataKey::Encode(row_id,
                                         DatabaseMetaDataKey::USER_INT_VERSION),
             int_version);
   return true;
 }
 
 // If you're deleting a range that contains user keys that have blob info, this
 // won't clean up the blobs.
 static leveldb::Status DeleteRangeBasic(LevelDBTransaction* transaction,
                                         const std::string& begin,
                                         const std::string& end,
                                         bool upper_open) {
   scoped_ptr<LevelDBIterator> it = transaction->CreateIterator();
   leveldb::Status s;
   for (s = it->Seek(begin); s.ok() && it->IsValid() &&
                                 (upper_open ? CompareKeys(it->Key(), end) < 0
                                             : CompareKeys(it->Key(), end) <= 0);
        s = it->Next())
     transaction->Remove(it->Key());
   return s;
 }
 
 static leveldb::Status DeleteBlobsInRange(
     IndexedDBBackingStore::Transaction* transaction,
-    int64 database_id,
-    int64 object_store_id,
+    int64_t database_id,
+    int64_t object_store_id,
     const std::string& start_key,
     const std::string& end_key,
     bool upper_open) {
   scoped_ptr<LevelDBIterator> it = transaction->transaction()->CreateIterator();
   leveldb::Status s = it->Seek(start_key);
   for (; s.ok() && it->IsValid() &&
              (upper_open ? CompareKeys(it->Key(), end_key) < 0
                          : CompareKeys(it->Key(), end_key) <= 0);
        s = it->Next()) {
     StringPiece key_piece(it->Key());
     std::string user_key =
         BlobEntryKey::ReencodeToObjectStoreDataKey(&key_piece);
     if (!user_key.size()) {
       INTERNAL_CONSISTENCY_ERROR_UNTESTED(GET_IDBDATABASE_METADATA);
       return InternalInconsistencyStatus();
     }
     transaction->PutBlobInfo(
         database_id, object_store_id, user_key, NULL, NULL);
   }
   return s;
 }
 
 static leveldb::Status DeleteBlobsInObjectStore(
     IndexedDBBackingStore::Transaction* transaction,
-    int64 database_id,
-    int64 object_store_id) {
+    int64_t database_id,
+    int64_t object_store_id) {
   std::string start_key, stop_key;
   start_key =
       BlobEntryKey::EncodeMinKeyForObjectStore(database_id, object_store_id);
   stop_key =
       BlobEntryKey::EncodeStopKeyForObjectStore(database_id, object_store_id);
   return DeleteBlobsInRange(
       transaction, database_id, object_store_id, start_key, stop_key, true);
 }
 
 leveldb::Status IndexedDBBackingStore::DeleteDatabase(
@@ skipping 55 matching lines @@
   // the journal until completion.
   if (need_cleanup)
     CleanPrimaryJournalIgnoreReturn();
 
   db_->Compact(start_key, stop_key);
   return s;
 }
 
 static bool CheckObjectStoreAndMetaDataType(const LevelDBIterator* it,
                                             const std::string& stop_key,
-                                            int64 object_store_id,
-                                            int64 meta_data_type) {
+                                            int64_t object_store_id,
+                                            int64_t meta_data_type) {
   if (!it->IsValid() || CompareKeys(it->Key(), stop_key) >= 0)
     return false;
 
   StringPiece slice(it->Key());
   ObjectStoreMetaDataKey meta_data_key;
   bool ok =
       ObjectStoreMetaDataKey::Decode(&slice, &meta_data_key) && slice.empty();
   DCHECK(ok);
   if (meta_data_key.ObjectStoreId() != object_store_id)
     return false;
   if (meta_data_key.MetaDataType() != meta_data_type)
     return false;
   return ok;
 }
 
 // TODO(jsbell): This should do some error handling rather than
 // plowing ahead when bad data is encountered.
 leveldb::Status IndexedDBBackingStore::GetObjectStores(
-    int64 database_id,
+    int64_t database_id,
     IndexedDBDatabaseMetadata::ObjectStoreMap* object_stores) {
   IDB_TRACE("IndexedDBBackingStore::GetObjectStores");
   if (!KeyPrefix::IsValidDatabaseId(database_id))
     return InvalidDBKeyStatus();
   const std::string start_key =
       ObjectStoreMetaDataKey::Encode(database_id, 1, 0);
   const std::string stop_key =
       ObjectStoreMetaDataKey::EncodeMaxKey(database_id);
 
   DCHECK(object_stores->empty());
 
   scoped_ptr<LevelDBIterator> it = db_->CreateIterator();
   leveldb::Status s = it->Seek(start_key);
   while (s.ok() && it->IsValid() && CompareKeys(it->Key(), stop_key) < 0) {
     StringPiece slice(it->Key());
     ObjectStoreMetaDataKey meta_data_key;
     bool ok =
         ObjectStoreMetaDataKey::Decode(&slice, &meta_data_key) && slice.empty();
     DCHECK(ok);
     if (!ok || meta_data_key.MetaDataType() != ObjectStoreMetaDataKey::NAME) {
       INTERNAL_CONSISTENCY_ERROR_UNTESTED(GET_OBJECT_STORES);
       // Possible stale metadata, but don't fail the load.
       s = it->Next();
       if (!s.ok())
         break;
       continue;
     }
 
-    int64 object_store_id = meta_data_key.ObjectStoreId();
+    int64_t object_store_id = meta_data_key.ObjectStoreId();
 
     // TODO(jsbell): Do this by direct key lookup rather than iteration, to
     // simplify.
     base::string16 object_store_name;
     {
       StringPiece slice(it->Value());
       if (!DecodeString(&slice, &object_store_name) || !slice.empty())
         INTERNAL_CONSISTENCY_ERROR_UNTESTED(GET_OBJECT_STORES);
     }
 
@@ skipping 59 matching lines @@
     if (!s.ok())
       break;
     if (!CheckObjectStoreAndMetaDataType(
              it.get(),
              stop_key,
              object_store_id,
              ObjectStoreMetaDataKey::MAX_INDEX_ID)) {
       INTERNAL_CONSISTENCY_ERROR_UNTESTED(GET_OBJECT_STORES);
       break;
     }
-    int64 max_index_id;
+    int64_t max_index_id;
     {
       StringPiece slice(it->Value());
       if (!DecodeInt(&slice, &max_index_id) || !slice.empty())
         INTERNAL_CONSISTENCY_ERROR_UNTESTED(GET_OBJECT_STORES);
     }
 
     s = it->Next();  // [optional] has key path (is not null)
     if (!s.ok())
       break;
     if (CheckObjectStoreAndMetaDataType(it.get(),
@@ skipping 16 matching lines @@
         INTERNAL_CONSISTENCY_ERROR_UNTESTED(GET_OBJECT_STORES);
         break;
       }
       if (!has_key_path)
         key_path = IndexedDBKeyPath();
       s = it->Next();
       if (!s.ok())
         break;
     }
 
-    int64 key_generator_current_number = -1;
+    int64_t key_generator_current_number = -1;
     if (CheckObjectStoreAndMetaDataType(
             it.get(),
             stop_key,
             object_store_id,
             ObjectStoreMetaDataKey::KEY_GENERATOR_CURRENT_NUMBER)) {
       StringPiece slice(it->Value());
       if (!DecodeInt(&slice, &key_generator_current_number) || !slice.empty())
         INTERNAL_CONSISTENCY_ERROR_UNTESTED(GET_OBJECT_STORES);
 
       // TODO(jsbell): Return key_generator_current_number, cache in
@@ skipping 17 matching lines @@
   }
 
   if (!s.ok())
     INTERNAL_READ_ERROR_UNTESTED(GET_OBJECT_STORES);
 
   return s;
 }
 
 WARN_UNUSED_RESULT static leveldb::Status SetMaxObjectStoreId(
     LevelDBTransaction* transaction,
-    int64 database_id,
-    int64 object_store_id) {
+    int64_t database_id,
+    int64_t object_store_id) {
   const std::string max_object_store_id_key = DatabaseMetaDataKey::Encode(
       database_id, DatabaseMetaDataKey::MAX_OBJECT_STORE_ID);
-  int64 max_object_store_id = -1;
+  int64_t max_object_store_id = -1;
   leveldb::Status s = GetMaxObjectStoreId(
       transaction, max_object_store_id_key, &max_object_store_id);
   if (!s.ok()) {
     INTERNAL_READ_ERROR_UNTESTED(SET_MAX_OBJECT_STORE_ID);
     return s;
   }
 
   if (object_store_id <= max_object_store_id) {
     INTERNAL_CONSISTENCY_ERROR_UNTESTED(SET_MAX_OBJECT_STORE_ID);
     return InternalInconsistencyStatus();
   }
   PutInt(transaction, max_object_store_id_key, object_store_id);
   return s;
 }
 
 void IndexedDBBackingStore::Compact() { db_->CompactAll(); }
 
 leveldb::Status IndexedDBBackingStore::CreateObjectStore(
     IndexedDBBackingStore::Transaction* transaction,
-    int64 database_id,
-    int64 object_store_id,
+    int64_t database_id,
+    int64_t object_store_id,
     const base::string16& name,
     const IndexedDBKeyPath& key_path,
     bool auto_increment) {
   IDB_TRACE("IndexedDBBackingStore::CreateObjectStore");
   if (!KeyPrefix::ValidIds(database_id, object_store_id))
     return InvalidDBKeyStatus();
   LevelDBTransaction* leveldb_transaction = transaction->transaction();
   leveldb::Status s =
       SetMaxObjectStoreId(leveldb_transaction, database_id, object_store_id);
   if (!s.ok())
@@ skipping 29 matching lines @@
   PutBool(leveldb_transaction, has_key_path_key, !key_path.IsNull());
   PutInt(leveldb_transaction,
          key_generator_current_number_key,
          kKeyGeneratorInitialNumber);
   PutInt(leveldb_transaction, names_key, object_store_id);
   return s;
 }
 
 leveldb::Status IndexedDBBackingStore::DeleteObjectStore(
     IndexedDBBackingStore::Transaction* transaction,
-    int64 database_id,
-    int64 object_store_id) {
+    int64_t database_id,
+    int64_t object_store_id) {
   IDB_TRACE("IndexedDBBackingStore::DeleteObjectStore");
   if (!KeyPrefix::ValidIds(database_id, object_store_id))
     return InvalidDBKeyStatus();
   LevelDBTransaction* leveldb_transaction = transaction->transaction();
 
   base::string16 object_store_name;
   bool found = false;
   leveldb::Status s =
       GetString(leveldb_transaction,
                 ObjectStoreMetaDataKey::Encode(
@@ skipping 43 matching lines @@
   if (!s.ok()) {
     INTERNAL_WRITE_ERROR_UNTESTED(DELETE_OBJECT_STORE);
     return s;
   }
 
   return ClearObjectStore(transaction, database_id, object_store_id);
 }
 
 leveldb::Status IndexedDBBackingStore::GetRecord(
     IndexedDBBackingStore::Transaction* transaction,
-    int64 database_id,
-    int64 object_store_id,
+    int64_t database_id,
+    int64_t object_store_id,
     const IndexedDBKey& key,
     IndexedDBValue* record) {
   IDB_TRACE("IndexedDBBackingStore::GetRecord");
   if (!KeyPrefix::ValidIds(database_id, object_store_id))
     return InvalidDBKeyStatus();
   LevelDBTransaction* leveldb_transaction = transaction->transaction();
 
   const std::string leveldb_key =
       ObjectStoreDataKey::Encode(database_id, object_store_id, key);
   std::string data;
 
   record->clear();
 
   bool found = false;
   leveldb::Status s = leveldb_transaction->Get(leveldb_key, &data, &found);
   if (!s.ok()) {
     INTERNAL_READ_ERROR(GET_RECORD);
     return s;
   }
   if (!found)
     return s;
   if (data.empty()) {
     INTERNAL_READ_ERROR_UNTESTED(GET_RECORD);
     return leveldb::Status::NotFound("Record contained no data");
   }
 
-  int64 version;
+  int64_t version;
   StringPiece slice(data);
   if (!DecodeVarInt(&slice, &version)) {
     INTERNAL_READ_ERROR_UNTESTED(GET_RECORD);
     return InternalInconsistencyStatus();
   }
 
   record->bits = slice.as_string();
   return transaction->GetBlobInfoForRecord(database_id, leveldb_key, record);
 }
 
 WARN_UNUSED_RESULT static leveldb::Status GetNewVersionNumber(
     LevelDBTransaction* transaction,
-    int64 database_id,
-    int64 object_store_id,
-    int64* new_version_number) {
+    int64_t database_id,
+    int64_t object_store_id,
+    int64_t* new_version_number) {
   const std::string last_version_key = ObjectStoreMetaDataKey::Encode(
       database_id, object_store_id, ObjectStoreMetaDataKey::LAST_VERSION);
 
   *new_version_number = -1;
-  int64 last_version = -1;
+  int64_t last_version = -1;
   bool found = false;
   leveldb::Status s =
       GetInt(transaction, last_version_key, &last_version, &found);
   if (!s.ok()) {
     INTERNAL_READ_ERROR_UNTESTED(GET_NEW_VERSION_NUMBER);
     return s;
   }
   if (!found)
     last_version = 0;
 
   DCHECK_GE(last_version, 0);
 
-  int64 version = last_version + 1;
+  int64_t version = last_version + 1;
   PutInt(transaction, last_version_key, version);
 
   // TODO(jsbell): Think about how we want to handle the overflow scenario.
   DCHECK(version > last_version);
 
   *new_version_number = version;
   return s;
 }
 
 leveldb::Status IndexedDBBackingStore::PutRecord(
     IndexedDBBackingStore::Transaction* transaction,
-    int64 database_id,
-    int64 object_store_id,
+    int64_t database_id,
+    int64_t object_store_id,
     const IndexedDBKey& key,
     IndexedDBValue* value,
     ScopedVector<storage::BlobDataHandle>* handles,
     RecordIdentifier* record_identifier) {
   IDB_TRACE("IndexedDBBackingStore::PutRecord");
   if (!KeyPrefix::ValidIds(database_id, object_store_id))
     return InvalidDBKeyStatus();
   DCHECK(key.IsValid());
 
   LevelDBTransaction* leveldb_transaction = transaction->transaction();
-  int64 version = -1;
+  int64_t version = -1;
   leveldb::Status s = GetNewVersionNumber(
       leveldb_transaction, database_id, object_store_id, &version);
   if (!s.ok())
     return s;
   DCHECK_GE(version, 0);
   const std::string object_store_data_key =
       ObjectStoreDataKey::Encode(database_id, object_store_id, key);
 
   std::string v;
   EncodeVarInt(version, &v);
@@ skipping 16 matching lines @@
   leveldb_transaction->Put(exists_entry_key, &version_encoded);
 
   std::string key_encoded;
   EncodeIDBKey(key, &key_encoded);
   record_identifier->Reset(key_encoded, version);
   return s;
 }
 
 leveldb::Status IndexedDBBackingStore::ClearObjectStore(
     IndexedDBBackingStore::Transaction* transaction,
-    int64 database_id,
-    int64 object_store_id) {
+    int64_t database_id,
+    int64_t object_store_id) {
   IDB_TRACE("IndexedDBBackingStore::ClearObjectStore");
   if (!KeyPrefix::ValidIds(database_id, object_store_id))
     return InvalidDBKeyStatus();
   const std::string start_key =
       KeyPrefix(database_id, object_store_id).Encode();
   const std::string stop_key =
       KeyPrefix(database_id, object_store_id + 1).Encode();
 
   leveldb::Status s =
       DeleteRangeBasic(transaction->transaction(), start_key, stop_key, true);
   if (!s.ok()) {
     INTERNAL_WRITE_ERROR(CLEAR_OBJECT_STORE);
     return s;
   }
   return DeleteBlobsInObjectStore(transaction, database_id, object_store_id);
 }
 
 leveldb::Status IndexedDBBackingStore::DeleteRecord(
     IndexedDBBackingStore::Transaction* transaction,
-    int64 database_id,
-    int64 object_store_id,
+    int64_t database_id,
+    int64_t object_store_id,
     const RecordIdentifier& record_identifier) {
   IDB_TRACE("IndexedDBBackingStore::DeleteRecord");
   if (!KeyPrefix::ValidIds(database_id, object_store_id))
     return InvalidDBKeyStatus();
   LevelDBTransaction* leveldb_transaction = transaction->transaction();
 
   const std::string object_store_data_key = ObjectStoreDataKey::Encode(
       database_id, object_store_id, record_identifier.primary_key());
   leveldb_transaction->Remove(object_store_data_key);
   leveldb::Status s = transaction->PutBlobInfoIfNeeded(
       database_id, object_store_id, object_store_data_key, NULL, NULL);
   if (!s.ok())
     return s;
 
   const std::string exists_entry_key = ExistsEntryKey::Encode(
       database_id, object_store_id, record_identifier.primary_key());
   leveldb_transaction->Remove(exists_entry_key);
   return leveldb::Status::OK();
 }
 
 leveldb::Status IndexedDBBackingStore::DeleteRange(
     IndexedDBBackingStore::Transaction* transaction,
-    int64 database_id,
-    int64 object_store_id,
+    int64_t database_id,
+    int64_t object_store_id,
     const IndexedDBKeyRange& key_range) {
   leveldb::Status s;
   scoped_ptr<IndexedDBBackingStore::Cursor> start_cursor =
       OpenObjectStoreCursor(transaction,
                             database_id,
                             object_store_id,
                             key_range,
                             blink::WebIDBCursorDirectionNext,
                             &s);
   if (!s.ok())
@@ skipping 41 matching lines @@
   start_key =
       ExistsEntryKey::Encode(database_id, object_store_id, start_cursor->key());
   stop_key =
       ExistsEntryKey::Encode(database_id, object_store_id, end_cursor->key());
   return DeleteRangeBasic(
       transaction->transaction(), start_key, stop_key, false);
 }
 
 leveldb::Status IndexedDBBackingStore::GetKeyGeneratorCurrentNumber(
     IndexedDBBackingStore::Transaction* transaction,
-    int64 database_id,
-    int64 object_store_id,
-    int64* key_generator_current_number) {
+    int64_t database_id,
+    int64_t object_store_id,
+    int64_t* key_generator_current_number) {
   if (!KeyPrefix::ValidIds(database_id, object_store_id))
     return InvalidDBKeyStatus();
   LevelDBTransaction* leveldb_transaction = transaction->transaction();
 
   const std::string key_generator_current_number_key =
       ObjectStoreMetaDataKey::Encode(
           database_id,
           object_store_id,
           ObjectStoreMetaDataKey::KEY_GENERATOR_CURRENT_NUMBER);
 
@@ skipping 20 matching lines @@
   // but derived from the maximum numeric key present in existing
   // data. This violates the spec as the data may be cleared but the
   // key generator state must be preserved.
   // TODO(jsbell): Fix this for all stores on database open?
   const std::string start_key =
       ObjectStoreDataKey::Encode(database_id, object_store_id, MinIDBKey());
   const std::string stop_key =
       ObjectStoreDataKey::Encode(database_id, object_store_id, MaxIDBKey());
 
   scoped_ptr<LevelDBIterator> it = leveldb_transaction->CreateIterator();
-  int64 max_numeric_key = 0;
+  int64_t max_numeric_key = 0;
 
   for (s = it->Seek(start_key);
        s.ok() && it->IsValid() && CompareKeys(it->Key(), stop_key) < 0;
        s = it->Next()) {
     StringPiece slice(it->Key());
     ObjectStoreDataKey data_key;
     if (!ObjectStoreDataKey::Decode(&slice, &data_key) || !slice.empty()) {
       INTERNAL_READ_ERROR_UNTESTED(GET_KEY_GENERATOR_CURRENT_NUMBER);
       return InternalInconsistencyStatus();
     }
     scoped_ptr<IndexedDBKey> user_key = data_key.user_key();
     if (user_key->type() == blink::WebIDBKeyTypeNumber) {
-      int64 n = static_cast<int64>(user_key->number());
+      int64_t n = static_cast<int64_t>(user_key->number());
       if (n > max_numeric_key)
         max_numeric_key = n;
     }
   }
 
   if (s.ok())
     *key_generator_current_number = max_numeric_key + 1;
   else
     INTERNAL_READ_ERROR_UNTESTED(GET_KEY_GENERATOR_CURRENT_NUMBER);
 
   return s;
 }
 
 leveldb::Status IndexedDBBackingStore::MaybeUpdateKeyGeneratorCurrentNumber(
     IndexedDBBackingStore::Transaction* transaction,
-    int64 database_id,
-    int64 object_store_id,
-    int64 new_number,
+    int64_t database_id,
+    int64_t object_store_id,
+    int64_t new_number,
     bool check_current) {
   if (!KeyPrefix::ValidIds(database_id, object_store_id))
     return InvalidDBKeyStatus();
 
   if (check_current) {
-    int64 current_number;
+    int64_t current_number;
     leveldb::Status s = GetKeyGeneratorCurrentNumber(
         transaction, database_id, object_store_id, &current_number);
     if (!s.ok())
       return s;
     if (new_number <= current_number)
       return s;
   }
 
   const std::string key_generator_current_number_key =
       ObjectStoreMetaDataKey::Encode(
           database_id,
           object_store_id,
           ObjectStoreMetaDataKey::KEY_GENERATOR_CURRENT_NUMBER);
   PutInt(
       transaction->transaction(), key_generator_current_number_key, new_number);
   return leveldb::Status::OK();
 }
 
 leveldb::Status IndexedDBBackingStore::KeyExistsInObjectStore(
     IndexedDBBackingStore::Transaction* transaction,
-    int64 database_id,
-    int64 object_store_id,
+    int64_t database_id,
+    int64_t object_store_id,
     const IndexedDBKey& key,
     RecordIdentifier* found_record_identifier,
     bool* found) {
   IDB_TRACE("IndexedDBBackingStore::KeyExistsInObjectStore");
   if (!KeyPrefix::ValidIds(database_id, object_store_id))
     return InvalidDBKeyStatus();
   *found = false;
   const std::string leveldb_key =
       ObjectStoreDataKey::Encode(database_id, object_store_id, key);
   std::string data;
 
   leveldb::Status s =
       transaction->transaction()->Get(leveldb_key, &data, found);
   if (!s.ok()) {
     INTERNAL_READ_ERROR_UNTESTED(KEY_EXISTS_IN_OBJECT_STORE);
     return s;
   }
   if (!*found)
     return leveldb::Status::OK();
   if (!data.size()) {
     INTERNAL_READ_ERROR_UNTESTED(KEY_EXISTS_IN_OBJECT_STORE);
     return InternalInconsistencyStatus();
   }
 
-  int64 version;
+  int64_t version;
   StringPiece slice(data);
   if (!DecodeVarInt(&slice, &version))
     return InternalInconsistencyStatus();
 
   std::string encoded_key;
   EncodeIDBKey(key, &encoded_key);
   found_record_identifier->Reset(encoded_key, version);
   return s;
 }
 
 class IndexedDBBackingStore::Transaction::ChainedBlobWriterImpl
     : public IndexedDBBackingStore::Transaction::ChainedBlobWriter {
  public:
   typedef IndexedDBBackingStore::Transaction::WriteDescriptorVec
       WriteDescriptorVec;
   ChainedBlobWriterImpl(
-      int64 database_id,
+      int64_t database_id,
       IndexedDBBackingStore* backing_store,
       WriteDescriptorVec* blobs,
       scoped_refptr<IndexedDBBackingStore::BlobWriteCallback> callback)
       : waiting_for_callback_(false),
         database_id_(database_id),
         backing_store_(backing_store),
         callback_(callback),
         aborted_(false) {
     blobs_.swap(*blobs);
     iter_ = blobs_.begin();
     backing_store->task_runner()->PostTask(
         FROM_HERE, base::Bind(&ChainedBlobWriterImpl::WriteNextFile, this));
   }
 
   void set_delegate(scoped_ptr<FileWriterDelegate> delegate) override {
     delegate_.reset(delegate.release());
   }
 
-  void ReportWriteCompletion(bool succeeded, int64 bytes_written) override {
+  void ReportWriteCompletion(bool succeeded, int64_t bytes_written) override {
     DCHECK(waiting_for_callback_);
     DCHECK(!succeeded || bytes_written >= 0);
     waiting_for_callback_ = false;
     if (delegate_.get())  // Only present for Blob, not File.
       content::BrowserThread::DeleteSoon(
           content::BrowserThread::IO, FROM_HERE, delegate_.release());
     if (aborted_) {
       self_ref_ = NULL;
       return;
     }
@@ skipping 33 matching lines @@
         return;
       }
       waiting_for_callback_ = true;
     }
   }
 
   bool waiting_for_callback_;
   scoped_refptr<ChainedBlobWriterImpl> self_ref_;
   WriteDescriptorVec blobs_;
   WriteDescriptorVec::const_iterator iter_;
-  int64 database_id_;
+  int64_t database_id_;
   IndexedDBBackingStore* backing_store_;
   scoped_refptr<IndexedDBBackingStore::BlobWriteCallback> callback_;
   scoped_ptr<FileWriterDelegate> delegate_;
   bool aborted_;
 
   DISALLOW_COPY_AND_ASSIGN(ChainedBlobWriterImpl);
 };
 
 class LocalWriteClosure : public FileWriterDelegate::DelegateWriteCallback,
                           public base::RefCountedThreadSafe<LocalWriteClosure> {
  public:
   LocalWriteClosure(IndexedDBBackingStore::Transaction::ChainedBlobWriter*
                         chained_blob_writer,
                     base::SequencedTaskRunner* task_runner)
       : chained_blob_writer_(chained_blob_writer),
         task_runner_(task_runner),
         bytes_written_(0) {}
 
   void Run(base::File::Error rv,
-           int64 bytes,
+           int64_t bytes,
            FileWriterDelegate::WriteProgressStatus write_status) {
     DCHECK_GE(bytes, 0);
     bytes_written_ += bytes;
     if (write_status == FileWriterDelegate::SUCCESS_IO_PENDING)
       return;  // We don't care about progress events.
     if (rv == base::File::FILE_OK) {
       DCHECK_EQ(write_status, FileWriterDelegate::SUCCESS_COMPLETED);
     } else {
       DCHECK(write_status == FileWriterDelegate::ERROR_WRITE_STARTED ||
              write_status == FileWriterDelegate::ERROR_WRITE_NOT_STARTED);
@@ skipping 78 matching lines @@
         !file.SetTimes(last_modified_, last_modified_)) {
       // TODO(cmumford): Complain quietly; timestamp's probably not vital.
     }
     file.Close();
     chained_blob_writer_->ReportWriteCompletion(success, bytes_written_);
   }
 
   scoped_refptr<IndexedDBBackingStore::Transaction::ChainedBlobWriter>
       chained_blob_writer_;
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
-  int64 bytes_written_;
+  int64_t bytes_written_;
 
   base::FilePath file_path_;
   base::Time last_modified_;
 
   DISALLOW_COPY_AND_ASSIGN(LocalWriteClosure);
 };
 
 bool IndexedDBBackingStore::WriteBlobFile(
-    int64 database_id,
+    int64_t database_id,
     const Transaction::WriteDescriptor& descriptor,
     Transaction::ChainedBlobWriter* chained_blob_writer) {
-
   if (!MakeIDBBlobDirectory(blob_path_, database_id, descriptor.key()))
     return false;
 
   FilePath path = GetBlobFileName(database_id, descriptor.key());
 
   if (descriptor.is_file() && !descriptor.file_path().empty()) {
     if (!base::CopyFile(descriptor.file_path(), path))
       return false;
 
     base::File::Info info;
     if (base::GetFileInfo(descriptor.file_path(), &info)) {
       if (descriptor.size() != -1) {
         if (descriptor.size() != info.size)
           return false;
         // The round-trip can be lossy; round to nearest millisecond.
-        int64 delta = (descriptor.last_modified() -
-            info.last_modified).InMilliseconds();
+        int64_t delta =
+            (descriptor.last_modified() - info.last_modified).InMilliseconds();
         if (std::abs(delta) > 1)
           return false;
       }
       if (!base::TouchFile(path, info.last_accessed, info.last_modified)) {
         // TODO(ericu): Complain quietly; timestamp's probably not vital.
       }
     } else {
       // TODO(ericu): Complain quietly; timestamp's probably not vital.
     }
 
@@ skipping 13 matching lines @@
         base::Bind(&LocalWriteClosure::WriteBlobToFileOnIOThread,
                    write_closure.get(),
                    path,
                    descriptor.url(),
                    descriptor.last_modified(),
                    request_context_));
   }
   return true;
 }
 
-void IndexedDBBackingStore::ReportBlobUnused(int64 database_id,
-                                             int64 blob_key) {
+void IndexedDBBackingStore::ReportBlobUnused(int64_t database_id,
+                                             int64_t blob_key) {
   DCHECK(KeyPrefix::IsValidDatabaseId(database_id));
   bool all_blobs = blob_key == DatabaseMetaDataKey::kAllBlobsKey;
   DCHECK(all_blobs || DatabaseMetaDataKey::IsValidBlobKey(blob_key));
   scoped_refptr<LevelDBTransaction> transaction =
       IndexedDBClassFactory::Get()->CreateLevelDBTransaction(db_.get());
 
   BlobJournalType live_blob_journal, primary_journal;
   if (!GetLiveBlobJournal(transaction.get(), &live_blob_journal).ok())
     return;
   DCHECK(!live_blob_journal.empty());
   if (!GetPrimaryBlobJournal(transaction.get(), &primary_journal).ok())
     return;
 
   // There are several cases to handle.  If blob_key is kAllBlobsKey, we want to
   // remove all entries with database_id from the live_blob journal and add only
   // kAllBlobsKey to the primary journal.  Otherwise if IsValidBlobKey(blob_key)
   // and we hit kAllBlobsKey for the right database_id in the journal, we leave
   // the kAllBlobsKey entry in the live_blob journal but add the specific blob
   // to the primary.  Otherwise if IsValidBlobKey(blob_key) and we find a
   // matching (database_id, blob_key) tuple, we should move it to the primary
   // journal.
   BlobJournalType new_live_blob_journal;
   for (BlobJournalType::iterator journal_iter = live_blob_journal.begin();
        journal_iter != live_blob_journal.end();
        ++journal_iter) {
-    int64 current_database_id = journal_iter->first;
-    int64 current_blob_key = journal_iter->second;
+    int64_t current_database_id = journal_iter->first;
+    int64_t current_blob_key = journal_iter->second;
     bool current_all_blobs =
         current_blob_key == DatabaseMetaDataKey::kAllBlobsKey;
     DCHECK(KeyPrefix::IsValidDatabaseId(current_database_id) ||
            current_all_blobs);
     if (current_database_id == database_id &&
         (all_blobs || current_all_blobs || blob_key == current_blob_key)) {
       if (!all_blobs) {
         primary_journal.push_back(
             std::make_pair(database_id, current_blob_key));
         if (current_all_blobs)
@@ skipping 26 matching lines @@
 // deleted, the timer will automatically be canceled on destruction.
 void IndexedDBBackingStore::StartJournalCleaningTimer() {
   journal_cleaning_timer_.Start(
       FROM_HERE,
       base::TimeDelta::FromSeconds(5),
       this,
       &IndexedDBBackingStore::CleanPrimaryJournalIgnoreReturn);
 }
 
 // This assumes a file path of dbId/second-to-LSB-of-counter/counter.
-FilePath IndexedDBBackingStore::GetBlobFileName(int64 database_id,
-                                                int64 key) const {
+FilePath IndexedDBBackingStore::GetBlobFileName(int64_t database_id,
+                                                int64_t key) const {
   return GetBlobFileNameForKey(blob_path_, database_id, key);
 }
 
 static bool CheckIndexAndMetaDataKey(const LevelDBIterator* it,
                                      const std::string& stop_key,
-                                     int64 index_id,
+                                     int64_t index_id,
                                      unsigned char meta_data_type) {
   if (!it->IsValid() || CompareKeys(it->Key(), stop_key) >= 0)
     return false;
 
   StringPiece slice(it->Key());
   IndexMetaDataKey meta_data_key;
   bool ok = IndexMetaDataKey::Decode(&slice, &meta_data_key);
   DCHECK(ok);
   if (meta_data_key.IndexId() != index_id)
     return false;
   if (meta_data_key.meta_data_type() != meta_data_type)
     return false;
   return true;
 }
 
 // TODO(jsbell): This should do some error handling rather than plowing ahead
 // when bad data is encountered.
 leveldb::Status IndexedDBBackingStore::GetIndexes(
-    int64 database_id,
-    int64 object_store_id,
+    int64_t database_id,
+    int64_t object_store_id,
     IndexedDBObjectStoreMetadata::IndexMap* indexes) {
   IDB_TRACE("IndexedDBBackingStore::GetIndexes");
   if (!KeyPrefix::ValidIds(database_id, object_store_id))
     return InvalidDBKeyStatus();
   const std::string start_key =
       IndexMetaDataKey::Encode(database_id, object_store_id, 0, 0);
   const std::string stop_key =
       IndexMetaDataKey::Encode(database_id, object_store_id + 1, 0, 0);
 
   DCHECK(indexes->empty());
@@ skipping 10 matching lines @@
       // Possible stale metadata due to http://webkit.org/b/85557 but don't fail
       // the load.
       s = it->Next();
       if (!s.ok())
         break;
       continue;
     }
 
     // TODO(jsbell): Do this by direct key lookup rather than iteration, to
     // simplify.
-    int64 index_id = meta_data_key.IndexId();
+    int64_t index_id = meta_data_key.IndexId();
     base::string16 index_name;
     {
       StringPiece slice(it->Value());
       if (!DecodeString(&slice, &index_name) || !slice.empty())
         INTERNAL_CONSISTENCY_ERROR_UNTESTED(GET_INDEXES);
     }
 
     s = it->Next();  // unique flag
     if (!s.ok())
       break;
@@ skipping 42 matching lines @@
     (*indexes)[index_id] = IndexedDBIndexMetadata(
         index_name, index_id, key_path, index_unique, index_multi_entry);
   }
 
   if (!s.ok())
     INTERNAL_READ_ERROR_UNTESTED(GET_INDEXES);
 
   return s;
 }
 
-bool IndexedDBBackingStore::RemoveBlobFile(int64 database_id, int64 key) const {
+bool IndexedDBBackingStore::RemoveBlobFile(int64_t database_id,
+                                           int64_t key) const {
   FilePath path = GetBlobFileName(database_id, key);
   return base::DeleteFile(path, false);
 }
 
-bool IndexedDBBackingStore::RemoveBlobDirectory(int64 database_id) const {
+bool IndexedDBBackingStore::RemoveBlobDirectory(int64_t database_id) const {
   FilePath path = GetBlobDirectoryName(blob_path_, database_id);
   return base::DeleteFile(path, true);
 }
 
 leveldb::Status IndexedDBBackingStore::CleanUpBlobJournalEntries(
     const BlobJournalType& journal) const {
   IDB_TRACE("IndexedDBBackingStore::CleanUpBlobJournalEntries");
   if (journal.empty())
     return leveldb::Status::OK();
   for (const auto& entry : journal) {
-    int64 database_id = entry.first;
-    int64 blob_key = entry.second;
+    int64_t database_id = entry.first;
+    int64_t blob_key = entry.second;
     DCHECK(KeyPrefix::IsValidDatabaseId(database_id));
     if (blob_key == DatabaseMetaDataKey::kAllBlobsKey) {
       if (!RemoveBlobDirectory(database_id))
         return IOErrorStatus();
     } else {
       DCHECK(DatabaseMetaDataKey::IsValidBlobKey(blob_key));
       if (!RemoveBlobFile(database_id, blob_key))
         return IOErrorStatus();
     }
   }
@@ skipping 15 matching lines @@
   if (journal.empty())
     return leveldb::Status::OK();
   s = CleanUpBlobJournalEntries(journal);
   if (!s.ok())
     return s;
   ClearBlobJournal(journal_transaction.get(), level_db_key);
   return journal_transaction->Commit();
 }
 
 leveldb::Status IndexedDBBackingStore::Transaction::GetBlobInfoForRecord(
-    int64 database_id,
+    int64_t database_id,
     const std::string& object_store_data_key,
     IndexedDBValue* value) {
   BlobChangeRecord* change_record = NULL;
   BlobChangeMap::const_iterator blob_iter =
       blob_change_map_.find(object_store_data_key);
   if (blob_iter != blob_change_map_.end()) {
     change_record = blob_iter->second;
   } else {
     blob_iter = incognito_blob_map_.find(object_store_data_key);
     if (blob_iter != incognito_blob_map_.end())
@@ skipping 51 matching lines @@
 void IndexedDBBackingStore::CleanPrimaryJournalIgnoreReturn() {
   // While a transaction is busy it is not safe to clean the journal.
   if (committing_transaction_count_ > 0)
     StartJournalCleaningTimer();
   else
     CleanUpBlobJournal(BlobJournalKey::Encode());
 }
 
 WARN_UNUSED_RESULT static leveldb::Status SetMaxIndexId(
     LevelDBTransaction* transaction,
-    int64 database_id,
-    int64 object_store_id,
-    int64 index_id) {
-  int64 max_index_id = -1;
+    int64_t database_id,
+    int64_t object_store_id,
+    int64_t index_id) {
+  int64_t max_index_id = -1;
   const std::string max_index_id_key = ObjectStoreMetaDataKey::Encode(
       database_id, object_store_id, ObjectStoreMetaDataKey::MAX_INDEX_ID);
   bool found = false;
   leveldb::Status s =
       GetInt(transaction, max_index_id_key, &max_index_id, &found);
   if (!s.ok()) {
     INTERNAL_READ_ERROR_UNTESTED(SET_MAX_INDEX_ID);
     return s;
   }
   if (!found)
     max_index_id = kMinimumIndexId;
 
   if (index_id <= max_index_id) {
     INTERNAL_CONSISTENCY_ERROR_UNTESTED(SET_MAX_INDEX_ID);
     return InternalInconsistencyStatus();
   }
 
   PutInt(transaction, max_index_id_key, index_id);
   return s;
 }
 
 leveldb::Status IndexedDBBackingStore::CreateIndex(
     IndexedDBBackingStore::Transaction* transaction,
-    int64 database_id,
-    int64 object_store_id,
-    int64 index_id,
+    int64_t database_id,
+    int64_t object_store_id,
+    int64_t index_id,
     const base::string16& name,
     const IndexedDBKeyPath& key_path,
     bool is_unique,
     bool is_multi_entry) {
   IDB_TRACE("IndexedDBBackingStore::CreateIndex");
   if (!KeyPrefix::ValidIds(database_id, object_store_id, index_id))
     return InvalidDBKeyStatus();
   LevelDBTransaction* leveldb_transaction = transaction->transaction();
   leveldb::Status s = SetMaxIndexId(
       leveldb_transaction, database_id, object_store_id, index_id);
@@ skipping 12 matching lines @@
 
   PutString(leveldb_transaction, name_key, name);
   PutBool(leveldb_transaction, unique_key, is_unique);
   PutIDBKeyPath(leveldb_transaction, key_path_key, key_path);
   PutBool(leveldb_transaction, multi_entry_key, is_multi_entry);
   return s;
 }
 
 leveldb::Status IndexedDBBackingStore::DeleteIndex(
     IndexedDBBackingStore::Transaction* transaction,
-    int64 database_id,
-    int64 object_store_id,
-    int64 index_id) {
+    int64_t database_id,
+    int64_t object_store_id,
+    int64_t index_id) {
   IDB_TRACE("IndexedDBBackingStore::DeleteIndex");
   if (!KeyPrefix::ValidIds(database_id, object_store_id, index_id))
     return InvalidDBKeyStatus();
   LevelDBTransaction* leveldb_transaction = transaction->transaction();
 
   const std::string index_meta_data_start =
       IndexMetaDataKey::Encode(database_id, object_store_id, index_id, 0);
   const std::string index_meta_data_end =
       IndexMetaDataKey::EncodeMaxKey(database_id, object_store_id, index_id);
   leveldb::Status s = DeleteRangeBasic(
       leveldb_transaction, index_meta_data_start, index_meta_data_end, true);
 
   if (s.ok()) {
     const std::string index_data_start =
         IndexDataKey::EncodeMinKey(database_id, object_store_id, index_id);
     const std::string index_data_end =
         IndexDataKey::EncodeMaxKey(database_id, object_store_id, index_id);
     s = DeleteRangeBasic(
         leveldb_transaction, index_data_start, index_data_end, true);
   }
 
   if (!s.ok())
     INTERNAL_WRITE_ERROR_UNTESTED(DELETE_INDEX);
 
   return s;
 }
 
 leveldb::Status IndexedDBBackingStore::PutIndexDataForRecord(
     IndexedDBBackingStore::Transaction* transaction,
-    int64 database_id,
-    int64 object_store_id,
-    int64 index_id,
+    int64_t database_id,
+    int64_t object_store_id,
+    int64_t index_id,
     const IndexedDBKey& key,
     const RecordIdentifier& record_identifier) {
   IDB_TRACE("IndexedDBBackingStore::PutIndexDataForRecord");
   DCHECK(key.IsValid());
   if (!KeyPrefix::ValidIds(database_id, object_store_id, index_id))
     return InvalidDBKeyStatus();
 
   std::string encoded_key;
   EncodeIDBKey(key, &encoded_key);
 
@@ skipping 38 matching lines @@
     *found_key = it->Key().as_string();
 
     // There can be several index keys that compare equal. We want the last one.
     *s = it->Next();
   } while (s->ok() && it->IsValid() && !CompareIndexKeys(it->Key(), target));
 
   return true;
 }
 
 static leveldb::Status VersionExists(LevelDBTransaction* transaction,
-                                     int64 database_id,
-                                     int64 object_store_id,
-                                     int64 version,
+                                     int64_t database_id,
+                                     int64_t object_store_id,
+                                     int64_t version,
                                      const std::string& encoded_primary_key,
                                      bool* exists) {
   const std::string key =
       ExistsEntryKey::Encode(database_id, object_store_id, encoded_primary_key);
   std::string data;
 
   leveldb::Status s = transaction->Get(key, &data, exists);
   if (!s.ok()) {
     INTERNAL_READ_ERROR_UNTESTED(VERSION_EXISTS);
     return s;
   }
   if (!*exists)
     return s;
 
   StringPiece slice(data);
-  int64 decoded;
+  int64_t decoded;
   if (!DecodeInt(&slice, &decoded) || !slice.empty())
     return InternalInconsistencyStatus();
   *exists = (decoded == version);
   return s;
 }
 
 leveldb::Status IndexedDBBackingStore::FindKeyInIndex(
     IndexedDBBackingStore::Transaction* transaction,
-    int64 database_id,
-    int64 object_store_id,
-    int64 index_id,
+    int64_t database_id,
+    int64_t object_store_id,
+    int64_t index_id,
     const IndexedDBKey& key,
     std::string* found_encoded_primary_key,
     bool* found) {
   IDB_TRACE("IndexedDBBackingStore::FindKeyInIndex");
   DCHECK(KeyPrefix::ValidIds(database_id, object_store_id, index_id));
 
   DCHECK(found_encoded_primary_key->empty());
   *found = false;
 
   LevelDBTransaction* leveldb_transaction = transaction->transaction();
   const std::string leveldb_key =
       IndexDataKey::Encode(database_id, object_store_id, index_id, key);
   scoped_ptr<LevelDBIterator> it = leveldb_transaction->CreateIterator();
   leveldb::Status s = it->Seek(leveldb_key);
   if (!s.ok()) {
     INTERNAL_READ_ERROR_UNTESTED(FIND_KEY_IN_INDEX);
     return s;
   }
 
   for (;;) {
     if (!it->IsValid())
       return leveldb::Status::OK();
     if (CompareIndexKeys(it->Key(), leveldb_key) > 0)
       return leveldb::Status::OK();
 
     StringPiece slice(it->Value());
 
-    int64 version;
+    int64_t version;
     if (!DecodeVarInt(&slice, &version)) {
       INTERNAL_READ_ERROR_UNTESTED(FIND_KEY_IN_INDEX);
       return InternalInconsistencyStatus();
     }
     *found_encoded_primary_key = slice.as_string();
 
     bool exists = false;
     s = VersionExists(leveldb_transaction,
                       database_id,
                       object_store_id,
                       version,
                       *found_encoded_primary_key,
                       &exists);
     if (!s.ok())
       return s;
     if (!exists) {
       // Delete stale index data entry and continue.
       leveldb_transaction->Remove(it->Key());
       s = it->Next();
       continue;
     }
     *found = true;
     return s;
   }
 }
 
 leveldb::Status IndexedDBBackingStore::GetPrimaryKeyViaIndex(
     IndexedDBBackingStore::Transaction* transaction,
-    int64 database_id,
-    int64 object_store_id,
-    int64 index_id,
+    int64_t database_id,
+    int64_t object_store_id,
+    int64_t index_id,
     const IndexedDBKey& key,
     scoped_ptr<IndexedDBKey>* primary_key) {
   IDB_TRACE("IndexedDBBackingStore::GetPrimaryKeyViaIndex");
   if (!KeyPrefix::ValidIds(database_id, object_store_id, index_id))
     return InvalidDBKeyStatus();
 
   bool found = false;
   std::string found_encoded_primary_key;
   leveldb::Status s = FindKeyInIndex(transaction,
                                      database_id,
@@ skipping 15 matching lines @@
 
   StringPiece slice(found_encoded_primary_key);
   if (DecodeIDBKey(&slice, primary_key) && slice.empty())
     return s;
   else
     return InvalidDBKeyStatus();
 }
 
 leveldb::Status IndexedDBBackingStore::KeyExistsInIndex(
     IndexedDBBackingStore::Transaction* transaction,
-    int64 database_id,
-    int64 object_store_id,
-    int64 index_id,
+    int64_t database_id,
+    int64_t object_store_id,
+    int64_t index_id,
     const IndexedDBKey& index_key,
     scoped_ptr<IndexedDBKey>* found_primary_key,
     bool* exists) {
   IDB_TRACE("IndexedDBBackingStore::KeyExistsInIndex");
   if (!KeyPrefix::ValidIds(database_id, object_store_id, index_id))
     return InvalidDBKeyStatus();
 
   *exists = false;
   std::string found_encoded_primary_key;
   leveldb::Status s = FindKeyInIndex(transaction,
@@ skipping 35 matching lines @@
       leveldb::Status s = iterator_->Seek(other->iterator_->Key());
       // TODO(cmumford): Handle this error (crbug.com/363397)
       DCHECK(iterator_->IsValid());
     }
   }
 }
 
 IndexedDBBackingStore::Cursor::Cursor(
     scoped_refptr<IndexedDBBackingStore> backing_store,
     IndexedDBBackingStore::Transaction* transaction,
-    int64 database_id,
+    int64_t database_id,
     const CursorOptions& cursor_options)
     : backing_store_(backing_store.get()),
       transaction_(transaction),
       database_id_(database_id),
-      cursor_options_(cursor_options) {
-}
+      cursor_options_(cursor_options) {}
 IndexedDBBackingStore::Cursor::~Cursor() {}
 
 bool IndexedDBBackingStore::Cursor::FirstSeek(leveldb::Status* s) {
   iterator_ = transaction_->transaction()->CreateIterator();
   if (cursor_options_.forward)
     *s = iterator_->Seek(cursor_options_.low_key);
   else
     *s = iterator_->Seek(cursor_options_.high_key);
   if (!s->ok())
     return false;
 
   return Continue(0, READY, s);
 }
 
-bool IndexedDBBackingStore::Cursor::Advance(uint32 count, leveldb::Status* s) {
+bool IndexedDBBackingStore::Cursor::Advance(uint32_t count,
+                                            leveldb::Status* s) {
   *s = leveldb::Status::OK();
   while (count--) {
     if (!Continue(s))
       return false;
   }
   return true;
 }
 
 bool IndexedDBBackingStore::Cursor::Continue(const IndexedDBKey* key,
                                              const IndexedDBKey* primary_key,
@@ skipping 220 matching lines @@
 const IndexedDBBackingStore::RecordIdentifier&
 IndexedDBBackingStore::Cursor::record_identifier() const {
   return record_identifier_;
 }
 
 class ObjectStoreKeyCursorImpl : public IndexedDBBackingStore::Cursor {
  public:
   ObjectStoreKeyCursorImpl(
       scoped_refptr<IndexedDBBackingStore> backing_store,
       IndexedDBBackingStore::Transaction* transaction,
-      int64 database_id,
+      int64_t database_id,
       const IndexedDBBackingStore::Cursor::CursorOptions& cursor_options)
       : IndexedDBBackingStore::Cursor(backing_store,
                                       transaction,
                                       database_id,
                                       cursor_options) {}
 
   Cursor* Clone() override { return new ObjectStoreKeyCursorImpl(this); }
 
   // IndexedDBBackingStore::Cursor
   IndexedDBValue* value() override {
@@ skipping 24 matching lines @@
   StringPiece slice(iterator_->Key());
   ObjectStoreDataKey object_store_data_key;
   if (!ObjectStoreDataKey::Decode(&slice, &object_store_data_key)) {
     INTERNAL_READ_ERROR_UNTESTED(LOAD_CURRENT_ROW);
     *s = InvalidDBKeyStatus();
     return false;
   }
 
   current_key_ = object_store_data_key.user_key();
 
-  int64 version;
+  int64_t version;
   slice = StringPiece(iterator_->Value());
   if (!DecodeVarInt(&slice, &version)) {
     INTERNAL_READ_ERROR_UNTESTED(LOAD_CURRENT_ROW);
     *s = InternalInconsistencyStatus();
     return false;
   }
 
   // TODO(jsbell): This re-encodes what was just decoded; try and optimize.
   std::string encoded_key;
   EncodeIDBKey(*current_key_, &encoded_key);
   record_identifier_.Reset(encoded_key, version);
 
   return true;
 }
 
 class ObjectStoreCursorImpl : public IndexedDBBackingStore::Cursor {
  public:
   ObjectStoreCursorImpl(
       scoped_refptr<IndexedDBBackingStore> backing_store,
       IndexedDBBackingStore::Transaction* transaction,
-      int64 database_id,
+      int64_t database_id,
       const IndexedDBBackingStore::Cursor::CursorOptions& cursor_options)
       : IndexedDBBackingStore::Cursor(backing_store,
                                       transaction,
                                       database_id,
                                       cursor_options) {}
 
   Cursor* Clone() override { return new ObjectStoreCursorImpl(this); }
 
   // IndexedDBBackingStore::Cursor
   IndexedDBValue* value() override { return &current_value_; }
@@ skipping 24 matching lines @@
   StringPiece key_slice(iterator_->Key());
   ObjectStoreDataKey object_store_data_key;
   if (!ObjectStoreDataKey::Decode(&key_slice, &object_store_data_key)) {
     INTERNAL_READ_ERROR_UNTESTED(LOAD_CURRENT_ROW);
     *s = InvalidDBKeyStatus();
     return false;
   }
 
   current_key_ = object_store_data_key.user_key();
 
-  int64 version;
+  int64_t version;
   StringPiece value_slice = StringPiece(iterator_->Value());
   if (!DecodeVarInt(&value_slice, &version)) {
     INTERNAL_READ_ERROR_UNTESTED(LOAD_CURRENT_ROW);
     *s = InternalInconsistencyStatus();
     return false;
   }
 
   // TODO(jsbell): This re-encodes what was just decoded; try and optimize.
   std::string encoded_key;
   EncodeIDBKey(*current_key_, &encoded_key);
   record_identifier_.Reset(encoded_key, version);
 
   *s = transaction_->GetBlobInfoForRecord(
       database_id_, iterator_->Key().as_string(), &current_value_);
   if (!s->ok())
     return false;
 
   current_value_.bits = value_slice.as_string();
   return true;
 }
 
 class IndexKeyCursorImpl : public IndexedDBBackingStore::Cursor {
  public:
   IndexKeyCursorImpl(
       scoped_refptr<IndexedDBBackingStore> backing_store,
       IndexedDBBackingStore::Transaction* transaction,
-      int64 database_id,
+      int64_t database_id,
       const IndexedDBBackingStore::Cursor::CursorOptions& cursor_options)
       : IndexedDBBackingStore::Cursor(backing_store,
                                       transaction,
                                       database_id,
                                       cursor_options) {}
 
   Cursor* Clone() override { return new IndexKeyCursorImpl(this); }
 
   // IndexedDBBackingStore::Cursor
   IndexedDBValue* value() override {
@@ skipping 40 matching lines @@
   if (!IndexDataKey::Decode(&slice, &index_data_key)) {
     INTERNAL_READ_ERROR_UNTESTED(LOAD_CURRENT_ROW);
     *s = InvalidDBKeyStatus();
     return false;
   }
 
   current_key_ = index_data_key.user_key();
   DCHECK(current_key_);
 
   slice = StringPiece(iterator_->Value());
-  int64 index_data_version;
+  int64_t index_data_version;
   if (!DecodeVarInt(&slice, &index_data_version)) {
     INTERNAL_READ_ERROR_UNTESTED(LOAD_CURRENT_ROW);
     *s = InternalInconsistencyStatus();
     return false;
   }
 
   if (!DecodeIDBKey(&slice, &primary_key_) || !slice.empty()) {
     INTERNAL_READ_ERROR_UNTESTED(LOAD_CURRENT_ROW);
     *s = InternalInconsistencyStatus();
     return false;
@@ skipping 13 matching lines @@
   }
   if (!found) {
     transaction_->transaction()->Remove(iterator_->Key());
     return false;
   }
   if (!result.size()) {
     INTERNAL_READ_ERROR_UNTESTED(LOAD_CURRENT_ROW);
     return false;
   }
 
-  int64 object_store_data_version;
+  int64_t object_store_data_version;
   slice = StringPiece(result);
   if (!DecodeVarInt(&slice, &object_store_data_version)) {
     INTERNAL_READ_ERROR_UNTESTED(LOAD_CURRENT_ROW);
     *s = InternalInconsistencyStatus();
     return false;
   }
 
   if (object_store_data_version != index_data_version) {
     transaction_->transaction()->Remove(iterator_->Key());
     return false;
   }
 
   return true;
 }
 
 class IndexCursorImpl : public IndexedDBBackingStore::Cursor {
  public:
   IndexCursorImpl(
       scoped_refptr<IndexedDBBackingStore> backing_store,
       IndexedDBBackingStore::Transaction* transaction,
-      int64 database_id,
+      int64_t database_id,
       const IndexedDBBackingStore::Cursor::CursorOptions& cursor_options)
       : IndexedDBBackingStore::Cursor(backing_store,
                                       transaction,
                                       database_id,
                                       cursor_options) {}
 
   Cursor* Clone() override { return new IndexCursorImpl(this); }
 
   // IndexedDBBackingStore::Cursor
   IndexedDBValue* value() override { return &current_value_; }
@@ skipping 41 matching lines @@
   if (!IndexDataKey::Decode(&slice, &index_data_key)) {
     INTERNAL_READ_ERROR_UNTESTED(LOAD_CURRENT_ROW);
     *s = InvalidDBKeyStatus();
     return false;
   }
 
   current_key_ = index_data_key.user_key();
   DCHECK(current_key_);
 
   slice = StringPiece(iterator_->Value());
-  int64 index_data_version;
+  int64_t index_data_version;
   if (!DecodeVarInt(&slice, &index_data_version)) {
     INTERNAL_READ_ERROR_UNTESTED(LOAD_CURRENT_ROW);
     *s = InternalInconsistencyStatus();
     return false;
   }
   if (!DecodeIDBKey(&slice, &primary_key_)) {
     INTERNAL_READ_ERROR_UNTESTED(LOAD_CURRENT_ROW);
     *s = InvalidDBKeyStatus();
     return false;
   }
@@ skipping 13 matching lines @@
   }
   if (!found) {
     transaction_->transaction()->Remove(iterator_->Key());
     return false;
   }
   if (!result.size()) {
     INTERNAL_READ_ERROR_UNTESTED(LOAD_CURRENT_ROW);
     return false;
   }
 
-  int64 object_store_data_version;
+  int64_t object_store_data_version;
   slice = StringPiece(result);
   if (!DecodeVarInt(&slice, &object_store_data_version)) {
     INTERNAL_READ_ERROR_UNTESTED(LOAD_CURRENT_ROW);
     *s = InternalInconsistencyStatus();
     return false;
   }
 
   if (object_store_data_version != index_data_version) {
     transaction_->transaction()->Remove(iterator_->Key());
     return false;
   }
 
   current_value_.bits = slice.as_string();
   *s = transaction_->GetBlobInfoForRecord(database_id_, primary_leveldb_key_,
                                           &current_value_);
   return s->ok();
 }
 
 bool ObjectStoreCursorOptions(
     LevelDBTransaction* transaction,
-    int64 database_id,
-    int64 object_store_id,
+    int64_t database_id,
+    int64_t object_store_id,
     const IndexedDBKeyRange& range,
     blink::WebIDBCursorDirection direction,
     IndexedDBBackingStore::Cursor::CursorOptions* cursor_options) {
   cursor_options->database_id = database_id;
   cursor_options->object_store_id = object_store_id;
 
   bool lower_bound = range.lower().IsValid();
   bool upper_bound = range.upper().IsValid();
   cursor_options->forward =
       (direction == blink::WebIDBCursorDirectionNextNoDuplicate ||
@@ skipping 51 matching lines @@
 
       cursor_options->high_key = found_high_key;
     }
   }
 
   return true;
 }
 
 bool IndexCursorOptions(
     LevelDBTransaction* transaction,
-    int64 database_id,
-    int64 object_store_id,
-    int64 index_id,
+    int64_t database_id,
+    int64_t object_store_id,
+    int64_t index_id,
     const IndexedDBKeyRange& range,
     blink::WebIDBCursorDirection direction,
     IndexedDBBackingStore::Cursor::CursorOptions* cursor_options) {
   DCHECK(transaction);
   if (!KeyPrefix::ValidIds(database_id, object_store_id, index_id))
     return false;
 
   cursor_options->database_id = database_id;
   cursor_options->object_store_id = object_store_id;
   cursor_options->index_id = index_id;
@@ skipping 52 matching lines @@
 
     cursor_options->high_key = found_high_key;
   }
 
   return true;
 }
 
 scoped_ptr<IndexedDBBackingStore::Cursor>
 IndexedDBBackingStore::OpenObjectStoreCursor(
     IndexedDBBackingStore::Transaction* transaction,
-    int64 database_id,
-    int64 object_store_id,
+    int64_t database_id,
+    int64_t object_store_id,
     const IndexedDBKeyRange& range,
     blink::WebIDBCursorDirection direction,
     leveldb::Status* s) {
   IDB_TRACE("IndexedDBBackingStore::OpenObjectStoreCursor");
   *s = leveldb::Status::OK();
   LevelDBTransaction* leveldb_transaction = transaction->transaction();
   IndexedDBBackingStore::Cursor::CursorOptions cursor_options;
   if (!ObjectStoreCursorOptions(leveldb_transaction,
                                 database_id,
                                 object_store_id,
                                 range,
                                 direction,
                                 &cursor_options))
     return scoped_ptr<IndexedDBBackingStore::Cursor>();
   scoped_ptr<ObjectStoreCursorImpl> cursor(new ObjectStoreCursorImpl(
       this, transaction, database_id, cursor_options));
   if (!cursor->FirstSeek(s))
     return scoped_ptr<IndexedDBBackingStore::Cursor>();
 
   return cursor.Pass();
 }
 
 scoped_ptr<IndexedDBBackingStore::Cursor>
 IndexedDBBackingStore::OpenObjectStoreKeyCursor(
     IndexedDBBackingStore::Transaction* transaction,
-    int64 database_id,
-    int64 object_store_id,
+    int64_t database_id,
+    int64_t object_store_id,
     const IndexedDBKeyRange& range,
     blink::WebIDBCursorDirection direction,
     leveldb::Status* s) {
   IDB_TRACE("IndexedDBBackingStore::OpenObjectStoreKeyCursor");
   *s = leveldb::Status::OK();
   LevelDBTransaction* leveldb_transaction = transaction->transaction();
   IndexedDBBackingStore::Cursor::CursorOptions cursor_options;
   if (!ObjectStoreCursorOptions(leveldb_transaction,
                                 database_id,
                                 object_store_id,
                                 range,
                                 direction,
                                 &cursor_options))
     return scoped_ptr<IndexedDBBackingStore::Cursor>();
   scoped_ptr<ObjectStoreKeyCursorImpl> cursor(new ObjectStoreKeyCursorImpl(
       this, transaction, database_id, cursor_options));
   if (!cursor->FirstSeek(s))
     return scoped_ptr<IndexedDBBackingStore::Cursor>();
 
   return cursor.Pass();
 }
 
 scoped_ptr<IndexedDBBackingStore::Cursor>
 IndexedDBBackingStore::OpenIndexKeyCursor(
     IndexedDBBackingStore::Transaction* transaction,
-    int64 database_id,
-    int64 object_store_id,
-    int64 index_id,
+    int64_t database_id,
+    int64_t object_store_id,
+    int64_t index_id,
     const IndexedDBKeyRange& range,
     blink::WebIDBCursorDirection direction,
     leveldb::Status* s) {
   IDB_TRACE("IndexedDBBackingStore::OpenIndexKeyCursor");
   *s = leveldb::Status::OK();
   LevelDBTransaction* leveldb_transaction = transaction->transaction();
   IndexedDBBackingStore::Cursor::CursorOptions cursor_options;
   if (!IndexCursorOptions(leveldb_transaction,
                           database_id,
                           object_store_id,
                           index_id,
                           range,
                           direction,
                           &cursor_options))
     return scoped_ptr<IndexedDBBackingStore::Cursor>();
   scoped_ptr<IndexKeyCursorImpl> cursor(
       new IndexKeyCursorImpl(this, transaction, database_id, cursor_options));
   if (!cursor->FirstSeek(s))
     return scoped_ptr<IndexedDBBackingStore::Cursor>();
 
   return cursor.Pass();
 }
 
 scoped_ptr<IndexedDBBackingStore::Cursor>
 IndexedDBBackingStore::OpenIndexCursor(
     IndexedDBBackingStore::Transaction* transaction,
-    int64 database_id,
-    int64 object_store_id,
-    int64 index_id,
+    int64_t database_id,
+    int64_t object_store_id,
+    int64_t index_id,
     const IndexedDBKeyRange& range,
     blink::WebIDBCursorDirection direction,
     leveldb::Status* s) {
   IDB_TRACE("IndexedDBBackingStore::OpenIndexCursor");
   LevelDBTransaction* leveldb_transaction = transaction->transaction();
   IndexedDBBackingStore::Cursor::CursorOptions cursor_options;
   if (!IndexCursorOptions(leveldb_transaction,
                           database_id,
                           object_store_id,
                           index_id,
@@ skipping 52 matching lines @@
     return leveldb::Status::OK();
 
   // Create LevelDBTransaction for the name generator seed and add-journal.
   scoped_refptr<LevelDBTransaction> pre_transaction =
       IndexedDBClassFactory::Get()->CreateLevelDBTransaction(
           backing_store_->db_.get());
 
   for (auto& iter : blob_change_map_) {
     std::vector<IndexedDBBlobInfo*> new_blob_keys;
     for (auto& entry : iter.second->mutable_blob_info()) {
-      int64 next_blob_key = -1;
+      int64_t next_blob_key = -1;
       bool result = GetBlobKeyGeneratorCurrentNumber(
           pre_transaction.get(), database_id_, &next_blob_key);
       if (!result || next_blob_key < 0)
         return InternalInconsistencyStatus();
       blobs_to_write_.push_back(std::make_pair(database_id_, next_blob_key));
       if (entry.is_file() && !entry.file_path().empty()) {
         new_files_to_write->push_back(
             WriteDescriptor(entry.file_path(), next_blob_key, entry.size(),
                             entry.last_modified()));
       } else {
@@ skipping 280 matching lines @@
     chained_blob_writer_ = NULL;
   }
   if (transaction_.get() == NULL)
     return;
   transaction_->Rollback();
   transaction_ = NULL;
 }
 
 IndexedDBBackingStore::BlobChangeRecord::BlobChangeRecord(
     const std::string& key,
-    int64 object_store_id)
-    : key_(key), object_store_id_(object_store_id) {
-}
+    int64_t object_store_id)
+    : key_(key), object_store_id_(object_store_id) {}
 
 IndexedDBBackingStore::BlobChangeRecord::~BlobChangeRecord() {
 }
 
 void IndexedDBBackingStore::BlobChangeRecord::SetBlobInfo(
     std::vector<IndexedDBBlobInfo>* blob_info) {
   blob_info_.clear();
   if (blob_info)
     blob_info_.swap(*blob_info);
 }
@@ skipping 10 matching lines @@
   scoped_ptr<IndexedDBBackingStore::BlobChangeRecord> record(
       new BlobChangeRecord(key_, object_store_id_));
   record->blob_info_ = blob_info_;
 
   for (const auto* handle : handles_)
     record->handles_.push_back(new storage::BlobDataHandle(*handle));
   return record.Pass();
 }
 
 leveldb::Status IndexedDBBackingStore::Transaction::PutBlobInfoIfNeeded(
-    int64 database_id,
-    int64 object_store_id,
+    int64_t database_id,
+    int64_t object_store_id,
     const std::string& object_store_data_key,
     std::vector<IndexedDBBlobInfo>* blob_info,
     ScopedVector<storage::BlobDataHandle>* handles) {
   if (!blob_info || blob_info->empty()) {
     blob_change_map_.erase(object_store_data_key);
     incognito_blob_map_.erase(object_store_data_key);
 
     BlobEntryKey blob_entry_key;
     StringPiece leveldb_key_piece(object_store_data_key);
     if (!BlobEntryKey::FromObjectStoreDataKey(&leveldb_key_piece,
@@ skipping 13 matching lines @@
   PutBlobInfo(
       database_id, object_store_id, object_store_data_key, blob_info, handles);
   return leveldb::Status::OK();
 }
 
 // This is storing an info, even if empty, even if the previous key had no blob
 // info that we know of.  It duplicates a bunch of information stored in the
 // leveldb transaction, but only w.r.t. the user keys altered--we don't keep the
 // changes to exists or index keys here.
 void IndexedDBBackingStore::Transaction::PutBlobInfo(
-    int64 database_id,
-    int64 object_store_id,
+    int64_t database_id,
+    int64_t object_store_id,
     const std::string& object_store_data_key,
     std::vector<IndexedDBBlobInfo>* blob_info,
     ScopedVector<storage::BlobDataHandle>* handles) {
   DCHECK_GT(object_store_data_key.size(), 0UL);
   if (database_id_ < 0)
     database_id_ = database_id;
   DCHECK_EQ(database_id_, database_id);
 
   BlobChangeMap::iterator it = blob_change_map_.find(object_store_data_key);
   BlobChangeRecord* record = NULL;
@@ skipping 35 matching lines @@
 
 IndexedDBBackingStore::Transaction::WriteDescriptor::WriteDescriptor(
     const WriteDescriptor& other) = default;
 IndexedDBBackingStore::Transaction::WriteDescriptor::~WriteDescriptor() =
     default;
 IndexedDBBackingStore::Transaction::WriteDescriptor&
     IndexedDBBackingStore::Transaction::WriteDescriptor::
     operator=(const WriteDescriptor& other) = default;
 
 }  // namespace content