Switch to standard integer types in content/.

content/child/indexed_db/indexed_db_dispatcher.cc

 // Copyright 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/child/indexed_db/indexed_db_dispatcher.h"
 
 #include <utility>
 
 #include "base/format_macros.h"
 #include "base/lazy_instance.h"
@@ skipping 153 matching lines @@
                   << IPC_MESSAGE_ID_LINE(msg.type());
 }
 
 bool IndexedDBDispatcher::Send(IPC::Message* msg) {
   return thread_safe_sender_->Send(msg);
 }
 
 void IndexedDBDispatcher::RequestIDBCursorAdvance(
     unsigned long count,
     WebIDBCallbacks* callbacks_ptr,
-    int32 ipc_cursor_id,
-    int64 transaction_id) {
+    int32_t ipc_cursor_id,
+    int64_t transaction_id) {
   // Reset all cursor prefetch caches except for this cursor.
   ResetCursorPrefetchCaches(transaction_id, ipc_cursor_id);
 
   scoped_ptr<WebIDBCallbacks> callbacks(callbacks_ptr);
 
-  int32 ipc_callbacks_id = pending_callbacks_.Add(callbacks.release());
+  int32_t ipc_callbacks_id = pending_callbacks_.Add(callbacks.release());
   Send(new IndexedDBHostMsg_CursorAdvance(
       ipc_cursor_id, CurrentWorkerId(), ipc_callbacks_id, count));
 }
 
 void IndexedDBDispatcher::RequestIDBCursorContinue(
     const IndexedDBKey& key,
     const IndexedDBKey& primary_key,
     WebIDBCallbacks* callbacks_ptr,
-    int32 ipc_cursor_id,
-    int64 transaction_id) {
+    int32_t ipc_cursor_id,
+    int64_t transaction_id) {
   // Reset all cursor prefetch caches except for this cursor.
   ResetCursorPrefetchCaches(transaction_id, ipc_cursor_id);
 
   scoped_ptr<WebIDBCallbacks> callbacks(callbacks_ptr);
 
-  int32 ipc_callbacks_id = pending_callbacks_.Add(callbacks.release());
+  int32_t ipc_callbacks_id = pending_callbacks_.Add(callbacks.release());
   Send(new IndexedDBHostMsg_CursorContinue(
       ipc_cursor_id, CurrentWorkerId(), ipc_callbacks_id, key, primary_key));
 }
 
 void IndexedDBDispatcher::RequestIDBCursorPrefetch(
     int n,
     WebIDBCallbacks* callbacks_ptr,
-    int32 ipc_cursor_id) {
+    int32_t ipc_cursor_id) {
   scoped_ptr<WebIDBCallbacks> callbacks(callbacks_ptr);
 
-  int32 ipc_callbacks_id = pending_callbacks_.Add(callbacks.release());
+  int32_t ipc_callbacks_id = pending_callbacks_.Add(callbacks.release());
   Send(new IndexedDBHostMsg_CursorPrefetch(
       ipc_cursor_id, CurrentWorkerId(), ipc_callbacks_id, n));
 }
 
 void IndexedDBDispatcher::RequestIDBCursorPrefetchReset(int used_prefetches,
                                                         int unused_prefetches,
-                                                        int32 ipc_cursor_id) {
+                                                        int32_t ipc_cursor_id) {
   Send(new IndexedDBHostMsg_CursorPrefetchReset(
       ipc_cursor_id, used_prefetches, unused_prefetches));
 }
 
 void IndexedDBDispatcher::RequestIDBFactoryOpen(
     const base::string16& name,
-    int64 version,
-    int64 transaction_id,
+    int64_t version,
+    int64_t transaction_id,
     WebIDBCallbacks* callbacks_ptr,
     WebIDBDatabaseCallbacks* database_callbacks_ptr,
     const std::string& database_identifier) {
   scoped_ptr<WebIDBCallbacks> callbacks(callbacks_ptr);
   scoped_ptr<WebIDBDatabaseCallbacks> database_callbacks(
       database_callbacks_ptr);
 
   IndexedDBHostMsg_FactoryOpen_Params params;
   params.ipc_thread_id = CurrentWorkerId();
   params.ipc_callbacks_id = pending_callbacks_.Add(callbacks.release());
@@ skipping 26 matching lines @@
 
   IndexedDBHostMsg_FactoryDeleteDatabase_Params params;
   params.ipc_thread_id = CurrentWorkerId();
   params.ipc_callbacks_id = pending_callbacks_.Add(callbacks.release());
   params.database_identifier = database_identifier;
   params.name = name;
   Send(new IndexedDBHostMsg_FactoryDeleteDatabase(params));
 }
 
 void IndexedDBDispatcher::RequestIDBDatabaseClose(
-    int32 ipc_database_id,
-    int32 ipc_database_callbacks_id) {
+    int32_t ipc_database_id,
+    int32_t ipc_database_callbacks_id) {
   Send(new IndexedDBHostMsg_DatabaseClose(ipc_database_id));
   // There won't be pending database callbacks if the transaction was aborted in
   // the initial upgradeneeded event handler.
   if (pending_database_callbacks_.Lookup(ipc_database_callbacks_id))
     pending_database_callbacks_.Remove(ipc_database_callbacks_id);
 }
 
 void IndexedDBDispatcher::NotifyIDBDatabaseVersionChangeIgnored(
-    int32 ipc_database_id) {
+    int32_t ipc_database_id) {
   Send(new IndexedDBHostMsg_DatabaseVersionChangeIgnored(ipc_database_id));
 }
 
 void IndexedDBDispatcher::RequestIDBDatabaseCreateTransaction(
-    int32 ipc_database_id,
-    int64 transaction_id,
+    int32_t ipc_database_id,
+    int64_t transaction_id,
     WebIDBDatabaseCallbacks* database_callbacks_ptr,
     WebVector<long long> object_store_ids,
     blink::WebIDBTransactionMode mode) {
   scoped_ptr<WebIDBDatabaseCallbacks> database_callbacks(
       database_callbacks_ptr);
   IndexedDBHostMsg_DatabaseCreateTransaction_Params params;
   params.ipc_thread_id = CurrentWorkerId();
   params.ipc_database_id = ipc_database_id;
   params.transaction_id = transaction_id;
   params.ipc_database_callbacks_id =
       pending_database_callbacks_.Add(database_callbacks.release());
   params.object_store_ids
       .assign(object_store_ids.data(),
               object_store_ids.data() + object_store_ids.size());
   params.mode = mode;
 
   Send(new IndexedDBHostMsg_DatabaseCreateTransaction(params));
 }
 
 void IndexedDBDispatcher::RequestIDBDatabaseGet(
-    int32 ipc_database_id,
-    int64 transaction_id,
-    int64 object_store_id,
-    int64 index_id,
+    int32_t ipc_database_id,
+    int64_t transaction_id,
+    int64_t object_store_id,
+    int64_t index_id,
     const IndexedDBKeyRange& key_range,
     bool key_only,
     WebIDBCallbacks* callbacks) {
   ResetCursorPrefetchCaches(transaction_id, kAllCursors);
   IndexedDBHostMsg_DatabaseGet_Params params;
   init_params(&params, callbacks);
   params.ipc_database_id = ipc_database_id;
   params.transaction_id = transaction_id;
   params.object_store_id = object_store_id;
   params.index_id = index_id;
   params.key_range = key_range;
   params.key_only = key_only;
   Send(new IndexedDBHostMsg_DatabaseGet(params));
 }
 
 void IndexedDBDispatcher::RequestIDBDatabaseGetAll(
-    int32 ipc_database_id,
-    int64 transaction_id,
-    int64 object_store_id,
-    int64 index_id,
+    int32_t ipc_database_id,
+    int64_t transaction_id,
+    int64_t object_store_id,
+    int64_t index_id,
     const IndexedDBKeyRange& key_range,
     bool key_only,
-    int64 max_count,
+    int64_t max_count,
     WebIDBCallbacks* callbacks) {
   ResetCursorPrefetchCaches(transaction_id, kAllCursors);
   IndexedDBHostMsg_DatabaseGetAll_Params params;
   init_params(&params, callbacks);
   params.ipc_database_id = ipc_database_id;
   params.transaction_id = transaction_id;
   params.object_store_id = object_store_id;
   params.index_id = index_id;
   params.key_range = key_range;
   params.key_only = key_only;
   params.max_count = max_count;
   Send(new IndexedDBHostMsg_DatabaseGetAll(params));
 }
 
 void IndexedDBDispatcher::RequestIDBDatabasePut(
-    int32 ipc_database_id,
-    int64 transaction_id,
-    int64 object_store_id,
+    int32_t ipc_database_id,
+    int64_t transaction_id,
+    int64_t object_store_id,
     const WebData& value,
     const blink::WebVector<WebBlobInfo>& web_blob_info,
     const IndexedDBKey& key,
     blink::WebIDBPutMode put_mode,
     WebIDBCallbacks* callbacks,
     const WebVector<long long>& index_ids,
-    const WebVector<WebVector<WebIDBKey> >& index_keys) {
+    const WebVector<WebVector<WebIDBKey>>& index_keys) {
   if (value.size() + key.size_estimate() > max_put_value_size_) {
     callbacks->onError(WebIDBDatabaseError(
         blink::WebIDBDatabaseExceptionUnknownError,
         WebString::fromUTF8(base::StringPrintf(
             "The serialized value is too large"
             " (size=%" PRIuS " bytes, max=%" PRIuS " bytes).",
             value.size(),
             max_put_value_size_).c_str())));
     return;
   }
@@ skipping 34 matching lines @@
     blob_or_file_info.size = info.size();
     blob_or_file_info.uuid = info.uuid().latin1();
     DCHECK(blob_or_file_info.uuid.size());
     blob_or_file_info.mime_type = info.type();
   }
 
   Send(new IndexedDBHostMsg_DatabasePut(params));
 }
 
 void IndexedDBDispatcher::RequestIDBDatabaseOpenCursor(
-    int32 ipc_database_id,
-    int64 transaction_id,
-    int64 object_store_id,
-    int64 index_id,
+    int32_t ipc_database_id,
+    int64_t transaction_id,
+    int64_t object_store_id,
+    int64_t index_id,
     const IndexedDBKeyRange& key_range,
     blink::WebIDBCursorDirection direction,
     bool key_only,
     blink::WebIDBTaskType task_type,
     WebIDBCallbacks* callbacks) {
   ResetCursorPrefetchCaches(transaction_id, kAllCursors);
   IndexedDBHostMsg_DatabaseOpenCursor_Params params;
   init_params(&params, callbacks);
   params.ipc_database_id = ipc_database_id;
   params.transaction_id = transaction_id;
   params.object_store_id = object_store_id;
   params.index_id = index_id;
   params.key_range = key_range;
   params.direction = direction;
   params.key_only = key_only;
   params.task_type = task_type;
   Send(new IndexedDBHostMsg_DatabaseOpenCursor(params));
 
   DCHECK(cursor_transaction_ids_.find(params.ipc_callbacks_id) ==
          cursor_transaction_ids_.end());
   cursor_transaction_ids_[params.ipc_callbacks_id] = transaction_id;
 }
 
 void IndexedDBDispatcher::RequestIDBDatabaseCount(
-    int32 ipc_database_id,
-    int64 transaction_id,
-    int64 object_store_id,
-    int64 index_id,
+    int32_t ipc_database_id,
+    int64_t transaction_id,
+    int64_t object_store_id,
+    int64_t index_id,
     const IndexedDBKeyRange& key_range,
     WebIDBCallbacks* callbacks) {
   ResetCursorPrefetchCaches(transaction_id, kAllCursors);
   IndexedDBHostMsg_DatabaseCount_Params params;
   init_params(&params, callbacks);
   params.ipc_database_id = ipc_database_id;
   params.transaction_id = transaction_id;
   params.object_store_id = object_store_id;
   params.index_id = index_id;
   params.key_range = key_range;
   Send(new IndexedDBHostMsg_DatabaseCount(params));
 }
 
 void IndexedDBDispatcher::RequestIDBDatabaseDeleteRange(
-    int32 ipc_database_id,
-    int64 transaction_id,
-    int64 object_store_id,
+    int32_t ipc_database_id,
+    int64_t transaction_id,
+    int64_t object_store_id,
     const IndexedDBKeyRange& key_range,
     WebIDBCallbacks* callbacks) {
   ResetCursorPrefetchCaches(transaction_id, kAllCursors);
   IndexedDBHostMsg_DatabaseDeleteRange_Params params;
   init_params(&params, callbacks);
   params.ipc_database_id = ipc_database_id;
   params.transaction_id = transaction_id;
   params.object_store_id = object_store_id;
   params.key_range = key_range;
   Send(new IndexedDBHostMsg_DatabaseDeleteRange(params));
 }
 
 void IndexedDBDispatcher::RequestIDBDatabaseClear(
-    int32 ipc_database_id,
-    int64 transaction_id,
-    int64 object_store_id,
+    int32_t ipc_database_id,
+    int64_t transaction_id,
+    int64_t object_store_id,
     WebIDBCallbacks* callbacks_ptr) {
   ResetCursorPrefetchCaches(transaction_id, kAllCursors);
   scoped_ptr<WebIDBCallbacks> callbacks(callbacks_ptr);
-  int32 ipc_callbacks_id = pending_callbacks_.Add(callbacks.release());
+  int32_t ipc_callbacks_id = pending_callbacks_.Add(callbacks.release());
   Send(new IndexedDBHostMsg_DatabaseClear(CurrentWorkerId(),
                                           ipc_callbacks_id,
                                           ipc_database_id,
                                           transaction_id,
                                           object_store_id));
 }
 
