[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) {
+int32_t IndexedDBDispatcherHost::Add(
+    std::unique_ptr<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);
+  IndexedDBConnection* connection_ptr = connection.get();
+  int32_t ipc_database_id =
+      database_dispatcher_host_->map_.Add(std::move(connection));
+  context()->ConnectionOpened(origin, connection_ptr);
   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,
-          version);
+          callbacks, database_callbacks, ipc_process_id_, origin,
+          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,
     const base::string16& name) {
@@ skipping 13 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,
-                                                bool committed) {
+void IndexedDBDispatcherHost::FinishTransaction(

[jsbell, 2016/11/08 00:42:52]

The only purpose of this method now is to poke the quota system via the
contextimpl. We could possibly rename this, and even only call if we committed
to simplify, e.g. make it NotifyTransactionCommitted(origin)

[dmurph, 2016/11/09 00:27:32]

Done.

+    const 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) {
   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_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_t ipc_object_id) {
   GetOrTerminateProcess(map, ipc_object_id);
   map->Remove(ipc_object_id);
 }
 
 //////////////////////////////////////////////////////////////////////
 // IndexedDBDispatcherHost::DatabaseDispatcherHost
 //
 
 IndexedDBDispatcherHost::DatabaseDispatcherHost::DatabaseDispatcherHost(
     IndexedDBDispatcherHost* parent)
     : parent_(parent), weak_factory_(this) {
   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_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()) {
+    IndexedDBConnection* connection = iterator.GetCurrentValue();
     if (connection && connection->IsConnected()) {
-      connection->database()->Abort(
-          transaction_id,
+      // TODO(dmurph): Perhaps mark these transactions as DOOMED instead, so we
+      // can prevent side effects in the rest of the system.
+      connection->AbortAllTransactions(
           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]);
+      params.transaction_id, connection, params.object_store_ids, params.mode);
 }
 
 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->AbortTransaction(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(connection->origin().Serialize()),

[jsbell, 2016/11/08 00:42:52]

This can be replaced by connection->origin().GetURL() now (recently added).
(Should probably do that in a separate CL, I guess.)

       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,
+    connection->AbortTransaction(
+        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