Switch to standard integer types in content/browser/.

content/browser/indexed_db/indexed_db_database.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_database.h"
 
 #include <math.h>
 #include <limits>
 #include <set>
 
 #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"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.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_connection.h"
 #include "content/browser/indexed_db/indexed_db_context_impl.h"
@@ skipping 45 matching lines @@
 }
 
 }  // namespace
 
 // PendingUpgradeCall has a scoped_ptr<IndexedDBConnection> because it owns the
 // in-progress connection.
 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),
         transaction_id_(transaction_id) {}
   scoped_refptr<IndexedDBCallbacks> callbacks() const { return callbacks_; }
   // Takes ownership of the connection object.
   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
 // owned elsewhere, but we need to cancel the success call if that connection
 // closes before it is sent.
 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 {
  public:
   explicit PendingDeleteCall(scoped_refptr<IndexedDBCallbacks> callbacks)
       : callbacks_(callbacks) {}
   scoped_refptr<IndexedDBCallbacks> callbacks() const { return callbacks_; }
 
  private:
   scoped_refptr<IndexedDBCallbacks> callbacks_;
@@ skipping 29 matching lines @@
                 kNoStringVersion,
                 IndexedDBDatabaseMetadata::NO_INT_VERSION,
                 kInvalidId),
       identifier_(unique_identifier),
       factory_(factory) {
   DCHECK(factory != NULL);
 }
 
 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) {
     DCHECK_LT(metadata_.max_object_store_id, new_max_object_store_id);
     metadata_.max_object_store_id = new_max_object_store_id;
   }
   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 =
       metadata_.object_stores[object_store_id];
 
   DCHECK(object_store.indexes.find(index.id) == object_store.indexes.end());
   object_store.indexes[index.id] = index;
   if (new_max_index_id != IndexedDBIndexMetadata::kInvalidId) {
     DCHECK_LT(object_store.max_index_id, new_max_index_id);
     object_store.max_index_id = new_max_index_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 =
       metadata_.object_stores[object_store_id];
 
   DCHECK(object_store.indexes.find(index_id) != object_store.indexes.end());
   object_store.indexes.erase(index_id);
   metadata_.object_stores[object_store_id] = object_store;
 }
 