-void IndexedDBDispatcher::CursorDestroyed(int32 ipc_cursor_id) {
+void IndexedDBDispatcher::CursorDestroyed(int32_t ipc_cursor_id) {
   cursors_.erase(ipc_cursor_id);
 }
 
-void IndexedDBDispatcher::DatabaseDestroyed(int32 ipc_database_id) {
+void IndexedDBDispatcher::DatabaseDestroyed(int32_t ipc_database_id) {
   DCHECK_EQ(databases_.count(ipc_database_id), 1u);
   databases_.erase(ipc_database_id);
 }
 
 void IndexedDBDispatcher::OnSuccessIDBDatabase(
-    int32 ipc_thread_id,
-    int32 ipc_callbacks_id,
-    int32 ipc_database_callbacks_id,
-    int32 ipc_object_id,
+    int32_t ipc_thread_id,
+    int32_t ipc_callbacks_id,
+    int32_t ipc_database_callbacks_id,
+    int32_t ipc_object_id,
     const IndexedDBDatabaseMetadata& idb_metadata) {
   DCHECK_EQ(ipc_thread_id, CurrentWorkerId());
   WebIDBCallbacks* callbacks = pending_callbacks_.Lookup(ipc_callbacks_id);
   if (!callbacks)
     return;
   WebIDBMetadata metadata(ConvertMetadata(idb_metadata));
   // If an upgrade was performed, count will be non-zero.
   WebIDBDatabase* database = NULL;
 
   // Back-end will send kNoDatabase if it was already sent in OnUpgradeNeeded.
   // May already be deleted and removed from the table, but do not recreate..
   if (ipc_object_id != kNoDatabase) {
     DCHECK(!databases_.count(ipc_object_id));
     database = databases_[ipc_object_id] = new WebIDBDatabaseImpl(
         ipc_object_id, ipc_database_callbacks_id, thread_safe_sender_.get());
   }
 
   callbacks->onSuccess(database, metadata);
   pending_callbacks_.Remove(ipc_callbacks_id);
 }
 
-void IndexedDBDispatcher::OnSuccessIndexedDBKey(int32 ipc_thread_id,
-                                                int32 ipc_callbacks_id,
+void IndexedDBDispatcher::OnSuccessIndexedDBKey(int32_t ipc_thread_id,
+                                                int32_t ipc_callbacks_id,
                                                 const IndexedDBKey& key) {
   DCHECK_EQ(ipc_thread_id, CurrentWorkerId());
   WebIDBCallbacks* callbacks = pending_callbacks_.Lookup(ipc_callbacks_id);
   if (!callbacks)
     return;
   callbacks->onSuccess(WebIDBKeyBuilder::Build(key));
   pending_callbacks_.Remove(ipc_callbacks_id);
 }
 
 void IndexedDBDispatcher::OnSuccessStringList(
-    int32 ipc_thread_id,
-    int32 ipc_callbacks_id,
+    int32_t ipc_thread_id,
+    int32_t ipc_callbacks_id,
     const std::vector<base::string16>& value) {
   DCHECK_EQ(ipc_thread_id, CurrentWorkerId());
   WebIDBCallbacks* callbacks = pending_callbacks_.Lookup(ipc_callbacks_id);
   if (!callbacks)
     return;
   callbacks->onSuccess(WebVector<WebString>(value));
   pending_callbacks_.Remove(ipc_callbacks_id);
 }
 
 // Populate some WebIDBValue members (data & blob info) from the supplied
@@ skipping 24 matching lines @@
 static void PrepareReturnWebValue(const IndexedDBMsg_ReturnValue& value,
                                   WebIDBValue* web_value) {
   PrepareWebValue(value, web_value);
   web_value->primaryKey = WebIDBKeyBuilder::Build(value.primary_key);
   web_value->keyPath = WebIDBKeyPathBuilder::Build(value.key_path);
 }
 
 void IndexedDBDispatcher::OnSuccessArray(
     const IndexedDBMsg_CallbacksSuccessArray_Params& p) {
   DCHECK_EQ(p.ipc_thread_id, CurrentWorkerId());
-  int32 ipc_callbacks_id = p.ipc_callbacks_id;
+  int32_t ipc_callbacks_id = p.ipc_callbacks_id;
   blink::WebVector<WebIDBValue> web_values(p.values.size());
   for (size_t i = 0; i < p.values.size(); ++i)
     PrepareReturnWebValue(p.values[i], &web_values[i]);
   WebIDBCallbacks* callbacks = pending_callbacks_.Lookup(ipc_callbacks_id);
   DCHECK(callbacks);
   callbacks->onSuccess(web_values);
   pending_callbacks_.Remove(ipc_callbacks_id);
 }
 
 void IndexedDBDispatcher::OnSuccessValue(
     const IndexedDBMsg_CallbacksSuccessValue_Params& params) {
   DCHECK_EQ(params.ipc_thread_id, CurrentWorkerId());
   WebIDBCallbacks* callbacks =
       pending_callbacks_.Lookup(params.ipc_callbacks_id);
   if (!callbacks)
     return;
   WebIDBValue web_value;
   PrepareReturnWebValue(params.value, &web_value);
   if (params.value.primary_key.IsValid()) {
     web_value.primaryKey = WebIDBKeyBuilder::Build(params.value.primary_key);
     web_value.keyPath = WebIDBKeyPathBuilder::Build(params.value.key_path);
   }
   callbacks->onSuccess(web_value);
   cursor_transaction_ids_.erase(params.ipc_callbacks_id);
   pending_callbacks_.Remove(params.ipc_callbacks_id);
 }
 
-void IndexedDBDispatcher::OnSuccessInteger(int32 ipc_thread_id,
-                                           int32 ipc_callbacks_id,
-                                           int64 value) {
+void IndexedDBDispatcher::OnSuccessInteger(int32_t ipc_thread_id,
+                                           int32_t ipc_callbacks_id,
+                                           int64_t value) {
   DCHECK_EQ(ipc_thread_id, CurrentWorkerId());
   WebIDBCallbacks* callbacks = pending_callbacks_.Lookup(ipc_callbacks_id);
   if (!callbacks)
     return;
   callbacks->onSuccess(value);
   pending_callbacks_.Remove(ipc_callbacks_id);
 }
 
-void IndexedDBDispatcher::OnSuccessUndefined(int32 ipc_thread_id,
-                                             int32 ipc_callbacks_id) {
+void IndexedDBDispatcher::OnSuccessUndefined(int32_t ipc_thread_id,
+                                             int32_t ipc_callbacks_id) {
   DCHECK_EQ(ipc_thread_id, CurrentWorkerId());
   WebIDBCallbacks* callbacks = pending_callbacks_.Lookup(ipc_callbacks_id);
   if (!callbacks)
     return;
   callbacks->onSuccess();
   pending_callbacks_.Remove(ipc_callbacks_id);
 }
 
 void IndexedDBDispatcher::OnSuccessOpenCursor(
     const IndexedDBMsg_CallbacksSuccessIDBCursor_Params& p) {
   DCHECK_EQ(p.ipc_thread_id, CurrentWorkerId());
-  int32 ipc_callbacks_id = p.ipc_callbacks_id;
-  int32 ipc_object_id = p.ipc_cursor_id;
+  int32_t ipc_callbacks_id = p.ipc_callbacks_id;
+  int32_t ipc_object_id = p.ipc_cursor_id;
   const IndexedDBKey& key = p.key;
   const IndexedDBKey& primary_key = p.primary_key;
   WebIDBValue web_value;
   PrepareWebValue(p.value, &web_value);
 
   DCHECK(cursor_transaction_ids_.find(ipc_callbacks_id) !=
          cursor_transaction_ids_.end());
-  int64 transaction_id = cursor_transaction_ids_[ipc_callbacks_id];
+  int64_t transaction_id = cursor_transaction_ids_[ipc_callbacks_id];
   cursor_transaction_ids_.erase(ipc_callbacks_id);
 
   WebIDBCallbacks* callbacks = pending_callbacks_.Lookup(ipc_callbacks_id);
   if (!callbacks)
     return;
 
   WebIDBCursorImpl* cursor = new WebIDBCursorImpl(
       ipc_object_id, transaction_id, thread_safe_sender_.get());
   cursors_[ipc_object_id] = cursor;
   callbacks->onSuccess(cursor, WebIDBKeyBuilder::Build(key),
                        WebIDBKeyBuilder::Build(primary_key), web_value);
 
   pending_callbacks_.Remove(ipc_callbacks_id);
 }
 
 void IndexedDBDispatcher::OnSuccessCursorContinue(
     const IndexedDBMsg_CallbacksSuccessCursorContinue_Params& p) {
   DCHECK_EQ(p.ipc_thread_id, CurrentWorkerId());
-  int32 ipc_callbacks_id = p.ipc_callbacks_id;
-  int32 ipc_cursor_id = p.ipc_cursor_id;
+  int32_t ipc_callbacks_id = p.ipc_callbacks_id;
+  int32_t ipc_cursor_id = p.ipc_cursor_id;
   const IndexedDBKey& key = p.key;
   const IndexedDBKey& primary_key = p.primary_key;
 
   if (cursors_.find(ipc_cursor_id) == cursors_.end())
     return;
 
   WebIDBCallbacks* callbacks = pending_callbacks_.Lookup(ipc_callbacks_id);
   if (!callbacks)
     return;
 
   WebIDBValue web_value;
   PrepareWebValue(p.value, &web_value);
   callbacks->onSuccess(WebIDBKeyBuilder::Build(key),
                        WebIDBKeyBuilder::Build(primary_key), web_value);
 
   pending_callbacks_.Remove(ipc_callbacks_id);
 }
 
 void IndexedDBDispatcher::OnSuccessCursorPrefetch(
     const IndexedDBMsg_CallbacksSuccessCursorPrefetch_Params& p) {
   DCHECK_EQ(p.ipc_thread_id, CurrentWorkerId());
-  int32 ipc_callbacks_id = p.ipc_callbacks_id;
-  int32 ipc_cursor_id = p.ipc_cursor_id;
+  int32_t ipc_callbacks_id = p.ipc_callbacks_id;
+  int32_t ipc_cursor_id = p.ipc_cursor_id;
   std::vector<WebIDBValue> values(p.values.size());
   for (size_t i = 0; i < p.values.size(); ++i)
     PrepareWebValue(p.values[i], &values[i]);
-  std::map<int32, WebIDBCursorImpl*>::const_iterator cur_iter =
+  std::map<int32_t, WebIDBCursorImpl*>::const_iterator cur_iter =
       cursors_.find(ipc_cursor_id);
   if (cur_iter == cursors_.end())
     return;
 
   cur_iter->second->SetPrefetchData(p.keys, p.primary_keys, values);
 
   WebIDBCallbacks* callbacks = pending_callbacks_.Lookup(ipc_callbacks_id);
   DCHECK(callbacks);
   cur_iter->second->CachedContinue(callbacks);
   pending_callbacks_.Remove(ipc_callbacks_id);
 }
 
-void IndexedDBDispatcher::OnIntBlocked(int32 ipc_thread_id,
-                                       int32 ipc_callbacks_id,
-                                       int64 existing_version) {
+void IndexedDBDispatcher::OnIntBlocked(int32_t ipc_thread_id,
+                                       int32_t ipc_callbacks_id,
+                                       int64_t existing_version) {
   DCHECK_EQ(ipc_thread_id, CurrentWorkerId());
   WebIDBCallbacks* callbacks = pending_callbacks_.Lookup(ipc_callbacks_id);
   DCHECK(callbacks);
   callbacks->onBlocked(existing_version);
 }
 
 void IndexedDBDispatcher::OnUpgradeNeeded(
     const IndexedDBMsg_CallbacksUpgradeNeeded_Params& p) {
   DCHECK_EQ(p.ipc_thread_id, CurrentWorkerId());
   WebIDBCallbacks* callbacks = pending_callbacks_.Lookup(p.ipc_callbacks_id);
   DCHECK(callbacks);
   WebIDBMetadata metadata(ConvertMetadata(p.idb_metadata));
   DCHECK(!databases_.count(p.ipc_database_id));
   databases_[p.ipc_database_id] =
       new WebIDBDatabaseImpl(p.ipc_database_id,
                              p.ipc_database_callbacks_id,
                              thread_safe_sender_.get());
   callbacks->onUpgradeNeeded(
       p.old_version,
       databases_[p.ipc_database_id],
       metadata,
       static_cast<blink::WebIDBDataLoss>(p.data_loss),
       WebString::fromUTF8(p.data_loss_message));
 }
 
-void IndexedDBDispatcher::OnError(int32 ipc_thread_id,
-                                  int32 ipc_callbacks_id,
+void IndexedDBDispatcher::OnError(int32_t ipc_thread_id,
+                                  int32_t ipc_callbacks_id,
                                   int code,
                                   const base::string16& message) {
   DCHECK_EQ(ipc_thread_id, CurrentWorkerId());
   WebIDBCallbacks* callbacks = pending_callbacks_.Lookup(ipc_callbacks_id);
   if (!callbacks)
     return;
   if (message.empty())
     callbacks->onError(WebIDBDatabaseError(code));
   else
     callbacks->onError(WebIDBDatabaseError(code, message));
   pending_callbacks_.Remove(ipc_callbacks_id);
   cursor_transaction_ids_.erase(ipc_callbacks_id);
 }
 
-void IndexedDBDispatcher::OnAbort(int32 ipc_thread_id,
-                                  int32 ipc_database_callbacks_id,
-                                  int64 transaction_id,
+void IndexedDBDispatcher::OnAbort(int32_t ipc_thread_id,
+                                  int32_t ipc_database_callbacks_id,
+                                  int64_t transaction_id,
                                   int code,
                                   const base::string16& message) {
   DCHECK_EQ(ipc_thread_id, CurrentWorkerId());
   WebIDBDatabaseCallbacks* callbacks =
       pending_database_callbacks_.Lookup(ipc_database_callbacks_id);
   if (!callbacks)
     return;
   if (message.empty())
     callbacks->onAbort(transaction_id, WebIDBDatabaseError(code));
   else
     callbacks->onAbort(transaction_id, WebIDBDatabaseError(code, message));
 }
 
-void IndexedDBDispatcher::OnComplete(int32 ipc_thread_id,
-                                     int32 ipc_database_callbacks_id,
-                                     int64 transaction_id) {
+void IndexedDBDispatcher::OnComplete(int32_t ipc_thread_id,
+                                     int32_t ipc_database_callbacks_id,
+                                     int64_t transaction_id) {
   DCHECK_EQ(ipc_thread_id, CurrentWorkerId());
   WebIDBDatabaseCallbacks* callbacks =
       pending_database_callbacks_.Lookup(ipc_database_callbacks_id);
   if (!callbacks)
     return;
   callbacks->onComplete(transaction_id);
 }
 
-void IndexedDBDispatcher::OnForcedClose(int32 ipc_thread_id,
-                                        int32 ipc_database_callbacks_id) {
+void IndexedDBDispatcher::OnForcedClose(int32_t ipc_thread_id,
+                                        int32_t ipc_database_callbacks_id) {
   DCHECK_EQ(ipc_thread_id, CurrentWorkerId());
   WebIDBDatabaseCallbacks* callbacks =
       pending_database_callbacks_.Lookup(ipc_database_callbacks_id);
   if (!callbacks)
     return;
   callbacks->onForcedClose();
 }
 
-void IndexedDBDispatcher::OnIntVersionChange(int32 ipc_thread_id,
-                                             int32 ipc_database_callbacks_id,
-                                             int64 old_version,
-                                             int64 new_version) {
+void IndexedDBDispatcher::OnIntVersionChange(int32_t ipc_thread_id,
+                                             int32_t ipc_database_callbacks_id,
+                                             int64_t old_version,
+                                             int64_t new_version) {
   DCHECK_EQ(ipc_thread_id, CurrentWorkerId());
   WebIDBDatabaseCallbacks* callbacks =
       pending_database_callbacks_.Lookup(ipc_database_callbacks_id);
   // callbacks would be NULL if a versionchange event is received after close
   // has been called.
   if (!callbacks)
     return;
   callbacks->onVersionChange(old_version, new_version);
 }
 
 void IndexedDBDispatcher::ResetCursorPrefetchCaches(
-    int64 transaction_id,
-    int32 ipc_exception_cursor_id) {
-  typedef std::map<int32, WebIDBCursorImpl*>::iterator Iterator;
+    int64_t transaction_id,
+    int32_t ipc_exception_cursor_id) {
+  typedef std::map<int32_t, WebIDBCursorImpl*>::iterator Iterator;
   for (Iterator i = cursors_.begin(); i != cursors_.end(); ++i) {
     if (i->first == ipc_exception_cursor_id ||
         i->second->transaction_id() != transaction_id)
       continue;
     i->second->ResetPrefetchCache();
   }
 }
 
 }  // namespace content