Switch to standard integer types in content/browser/.

content/browser/indexed_db/indexed_db_dispatcher_host.cc

 // Copyright (c) 2012 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_dispatcher_host.h"
 
+#include <stddef.h>
+
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/guid.h"
 #include "base/memory/scoped_vector.h"
 #include "base/process/process.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/bad_message.h"
 #include "content/browser/child_process_security_policy_impl.h"
@@ skipping 52 matching lines @@
       cursor_dispatcher_host_(new CursorDispatcherHost(this)),
       ipc_process_id_(ipc_process_id) {
   DCHECK(indexed_db_context_.get());
 }
 
 IndexedDBDispatcherHost::~IndexedDBDispatcherHost() {
   for (auto& iter : blob_data_handle_map_)
     delete iter.second.first;
 }
 
-void IndexedDBDispatcherHost::OnChannelConnected(int32 peer_pid) {
+void IndexedDBDispatcherHost::OnChannelConnected(int32_t peer_pid) {
   BrowserMessageFilter::OnChannelConnected(peer_pid);
 
   if (request_context_getter_.get()) {
     DCHECK(!request_context_);
     request_context_ = request_context_getter_->GetURLRequestContext();
     request_context_getter_ = NULL;
     DCHECK(request_context_);
   }
 }
 
@@ skipping 63 matching lines @@
       IPC_MESSAGE_HANDLER(IndexedDBHostMsg_FactoryOpen, OnIDBFactoryOpen)
       IPC_MESSAGE_HANDLER(IndexedDBHostMsg_FactoryDeleteDatabase,
                           OnIDBFactoryDeleteDatabase)
       IPC_MESSAGE_HANDLER(IndexedDBHostMsg_AckReceivedBlobs, OnAckReceivedBlobs)
       IPC_MESSAGE_UNHANDLED(handled = false)
     IPC_END_MESSAGE_MAP()
   }
   return handled;
 }
 
