Switch to standard integer types in content/browser/.

content/browser/indexed_db/indexed_db_database.cc

Index: content/browser/indexed_db/indexed_db_database.cc
diff --git a/content/browser/indexed_db/indexed_db_database.cc b/content/browser/indexed_db/indexed_db_database.cc
index 03a41d15b09ef0c125ee94a77cf4662afb97c130..60021d6edbcce78bac69bbc16611af486c47e393 100644
--- a/content/browser/indexed_db/indexed_db_database.cc
+++ b/content/browser/indexed_db/indexed_db_database.cc
@@ -10,6 +10,7 @@
 
 #include "base/auto_reset.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/metrics/histogram_macros.h"
@@ -75,8 +76,8 @@ class IndexedDBDatabase::PendingUpgradeCall {
  public:
   PendingUpgradeCall(scoped_refptr<IndexedDBCallbacks> callbacks,
                      scoped_ptr<IndexedDBConnection> connection,
-                     int64 transaction_id,
-                     int64 version)
+                     int64_t transaction_id,
+                     int64_t version)
       : callbacks_(callbacks),
         connection_(connection.Pass()),
         version_(version),
@@ -86,14 +87,14 @@ class IndexedDBDatabase::PendingUpgradeCall {
   scoped_ptr<IndexedDBConnection> ReleaseConnection() WARN_UNUSED_RESULT {
     return connection_.Pass();
   }
-  int64 version() const { return version_; }
-  int64 transaction_id() const { return transaction_id_; }
+  int64_t version() const { return version_; }
+  int64_t transaction_id() const { return transaction_id_; }
 
  private:
   scoped_refptr<IndexedDBCallbacks> callbacks_;
   scoped_ptr<IndexedDBConnection> connection_;
-  int64 version_;
-  const int64 transaction_id_;
+  int64_t version_;
+  const int64_t transaction_id_;
 };
 
 // PendingSuccessCall has a IndexedDBConnection* because the connection is now
@@ -103,16 +104,16 @@ class IndexedDBDatabase::PendingSuccessCall {
  public:
   PendingSuccessCall(scoped_refptr<IndexedDBCallbacks> callbacks,
                      IndexedDBConnection* connection,
-                     int64 version)
+                     int64_t version)
       : callbacks_(callbacks), connection_(connection), version_(version) {}
   scoped_refptr<IndexedDBCallbacks> callbacks() const { return callbacks_; }
   IndexedDBConnection* connection() const { return connection_; }
-  int64 version() const { return version_; }
+  int64_t version() const { return version_; }
 
  private:
   scoped_refptr<IndexedDBCallbacks> callbacks_;
   IndexedDBConnection* connection_;
