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

content/browser/indexed_db/indexed_db_database.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/indexed_db/indexed_db_database.h"
 
 #include <math.h>
 
 #include <limits>
 #include <set>
@@ skipping 79 matching lines @@
 
   // Called if a front-end signals that it is ignoring a "versionchange"
   // event. This should result in firing a "blocked" event at the request.
   virtual void OnVersionChangeIgnored() const = 0;
 
   // Called when a connection is closed; if it corresponds to this connection,
   // need to do cleanup. Otherwise, it may unblock further steps.
   virtual void OnConnectionClosed(IndexedDBConnection* connection) = 0;
 
   // Called when the upgrade transaction has started executing.
-  virtual void UpgradeTransactionStarted(int64_t old_version) = 0;
+  virtual void UpgradeTransactionStarted(int64_t old_version,
+                                         IndexedDBTransaction* transaction) = 0;
 
   // Called when the upgrade transaction has finished.
   virtual void UpgradeTransactionFinished(bool committed) = 0;
 
  protected:
   scoped_refptr<IndexedDBDatabase> db_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ConnectionRequest);
 };
@@ skipping 38 matching lines @@
     int64_t& new_version = pending_->version;
 
     bool is_new_database = old_version == IndexedDBDatabaseMetadata::NO_VERSION;
 
     if (new_version == IndexedDBDatabaseMetadata::DEFAULT_VERSION) {
       // For unit tests only - skip upgrade steps. (Calling from script with
       // DEFAULT_VERSION throws exception.)
       DCHECK(is_new_database);
       pending_->callbacks->OnSuccess(
           db_->CreateConnection(pending_->database_callbacks,
-                                pending_->child_process_id),
+                                pending_->child_process_id, pending_->origin),
           db_->metadata_);
       db_->RequestComplete(this);
       return;
     }
 
     if (!is_new_database &&
         (new_version == old_version ||
          new_version == IndexedDBDatabaseMetadata::NO_VERSION)) {
       pending_->callbacks->OnSuccess(
           db_->CreateConnection(pending_->database_callbacks,
-                                pending_->child_process_id),
+                                pending_->child_process_id, pending_->origin),
           db_->metadata_);
       db_->RequestComplete(this);
       return;
     }
 
     if (new_version == IndexedDBDatabaseMetadata::NO_VERSION) {
       // If no version is specified and no database exists, upgrade the
       // database version to 1.
       DCHECK(is_new_database);
       new_version = 1;
@@ skipping 47 matching lines @@
     if (!db_->connections_.empty())
       return;
 
     StartUpgrade();
   }
 
   // Initiate the upgrade. The bulk of the work actually happens in
   // IndexedDBDatabase::VersionChangeOperation in order to kick the
   // transaction into the correct state.
   void StartUpgrade() {
-    connection_ = db_->CreateConnection(pending_->database_callbacks,
-                                        pending_->child_process_id);
+    connection_ =
+        db_->CreateConnection(pending_->database_callbacks,
+                              pending_->child_process_id, pending_->origin);
     DCHECK_EQ(db_->connections_.count(connection_.get()), 1UL);
 
     std::vector<int64_t> object_store_ids;
     IndexedDBTransaction* transaction = db_->CreateTransaction(
         pending_->transaction_id, connection_.get(), object_store_ids,
         blink::WebIDBTransactionModeVersionChange);
 
     DCHECK(db_->transaction_coordinator_.IsRunningVersionChangeTransaction());
     transaction->ScheduleTask(
         base::Bind(&IndexedDBDatabase::VersionChangeOperation, db_,
                    pending_->version, pending_->callbacks));
   }
 
   // Called when the upgrade transaction has started executing.