-int32 IndexedDBDispatcherHost::Add(IndexedDBCursor* cursor) {
+int32_t IndexedDBDispatcherHost::Add(IndexedDBCursor* cursor) {
   if (!cursor_dispatcher_host_) {
     return 0;
   }
   return cursor_dispatcher_host_->map_.Add(cursor);
 }
 
-int32 IndexedDBDispatcherHost::Add(IndexedDBConnection* connection,
-                                   int32 ipc_thread_id,
-                                   const GURL& origin_url) {
+int32_t IndexedDBDispatcherHost::Add(IndexedDBConnection* connection,
+                                     int32_t ipc_thread_id,
+                                     const GURL& origin_url) {
   if (!database_dispatcher_host_) {
     connection->Close();
     delete connection;
     return -1;
   }
-  int32 ipc_database_id = database_dispatcher_host_->map_.Add(connection);
+  int32_t ipc_database_id = database_dispatcher_host_->map_.Add(connection);
   Context()->ConnectionOpened(origin_url, connection);
   database_dispatcher_host_->database_url_map_[ipc_database_id] = origin_url;
   return ipc_database_id;
 }
 
-void IndexedDBDispatcherHost::RegisterTransactionId(int64 host_transaction_id,
+void IndexedDBDispatcherHost::RegisterTransactionId(int64_t host_transaction_id,
                                                     const GURL& url) {
   if (!database_dispatcher_host_)
     return;
   database_dispatcher_host_->transaction_url_map_[host_transaction_id] = url;
 }
 
-int64 IndexedDBDispatcherHost::HostTransactionId(int64 transaction_id) {
+int64_t IndexedDBDispatcherHost::HostTransactionId(int64_t transaction_id) {
   // Inject the renderer process id into the transaction id, to
   // uniquely identify this transaction, and effectively bind it to
   // the renderer that initiated it. The lower 32 bits of
   // transaction_id are guaranteed to be unique within that renderer.
   base::ProcessId pid = peer_pid();
   DCHECK(!(transaction_id >> 32)) << "Transaction ids can only be 32 bits";
-  static_assert(sizeof(base::ProcessId) <= sizeof(int32),
+  static_assert(sizeof(base::ProcessId) <= sizeof(int32_t),
                 "Process ID must fit in 32 bits");
 
-  return transaction_id | (static_cast<uint64>(pid) << 32);
+  return transaction_id | (static_cast<uint64_t>(pid) << 32);
 }
 
-int64 IndexedDBDispatcherHost::RendererTransactionId(
-    int64 host_transaction_id) {
+int64_t IndexedDBDispatcherHost::RendererTransactionId(
+    int64_t host_transaction_id) {
   DCHECK(host_transaction_id >> 32 == peer_pid())
       << "Invalid renderer target for transaction id";
   return host_transaction_id & 0xffffffff;
 }
 
 // static
-uint32 IndexedDBDispatcherHost::TransactionIdToRendererTransactionId(
-    int64 host_transaction_id) {
+uint32_t IndexedDBDispatcherHost::TransactionIdToRendererTransactionId(
+    int64_t host_transaction_id) {
   return host_transaction_id & 0xffffffff;
 }
 
 // static
-uint32 IndexedDBDispatcherHost::TransactionIdToProcessId(
-    int64 host_transaction_id) {
+uint32_t IndexedDBDispatcherHost::TransactionIdToProcessId(
+    int64_t host_transaction_id) {
   return (host_transaction_id >> 32) & 0xffffffff;
 }
 
 std::string IndexedDBDispatcherHost::HoldBlobData(
     const IndexedDBBlobInfo& blob_info) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   std::string uuid = blob_info.uuid();
   storage::BlobStorageContext* context = blob_storage_context_->context();
   scoped_ptr<storage::BlobDataHandle> blob_data_handle;
   if (uuid.empty()) {
@@ skipping 26 matching lines @@
       delete iter->second.first;
       blob_data_handle_map_.erase(iter);
     } else {
       iter->second.second -= 1;
     }
   } else {
     DLOG(FATAL) << "Failed to find blob UUID in map:" << uuid;
   }
 }
 
-IndexedDBCursor* IndexedDBDispatcherHost::GetCursorFromId(int32 ipc_cursor_id) {
+IndexedDBCursor* IndexedDBDispatcherHost::GetCursorFromId(
+    int32_t ipc_cursor_id) {
   DCHECK(indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   return cursor_dispatcher_host_->map_.Lookup(ipc_cursor_id);
 }
 
 ::IndexedDBDatabaseMetadata IndexedDBDispatcherHost::ConvertMetadata(
     const content::IndexedDBDatabaseMetadata& web_metadata) {
   ::IndexedDBDatabaseMetadata metadata;
   metadata.id = web_metadata.id;
   metadata.name = web_metadata.name;
   metadata.version = web_metadata.version;
@@ skipping 44 matching lines @@
 
 void IndexedDBDispatcherHost::OnIDBFactoryOpen(
     const IndexedDBHostMsg_FactoryOpen_Params& params) {
   DCHECK(indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   base::TimeTicks begin_time = base::TimeTicks::Now();
   base::FilePath indexed_db_path = indexed_db_context_->data_path();
 
   GURL origin_url =
       storage::GetOriginFromIdentifier(params.database_identifier);
 
-  int64 host_transaction_id = HostTransactionId(params.transaction_id);
+  int64_t host_transaction_id = HostTransactionId(params.transaction_id);
 
   // TODO(dgrogan): Don't let a non-existing database be opened (and therefore
   // created) if this origin is already over quota.
   scoped_refptr<IndexedDBCallbacks> callbacks =
       new IndexedDBCallbacks(this,
                              params.ipc_thread_id,
                              params.ipc_callbacks_id,
                              params.ipc_database_callbacks_id,
                              host_transaction_id,
                              origin_url);
@@ skipping 35 matching lines @@
   database_dispatcher_host_->OnPut(params, handles);
 }
 
 void IndexedDBDispatcherHost::OnAckReceivedBlobs(
     const std::vector<std::string>& uuids) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   for (const auto& uuid : uuids)
     DropBlobData(uuid);
 }
 
-void IndexedDBDispatcherHost::FinishTransaction(int64 host_transaction_id,
+void IndexedDBDispatcherHost::FinishTransaction(int64_t host_transaction_id,
                                                 bool committed) {
   DCHECK(indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   if (!database_dispatcher_host_)
     return;
   TransactionIDToURLMap& transaction_url_map =
       database_dispatcher_host_->transaction_url_map_;
   TransactionIDToSizeMap& transaction_size_map =
       database_dispatcher_host_->transaction_size_map_;
   TransactionIDToDatabaseIDMap& transaction_database_map =
       database_dispatcher_host_->transaction_database_map_;
   if (committed)
     Context()->TransactionComplete(transaction_url_map[host_transaction_id]);
   transaction_url_map.erase(host_transaction_id);
   transaction_size_map.erase(host_transaction_id);
   transaction_database_map.erase(host_transaction_id);
 }
 
 //////////////////////////////////////////////////////////////////////
 // Helper templates.
 //
 
 template <typename ObjectType>
 ObjectType* IndexedDBDispatcherHost::GetOrTerminateProcess(
     IDMap<ObjectType, IDMapOwnPointer>* map,
-    int32 ipc_return_object_id) {
+    int32_t ipc_return_object_id) {
   DCHECK(indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   ObjectType* return_object = map->Lookup(ipc_return_object_id);
   if (!return_object) {
     NOTREACHED() << "Uh oh, couldn't find object with id "
                  << ipc_return_object_id;
     bad_message::ReceivedBadMessage(this, bad_message::IDBDH_GET_OR_TERMINATE);
   }
   return return_object;
 }
 
 template <typename ObjectType>
 ObjectType* IndexedDBDispatcherHost::GetOrTerminateProcess(
     RefIDMap<ObjectType>* map,
-    int32 ipc_return_object_id) {
+    int32_t ipc_return_object_id) {
   DCHECK(indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   ObjectType* return_object = map->Lookup(ipc_return_object_id);
   if (!return_object) {
     NOTREACHED() << "Uh oh, couldn't find object with id "
                  << ipc_return_object_id;
     bad_message::ReceivedBadMessage(this, bad_message::IDBDH_GET_OR_TERMINATE);
   }
   return return_object;
 }
 
 template <typename MapType>
-void IndexedDBDispatcherHost::DestroyObject(MapType* map, int32 ipc_object_id) {
+void IndexedDBDispatcherHost::DestroyObject(MapType* map,
+                                            int32_t ipc_object_id) {
   GetOrTerminateProcess(map, ipc_object_id);
   map->Remove(ipc_object_id);
 }
 
 //////////////////////////////////////////////////////////////////////
 // IndexedDBDispatcherHost::DatabaseDispatcherHost
 //
 
 IndexedDBDispatcherHost::DatabaseDispatcherHost::DatabaseDispatcherHost(
     IndexedDBDispatcherHost* parent)
     : parent_(parent) {
   map_.set_check_on_null_data(true);
 }
 
 IndexedDBDispatcherHost::DatabaseDispatcherHost::~DatabaseDispatcherHost() {
   // TODO(alecflett): uncomment these when we find the source of these leaks.
   // DCHECK(transaction_size_map_.empty());
   // DCHECK(transaction_url_map_.empty());
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::CloseAll() {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   // Abort outstanding transactions started by connections in the associated
   // front-end to unblock later transactions. This should only occur on unclean
   // (crash) or abrupt (process-kill) shutdowns.
   for (TransactionIDToDatabaseIDMap::iterator iter =
            transaction_database_map_.begin();
        iter != transaction_database_map_.end();) {
-    int64 transaction_id = iter->first;
-    int32 ipc_database_id = iter->second;
+    int64_t transaction_id = iter->first;
+    int32_t ipc_database_id = iter->second;
     ++iter;
     IndexedDBConnection* connection = map_.Lookup(ipc_database_id);
     if (connection && connection->IsConnected()) {
       connection->database()->Abort(
           transaction_id,
           IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionUnknownError));
     }
   }
   DCHECK(transaction_database_map_.empty());
 
@@ skipping 48 matching lines @@
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnCreateObjectStore(
     const IndexedDBHostMsg_DatabaseCreateObjectStore_Params& params) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!connection || !connection->IsConnected())
     return;
 
-  int64 host_transaction_id = parent_->HostTransactionId(params.transaction_id);
+  int64_t host_transaction_id =
+      parent_->HostTransactionId(params.transaction_id);
   connection->database()->CreateObjectStore(host_transaction_id,
                                             params.object_store_id,
                                             params.name,
                                             params.key_path,
                                             params.auto_increment);
   if (parent_->Context()->IsOverQuota(
           database_url_map_[params.ipc_database_id])) {
     connection->database()->Abort(
         host_transaction_id,
         IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionQuotaError));
   }
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnDeleteObjectStore(
-    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) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, ipc_database_id);
   if (!connection || !connection->IsConnected())
     return;
 
   connection->database()->DeleteObjectStore(
       parent_->HostTransactionId(transaction_id), object_store_id);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnCreateTransaction(
     const IndexedDBHostMsg_DatabaseCreateTransaction_Params& params) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!connection || !connection->IsConnected())
     return;
 
-  int64 host_transaction_id = parent_->HostTransactionId(params.transaction_id);
+  int64_t host_transaction_id =
+      parent_->HostTransactionId(params.transaction_id);
 
   if (transaction_database_map_.find(host_transaction_id) !=
       transaction_database_map_.end()) {
     DLOG(ERROR) << "Duplicate host_transaction_id.";
     return;
   }
 
   connection->database()->CreateTransaction(
       host_transaction_id, connection, params.object_store_ids, params.mode);
   transaction_database_map_[host_transaction_id] = params.ipc_database_id;
   parent_->RegisterTransactionId(host_transaction_id,
                                  database_url_map_[params.ipc_database_id]);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnClose(
-    int32 ipc_database_id) {
+    int32_t ipc_database_id) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, ipc_database_id);
   if (!connection || !connection->IsConnected())
     return;
   connection->Close();
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnVersionChangeIgnored(
-    int32 ipc_database_id) {
+    int32_t ipc_database_id) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, ipc_database_id);
   if (!connection || !connection->IsConnected())
     return;
   connection->VersionChangeIgnored();
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnDestroyed(
-    int32 ipc_object_id) {
+    int32_t ipc_object_id) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, ipc_object_id);
   if (!connection)
     return;
   if (connection->IsConnected())
     connection->Close();
   parent_->Context()
       ->ConnectionClosed(database_url_map_[ipc_object_id], connection);
@@ skipping 62 matching lines @@
   ScopedVector<storage::BlobDataHandle> scoped_handles;
   scoped_handles.swap(handles);
 
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!connection || !connection->IsConnected())
     return;
   scoped_refptr<IndexedDBCallbacks> callbacks(new IndexedDBCallbacks(
       parent_, params.ipc_thread_id, params.ipc_callbacks_id));
 
-  int64 host_transaction_id = parent_->HostTransactionId(params.transaction_id);
+  int64_t host_transaction_id =
+      parent_->HostTransactionId(params.transaction_id);
 
   std::vector<IndexedDBBlobInfo> blob_info(
       params.value.blob_or_file_info.size());
 
   ChildProcessSecurityPolicyImpl* policy =
       ChildProcessSecurityPolicyImpl::GetInstance();
 
   for (size_t i = 0; i < params.value.blob_or_file_info.size(); ++i) {
     const IndexedDBMsg_BlobOrFileInfo& info = params.value.blob_or_file_info[i];
     if (info.is_file) {
@@ skipping 39 matching lines @@
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnSetIndexKeys(
     const IndexedDBHostMsg_DatabaseSetIndexKeys_Params& params) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!connection || !connection->IsConnected())
     return;
 
-  int64 host_transaction_id = parent_->HostTransactionId(params.transaction_id);
+  int64_t host_transaction_id =
+      parent_->HostTransactionId(params.transaction_id);
   connection->database()->SetIndexKeys(
       host_transaction_id,
       params.object_store_id,
       make_scoped_ptr(new IndexedDBKey(params.primary_key)),
       params.index_keys);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnSetIndexesReady(
-    int32 ipc_database_id,
-    int64 transaction_id,
-    int64 object_store_id,
-    const std::vector<int64>& index_ids) {
+    int32_t ipc_database_id,
+    int64_t transaction_id,
+    int64_t object_store_id,
+    const std::vector<int64_t>& index_ids) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, ipc_database_id);
   if (!connection || !connection->IsConnected())
     return;
 
   connection->database()->SetIndexesReady(
       parent_->HostTransactionId(transaction_id), object_store_id, index_ids);
 }
@@ skipping 51 matching lines @@
   scoped_refptr<IndexedDBCallbacks> callbacks(new IndexedDBCallbacks(
       parent_, params.ipc_thread_id, params.ipc_callbacks_id));
   connection->database()->DeleteRange(
       parent_->HostTransactionId(params.transaction_id),
       params.object_store_id,
       make_scoped_ptr(new IndexedDBKeyRange(params.key_range)),
       callbacks);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnClear(
-    int32 ipc_thread_id,
-    int32 ipc_callbacks_id,
-    int32 ipc_database_id,
-    int64 transaction_id,
-    int64 object_store_id) {
+    int32_t ipc_thread_id,
+    int32_t ipc_callbacks_id,
+    int32_t ipc_database_id,
+    int64_t transaction_id,
+    int64_t object_store_id) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, ipc_database_id);
   if (!connection || !connection->IsConnected())
     return;
 
   scoped_refptr<IndexedDBCallbacks> callbacks(
       new IndexedDBCallbacks(parent_, ipc_thread_id, ipc_callbacks_id));
 
   connection->database()->Clear(
       parent_->HostTransactionId(transaction_id), object_store_id, callbacks);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnAbort(
-    int32 ipc_database_id,
-    int64 transaction_id) {
+    int32_t ipc_database_id,
+    int64_t transaction_id) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, ipc_database_id);
   if (!connection || !connection->IsConnected())
     return;
 
   connection->database()->Abort(parent_->HostTransactionId(transaction_id));
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnCommit(
-    int32 ipc_database_id,
-    int64 transaction_id) {
+    int32_t ipc_database_id,
+    int64_t transaction_id) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, ipc_database_id);
   if (!connection || !connection->IsConnected())
     return;
 
-  int64 host_transaction_id = parent_->HostTransactionId(transaction_id);
-  int64 transaction_size = transaction_size_map_[host_transaction_id];
+  int64_t host_transaction_id = parent_->HostTransactionId(transaction_id);
+  int64_t transaction_size = transaction_size_map_[host_transaction_id];
   if (transaction_size &&
       parent_->Context()->WouldBeOverQuota(
           transaction_url_map_[host_transaction_id], transaction_size)) {
     connection->database()->Abort(
         host_transaction_id,
         IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionQuotaError));
     return;
   }
 
   connection->database()->Commit(host_transaction_id);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnCreateIndex(
     const IndexedDBHostMsg_DatabaseCreateIndex_Params& params) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!connection || !connection->IsConnected())
     return;
 
-  int64 host_transaction_id = parent_->HostTransactionId(params.transaction_id);
+  int64_t host_transaction_id =
+      parent_->HostTransactionId(params.transaction_id);
   connection->database()->CreateIndex(host_transaction_id,
                                       params.object_store_id,
                                       params.index_id,
                                       params.name,
                                       params.key_path,
                                       params.unique,
                                       params.multi_entry);
   if (parent_->Context()->IsOverQuota(
           database_url_map_[params.ipc_database_id])) {
     connection->database()->Abort(
         host_transaction_id,
         IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionQuotaError));
   }
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnDeleteIndex(
-    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) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, ipc_database_id);
   if (!connection || !connection->IsConnected())
     return;
 
   connection->database()->DeleteIndex(
       parent_->HostTransactionId(transaction_id), object_store_id, index_id);
 }