-  int64 version_;
+  int64_t version_;
 };
 
 class IndexedDBDatabase::PendingDeleteCall {
@@ -162,7 +163,7 @@ IndexedDBDatabase::IndexedDBDatabase(const base::string16& name,
 
 void IndexedDBDatabase::AddObjectStore(
     const IndexedDBObjectStoreMetadata& object_store,
-    int64 new_max_object_store_id) {
+    int64_t new_max_object_store_id) {
   DCHECK(metadata_.object_stores.find(object_store.id) ==
          metadata_.object_stores.end());
   if (new_max_object_store_id != IndexedDBObjectStoreMetadata::kInvalidId) {
@@ -172,15 +173,15 @@ void IndexedDBDatabase::AddObjectStore(
   metadata_.object_stores[object_store.id] = object_store;
 }
 
-void IndexedDBDatabase::RemoveObjectStore(int64 object_store_id) {
+void IndexedDBDatabase::RemoveObjectStore(int64_t object_store_id) {
   DCHECK(metadata_.object_stores.find(object_store_id) !=
          metadata_.object_stores.end());
   metadata_.object_stores.erase(object_store_id);
 }
 
-void IndexedDBDatabase::AddIndex(int64 object_store_id,
+void IndexedDBDatabase::AddIndex(int64_t object_store_id,
                                  const IndexedDBIndexMetadata& index,
-                                 int64 new_max_index_id) {
+                                 int64_t new_max_index_id) {
   DCHECK(metadata_.object_stores.find(object_store_id) !=
          metadata_.object_stores.end());
   IndexedDBObjectStoreMetadata object_store =
@@ -195,7 +196,7 @@ void IndexedDBDatabase::AddIndex(int64 object_store_id,
   metadata_.object_stores[object_store_id] = object_store;
 }
 
-void IndexedDBDatabase::RemoveIndex(int64 object_store_id, int64 index_id) {
+void IndexedDBDatabase::RemoveIndex(int64_t object_store_id, int64_t index_id) {
   DCHECK(metadata_.object_stores.find(object_store_id) !=
          metadata_.object_stores.end());
   IndexedDBObjectStoreMetadata object_store =
@@ -243,7 +244,7 @@ scoped_ptr<IndexedDBConnection> IndexedDBDatabase::CreateConnection(
 }
 
 IndexedDBTransaction* IndexedDBDatabase::GetTransaction(
-    int64 transaction_id) const {
+    int64_t transaction_id) const {
   TransactionMap::const_iterator trans_iterator =
       transactions_.find(transaction_id);
   if (trans_iterator == transactions_.end())
@@ -251,7 +252,7 @@ IndexedDBTransaction* IndexedDBDatabase::GetTransaction(
   return trans_iterator->second;
 }
 
-bool IndexedDBDatabase::ValidateObjectStoreId(int64 object_store_id) const {
+bool IndexedDBDatabase::ValidateObjectStoreId(int64_t object_store_id) const {
   if (!ContainsKey(metadata_.object_stores, object_store_id)) {
     DLOG(ERROR) << "Invalid object_store_id";
     return false;
@@ -259,8 +260,9 @@ bool IndexedDBDatabase::ValidateObjectStoreId(int64 object_store_id) const {
   return true;
 }
 
-bool IndexedDBDatabase::ValidateObjectStoreIdAndIndexId(int64 object_store_id,
-                                                        int64 index_id) const {
+bool IndexedDBDatabase::ValidateObjectStoreIdAndIndexId(
+    int64_t object_store_id,
+    int64_t index_id) const {
   if (!ValidateObjectStoreId(object_store_id))
     return false;
   const IndexedDBObjectStoreMetadata& object_store_metadata =
@@ -273,8 +275,8 @@ bool IndexedDBDatabase::ValidateObjectStoreIdAndIndexId(int64 object_store_id,
 }
 
 bool IndexedDBDatabase::ValidateObjectStoreIdAndOptionalIndexId(
-    int64 object_store_id,
-    int64 index_id) const {
+    int64_t object_store_id,
+    int64_t index_id) const {
   if (!ValidateObjectStoreId(object_store_id))
     return false;
   const IndexedDBObjectStoreMetadata& object_store_metadata =
@@ -288,8 +290,8 @@ bool IndexedDBDatabase::ValidateObjectStoreIdAndOptionalIndexId(
 }
 
 bool IndexedDBDatabase::ValidateObjectStoreIdAndNewIndexId(
-    int64 object_store_id,
-    int64 index_id) const {
+    int64_t object_store_id,
+    int64_t index_id) const {
   if (!ValidateObjectStoreId(object_store_id))
     return false;
   const IndexedDBObjectStoreMetadata& object_store_metadata =
@@ -301,8 +303,8 @@ bool IndexedDBDatabase::ValidateObjectStoreIdAndNewIndexId(
   return true;
 }
 
-void IndexedDBDatabase::CreateObjectStore(int64 transaction_id,
-                                          int64 object_store_id,
+void IndexedDBDatabase::CreateObjectStore(int64_t transaction_id,
+                                          int64_t object_store_id,
                                           const base::string16& name,
                                           const IndexedDBKeyPath& key_path,
                                           bool auto_increment) {
@@ -358,8 +360,8 @@ void IndexedDBDatabase::CreateObjectStore(int64 transaction_id,
                  object_store_id));
 }
 
-void IndexedDBDatabase::DeleteObjectStore(int64 transaction_id,
-                                          int64 object_store_id) {
+void IndexedDBDatabase::DeleteObjectStore(int64_t transaction_id,
+                                          int64_t object_store_id) {
   IDB_TRACE1("IndexedDBDatabase::DeleteObjectStore", "txn.id", transaction_id);
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
@@ -375,9 +377,9 @@ void IndexedDBDatabase::DeleteObjectStore(int64 transaction_id,
                  object_store_id));
 }
 
-void IndexedDBDatabase::CreateIndex(int64 transaction_id,
-                                    int64 object_store_id,
-                                    int64 index_id,
+void IndexedDBDatabase::CreateIndex(int64_t transaction_id,
+                                    int64_t object_store_id,
+                                    int64_t index_id,
                                     const base::string16& name,
                                     const IndexedDBKeyPath& key_path,
                                     bool unique,
@@ -427,17 +429,17 @@ void IndexedDBDatabase::CreateIndex(int64 transaction_id,
 }
 
 void IndexedDBDatabase::CreateIndexAbortOperation(
-    int64 object_store_id,
-    int64 index_id,
+    int64_t object_store_id,
+    int64_t index_id,
     IndexedDBTransaction* transaction) {
   DCHECK(!transaction);
   IDB_TRACE("IndexedDBDatabase::CreateIndexAbortOperation");
   RemoveIndex(object_store_id, index_id);
 }
 
-void IndexedDBDatabase::DeleteIndex(int64 transaction_id,
-                                    int64 object_store_id,
-                                    int64 index_id) {
+void IndexedDBDatabase::DeleteIndex(int64_t transaction_id,
+                                    int64_t object_store_id,
+                                    int64_t index_id) {
   IDB_TRACE1("IndexedDBDatabase::DeleteIndex", "txn.id", transaction_id);
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
@@ -455,8 +457,8 @@ void IndexedDBDatabase::DeleteIndex(int64 transaction_id,
 }
 
 void IndexedDBDatabase::DeleteIndexOperation(
-    int64 object_store_id,
-    int64 index_id,
+    int64_t object_store_id,
+    int64_t index_id,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1(
       "IndexedDBDatabase::DeleteIndexOperation", "txn.id", transaction->id());
@@ -491,7 +493,7 @@ void IndexedDBDatabase::DeleteIndexOperation(
 }
 
 void IndexedDBDatabase::DeleteIndexAbortOperation(
-    int64 object_store_id,
+    int64_t object_store_id,
     const IndexedDBIndexMetadata& index_metadata,
     IndexedDBTransaction* transaction) {
   DCHECK(!transaction);
@@ -499,7 +501,7 @@ void IndexedDBDatabase::DeleteIndexAbortOperation(
   AddIndex(object_store_id, index_metadata, IndexedDBIndexMetadata::kInvalidId);
 }
 
-void IndexedDBDatabase::Commit(int64 transaction_id) {
+void IndexedDBDatabase::Commit(int64_t transaction_id) {
   // The frontend suggests that we commit, but we may have previously initiated
   // an abort, and so have disposed of the transaction. on_abort has already
   // been dispatched to the frontend, so it will find out about that
@@ -516,7 +518,7 @@ void IndexedDBDatabase::Commit(int64 transaction_id) {
   }
 }
 
-void IndexedDBDatabase::Abort(int64 transaction_id) {
+void IndexedDBDatabase::Abort(int64_t transaction_id) {
   // If the transaction is unknown, then it has already been aborted by the
   // backend before this call so it is safe to ignore it.
   IDB_TRACE1("IndexedDBDatabase::Abort", "txn.id", transaction_id);
@@ -525,7 +527,7 @@ void IndexedDBDatabase::Abort(int64 transaction_id) {
     transaction->Abort();
 }
 
-void IndexedDBDatabase::Abort(int64 transaction_id,
+void IndexedDBDatabase::Abort(int64_t transaction_id,
                               const IndexedDBDatabaseError& error) {
   IDB_TRACE1("IndexedDBDatabase::Abort(error)", "txn.id", transaction_id);
   // If the transaction is unknown, then it has already been aborted by the
@@ -535,12 +537,12 @@ void IndexedDBDatabase::Abort(int64 transaction_id,
     transaction->Abort(error);
 }
 
-void IndexedDBDatabase::GetAll(int64 transaction_id,
-                               int64 object_store_id,
-                               int64 index_id,
+void IndexedDBDatabase::GetAll(int64_t transaction_id,
+                               int64_t object_store_id,
+                               int64_t index_id,
                                scoped_ptr<IndexedDBKeyRange> key_range,
                                bool key_only,
-                               int64 max_count,
+                               int64_t max_count,
                                scoped_refptr<IndexedDBCallbacks> callbacks) {
   IDB_TRACE1("IndexedDBDatabase::GetAll", "txn.id", transaction_id);
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
@@ -557,9 +559,9 @@ void IndexedDBDatabase::GetAll(int64 transaction_id,
       max_count, callbacks));
 }
 
-void IndexedDBDatabase::Get(int64 transaction_id,
-                            int64 object_store_id,
-                            int64 index_id,
+void IndexedDBDatabase::Get(int64_t transaction_id,
+                            int64_t object_store_id,
+                            int64_t index_id,
                             scoped_ptr<IndexedDBKeyRange> key_range,
                             bool key_only,
                             scoped_refptr<IndexedDBCallbacks> callbacks) {
@@ -579,8 +581,8 @@ void IndexedDBDatabase::Get(int64 transaction_id,
 }
 
 void IndexedDBDatabase::GetOperation(
-    int64 object_store_id,
-    int64 index_id,
+    int64_t object_store_id,
+    int64_t index_id,
     scoped_ptr<IndexedDBKeyRange> key_range,
     indexed_db::CursorType cursor_type,
     scoped_refptr<IndexedDBCallbacks> callbacks,
@@ -741,11 +743,11 @@ void IndexedDBDatabase::GetOperation(
 }
 
 void IndexedDBDatabase::GetAllOperation(
-    int64 object_store_id,
-    int64 index_id,
+    int64_t object_store_id,
+    int64_t index_id,
     scoped_ptr<IndexedDBKeyRange> key_range,
     indexed_db::CursorType cursor_type,
-    int64 max_count,
+    int64_t max_count,
     scoped_refptr<IndexedDBCallbacks> callbacks,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1("IndexedDBDatabase::GetAllOperation", "txn.id", transaction->id());
@@ -815,7 +817,7 @@ void IndexedDBDatabase::GetAllOperation(
                        !object_store_metadata.key_path.IsNull();
 
   size_t response_size = kMaxIDBMessageOverhead;
-  int64 num_found_items = 0;
+  int64_t num_found_items = 0;
   while (num_found_items++ < max_count) {
     bool cursor_valid;
     if (did_first_seek) {
@@ -880,11 +882,11 @@ void IndexedDBDatabase::GetAllOperation(
 static scoped_ptr<IndexedDBKey> GenerateKey(
     IndexedDBBackingStore* backing_store,
     IndexedDBTransaction* transaction,
-    int64 database_id,
-    int64 object_store_id) {
-  const int64 max_generator_value =
+    int64_t database_id,
+    int64_t object_store_id) {
+  const int64_t max_generator_value =
       9007199254740992LL;  // Maximum integer storable as ECMAScript number.
-  int64 current_number;
+  int64_t current_number;
   leveldb::Status s = backing_store->GetKeyGeneratorCurrentNumber(
       transaction->BackingStoreTransaction(),
       database_id,
@@ -902,22 +904,19 @@ static scoped_ptr<IndexedDBKey> GenerateKey(
 
 static leveldb::Status UpdateKeyGenerator(IndexedDBBackingStore* backing_store,
                                           IndexedDBTransaction* transaction,
-                                          int64 database_id,
-                                          int64 object_store_id,
+                                          int64_t database_id,
+                                          int64_t object_store_id,
                                           const IndexedDBKey& key,
                                           bool check_current) {
   DCHECK_EQ(WebIDBKeyTypeNumber, key.type());
   return backing_store->MaybeUpdateKeyGeneratorCurrentNumber(
-      transaction->BackingStoreTransaction(),
-      database_id,
-      object_store_id,
-      static_cast<int64>(floor(key.number())) + 1,
-      check_current);
+      transaction->BackingStoreTransaction(), database_id, object_store_id,
+      static_cast<int64_t>(floor(key.number())) + 1, check_current);
 }
 
 struct IndexedDBDatabase::PutOperationParams {
   PutOperationParams() {}
-  int64 object_store_id;
+  int64_t object_store_id;
   IndexedDBValue value;
   ScopedVector<storage::BlobDataHandle> handles;
   scoped_ptr<IndexedDBKey> key;
@@ -929,8 +928,8 @@ struct IndexedDBDatabase::PutOperationParams {
   DISALLOW_COPY_AND_ASSIGN(PutOperationParams);
 };
 
-void IndexedDBDatabase::Put(int64 transaction_id,
-                            int64 object_store_id,
+void IndexedDBDatabase::Put(int64_t transaction_id,
+                            int64_t object_store_id,
                             IndexedDBValue* value,
                             ScopedVector<storage::BlobDataHandle>* handles,
                             scoped_ptr<IndexedDBKey> key,
@@ -1102,8 +1101,8 @@ void IndexedDBDatabase::PutOperation(scoped_ptr<PutOperationParams> params,
   }
 }
 
-void IndexedDBDatabase::SetIndexKeys(int64 transaction_id,
-                                     int64 object_store_id,
+void IndexedDBDatabase::SetIndexKeys(int64_t transaction_id,
+                                     int64_t object_store_id,
                                      scoped_ptr<IndexedDBKey> primary_key,
                                      const std::vector<IndexKeys>& index_keys) {
   IDB_TRACE1("IndexedDBDatabase::SetIndexKeys", "txn.id", transaction_id);
@@ -1178,9 +1177,9 @@ void IndexedDBDatabase::SetIndexKeys(int64 transaction_id,
   }
 }
 
-void IndexedDBDatabase::SetIndexesReady(int64 transaction_id,
-                                        int64,
-                                        const std::vector<int64>& index_ids) {
+void IndexedDBDatabase::SetIndexesReady(int64_t transaction_id,
+                                        int64_t,
+                                        const std::vector<int64_t>& index_ids) {
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
@@ -1202,8 +1201,8 @@ void IndexedDBDatabase::SetIndexesReadyOperation(
 
 struct IndexedDBDatabase::OpenCursorOperationParams {
   OpenCursorOperationParams() {}
-  int64 object_store_id;
-  int64 index_id;
+  int64_t object_store_id;
+  int64_t index_id;
   scoped_ptr<IndexedDBKeyRange> key_range;
   blink::WebIDBCursorDirection direction;
   indexed_db::CursorType cursor_type;
@@ -1215,9 +1214,9 @@ struct IndexedDBDatabase::OpenCursorOperationParams {
 };
 
 void IndexedDBDatabase::OpenCursor(
-    int64 transaction_id,
-    int64 object_store_id,
-    int64 index_id,
+    int64_t transaction_id,
+    int64_t object_store_id,
+    int64_t index_id,
     scoped_ptr<IndexedDBKeyRange> key_range,
     blink::WebIDBCursorDirection direction,
     bool key_only,
@@ -1326,9 +1325,9 @@ void IndexedDBDatabase::OpenCursorOperation(
       cursor, cursor->key(), cursor->primary_key(), cursor->Value());
 }
 
-void IndexedDBDatabase::Count(int64 transaction_id,
-                              int64 object_store_id,
-                              int64 index_id,
+void IndexedDBDatabase::Count(int64_t transaction_id,
+                              int64_t object_store_id,
+                              int64_t index_id,
                               scoped_ptr<IndexedDBKeyRange> key_range,
                               scoped_refptr<IndexedDBCallbacks> callbacks) {
   IDB_TRACE1("IndexedDBDatabase::Count", "txn.id", transaction_id);
@@ -1348,13 +1347,13 @@ void IndexedDBDatabase::Count(int64 transaction_id,
 }
 
 void IndexedDBDatabase::CountOperation(
-    int64 object_store_id,
-    int64 index_id,
+    int64_t object_store_id,
+    int64_t index_id,
     scoped_ptr<IndexedDBKeyRange> key_range,
     scoped_refptr<IndexedDBCallbacks> callbacks,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1("IndexedDBDatabase::CountOperation", "txn.id", transaction->id());
-  uint32 count = 0;
+  uint32_t count = 0;
   scoped_ptr<IndexedDBBackingStore::Cursor> backing_store_cursor;
 
   leveldb::Status s;
@@ -1400,8 +1399,8 @@ void IndexedDBDatabase::CountOperation(
 }
 
 void IndexedDBDatabase::DeleteRange(
-    int64 transaction_id,
-    int64 object_store_id,
+    int64_t transaction_id,
+    int64_t object_store_id,
     scoped_ptr<IndexedDBKeyRange> key_range,
     scoped_refptr<IndexedDBCallbacks> callbacks) {
   IDB_TRACE1("IndexedDBDatabase::DeleteRange", "txn.id", transaction_id);
@@ -1421,7 +1420,7 @@ void IndexedDBDatabase::DeleteRange(
 }
 
 void IndexedDBDatabase::DeleteRangeOperation(
-    int64 object_store_id,
+    int64_t object_store_id,
     scoped_ptr<IndexedDBKeyRange> key_range,
     scoped_refptr<IndexedDBCallbacks> callbacks,
     IndexedDBTransaction* transaction) {
@@ -1447,8 +1446,8 @@ void IndexedDBDatabase::DeleteRangeOperation(
   callbacks->OnSuccess();
 }
 
-void IndexedDBDatabase::Clear(int64 transaction_id,
-                              int64 object_store_id,
+void IndexedDBDatabase::Clear(int64_t transaction_id,
+                              int64_t object_store_id,
                               scoped_refptr<IndexedDBCallbacks> callbacks) {
   IDB_TRACE1("IndexedDBDatabase::Clear", "txn.id", transaction_id);
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
@@ -1464,7 +1463,7 @@ void IndexedDBDatabase::Clear(int64 transaction_id,
 }
 
 void IndexedDBDatabase::ClearOperation(
-    int64 object_store_id,
+    int64_t object_store_id,
     scoped_refptr<IndexedDBCallbacks> callbacks,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1("IndexedDBDatabase::ClearOperation", "txn.id", transaction->id());
@@ -1484,7 +1483,7 @@ void IndexedDBDatabase::ClearOperation(
 }
 
 void IndexedDBDatabase::DeleteObjectStoreOperation(
-    int64 object_store_id,
+    int64_t object_store_id,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1("IndexedDBDatabase::DeleteObjectStoreOperation",
              "txn.id",
@@ -1517,13 +1516,13 @@ void IndexedDBDatabase::DeleteObjectStoreOperation(
 }
 
 void IndexedDBDatabase::VersionChangeOperation(
-    int64 version,
+    int64_t version,
     scoped_refptr<IndexedDBCallbacks> callbacks,
     scoped_ptr<IndexedDBConnection> connection,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1(
       "IndexedDBDatabase::VersionChangeOperation", "txn.id", transaction->id());
-  int64 old_version = metadata_.int_version;
+  int64_t old_version = metadata_.int_version;
   DCHECK_GT(version, old_version);
 
   if (!backing_store_->UpdateIDBDatabaseIntVersion(
@@ -1660,9 +1659,9 @@ void IndexedDBDatabase::ProcessPendingCalls() {
 }
 
 void IndexedDBDatabase::CreateTransaction(
-    int64 transaction_id,
+    int64_t transaction_id,
     IndexedDBConnection* connection,
-    const std::vector<int64>& object_store_ids,
+    const std::vector<int64_t>& object_store_ids,
     blink::WebIDBTransactionMode mode) {
   IDB_TRACE1("IndexedDBDatabase::CreateTransaction", "txn.id", transaction_id);
   DCHECK(connections_.count(connection));
@@ -1690,7 +1689,7 @@ void IndexedDBDatabase::CreateTransaction(
   // manages the lifetime of the object.
   TransactionCreated(IndexedDBClassFactory::Get()->CreateIndexedDBTransaction(
       transaction_id, connection->callbacks(),
-      std::set<int64>(object_store_ids.begin(), object_store_ids.end()), mode,
+      std::set<int64_t>(object_store_ids.begin(), object_store_ids.end()), mode,
       this, new IndexedDBBackingStore::Transaction(backing_store_.get())));
 }
 
@@ -1760,7 +1759,7 @@ void IndexedDBDatabase::OpenConnection(
   }
 
   // We may need to change the version.
-  int64 local_version = connection.version;
+  int64_t local_version = connection.version;
   if (local_version == IndexedDBDatabaseMetadata::NO_INT_VERSION) {
     if (!is_new_database) {
       connection.callbacks->OnSuccess(
@@ -1801,8 +1800,8 @@ void IndexedDBDatabase::OpenConnection(
 void IndexedDBDatabase::RunVersionChangeTransaction(
     scoped_refptr<IndexedDBCallbacks> callbacks,
     scoped_ptr<IndexedDBConnection> connection,
-    int64 transaction_id,
-    int64 requested_version) {
+    int64_t transaction_id,
+    int64_t requested_version) {
   DCHECK(callbacks.get());
   DCHECK(connections_.count(connection.get()));
   if (ConnectionCount() > 1) {
@@ -1830,10 +1829,9 @@ void IndexedDBDatabase::RunVersionChangeTransaction(
 void IndexedDBDatabase::RunVersionChangeTransactionFinal(
     scoped_refptr<IndexedDBCallbacks> callbacks,
     scoped_ptr<IndexedDBConnection> connection,
-    int64 transaction_id,
-    int64 requested_version) {
-
-  std::vector<int64> object_store_ids;
+    int64_t transaction_id,
+    int64_t requested_version) {
+  std::vector<int64_t> object_store_ids;
   CreateTransaction(transaction_id,
                     connection.get(),
                     object_store_ids,
@@ -1887,7 +1885,7 @@ void IndexedDBDatabase::DeleteDatabaseFinal(
     }
     return;
   }
-  int64 old_version = metadata_.int_version;
+  int64_t old_version = metadata_.int_version;
   metadata_.version = kNoStringVersion;
   metadata_.id = kInvalidId;
   metadata_.int_version = IndexedDBDatabaseMetadata::NO_INT_VERSION;
@@ -1963,7 +1961,7 @@ void IndexedDBDatabase::Close(IndexedDBConnection* connection, bool forced) {
 }
 
 void IndexedDBDatabase::CreateObjectStoreAbortOperation(
-    int64 object_store_id,
+    int64_t object_store_id,
     IndexedDBTransaction* transaction) {
   DCHECK(!transaction);
   IDB_TRACE("IndexedDBDatabase::CreateObjectStoreAbortOperation");
@@ -1981,7 +1979,7 @@ void IndexedDBDatabase::DeleteObjectStoreAbortOperation(
 
 void IndexedDBDatabase::VersionChangeAbortOperation(
     const base::string16& previous_version,
-    int64 previous_int_version,
+    int64_t previous_int_version,
     IndexedDBTransaction* transaction) {
   DCHECK(!transaction);
   IDB_TRACE("IndexedDBDatabase::VersionChangeAbortOperation");