@@ skipping 27 matching lines @@
     scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks,
     int child_process_id) {
   scoped_ptr<IndexedDBConnection> connection(
       new IndexedDBConnection(this, database_callbacks));
   connections_.insert(connection.get());
   backing_store_->GrantChildProcessPermissions(child_process_id);
   return connection.Pass();
 }
 
 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())
     return NULL;
   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;
   }
   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 =
       metadata_.object_stores.find(object_store_id)->second;
   if (!ContainsKey(object_store_metadata.indexes, index_id)) {
     DLOG(ERROR) << "Invalid index_id";
     return false;
   }
   return true;
 }
 
 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 =
       metadata_.object_stores.find(object_store_id)->second;
   if (index_id != IndexedDBIndexMetadata::kInvalidId &&
       !ContainsKey(object_store_metadata.indexes, index_id)) {
     DLOG(ERROR) << "Invalid index_id";
     return false;
   }
   return true;
 }
 
 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 =
       metadata_.object_stores.find(object_store_id)->second;
   if (ContainsKey(object_store_metadata.indexes, index_id)) {
     DLOG(ERROR) << "Invalid index_id";
     return false;
   }
   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) {
   IDB_TRACE1("IndexedDBDatabase::CreateObjectStore", "txn.id", transaction_id);
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
   DCHECK_EQ(transaction->mode(), blink::WebIDBTransactionModeVersionChange);
 
   if (ContainsKey(metadata_.object_stores, object_store_id)) {
@@ skipping 35 matching lines @@
     return;
   }
 
   AddObjectStore(object_store_metadata, object_store_id);
   transaction->ScheduleAbortTask(
       base::Bind(&IndexedDBDatabase::CreateObjectStoreAbortOperation,
                  this,
                  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)
     return;
   DCHECK_EQ(transaction->mode(), blink::WebIDBTransactionModeVersionChange);
 
   if (!ValidateObjectStoreId(object_store_id))
     return;
 
   transaction->ScheduleTask(
       base::Bind(&IndexedDBDatabase::DeleteObjectStoreOperation,
                  this,
                  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,
                                     bool multi_entry) {
   IDB_TRACE1("IndexedDBDatabase::CreateIndex", "txn.id", transaction_id);
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
   DCHECK_EQ(transaction->mode(), blink::WebIDBTransactionModeVersionChange);
 
@@ skipping 29 matching lines @@
 
   AddIndex(object_store_id, index_metadata, index_id);
   transaction->ScheduleAbortTask(
       base::Bind(&IndexedDBDatabase::CreateIndexAbortOperation,
                  this,
                  object_store_id,
                  index_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)
     return;
   DCHECK_EQ(transaction->mode(), blink::WebIDBTransactionModeVersionChange);
 
   if (!ValidateObjectStoreIdAndIndexId(object_store_id, index_id))
     return;
 
   transaction->ScheduleTask(
       base::Bind(&IndexedDBDatabase::DeleteIndexOperation,
                  this,
                  object_store_id,
                  index_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());
 
   const IndexedDBIndexMetadata index_metadata =
       metadata_.object_stores[object_store_id].indexes[index_id];
 
   leveldb::Status s =
       backing_store_->DeleteIndex(transaction->BackingStoreTransaction(),
                                   transaction->database()->id(),
@@ skipping 14 matching lines @@
 
   RemoveIndex(object_store_id, index_id);
   transaction->ScheduleAbortTask(
       base::Bind(&IndexedDBDatabase::DeleteIndexAbortOperation,
                  this,
                  object_store_id,
                  index_metadata));
 }
 
 void IndexedDBDatabase::DeleteIndexAbortOperation(
-    int64 object_store_id,
+    int64_t object_store_id,
     const IndexedDBIndexMetadata& index_metadata,
     IndexedDBTransaction* transaction) {
   DCHECK(!transaction);
   IDB_TRACE("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
   // asynchronously.
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (transaction) {
     scoped_refptr<IndexedDBFactory> factory = factory_;
     leveldb::Status s = transaction->Commit();
     if (s.IsCorruption()) {
       IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                    "Internal error committing transaction.");
       factory->HandleBackingStoreCorruption(identifier_.first, error);
     }
   }
 }
 
-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);
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (transaction)
     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
   // backend before this call so it is safe to ignore it.
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (transaction)
     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);
   if (!transaction)
     return;
 
   if (!ValidateObjectStoreId(object_store_id))
     return;
 
   transaction->ScheduleTask(base::Bind(
       &IndexedDBDatabase::GetAllOperation, this, object_store_id, index_id,
       base::Passed(&key_range),
       key_only ? indexed_db::CURSOR_KEY_ONLY : indexed_db::CURSOR_KEY_AND_VALUE,
       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) {
   IDB_TRACE1("IndexedDBDatabase::Get", "txn.id", transaction_id);
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
 
   if (!ValidateObjectStoreIdAndOptionalIndexId(object_store_id, index_id))
     return;
 
   transaction->ScheduleTask(base::Bind(
       &IndexedDBDatabase::GetOperation, this, object_store_id, index_id,
       base::Passed(&key_range),
       key_only ? indexed_db::CURSOR_KEY_ONLY : indexed_db::CURSOR_KEY_AND_VALUE,
       callbacks));
 }
 
 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,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1("IndexedDBDatabase::GetOperation", "txn.id", transaction->id());
 
   DCHECK(metadata_.object_stores.find(object_store_id) !=
          metadata_.object_stores.end());
   const IndexedDBObjectStoreMetadata& object_store_metadata =
       metadata_.object_stores[object_store_id];
@@ skipping 140 matching lines @@
   }
   if (object_store_metadata.auto_increment &&
       !object_store_metadata.key_path.IsNull()) {
     value.primary_key = *primary_key;
     value.key_path = object_store_metadata.key_path;
   }
   callbacks->OnSuccess(&value);
 }
 
 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());
 
   DCHECK_GT(max_count, 0);
 
   DCHECK(metadata_.object_stores.find(object_store_id) !=
          metadata_.object_stores.end());
   const IndexedDBObjectStoreMetadata& object_store_metadata =
       metadata_.object_stores[object_store_id];
@@ skipping 49 matching lines @@
     // hits JavaScript.
     callbacks->OnSuccessArray(&found_values, object_store_metadata.key_path);
     return;
   }
 
   bool did_first_seek = false;
   bool generated_key = object_store_metadata.auto_increment &&
                        !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) {
       cursor_valid = cursor->Continue(&s);
     } else {
       cursor_valid = cursor->FirstSeek(&s);
       did_first_seek = true;
     }
     if (!s.ok()) {
       IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
@@ skipping 44 matching lines @@
     // to return an array of keys - no need to create our own array of keys.
     callbacks->OnSuccess(IndexedDBKey(found_keys));
   } else {
     callbacks->OnSuccessArray(&found_values, object_store_metadata.key_path);
   }
 }
 
 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,
       object_store_id,
       &current_number);
   if (!s.ok()) {
     LOG(ERROR) << "Failed to GetKeyGeneratorCurrentNumber";
     return make_scoped_ptr(new IndexedDBKey());
   }
   if (current_number < 0 || current_number > max_generator_value)
     return make_scoped_ptr(new IndexedDBKey());
 
   return make_scoped_ptr(new IndexedDBKey(current_number, WebIDBKeyTypeNumber));
 }
 
 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;
   blink::WebIDBPutMode put_mode;
   scoped_refptr<IndexedDBCallbacks> callbacks;
   std::vector<IndexKeys> index_keys;
 
  private:
   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,
                             blink::WebIDBPutMode put_mode,
                             scoped_refptr<IndexedDBCallbacks> callbacks,
                             const std::vector<IndexKeys>& index_keys) {
   IDB_TRACE1("IndexedDBDatabase::Put", "txn.id", transaction_id);
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
@@ skipping 151 matching lines @@
       return;
     }
   }
   {
     IDB_TRACE1("IndexedDBDatabase::PutOperation.Callbacks", "txn.id",
                transaction->id());
     params->callbacks->OnSuccess(*key);
   }
 }
 