@@ skipping 24 matching lines @@
   IPC_END_MESSAGE_MAP()
 
   DCHECK(
       !handled ||
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
 
   return handled;
 }
 
 void IndexedDBDispatcherHost::CursorDispatcherHost::OnAdvance(
-    int32 ipc_cursor_id,
-    int32 ipc_thread_id,
-    int32 ipc_callbacks_id,
-    uint32 count) {
+    int32_t ipc_cursor_id,
+    int32_t ipc_thread_id,
+    int32_t ipc_callbacks_id,
+    uint32_t count) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBCursor* idb_cursor =
       parent_->GetOrTerminateProcess(&map_, ipc_cursor_id);
   if (!idb_cursor)
     return;
 
   idb_cursor->Advance(
       count,
       new IndexedDBCallbacks(
           parent_, ipc_thread_id, ipc_callbacks_id, ipc_cursor_id));
 }
 
 void IndexedDBDispatcherHost::CursorDispatcherHost::OnContinue(
-    int32 ipc_cursor_id,
-    int32 ipc_thread_id,
-    int32 ipc_callbacks_id,
+    int32_t ipc_cursor_id,
+    int32_t ipc_thread_id,
+    int32_t ipc_callbacks_id,
     const IndexedDBKey& key,
     const IndexedDBKey& primary_key) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBCursor* idb_cursor =
       parent_->GetOrTerminateProcess(&map_, ipc_cursor_id);
   if (!idb_cursor)
     return;
 
   idb_cursor->Continue(
       key.IsValid() ? make_scoped_ptr(new IndexedDBKey(key))
                     : scoped_ptr<IndexedDBKey>(),
       primary_key.IsValid() ? make_scoped_ptr(new IndexedDBKey(primary_key))
                             : scoped_ptr<IndexedDBKey>(),
       new IndexedDBCallbacks(
           parent_, ipc_thread_id, ipc_callbacks_id, ipc_cursor_id));
 }
 
 void IndexedDBDispatcherHost::CursorDispatcherHost::OnPrefetch(
-    int32 ipc_cursor_id,
-    int32 ipc_thread_id,
-    int32 ipc_callbacks_id,
+    int32_t ipc_cursor_id,
+    int32_t ipc_thread_id,
+    int32_t ipc_callbacks_id,
     int n) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBCursor* idb_cursor =
       parent_->GetOrTerminateProcess(&map_, ipc_cursor_id);
   if (!idb_cursor)
     return;
 
   idb_cursor->PrefetchContinue(
       n,
       new IndexedDBCallbacks(
           parent_, ipc_thread_id, ipc_callbacks_id, ipc_cursor_id));
 }
 
 void IndexedDBDispatcherHost::CursorDispatcherHost::OnPrefetchReset(
-    int32 ipc_cursor_id,
+    int32_t ipc_cursor_id,
     int used_prefetches,
     int unused_prefetches) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBCursor* idb_cursor =
       parent_->GetOrTerminateProcess(&map_, ipc_cursor_id);
   if (!idb_cursor)
     return;
 
   leveldb::Status s =
       idb_cursor->PrefetchReset(used_prefetches, unused_prefetches);
   // TODO(cmumford): Handle this error (crbug.com/363397)
   if (!s.ok())
     DLOG(ERROR) << "Unable to reset prefetch";
 }
 
 void IndexedDBDispatcherHost::CursorDispatcherHost::OnDestroyed(
-    int32 ipc_object_id) {
+    int32_t ipc_object_id) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   parent_->DestroyObject(&map_, ipc_object_id);
 }
 
 }  // namespace content