[IndexedDB] Refactoring to remove ref ptrs and host transaction ids.

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/ptr_util.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"
 #include "content/browser/indexed_db/indexed_db_callbacks.h"
 #include "content/browser/indexed_db/indexed_db_connection.h"
 #include "content/browser/indexed_db/indexed_db_context_impl.h"
 #include "content/browser/indexed_db/indexed_db_cursor.h"
 #include "content/browser/indexed_db/indexed_db_database_callbacks.h"
 #include "content/browser/indexed_db/indexed_db_observation.h"
 #include "content/browser/indexed_db/indexed_db_observer_changes.h"
 #include "content/browser/indexed_db/indexed_db_pending_connection.h"
+#include "content/browser/indexed_db/indexed_db_transaction.h"
 #include "content/browser/indexed_db/indexed_db_value.h"
 #include "content/browser/renderer_host/render_message_filter.h"
 #include "content/common/indexed_db/indexed_db_messages.h"
 #include "content/common/indexed_db/indexed_db_metadata.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/result_codes.h"
 #include "storage/browser/blob/blob_data_builder.h"
 #include "storage/browser/blob/blob_storage_context.h"
@@ skipping 100 matching lines @@
   if (!handled) {
     handled = true;
     IPC_BEGIN_MESSAGE_MAP(IndexedDBDispatcherHost, message)
       IPC_MESSAGE_HANDLER(IndexedDBHostMsg_AckReceivedBlobs, OnAckReceivedBlobs)
       IPC_MESSAGE_UNHANDLED(handled = false)
     IPC_END_MESSAGE_MAP()
   }
   return handled;
 }
 