-  void UpgradeTransactionStarted(int64_t old_version) override {
+  void UpgradeTransactionStarted(int64_t old_version,
+                                 IndexedDBTransaction* transaction) override {
     DCHECK(connection_);
     pending_->callbacks->OnUpgradeNeeded(old_version, std::move(connection_),
-                                         db_->metadata_,
+                                         transaction, db_->metadata_,
                                          pending_->data_loss_info);
   }
 
   void UpgradeTransactionFinished(bool committed) override {
     // Ownership of connection was already passed along in OnUpgradeNeeded.
     DCHECK(!connection_);
 
     if (committed) {
       DCHECK_EQ(pending_->version, db_->metadata_.version);
       pending_->callbacks->OnSuccess(std::unique_ptr<IndexedDBConnection>(),
@@ skipping 71 matching lines @@
     db_->metadata_.id = kInvalidId;
     db_->metadata_.version = IndexedDBDatabaseMetadata::NO_VERSION;
     db_->metadata_.max_object_store_id = kInvalidId;
     db_->metadata_.object_stores.clear();
     callbacks_->OnSuccess(old_version);
     db_->factory_->DatabaseDeleted(db_->identifier_);
 
     db_->RequestComplete(this);
   }
 
-  void UpgradeTransactionStarted(int64_t old_version) override { NOTREACHED(); }
+  void UpgradeTransactionStarted(int64_t old_version,
+                                 IndexedDBTransaction* transaction) override {
+    NOTREACHED();
+  }
 
   void UpgradeTransactionFinished(bool committed) override { NOTREACHED(); }
 
  private:
   scoped_refptr<IndexedDBCallbacks> callbacks_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteRequest);
 };
 
 scoped_refptr<IndexedDBDatabase> IndexedDBDatabase::Create(
@@ skipping 101 matching lines @@
     return s;
   if (success)
     return backing_store_->GetObjectStores(metadata_.id,
                                            &metadata_.object_stores);
 
   return backing_store_->CreateIDBDatabaseMetaData(
       metadata_.name, metadata_.version, &metadata_.id);
 }
 
 IndexedDBDatabase::~IndexedDBDatabase() {
-  DCHECK(transactions_.empty());
   DCHECK(!active_request_);
   DCHECK(pending_requests_.empty());
 }
 
 size_t IndexedDBDatabase::GetMaxMessageSizeInBytes() const {
   return kMaxIDBMessageSizeInBytes;
 }
 
 std::unique_ptr<IndexedDBConnection> IndexedDBDatabase::CreateConnection(
     scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks,
-    int child_process_id) {
+    int child_process_id,
+    const url::Origin& origin) {
   std::unique_ptr<IndexedDBConnection> connection(
-      base::MakeUnique<IndexedDBConnection>(this, database_callbacks));
+      base::MakeUnique<IndexedDBConnection>(child_process_id, origin, this,
+                                            database_callbacks));
   connections_.insert(connection.get());
   backing_store_->GrantChildProcessPermissions(child_process_id);
   return connection;
 }
 
-IndexedDBTransaction* IndexedDBDatabase::GetTransaction(
-    int64_t transaction_id) const {
-  const auto& trans_iterator = transactions_.find(transaction_id);
-  if (trans_iterator == transactions_.end())
-    return NULL;
-  return trans_iterator->second;
-}
-
 bool IndexedDBDatabase::ValidateObjectStoreId(int64_t object_store_id) const {
   if (!base::ContainsKey(metadata_.object_stores, object_store_id)) {
     DLOG(ERROR) << "Invalid object_store_id";
     return false;
   }
   return true;
 }
 
 bool IndexedDBDatabase::ValidateObjectStoreIdAndIndexId(
     int64_t object_store_id,
@@ skipping 31 matching lines @@
     return false;
   const IndexedDBObjectStoreMetadata& object_store_metadata =
       metadata_.object_stores.find(object_store_id)->second;
   if (base::ContainsKey(object_store_metadata.indexes, index_id)) {
     DLOG(ERROR) << "Invalid index_id";
     return false;
   }
   return true;
 }
 