-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);
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
   DCHECK_EQ(transaction->mode(), blink::WebIDBTransactionModeVersionChange);
 
   // TODO(alecflett): This method could be asynchronous, but we need to
   // evaluate if it's worth the extra complexity.
@@ skipping 54 matching lines @@
   for (size_t i = 0; i < index_writers.size(); ++i) {
     IndexWriter* index_writer = index_writers[i];
     index_writer->WriteIndexKeys(record_identifier,
                                  backing_store_.get(),
                                  transaction->BackingStoreTransaction(),
                                  id(),
                                  object_store_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;
   DCHECK_EQ(transaction->mode(), blink::WebIDBTransactionModeVersionChange);
 
   transaction->ScheduleTask(
       blink::WebIDBTaskTypePreemptive,
       base::Bind(&IndexedDBDatabase::SetIndexesReadyOperation,
                  this,
                  index_ids.size()));
 }
 
 void IndexedDBDatabase::SetIndexesReadyOperation(
     size_t index_count,
     IndexedDBTransaction* transaction) {
   for (size_t i = 0; i < index_count; ++i)
     transaction->DidCompletePreemptiveEvent();
 }
 
 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;
   blink::WebIDBTaskType task_type;
   scoped_refptr<IndexedDBCallbacks> callbacks;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(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,
     blink::WebIDBTaskType task_type,
     scoped_refptr<IndexedDBCallbacks> callbacks) {
   IDB_TRACE1("IndexedDBDatabase::OpenCursor", "txn.id", transaction_id);
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
 
@@ skipping 88 matching lines @@
 
   scoped_refptr<IndexedDBCursor> cursor =
       new IndexedDBCursor(backing_store_cursor.Pass(),
                           params->cursor_type,
                           params->task_type,
                           transaction);
   params->callbacks->OnSuccess(
       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);
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
 
   if (!ValidateObjectStoreIdAndOptionalIndexId(object_store_id, index_id))
     return;
 
   transaction->ScheduleTask(base::Bind(&IndexedDBDatabase::CountOperation,
                                        this,
                                        object_store_id,
                                        index_id,
                                        base::Passed(&key_range),
                                        callbacks));
 }
 
 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;
   if (index_id == IndexedDBIndexMetadata::kInvalidId) {
     backing_store_cursor = backing_store_->OpenObjectStoreKeyCursor(
         transaction->BackingStoreTransaction(),
         id(),
         object_store_id,
         *key_range,
         blink::WebIDBCursorDirectionNext,
@@ skipping 25 matching lines @@
   do {
     ++count;
   } while (backing_store_cursor->Continue(&s));
 
   // TODO(cmumford): Check for database corruption.
 
   callbacks->OnSuccess(count);
 }
 
 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);
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
   DCHECK_NE(transaction->mode(), blink::WebIDBTransactionModeReadOnly);
 
   if (!ValidateObjectStoreId(object_store_id))
     return;
 
   transaction->ScheduleTask(base::Bind(&IndexedDBDatabase::DeleteRangeOperation,
                                        this,
                                        object_store_id,
                                        base::Passed(&key_range),
                                        callbacks));
 }
 
 void IndexedDBDatabase::DeleteRangeOperation(
-    int64 object_store_id,
+    int64_t object_store_id,
     scoped_ptr<IndexedDBKeyRange> key_range,
     scoped_refptr<IndexedDBCallbacks> callbacks,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1(
       "IndexedDBDatabase::DeleteRangeOperation", "txn.id", transaction->id());
   leveldb::Status s =
       backing_store_->DeleteRange(transaction->BackingStoreTransaction(),
                                   id(),
                                   object_store_id,
                                   *key_range);
   if (!s.ok()) {
     base::string16 error_string =
         ASCIIToUTF16("Internal error deleting data in range");
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  error_string);
     transaction->Abort(error);
     if (s.IsCorruption()) {
       factory_->HandleBackingStoreCorruption(backing_store_->origin_url(),
                                              error);
     }
     return;
   }
   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);
   if (!transaction)
     return;
   DCHECK_NE(transaction->mode(), blink::WebIDBTransactionModeReadOnly);
 
   if (!ValidateObjectStoreId(object_store_id))
     return;
 
   transaction->ScheduleTask(base::Bind(
       &IndexedDBDatabase::ClearOperation, this, object_store_id, callbacks));
 }
 
 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());
   leveldb::Status s = backing_store_->ClearObjectStore(
       transaction->BackingStoreTransaction(), id(), object_store_id);
   if (!s.ok()) {
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  "Internal error clearing object store");
     callbacks->OnError(error);
     if (s.IsCorruption()) {
       factory_->HandleBackingStoreCorruption(backing_store_->origin_url(),
                                              error);
     }
     return;
   }
   callbacks->OnSuccess();
 }
 
 void IndexedDBDatabase::DeleteObjectStoreOperation(
-    int64 object_store_id,
+    int64_t object_store_id,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1("IndexedDBDatabase::DeleteObjectStoreOperation",
              "txn.id",
              transaction->id());
 
   const IndexedDBObjectStoreMetadata object_store_metadata =
       metadata_.object_stores[object_store_id];
   leveldb::Status s =
       backing_store_->DeleteObjectStore(transaction->BackingStoreTransaction(),
                                         transaction->database()->id(),
@@ skipping 12 matching lines @@
   }
 
   RemoveObjectStore(object_store_id);
   transaction->ScheduleAbortTask(
       base::Bind(&IndexedDBDatabase::DeleteObjectStoreAbortOperation,
                  this,
                  object_store_metadata));
 }
 
 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(
           transaction->BackingStoreTransaction(), id(), version)) {
     IndexedDBDatabaseError error(
         blink::WebIDBDatabaseExceptionUnknownError,
         ASCIIToUTF16(
             "Internal error writing data to stable storage when "
             "updating version."));
     callbacks->OnError(error);
@@ skipping 116 matching lines @@
     PendingOpenCallList pending_open_calls;
     pending_open_calls_.swap(pending_open_calls);
     while (!pending_open_calls.empty()) {
       OpenConnection(pending_open_calls.front());
       pending_open_calls.pop_front();
     }
   }
 }
 
 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));
   DCHECK(transactions_.find(transaction_id) == transactions_.end());
   if (transactions_.find(transaction_id) != transactions_.end())
     return;
 
   UMA_HISTOGRAM_COUNTS_1000(
       "WebCore.IndexedDB.Database.OutstandingTransactionCount",
       transactions_.size());
 
   // Throttle transaction creation so that a renderer in a tight loop can't
   // cause browser memory to grow unbounded by creating transactions faster
   // than they can be processed.
   const size_t kMaxTransactionCount = 256;
   if (transactions_.size() >= kMaxTransactionCount) {
     connection->callbacks()->OnAbort(
         transaction_id, IndexedDBDatabaseError(
                             blink::WebIDBDatabaseExceptionUnknownError,
                             "Internal error: Too many transactions queued."));
     return;
   }
 
   // The transaction will add itself to this database's coordinator, which
   // 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())));
 }
 
 void IndexedDBDatabase::TransactionCreated(IndexedDBTransaction* transaction) {
   transactions_[transaction->id()] = transaction;
 }
 
 bool IndexedDBDatabase::IsOpenConnectionBlocked() const {
   return !pending_delete_calls_.empty() ||
          transaction_coordinator_.IsRunningVersionChangeTransaction() ||
@@ skipping 49 matching lines @@
     // TODO(jsbell): DCHECK that not in unit tests.
     DCHECK(is_new_database);
     connection.callbacks->OnSuccess(
         CreateConnection(connection.database_callbacks,
                          connection.child_process_id),
         this->metadata());
     return;
   }
 
   // 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(
           CreateConnection(connection.database_callbacks,
                            connection.child_process_id),
           this->metadata());
       return;
     }
     // Spec says: If no version is specified and no database exists, set
     // database version to 1.