-int32_t IndexedDBDispatcherHost::Add(IndexedDBCursor* cursor) {
+int32_t IndexedDBDispatcherHost::Add(std::unique_ptr<IndexedDBCursor> cursor) {
   if (!cursor_dispatcher_host_) {
     return 0;
   }
-  return cursor_dispatcher_host_->map_.Add(cursor);
+  return cursor_dispatcher_host_->map_.Add(std::move(cursor));
 }
 
 int32_t IndexedDBDispatcherHost::Add(IndexedDBConnection* connection,
                                      const url::Origin& origin) {
   if (!database_dispatcher_host_) {
     connection->Close();
     delete connection;
     return -1;
   }
   int32_t ipc_database_id = database_dispatcher_host_->map_.Add(connection);
   context()->ConnectionOpened(origin, connection);
   database_dispatcher_host_->database_origin_map_[ipc_database_id] = origin;
   return ipc_database_id;
 }
 
-void IndexedDBDispatcherHost::RegisterTransactionId(int64_t host_transaction_id,
-                                                    const url::Origin& origin) {
-  if (!database_dispatcher_host_)
-    return;
-  database_dispatcher_host_->transaction_size_map_[host_transaction_id] = 0;
-  database_dispatcher_host_->transaction_origin_map_[host_transaction_id] =
-      origin;
-}
-
-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_t),
-                "Process ID must fit in 32 bits");
-
-  return transaction_id | (static_cast<uint64_t>(pid) << 32);
-}
-
-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_t IndexedDBDispatcherHost::TransactionIdToRendererTransactionId(
-    int64_t host_transaction_id) {
-  return host_transaction_id & 0xffffffff;
-}
-
-// static
-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();
   std::unique_ptr<storage::BlobDataHandle> blob_data_handle;
   if (uuid.empty()) {
     uuid = base::GenerateGUID();
     storage::BlobDataBuilder blob_data_builder(uuid);
     blob_data_builder.set_content_type(base::UTF16ToUTF8(blob_info.type()));
@@ skipping 138 matching lines @@
     scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks,
     const url::Origin& origin,
     const base::string16& name,
     int64_t version,
     int64_t transaction_id) {
   DCHECK(indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
 
   base::TimeTicks begin_time = base::TimeTicks::Now();
   base::FilePath indexed_db_path = indexed_db_context_->data_path();
 
-  int64_t host_transaction_id = HostTransactionId(transaction_id);
-
   // TODO(dgrogan): Don't let a non-existing database be opened (and therefore
   // created) if this origin is already over quota.
   callbacks->SetConnectionOpenStartTime(begin_time);
-  callbacks->set_host_transaction_id(host_transaction_id);
+  callbacks->set_host_transaction_id(transaction_id);
   std::unique_ptr<IndexedDBPendingConnection> connection =
       base::MakeUnique<IndexedDBPendingConnection>(
-          callbacks, database_callbacks, ipc_process_id_, host_transaction_id,
+          callbacks, database_callbacks, ipc_process_id_, transaction_id,
           version);
   DCHECK(request_context_getter_);
   context()->GetIDBFactory()->Open(name, std::move(connection),
                                    request_context_getter_, origin,
                                    indexed_db_path);
 }
 
 void IndexedDBDispatcherHost::DeleteDatabaseOnIDBThread(
     scoped_refptr<IndexedDBCallbacks> callbacks,
     const url::Origin& origin,
@@ skipping 14 matching lines @@
   database_dispatcher_host_->OnPut(params, std::move(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_t host_transaction_id,
+void IndexedDBDispatcherHost::FinishTransaction(url::Origin transaction_origin,
                                                 bool committed) {
   DCHECK(indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   if (!database_dispatcher_host_)
     return;
-  TransactionIDToOriginMap& transaction_origin_map =
-      database_dispatcher_host_->transaction_origin_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_origin_map[host_transaction_id]);
-  transaction_origin_map.erase(host_transaction_id);
-  transaction_size_map.erase(host_transaction_id);
-  transaction_database_map.erase(host_transaction_id);
+    context()->TransactionComplete(transaction_origin);
 }
 
 //////////////////////////////////////////////////////////////////////
 // Helper templates.
 //
 
 template <typename ObjectType>
 ObjectType* IndexedDBDispatcherHost::GetOrTerminateProcess(
     IDMap<ObjectType, IDMapOwnPointer>* map,
     int32_t ipc_return_object_id) {
@@ skipping 42 matching lines @@
   // TODO(alecflett): uncomment these when we find the source of these leaks.
   // DCHECK(transaction_size_map_.empty());
   // DCHECK(transaction_origin_map_.empty());
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::CloseAll() {
   DCHECK(parent_->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_t transaction_id = iter->first;
-    int32_t ipc_database_id = iter->second;
-    ++iter;
-    IndexedDBConnection* connection = map_.Lookup(ipc_database_id);
+  IDMap<IndexedDBConnection, IDMapOwnPointer>::iterator iterator(&map_);
+  while (!iterator.IsAtEnd()) {

[jsbell, 2016/11/04 17:48:19]

We can't use range-based for here? :(

[dmurph, 2016/11/04 22:52:24]

We got rid of the extra map, and this map doesn't let us do range-based :(

+    IndexedDBConnection* connection = iterator.GetCurrentValue();
     if (connection && connection->IsConnected()) {
-      connection->database()->Abort(
-          transaction_id,
-          IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionUnknownError));
+      for (const auto& transaction_pair : connection->transactions()) {
+        connection->database()->Abort(

[jsbell, 2016/11/04 17:48:19]

As an aside (maybe a TODO?) - maybe we want to copy a pattern used in other
storage backends where various types (backing store, database) get a "doomed"
flag, set when we're rudely terminating connections, which e.g. prevents
aborting a TX from starting the next TX in line.

[dmurph, 2016/11/04 22:52:24]

Acknowledged.

+            transaction_pair.second.get(),
+            IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionUnknownError));
+      }
     }
+    iterator.Advance();
   }
-  DCHECK(transaction_database_map_.empty());
 
   for (const auto& iter : database_origin_map_) {
     IndexedDBConnection* connection = map_.Lookup(iter.first);
     if (connection && connection->IsConnected()) {
       connection->Close();
       parent_->context()->ConnectionClosed(iter.second, connection);
     }
   }
 }
 
@@ skipping 41 matching lines @@
   return handled;
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnCreateObjectStore(
     const IndexedDBHostMsg_DatabaseCreateObjectStore_Params& params) {
   DCHECK(parent_->context()->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!connection || !connection->IsConnected())
     return;
+  IndexedDBTransaction* transaction =
+      connection->GetTransaction(params.transaction_id);
+  if (!transaction)
+    return;
 
-  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,
+  connection->database()->CreateObjectStore(transaction, params.object_store_id,
+                                            params.name, params.key_path,
                                             params.auto_increment);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnDeleteObjectStore(
     int32_t ipc_database_id,
     int64_t transaction_id,
     int64_t object_store_id) {
   DCHECK(parent_->context()->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, ipc_database_id);
   if (!connection || !connection->IsConnected())
     return;
+  IndexedDBTransaction* transaction =
+      connection->GetTransaction(transaction_id);
+  if (!transaction)
+    return;
 
-  connection->database()->DeleteObjectStore(
-      parent_->HostTransactionId(transaction_id), object_store_id);
+  connection->database()->DeleteObjectStore(transaction, object_store_id);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnRenameObjectStore(
     int32_t ipc_database_id,
     int64_t transaction_id,
     int64_t object_store_id,
     const base::string16& new_name) {
   DCHECK(parent_->context()->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, ipc_database_id);
   if (!connection || !connection->IsConnected())
     return;
+  IndexedDBTransaction* transaction =
+      connection->GetTransaction(transaction_id);
+  if (!transaction)
+    return;
 
-  connection->database()->RenameObjectStore(
-      parent_->HostTransactionId(transaction_id), object_store_id, new_name);
+  connection->database()->RenameObjectStore(transaction, object_store_id,
+                                            new_name);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnCreateTransaction(
     const IndexedDBHostMsg_DatabaseCreateTransaction_Params& params) {
   DCHECK(parent_->context()->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!connection || !connection->IsConnected())
     return;
 
-  int64_t host_transaction_id =
-      parent_->HostTransactionId(params.transaction_id);
-
-  if (base::ContainsKey(transaction_database_map_, host_transaction_id)) {
+  if (connection->GetTransaction(params.transaction_id)) {
     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_origin_map_[params.ipc_database_id]);
+  IndexedDBTransaction* transaction = connection->database()->CreateTransaction(
+      params.transaction_id, connection, params.object_store_ids, params.mode);
+  transaction->set_origin(database_origin_map_[params.ipc_database_id]);

[cmumford, 2016/11/04 23:33:12]

Why aren't we passing in the origin to CreateTransaction?

[dmurph, 2016/11/07 20:05:23]

No longer needed now that we store it on the connection.

 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnClose(
     int32_t ipc_database_id) {
   DCHECK(parent_->context()->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, ipc_database_id);
   if (!connection || !connection->IsConnected())
     return;
   connection->Close();
@@ skipping 24 matching lines @@
   parent_->DestroyObject(&map_, ipc_object_id);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnObserve(
     const IndexedDBHostMsg_DatabaseObserve_Params& params) {
   DCHECK(parent_->context()->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!connection || !connection->IsConnected())
     return;
+  IndexedDBTransaction* transaction =
+      connection->GetTransaction(params.transaction_id);
+  if (!transaction)
+    return;
   IndexedDBObserver::Options options(params.include_transaction,
                                      params.no_records, params.values,
                                      params.operation_types);
-  connection->database()->AddPendingObserver(
-      parent_->HostTransactionId(params.transaction_id), params.observer_id,
-      options);
+  connection->database()->AddPendingObserver(transaction, params.observer_id,
+                                             options);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnUnobserve(
     int32_t ipc_database_id,
     const std::vector<int32_t>& observer_ids_to_remove) {
   DCHECK(parent_->context()->TaskRunner()->RunsTasksOnCurrentThread());
   DCHECK(!observer_ids_to_remove.empty());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, ipc_database_id);
   if (!connection || !connection->IsConnected())
     return;
   connection->RemoveObservers(observer_ids_to_remove);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnGet(
     const IndexedDBHostMsg_DatabaseGet_Params& params) {
   DCHECK(parent_->context()->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!connection || !connection->IsConnected())
     return;
+  IndexedDBTransaction* transaction =
+      connection->GetTransaction(params.transaction_id);
+  if (!transaction)
+    return;
 
   scoped_refptr<IndexedDBCallbacks> callbacks(new IndexedDBCallbacks(
       parent_, params.ipc_thread_id, params.ipc_callbacks_id));
   connection->database()->Get(
-      parent_->HostTransactionId(params.transaction_id), params.object_store_id,
-      params.index_id, base::MakeUnique<IndexedDBKeyRange>(params.key_range),
-      params.key_only, callbacks);
+      transaction, params.object_store_id, params.index_id,
+      base::MakeUnique<IndexedDBKeyRange>(params.key_range), params.key_only,
+      callbacks);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnGetAll(
     const IndexedDBHostMsg_DatabaseGetAll_Params& params) {
   DCHECK(parent_->context()->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!connection || !connection->IsConnected())
     return;
+  IndexedDBTransaction* transaction =
+      connection->GetTransaction(params.transaction_id);
+  if (!transaction)
+    return;
 
   scoped_refptr<IndexedDBCallbacks> callbacks(new IndexedDBCallbacks(
       parent_, params.ipc_thread_id, params.ipc_callbacks_id));
   connection->database()->GetAll(
-      parent_->HostTransactionId(params.transaction_id), params.object_store_id,
-      params.index_id, base::MakeUnique<IndexedDBKeyRange>(params.key_range),
-      params.key_only, params.max_count, callbacks);
+      transaction, params.object_store_id, params.index_id,
+      base::MakeUnique<IndexedDBKeyRange>(params.key_range), params.key_only,
+      params.max_count, callbacks);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnPutWrapper(
     const IndexedDBHostMsg_DatabasePut_Params& params) {
   std::vector<std::unique_ptr<storage::BlobDataHandle>> handles;
   for (const auto& info : params.value.blob_or_file_info) {
     handles.push_back(
         parent_->blob_storage_context_->context()->GetBlobDataFromUUID(
             info.uuid));
   }
   parent_->context()->TaskRunner()->PostTask(
       FROM_HERE, base::Bind(&IndexedDBDispatcherHost::OnPutHelper, parent_,
                             params, base::Passed(&handles)));
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnPut(
     const IndexedDBHostMsg_DatabasePut_Params& params,
     std::vector<std::unique_ptr<storage::BlobDataHandle>> handles) {
   DCHECK(parent_->context()->TaskRunner()->RunsTasksOnCurrentThread());
 
   std::vector<std::unique_ptr<storage::BlobDataHandle>> scoped_handles;
   scoped_handles.swap(handles);
 
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!connection || !connection->IsConnected())
     return;
+  IndexedDBTransaction* transaction =
+      connection->GetTransaction(params.transaction_id);
+  if (!transaction)
+    return;
   scoped_refptr<IndexedDBCallbacks> callbacks(new IndexedDBCallbacks(
       parent_, params.ipc_thread_id, params.ipc_callbacks_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();
 
   size_t i = 0;
   for (const auto& info : params.value.blob_or_file_info) {
     if (info.is_file) {
       base::FilePath path;
@@ skipping 15 matching lines @@
     } else {
       blob_info[i] = IndexedDBBlobInfo(info.uuid, info.mime_type, info.size);
     }
     ++i;
   }
 
   // TODO(alecflett): Avoid a copy here.
   IndexedDBValue value;
   value.bits = params.value.bits;
   value.blob_info.swap(blob_info);
-  connection->database()->Put(host_transaction_id, params.object_store_id,
-                              &value, &scoped_handles,
+  connection->database()->Put(transaction, params.object_store_id, &value,
+                              &scoped_handles,
                               base::MakeUnique<IndexedDBKey>(params.key),
                               params.put_mode, callbacks, params.index_keys);
   // Size can't be big enough to overflow because it represents the
   // actual bytes passed through IPC.
-  transaction_size_map_[host_transaction_id] += params.value.bits.size();
+  transaction->set_size(transaction->size() + params.value.bits.size());
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnSetIndexKeys(
     const IndexedDBHostMsg_DatabaseSetIndexKeys_Params& params) {
   DCHECK(parent_->context()->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!connection || !connection->IsConnected())
     return;
+  IndexedDBTransaction* transaction =
+      connection->GetTransaction(params.transaction_id);
+  if (!transaction)
+    return;
 
-  int64_t host_transaction_id =
-      parent_->HostTransactionId(params.transaction_id);
   connection->database()->SetIndexKeys(
-      host_transaction_id, params.object_store_id,
+      transaction, params.object_store_id,
       base::MakeUnique<IndexedDBKey>(params.primary_key), params.index_keys);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnSetIndexesReady(
     int32_t ipc_database_id,
     int64_t transaction_id,
     int64_t object_store_id,
     const std::vector<int64_t>& index_ids) {
   DCHECK(parent_->context()->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, ipc_database_id);
   if (!connection || !connection->IsConnected())
     return;
+  IndexedDBTransaction* transaction =
+      connection->GetTransaction(transaction_id);
+  if (!transaction)
+    return;
 
-  connection->database()->SetIndexesReady(
-      parent_->HostTransactionId(transaction_id), object_store_id, index_ids);
+  connection->database()->SetIndexesReady(transaction, object_store_id,
+                                          index_ids);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnOpenCursor(
     const IndexedDBHostMsg_DatabaseOpenCursor_Params& params) {
   DCHECK(parent_->context()->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!connection || !connection->IsConnected())
     return;
+  IndexedDBTransaction* transaction =
+      connection->GetTransaction(params.transaction_id);
+  if (!transaction)
+    return;
 
   scoped_refptr<IndexedDBCallbacks> callbacks(new IndexedDBCallbacks(
       parent_, params.ipc_thread_id, params.ipc_callbacks_id, -1));
   connection->database()->OpenCursor(
-      parent_->HostTransactionId(params.transaction_id), params.object_store_id,
-      params.index_id, base::MakeUnique<IndexedDBKeyRange>(params.key_range),
-      params.direction, params.key_only, params.task_type, callbacks);
+      transaction, params.object_store_id, params.index_id,
+      base::MakeUnique<IndexedDBKeyRange>(params.key_range), params.direction,
+      params.key_only, params.task_type, callbacks);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnCount(
     const IndexedDBHostMsg_DatabaseCount_Params& params) {
   DCHECK(parent_->context()->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!connection || !connection->IsConnected())
     return;
+  IndexedDBTransaction* transaction =
+      connection->GetTransaction(params.transaction_id);
+  if (!transaction)
+    return;
 
   scoped_refptr<IndexedDBCallbacks> callbacks(new IndexedDBCallbacks(
       parent_, params.ipc_thread_id, params.ipc_callbacks_id));
   connection->database()->Count(
-      parent_->HostTransactionId(params.transaction_id), params.object_store_id,
-      params.index_id, base::MakeUnique<IndexedDBKeyRange>(params.key_range),
-      callbacks);
+      transaction, params.object_store_id, params.index_id,
+      base::MakeUnique<IndexedDBKeyRange>(params.key_range), callbacks);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnDeleteRange(
     const IndexedDBHostMsg_DatabaseDeleteRange_Params& params) {
   DCHECK(parent_->context()->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!connection || !connection->IsConnected())
     return;
+  IndexedDBTransaction* transaction =
+      connection->GetTransaction(params.transaction_id);
+  if (!transaction)
+    return;
 
   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,
+      transaction, params.object_store_id,
       base::MakeUnique<IndexedDBKeyRange>(params.key_range), callbacks);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnClear(
     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_->context()->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, ipc_database_id);
   if (!connection || !connection->IsConnected())
     return;
+  IndexedDBTransaction* transaction =
+      connection->GetTransaction(transaction_id);
+  if (!transaction)
+    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);
+  connection->database()->Clear(transaction, object_store_id, callbacks);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnAbort(
     int32_t ipc_database_id,
     int64_t transaction_id) {
   DCHECK(parent_->context()->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, ipc_database_id);
   if (!connection || !connection->IsConnected())
     return;
+  IndexedDBTransaction* transaction =
+      connection->GetTransaction(transaction_id);
+  if (!transaction)
+    return;
 
-  connection->database()->Abort(parent_->HostTransactionId(transaction_id));
+  connection->database()->Abort(transaction);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnCommit(
     int32_t ipc_database_id,
     int64_t transaction_id) {
   DCHECK(parent_->context()->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, ipc_database_id);
   if (!connection || !connection->IsConnected())
     return;
+  IndexedDBTransaction* transaction =
+      connection->GetTransaction(transaction_id);
+  if (!transaction)
+    return;
 
-  int64_t host_transaction_id = parent_->HostTransactionId(transaction_id);
-  // May have been aborted by back end before front-end could request commit.
-  if (!base::ContainsKey(transaction_size_map_, host_transaction_id))
-    return;
-  int64_t transaction_size = transaction_size_map_[host_transaction_id];
+  int64_t transaction_size = transaction->size();
 
   // Always allow empty or delete-only transactions.
   if (!transaction_size) {
-    connection->database()->Commit(host_transaction_id);
+    connection->database()->Commit(transaction);
     return;
   }
 
   parent_->context()->quota_manager_proxy()->GetUsageAndQuota(
-      parent_->context()->TaskRunner(),
-      GURL(transaction_origin_map_[host_transaction_id].Serialize()),
+      parent_->context()->TaskRunner(), GURL(transaction->origin().Serialize()),
       storage::kStorageTypeTemporary,
       base::Bind(&IndexedDBDispatcherHost::DatabaseDispatcherHost::
                      OnGotUsageAndQuotaForCommit,
                  weak_factory_.GetWeakPtr(), ipc_database_id, transaction_id));
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::
     OnGotUsageAndQuotaForCommit(int32_t ipc_database_id,
                                 int64_t transaction_id,
                                 storage::QuotaStatusCode status,
                                 int64_t usage,
                                 int64_t quota) {
   DCHECK(parent_->context()->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection = map_.Lookup(ipc_database_id);
   // May have disconnected while quota check was pending.
   if (!connection || !connection->IsConnected())
     return;
-  int64_t host_transaction_id = parent_->HostTransactionId(transaction_id);
-  // May have aborted while quota check was pending.
-  if (!base::ContainsKey(transaction_size_map_, host_transaction_id))
+  IndexedDBTransaction* transaction =
+      connection->GetTransaction(transaction_id);
+  if (!transaction)
     return;
-  int64_t transaction_size = transaction_size_map_[host_transaction_id];
+
+  int64_t transaction_size = transaction->size();
 
   if (status == storage::kQuotaStatusOk &&
       usage + transaction_size <= quota) {
-    connection->database()->Commit(host_transaction_id);
+    connection->database()->Commit(transaction);
   } else {
     connection->database()->Abort(
-        host_transaction_id,
+        transaction,
         IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionQuotaError));
   }
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnCreateIndex(
     const IndexedDBHostMsg_DatabaseCreateIndex_Params& params) {
   DCHECK(parent_->context()->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!connection || !connection->IsConnected())
     return;
+  IndexedDBTransaction* transaction =
+      connection->GetTransaction(params.transaction_id);
+  if (!transaction)
+    return;
 
-  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);
+  connection->database()->CreateIndex(
+      transaction, params.object_store_id, params.index_id, params.name,
+      params.key_path, params.unique, params.multi_entry);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnDeleteIndex(
     int32_t ipc_database_id,
     int64_t transaction_id,
     int64_t object_store_id,
     int64_t index_id) {
   DCHECK(parent_->context()->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, ipc_database_id);
   if (!connection || !connection->IsConnected())
     return;
+  IndexedDBTransaction* transaction =
+      connection->GetTransaction(transaction_id);
+  if (!transaction)
+    return;
 
-  connection->database()->DeleteIndex(
-      parent_->HostTransactionId(transaction_id), object_store_id, index_id);
+  connection->database()->DeleteIndex(transaction, object_store_id, index_id);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnRenameIndex(
     int32_t ipc_database_id,
     int64_t transaction_id,
     int64_t object_store_id,
     int64_t index_id,
     const base::string16& new_name) {
   DCHECK(parent_->context()->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, ipc_database_id);
   if (!connection || !connection->IsConnected())
     return;
+  IndexedDBTransaction* transaction =
+      connection->GetTransaction(transaction_id);
+  if (!transaction)
+    return;
 
-  connection->database()->RenameIndex(
-      parent_->HostTransactionId(transaction_id), object_store_id, index_id,
-      new_name);
+  connection->database()->RenameIndex(transaction, object_store_id, index_id,
+                                      new_name);
 }
 
 //////////////////////////////////////////////////////////////////////
 // IndexedDBDispatcherHost::CursorDispatcherHost
 //
 
 IndexedDBDispatcherHost::CursorDispatcherHost::CursorDispatcherHost(
     IndexedDBDispatcherHost* parent)
     : parent_(parent) {
   map_.set_check_on_null_data(true);
@@ skipping 86 matching lines @@
     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_t ipc_object_id) {
+    int32_t ipc_cursor_id) {
   DCHECK(parent_->context()->TaskRunner()->RunsTasksOnCurrentThread());
-  parent_->DestroyObject(&map_, ipc_object_id);
+  IndexedDBCursor* idb_cursor =
+      parent_->GetOrTerminateProcess(&map_, ipc_cursor_id);
+  idb_cursor->RemoveCursorFromTransaction();
+  parent_->DestroyObject(&map_, ipc_cursor_id);
 }
 
 }  // namespace content