-void IndexedDBDatabase::CreateObjectStore(int64_t transaction_id,
+void IndexedDBDatabase::CreateObjectStore(IndexedDBTransaction* transaction,
                                           int64_t object_store_id,
                                           const base::string16& name,
                                           const IndexedDBKeyPath& key_path,
                                           bool auto_increment) {
-  IDB_TRACE1("IndexedDBDatabase::CreateObjectStore", "txn.id", transaction_id);
-  IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
+  IDB_TRACE1("IndexedDBDatabase::CreateObjectStore", "txn.id",
+             transaction->id());
   DCHECK_EQ(transaction->mode(), blink::WebIDBTransactionModeVersionChange);
 
   if (base::ContainsKey(metadata_.object_stores, object_store_id)) {
     DLOG(ERROR) << "Invalid object_store_id";
     return;
   }
 
   UMA_HISTOGRAM_ENUMERATION("WebCore.IndexedDB.Schema.ObjectStore.KeyPathType",
                             HistogramKeyPathType(key_path), KEY_PATH_TYPE_MAX);
   UMA_HISTOGRAM_BOOLEAN("WebCore.IndexedDB.Schema.ObjectStore.AutoIncrement",
@@ skipping 27 matching lines @@
     return;
   }
 
   AddObjectStore(object_store_metadata, object_store_id);
   transaction->ScheduleAbortTask(
       base::Bind(&IndexedDBDatabase::CreateObjectStoreAbortOperation,
                  this,
                  object_store_id));
 }
 
-void IndexedDBDatabase::DeleteObjectStore(int64_t transaction_id,
+void IndexedDBDatabase::DeleteObjectStore(IndexedDBTransaction* transaction,
                                           int64_t object_store_id) {
-  IDB_TRACE1("IndexedDBDatabase::DeleteObjectStore", "txn.id", transaction_id);
-  IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
+  IDB_TRACE1("IndexedDBDatabase::DeleteObjectStore", "txn.id",
+             transaction->id());
   DCHECK_EQ(transaction->mode(), blink::WebIDBTransactionModeVersionChange);
 
   if (!ValidateObjectStoreId(object_store_id))
     return;
 
   transaction->ScheduleTask(
       base::Bind(&IndexedDBDatabase::DeleteObjectStoreOperation,
                  this,
                  object_store_id));
 }
 
-void IndexedDBDatabase::RenameObjectStore(int64_t transaction_id,
+void IndexedDBDatabase::RenameObjectStore(IndexedDBTransaction* transaction,
                                           int64_t object_store_id,
                                           const base::string16& new_name) {
-  IDB_TRACE1("IndexedDBDatabase::RenameObjectStore", "txn.id", transaction_id);
-  IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
+  IDB_TRACE1("IndexedDBDatabase::RenameObjectStore", "txn.id",
+             transaction->id());
   DCHECK_EQ(transaction->mode(), blink::WebIDBTransactionModeVersionChange);
 
   if (!ValidateObjectStoreId(object_store_id))
     return;
 
   // Store renaming is done synchronously, as it may be followed by
   // index creation (also sync) since preemptive OpenCursor/SetIndexKeys
   // may follow.
   const IndexedDBObjectStoreMetadata object_store_metadata =
       metadata_.object_stores[object_store_id];
@@ skipping 15 matching lines @@
   }
 
   transaction->ScheduleAbortTask(
       base::Bind(&IndexedDBDatabase::RenameObjectStoreAbortOperation,
                  this,
                  object_store_id,
                  object_store_metadata.name));
   SetObjectStoreName(object_store_id, new_name);
 }
 
-void IndexedDBDatabase::CreateIndex(int64_t transaction_id,
+void IndexedDBDatabase::CreateIndex(IndexedDBTransaction* transaction,
                                     int64_t object_store_id,
                                     int64_t index_id,
                                     const base::string16& name,
                                     const IndexedDBKeyPath& key_path,
                                     bool unique,
                                     bool multi_entry) {
-  IDB_TRACE1("IndexedDBDatabase::CreateIndex", "txn.id", transaction_id);
-  IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
+  IDB_TRACE1("IndexedDBDatabase::CreateIndex", "txn.id", transaction->id());
   DCHECK_EQ(transaction->mode(), blink::WebIDBTransactionModeVersionChange);
 
   if (!ValidateObjectStoreIdAndNewIndexId(object_store_id, index_id))
     return;
 
   UMA_HISTOGRAM_ENUMERATION("WebCore.IndexedDB.Schema.Index.KeyPathType",
                             HistogramKeyPathType(key_path), KEY_PATH_TYPE_MAX);
   UMA_HISTOGRAM_BOOLEAN("WebCore.IndexedDB.Schema.Index.Unique", unique);
   UMA_HISTOGRAM_BOOLEAN("WebCore.IndexedDB.Schema.Index.MultiEntry",
                         multi_entry);
@@ skipping 29 matching lines @@
 
 void IndexedDBDatabase::CreateIndexAbortOperation(
     int64_t object_store_id,
     int64_t index_id,
     IndexedDBTransaction* transaction) {
   DCHECK(!transaction);
   IDB_TRACE("IndexedDBDatabase::CreateIndexAbortOperation");
   RemoveIndex(object_store_id, index_id);
 }
 
-void IndexedDBDatabase::DeleteIndex(int64_t transaction_id,
+void IndexedDBDatabase::DeleteIndex(IndexedDBTransaction* transaction,
                                     int64_t object_store_id,
                                     int64_t index_id) {
-  IDB_TRACE1("IndexedDBDatabase::DeleteIndex", "txn.id", transaction_id);
-  IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
+  IDB_TRACE1("IndexedDBDatabase::DeleteIndex", "txn.id", transaction->id());
   DCHECK_EQ(transaction->mode(), blink::WebIDBTransactionModeVersionChange);
 
   if (!ValidateObjectStoreIdAndIndexId(object_store_id, index_id))
     return;
 
   transaction->ScheduleTask(
       base::Bind(&IndexedDBDatabase::DeleteIndexOperation,
                  this,
                  object_store_id,
                  index_id));
@@ skipping 36 matching lines @@
 
 void IndexedDBDatabase::DeleteIndexAbortOperation(
     int64_t object_store_id,
     const IndexedDBIndexMetadata& index_metadata,
     IndexedDBTransaction* transaction) {
   DCHECK(!transaction);
   IDB_TRACE("IndexedDBDatabase::DeleteIndexAbortOperation");
   AddIndex(object_store_id, index_metadata, IndexedDBIndexMetadata::kInvalidId);
 }
 
-void IndexedDBDatabase::RenameIndex(int64_t transaction_id,
+void IndexedDBDatabase::RenameIndex(IndexedDBTransaction* transaction,
                                     int64_t object_store_id,
                                     int64_t index_id,
                                     const base::string16& new_name) {
-  IDB_TRACE1("IndexedDBDatabase::RenameIndex", "txn.id", transaction_id);
-  IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
+  IDB_TRACE1("IndexedDBDatabase::RenameIndex", "txn.id", transaction->id());
   DCHECK_EQ(transaction->mode(), blink::WebIDBTransactionModeVersionChange);
 
   if (!ValidateObjectStoreIdAndIndexId(object_store_id, index_id))
     return;
 
   // Index renaming is done synchronously since preemptive
   // OpenCursor/SetIndexKeys may follow.
 
   const IndexedDBIndexMetadata index_metadata =
       metadata_.object_stores[object_store_id].indexes[index_id];
@@ skipping 26 matching lines @@
 void IndexedDBDatabase::RenameIndexAbortOperation(
     int64_t object_store_id,
     int64_t index_id,
     const base::string16& old_name,
     IndexedDBTransaction* transaction) {
   DCHECK(!transaction);
   IDB_TRACE("IndexedDBDatabase::RenameIndexAbortOperation");
   SetIndexName(object_store_id, index_id, old_name);
 }
 
-void IndexedDBDatabase::Commit(int64_t transaction_id) {
+void IndexedDBDatabase::Commit(IndexedDBTransaction* transaction) {
   // The frontend suggests that we commit, but we may have previously initiated
   // an abort, and so have disposed of the transaction. on_abort has already
   // been dispatched to the frontend, so it will find out about that
   // asynchronously.
-  IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (transaction) {
     scoped_refptr<IndexedDBFactory> factory = factory_;
     leveldb::Status s = transaction->Commit();
     if (s.IsCorruption()) {
       IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                    "Internal error committing transaction.");
       factory->HandleBackingStoreCorruption(identifier_.first, error);
     }
   }
 }
 
-void IndexedDBDatabase::Abort(int64_t transaction_id) {
-  // If the transaction is unknown, then it has already been aborted by the
-  // backend before this call so it is safe to ignore it.
-  IDB_TRACE1("IndexedDBDatabase::Abort", "txn.id", transaction_id);
-  IndexedDBTransaction* transaction = GetTransaction(transaction_id);
-  if (transaction)
-    transaction->Abort();
-}
-
-void IndexedDBDatabase::Abort(int64_t transaction_id,
-                              const IndexedDBDatabaseError& error) {
-  IDB_TRACE1("IndexedDBDatabase::Abort(error)", "txn.id", transaction_id);
-  // If the transaction is unknown, then it has already been aborted by the
-  // backend before this call so it is safe to ignore it.
-  IndexedDBTransaction* transaction = GetTransaction(transaction_id);
-  if (transaction)
-    transaction->Abort(error);
-}
-
 void IndexedDBDatabase::AddPendingObserver(
-    int64_t transaction_id,
+    IndexedDBTransaction* transaction,
     int32_t observer_id,
     const IndexedDBObserver::Options& options) {
-  IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
   transaction->AddPendingObserver(observer_id, options);
 }
 
-void IndexedDBDatabase::RemovePendingObservers(
-    IndexedDBConnection* connection,
-    const std::vector<int32_t>& pending_observer_ids) {
-  for (const auto& it : transactions_) {
-    // Avoid call to RemovePendingObservers for transactions on other
-    // connections.
-    if (it.second->connection() == connection)
-      it.second->RemovePendingObservers(pending_observer_ids);
-  }
-}
-
 // TODO(palakj): Augment the function with IDBValue later. Issue
 // crbug.com/609934.
 void IndexedDBDatabase::FilterObservation(IndexedDBTransaction* transaction,
                                           int64_t object_store_id,
                                           blink::WebIDBOperationType type,
                                           const IndexedDBKeyRange& key_range) {
   for (auto* connection : connections_) {
     bool recorded = false;
     for (const auto& observer : connection->active_observers()) {
       if (!observer->IsRecordingType(type) ||
@@ skipping 19 matching lines @@
 
 void IndexedDBDatabase::SendObservations(
     std::map<int32_t, std::unique_ptr<IndexedDBObserverChanges>> changes_map) {
   for (auto* conn : connections_) {
     auto it = changes_map.find(conn->id());
     if (it != changes_map.end())
       conn->callbacks()->OnDatabaseChange(std::move(it->second));
   }
 }
 
-void IndexedDBDatabase::GetAll(int64_t transaction_id,
+void IndexedDBDatabase::GetAll(IndexedDBTransaction* transaction,
                                int64_t object_store_id,
                                int64_t index_id,
                                std::unique_ptr<IndexedDBKeyRange> key_range,
                                bool key_only,
                                int64_t max_count,
                                scoped_refptr<IndexedDBCallbacks> callbacks) {
-  IDB_TRACE1("IndexedDBDatabase::GetAll", "txn.id", transaction_id);
-  IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
+  IDB_TRACE1("IndexedDBDatabase::GetAll", "txn.id", transaction->id());
 
   if (!ValidateObjectStoreId(object_store_id))
     return;
 
   transaction->ScheduleTask(base::Bind(
       &IndexedDBDatabase::GetAllOperation, this, object_store_id, index_id,
       base::Passed(&key_range),
       key_only ? indexed_db::CURSOR_KEY_ONLY : indexed_db::CURSOR_KEY_AND_VALUE,
       max_count, callbacks));
 }
 
-void IndexedDBDatabase::Get(int64_t transaction_id,
+void IndexedDBDatabase::Get(IndexedDBTransaction* transaction,
                             int64_t object_store_id,
                             int64_t index_id,
                             std::unique_ptr<IndexedDBKeyRange> key_range,
                             bool key_only,
                             scoped_refptr<IndexedDBCallbacks> callbacks) {
-  IDB_TRACE1("IndexedDBDatabase::Get", "txn.id", transaction_id);
-  IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
+  IDB_TRACE1("IndexedDBDatabase::Get", "txn.id", transaction->id());
 
   if (!ValidateObjectStoreIdAndOptionalIndexId(object_store_id, index_id))
     return;
 
   transaction->ScheduleTask(base::Bind(
       &IndexedDBDatabase::GetOperation, this, object_store_id, index_id,
       base::Passed(&key_range),
       key_only ? indexed_db::CURSOR_KEY_ONLY : indexed_db::CURSOR_KEY_AND_VALUE,
       callbacks));
 }
@@ skipping 340 matching lines @@
   std::unique_ptr<IndexedDBKey> key;
   blink::WebIDBPutMode put_mode;
   scoped_refptr<IndexedDBCallbacks> callbacks;
   std::vector<IndexKeys> index_keys;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PutOperationParams);
 };
 
 void IndexedDBDatabase::Put(
-    int64_t transaction_id,
+    IndexedDBTransaction* transaction,
     int64_t object_store_id,
     IndexedDBValue* value,
     std::vector<std::unique_ptr<storage::BlobDataHandle>>* handles,
     std::unique_ptr<IndexedDBKey> key,
     blink::WebIDBPutMode put_mode,
     scoped_refptr<IndexedDBCallbacks> callbacks,
     const std::vector<IndexKeys>& index_keys) {
-  IDB_TRACE1("IndexedDBDatabase::Put", "txn.id", transaction_id);
-  IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
+  IDB_TRACE1("IndexedDBDatabase::Put", "txn.id", transaction->id());
   DCHECK_NE(transaction->mode(), blink::WebIDBTransactionModeReadOnly);
 
   if (!ValidateObjectStoreId(object_store_id))
     return;
 
   DCHECK(key);
   DCHECK(value);
   std::unique_ptr<PutOperationParams> params(
       base::MakeUnique<PutOperationParams>());
   params->object_store_id = object_store_id;
@@ skipping 143 matching lines @@
                transaction->id());
     params->callbacks->OnSuccess(*key);
   }
   FilterObservation(transaction, params->object_store_id,
                     params->put_mode == blink::WebIDBPutModeAddOnly
                         ? blink::WebIDBAdd
                         : blink::WebIDBPut,
                     IndexedDBKeyRange(*key));
 }
 
-void IndexedDBDatabase::SetIndexKeys(int64_t transaction_id,
+void IndexedDBDatabase::SetIndexKeys(IndexedDBTransaction* transaction,
                                      int64_t object_store_id,
                                      std::unique_ptr<IndexedDBKey> primary_key,
                                      const std::vector<IndexKeys>& index_keys) {
-  IDB_TRACE1("IndexedDBDatabase::SetIndexKeys", "txn.id", transaction_id);
-  IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
+  IDB_TRACE1("IndexedDBDatabase::SetIndexKeys", "txn.id", transaction->id());
   DCHECK_EQ(transaction->mode(), blink::WebIDBTransactionModeVersionChange);
 
   // TODO(alecflett): This method could be asynchronous, but we need to
   // evaluate if it's worth the extra complexity.
   IndexedDBBackingStore::RecordIdentifier record_identifier;
   bool found = false;
   leveldb::Status s = backing_store_->KeyExistsInObjectStore(
       transaction->BackingStoreTransaction(),
       metadata_.id,
       object_store_id,
@@ skipping 44 matching lines @@
     return;
   }
 
   for (const auto& writer : index_writers) {
     writer->WriteIndexKeys(record_identifier, backing_store_.get(),
                            transaction->BackingStoreTransaction(), id(),
                            object_store_id);
   }
 }
 
-void IndexedDBDatabase::SetIndexesReady(int64_t transaction_id,
+void IndexedDBDatabase::SetIndexesReady(IndexedDBTransaction* transaction,
                                         int64_t,
                                         const std::vector<int64_t>& index_ids) {
-  IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
   DCHECK_EQ(transaction->mode(), blink::WebIDBTransactionModeVersionChange);
 
   transaction->ScheduleTask(
       blink::WebIDBTaskTypePreemptive,
       base::Bind(&IndexedDBDatabase::SetIndexesReadyOperation,
                  this,
                  index_ids.size()));
 }
@@ skipping 13 matching lines @@
   blink::WebIDBCursorDirection direction;
   indexed_db::CursorType cursor_type;
   blink::WebIDBTaskType task_type;
   scoped_refptr<IndexedDBCallbacks> callbacks;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(OpenCursorOperationParams);
 };
 
 void IndexedDBDatabase::OpenCursor(
-    int64_t transaction_id,
+    IndexedDBTransaction* transaction,
     int64_t object_store_id,
     int64_t index_id,
     std::unique_ptr<IndexedDBKeyRange> key_range,
     blink::WebIDBCursorDirection direction,
     bool key_only,
     blink::WebIDBTaskType task_type,
     scoped_refptr<IndexedDBCallbacks> callbacks) {
-  IDB_TRACE1("IndexedDBDatabase::OpenCursor", "txn.id", transaction_id);
-  IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
+  IDB_TRACE1("IndexedDBDatabase::OpenCursor", "txn.id", transaction->id());
 
   if (!ValidateObjectStoreIdAndOptionalIndexId(object_store_id, index_id))
     return;
 
   std::unique_ptr<OpenCursorOperationParams> params(
       base::MakeUnique<OpenCursorOperationParams>());
   params->object_store_id = object_store_id;
   params->index_id = index_id;
   params->key_range = std::move(key_range);
   params->direction = direction;
@@ skipping 70 matching lines @@
       factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
     }
   }
 
   if (!backing_store_cursor) {
     // Why is Success being called?
     params->callbacks->OnSuccess(nullptr);
     return;
   }
 
-  scoped_refptr<IndexedDBCursor> cursor =
-      new IndexedDBCursor(std::move(backing_store_cursor), params->cursor_type,
-                          params->task_type, transaction);
-  params->callbacks->OnSuccess(
-      cursor, cursor->key(), cursor->primary_key(), cursor->Value());
+  std::unique_ptr<IndexedDBCursor> cursor = base::MakeUnique<IndexedDBCursor>(
+      std::move(backing_store_cursor), params->cursor_type, params->task_type,
+      transaction);
+  IndexedDBCursor* cursor_ptr = cursor.get();
+  transaction->RegisterOpenCursor(cursor_ptr);
+  params->callbacks->OnSuccess(std::move(cursor), cursor_ptr->key(),
+                               cursor_ptr->primary_key(), cursor_ptr->Value());
 }
 
-void IndexedDBDatabase::Count(int64_t transaction_id,
+void IndexedDBDatabase::Count(IndexedDBTransaction* transaction,
                               int64_t object_store_id,
                               int64_t index_id,
                               std::unique_ptr<IndexedDBKeyRange> key_range,
                               scoped_refptr<IndexedDBCallbacks> callbacks) {
-  IDB_TRACE1("IndexedDBDatabase::Count", "txn.id", transaction_id);
-  IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
+  IDB_TRACE1("IndexedDBDatabase::Count", "txn.id", transaction->id());
 
   if (!ValidateObjectStoreIdAndOptionalIndexId(object_store_id, index_id))
     return;
 
   transaction->ScheduleTask(base::Bind(&IndexedDBDatabase::CountOperation,
                                        this,
                                        object_store_id,
                                        index_id,
                                        base::Passed(&key_range),
                                        callbacks));
@@ skipping 44 matching lines @@
   do {
     ++count;
   } while (backing_store_cursor->Continue(&s));
 
   // TODO(cmumford): Check for database corruption.
 
   callbacks->OnSuccess(count);
 }
 
 void IndexedDBDatabase::DeleteRange(
-    int64_t transaction_id,
+    IndexedDBTransaction* transaction,
     int64_t object_store_id,
     std::unique_ptr<IndexedDBKeyRange> key_range,
     scoped_refptr<IndexedDBCallbacks> callbacks) {
-  IDB_TRACE1("IndexedDBDatabase::DeleteRange", "txn.id", transaction_id);
-  IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
+  IDB_TRACE1("IndexedDBDatabase::DeleteRange", "txn.id", transaction->id());
   DCHECK_NE(transaction->mode(), blink::WebIDBTransactionModeReadOnly);
 
   if (!ValidateObjectStoreId(object_store_id))
     return;
 
   transaction->ScheduleTask(base::Bind(&IndexedDBDatabase::DeleteRangeOperation,
                                        this,
                                        object_store_id,
                                        base::Passed(&key_range),
                                        callbacks));
@@ skipping 19 matching lines @@
     if (s.IsCorruption()) {
       factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
     }
     return;
   }
   callbacks->OnSuccess();
   FilterObservation(transaction, object_store_id, blink::WebIDBDelete,
                     *key_range);
 }
 
-void IndexedDBDatabase::Clear(int64_t transaction_id,
+void IndexedDBDatabase::Clear(IndexedDBTransaction* transaction,
                               int64_t object_store_id,
                               scoped_refptr<IndexedDBCallbacks> callbacks) {
-  IDB_TRACE1("IndexedDBDatabase::Clear", "txn.id", transaction_id);
-  IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
+  IDB_TRACE1("IndexedDBDatabase::Clear", "txn.id", transaction->id());
   DCHECK_NE(transaction->mode(), blink::WebIDBTransactionModeReadOnly);
 
   if (!ValidateObjectStoreId(object_store_id))
     return;
 
   transaction->ScheduleTask(base::Bind(
       &IndexedDBDatabase::ClearOperation, this, object_store_id, callbacks));
 }
 
 void IndexedDBDatabase::ClearOperation(
@@ skipping 69 matching lines @@
     callbacks->OnError(error);
     transaction->Abort(error);
     return;
   }
 
   transaction->ScheduleAbortTask(
       base::Bind(&IndexedDBDatabase::VersionChangeAbortOperation, this,
                  metadata_.version));
   metadata_.version = version;
 
-  active_request_->UpgradeTransactionStarted(old_version);
+  active_request_->UpgradeTransactionStarted(old_version, transaction);
 }
 
 void IndexedDBDatabase::TransactionFinished(IndexedDBTransaction* transaction,
                                             bool committed) {
-  IDB_TRACE1("IndexedDBTransaction::TransactionFinished", "txn.id", id());
-  DCHECK(transactions_.find(transaction->id()) != transactions_.end());
-  DCHECK_EQ(transactions_[transaction->id()], transaction);
-  transactions_.erase(transaction->id());
+  IDB_TRACE1("IndexedDBTransaction::TransactionFinished", "txn.id",
+             transaction->id());
+  --transaction_count_;
+  DCHECK_LE(0, transaction_count_);
 
   // This may be an unrelated transaction finishing while waiting for
   // connections to close, or the actual upgrade transaction from an active
   // request. Notify the active request if it's the latter.
   if (active_request_ &&
       transaction->mode() == blink::WebIDBTransactionModeVersionChange) {
     active_request_->UpgradeTransactionFinished(committed);
   }
 }
 
@@ skipping 42 matching lines @@
   } while (!active_request_ && !pending_requests_.empty());
 }
 
 IndexedDBTransaction* IndexedDBDatabase::CreateTransaction(
     int64_t transaction_id,
     IndexedDBConnection* connection,
     const std::vector<int64_t>& object_store_ids,
     blink::WebIDBTransactionMode mode) {
   IDB_TRACE1("IndexedDBDatabase::CreateTransaction", "txn.id", transaction_id);
   DCHECK(connections_.count(connection));
-  DCHECK(transactions_.find(transaction_id) == transactions_.end());
-  if (transactions_.find(transaction_id) != transactions_.end())
-    return nullptr;
 
   UMA_HISTOGRAM_COUNTS_1000(
       "WebCore.IndexedDB.Database.OutstandingTransactionCount",
-      transactions_.size());
+      transaction_count_);
 
-  // The transaction will add itself to this database's coordinator, which
-  // manages the lifetime of the object.
-  IndexedDBTransaction* transaction =
-      IndexedDBClassFactory::Get()->CreateIndexedDBTransaction(
-          transaction_id, connection->GetWeakPtr(),
-          std::set<int64_t>(object_store_ids.begin(), object_store_ids.end()),
-          mode, new IndexedDBBackingStore::Transaction(backing_store_.get()));
+  IndexedDBTransaction* transaction = connection->CreateTransaction(
+      transaction_id,
+      std::set<int64_t>(object_store_ids.begin(), object_store_ids.end()), mode,
+      new IndexedDBBackingStore::Transaction(backing_store_.get()));
   TransactionCreated(transaction);
   return transaction;
 }
 
 void IndexedDBDatabase::TransactionCreated(IndexedDBTransaction* transaction) {
-  transactions_[transaction->id()] = transaction;
+  transaction_count_++;
+  transaction_coordinator_.DidCreateTransaction(transaction);
 }
 
 void IndexedDBDatabase::OpenConnection(
     std::unique_ptr<IndexedDBPendingConnection> connection) {
   AppendRequest(base::MakeUnique<OpenRequest>(this, std::move(connection)));
 }
 
 void IndexedDBDatabase::DeleteDatabase(
     scoped_refptr<IndexedDBCallbacks> callbacks) {
   AppendRequest(base::MakeUnique<DeleteRequest>(this, callbacks));
@@ skipping 19 matching lines @@
   DCHECK(connections_.count(connection));
   DCHECK(connection->IsConnected());
   DCHECK(connection->database() == this);
 
   IDB_TRACE("IndexedDBDatabase::Close");
 
   // Abort outstanding transactions from the closing connection. This can not
   // happen if the close is requested by the connection itself as the
   // front-end defers the close until all transactions are complete, but can
   // occur on process termination or forced close.
-  {
-    auto transactions(transactions_);
-    for (const auto& it : transactions) {
-      if (it.second->callbacks() == connection->callbacks())
-        it.second->Abort(
-            IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionUnknownError,
-                                   "Connection is closing."));
-    }
-  }
+  connection->AbortAllTransactions(IndexedDBDatabaseError(
+      blink::WebIDBDatabaseExceptionUnknownError, "Connection is closing."));
 
   // Abort transactions before removing the connection; aborting may complete
   // an upgrade, and thus allow the next open/delete requests to proceed. The
   // new active_request_ should see the old connection count until explicitly
   // notified below.
   connections_.erase(connection);
 
   // Notify the active request, which may need to do cleanup or proceed with
   // the operation. This may trigger other work, such as more connections or
   // deletions, so |active_request_| itself may change.
   if (active_request_)
     active_request_->OnConnectionClosed(connection);
 
   // If there are no more connections (current, active, or pending), tell the
   // factory to clean us up.
   if (connections_.empty() && !active_request_ && pending_requests_.empty()) {
-    DCHECK(transactions_.empty());
     backing_store_ = nullptr;
     factory_->ReleaseDatabase(identifier_, forced);
   }
 }
 
 void IndexedDBDatabase::CreateObjectStoreAbortOperation(
     int64_t object_store_id,
     IndexedDBTransaction* transaction) {
   DCHECK(!transaction);
   IDB_TRACE("IndexedDBDatabase::CreateObjectStoreAbortOperation");
@@ skipping 20 matching lines @@
 
 void IndexedDBDatabase::VersionChangeAbortOperation(
     int64_t previous_version,
     IndexedDBTransaction* transaction) {
   DCHECK(!transaction);
   IDB_TRACE("IndexedDBDatabase::VersionChangeAbortOperation");
   metadata_.version = previous_version;
 }
 
 }  // namespace content