@@ skipping 20 matching lines @@
   DCHECK_EQ(local_version, metadata_.int_version);
   connection.callbacks->OnSuccess(
       CreateConnection(connection.database_callbacks,
                        connection.child_process_id),
       this->metadata());
 }
 
 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) {
     DCHECK_NE(blink::WebIDBDataLossTotal, callbacks->data_loss());
     // Front end ensures the event is not fired at connections that have
     // close_pending set.
     for (const auto* iter : connections_) {
       if (iter != connection.get()) {
         iter->callbacks()->OnVersionChange(metadata_.int_version,
                                            requested_version);
       }
     }
     // OnBlocked will be fired at the request when one of the other
     // connections acks that the OnVersionChange was ignored.
 
     DCHECK(!pending_run_version_change_transaction_call_);
     pending_run_version_change_transaction_call_.reset(new PendingUpgradeCall(
         callbacks, connection.Pass(), transaction_id, requested_version));
     return;
   }
   RunVersionChangeTransactionFinal(
       callbacks, connection.Pass(), transaction_id, requested_version);
 }
 
 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,
                     blink::WebIDBTransactionModeVersionChange);
 
   transactions_[transaction_id]->ScheduleTask(
       base::Bind(&IndexedDBDatabase::VersionChangeOperation,
                  this,
                  requested_version,
                  callbacks,
@@ skipping 33 matching lines @@
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  "Internal error deleting database.");
     callbacks->OnError(error);
     if (s.IsCorruption()) {
       GURL origin_url = backing_store_->origin_url();
       backing_store_ = NULL;
       factory_->HandleBackingStoreCorruption(origin_url, error);
     }
     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;
   metadata_.object_stores.clear();
   callbacks->OnSuccess(old_version);
   factory_->DatabaseDeleted(identifier_);
 }
 
 void IndexedDBDatabase::ForceClose() {
   // IndexedDBConnection::ForceClose() may delete this database, so hold ref.
@@ skipping 55 matching lines @@
     DCHECK(transactions_.empty());
 
     const GURL origin_url = backing_store_->origin_url();
     backing_store_ = NULL;
 
     factory_->ReleaseDatabase(identifier_, forced);
   }
 }
 
 void IndexedDBDatabase::CreateObjectStoreAbortOperation(
-    int64 object_store_id,
+    int64_t object_store_id,
     IndexedDBTransaction* transaction) {
   DCHECK(!transaction);
   IDB_TRACE("IndexedDBDatabase::CreateObjectStoreAbortOperation");
   RemoveObjectStore(object_store_id);
 }
 
 void IndexedDBDatabase::DeleteObjectStoreAbortOperation(
     const IndexedDBObjectStoreMetadata& object_store_metadata,
     IndexedDBTransaction* transaction) {
   DCHECK(!transaction);
   IDB_TRACE("IndexedDBDatabase::DeleteObjectStoreAbortOperation");
   AddObjectStore(object_store_metadata,
                  IndexedDBObjectStoreMetadata::kInvalidId);
 }
 
 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");
   metadata_.version = previous_version;
   metadata_.int_version = previous_int_version;
 }
 
 }  // namespace content