[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 52 matching lines @@
       return KEY_PATH_TYPE_NONE;
     case blink::WebIDBKeyPathTypeString:
       return KEY_PATH_TYPE_STRING;
     case blink::WebIDBKeyPathTypeArray:
       return KEY_PATH_TYPE_ARRAY;
   }
   NOTREACHED();
   return KEY_PATH_TYPE_NONE;
 }
 
+// The database will be closed (IndexedDBFactory::ForceClose) during this call.
+// This should NOT be used in an method scheduled as a transaction operation.
+void ReportError(leveldb::Status status,
+                 const url::Origin& origin,
+                 IndexedDBFactory* factory,
+                 const IndexedDBDatabaseError& error) {
+  DCHECK(!status.ok());
+  if (status.IsCorruption())
+    factory->HandleBackingStoreCorruption(origin, error);
+  else
+    factory->HandleBackingStoreFailure(origin);
+}
+
 }  // namespace
 
 // This represents what script calls an 'IDBOpenDBRequest' - either a database
 // open or delete call. These may be blocked on other connections. After every
 // callback, the request must call IndexedDBDatabase::RequestComplete() or be
 // expecting a further callback.
 class IndexedDBDatabase::ConnectionRequest {
  public:
   explicit ConnectionRequest(scoped_refptr<IndexedDBDatabase> db) : db_(db) {}
 
   virtual ~ConnectionRequest() {}
 
   // Called when the request makes it to the front of the queue.
   virtual void Perform() = 0;
 
   // 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 133 matching lines @@
         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);
 };
 
 std::tuple<scoped_refptr<IndexedDBDatabase>, leveldb::Status>
@@ skipping 100 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) {
   std::unique_ptr<IndexedDBConnection> connection(
-      base::MakeUnique<IndexedDBConnection>(this, database_callbacks));
+      base::MakeUnique<IndexedDBConnection>(child_process_id, 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 14 matching lines @@
                                         transaction->database()->id(),
                                         object_store_metadata.id,
                                         object_store_metadata.name,
                                         object_store_metadata.key_path,
                                         object_store_metadata.auto_increment);
   if (!s.ok()) {
     IndexedDBDatabaseError error(
         blink::WebIDBDatabaseExceptionUnknownError,
         ASCIIToUTF16("Internal error creating object store '") +
             object_store_metadata.name + ASCIIToUTF16("'."));
-    transaction->Abort(error);
-    if (s.IsCorruption())
-      factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
+    ReportError(s, origin(), factory_.get(), error);
     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];
 
   leveldb::Status s =
       backing_store_->RenameObjectStore(transaction->BackingStoreTransaction(),
                                         transaction->database()->id(),
                                         object_store_metadata.id, new_name);
   if (!s.ok()) {
     IndexedDBDatabaseError error(
         blink::WebIDBDatabaseExceptionUnknownError,
         ASCIIToUTF16("Internal error renaming object store '") +
             object_store_metadata.name + ASCIIToUTF16("' to '") + new_name +
             ASCIIToUTF16("'."));
-    transaction->Abort(error);
-    if (s.IsCorruption())
-      factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
+    ReportError(s, origin(), factory_.get(), error);
     return;
   }
 
   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 26 matching lines @@
                  object_store_id,
                  index_id));
 }
 
 void IndexedDBDatabase::CreateIndexAbortOperation(int64_t object_store_id,
                                                   int64_t index_id) {
   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));
 }
 
 leveldb::Status IndexedDBDatabase::DeleteIndexOperation(
     int64_t object_store_id,
     int64_t index_id,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1(
       "IndexedDBDatabase::DeleteIndexOperation", "txn.id", transaction->id());
 
   const IndexedDBIndexMetadata index_metadata =
       metadata_.object_stores[object_store_id].indexes[index_id];
 
   leveldb::Status s =
       backing_store_->DeleteIndex(transaction->BackingStoreTransaction(),
                                   transaction->database()->id(),
                                   object_store_id,
                                   index_id);
-  if (!s.ok()) {
-    base::string16 error_string =
-        ASCIIToUTF16("Internal error deleting index '") +
-        index_metadata.name + ASCIIToUTF16("'.");
-    IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
-                                 error_string);
-    transaction->Abort(error);
+  if (!s.ok())
     return s;
-  }
 
   RemoveIndex(object_store_id, index_id);
   transaction->ScheduleAbortTask(
       base::Bind(&IndexedDBDatabase::DeleteIndexAbortOperation,
                  this,
                  object_store_id,
                  index_metadata));
   return s;
 }
 
 void IndexedDBDatabase::DeleteIndexAbortOperation(
     int64_t object_store_id,
     const IndexedDBIndexMetadata& index_metadata) {
   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];
 
   leveldb::Status s =
       backing_store_->RenameIndex(transaction->BackingStoreTransaction(),
                                   transaction->database()->id(),
                                   object_store_id,
                                   index_id,
                                   new_name);
   if (!s.ok()) {
     base::string16 error_string =
         ASCIIToUTF16("Internal error renaming index '") +
         index_metadata.name + ASCIIToUTF16("' to '") + new_name +
         ASCIIToUTF16("'.");
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  error_string);
-    transaction->Abort(error);
-    if (s.IsCorruption())
-      factory_->HandleBackingStoreCorruption(origin(), error);
-    else
-      factory_->HandleBackingStoreFailure(origin());
+    ReportError(s, origin(), factory_.get(), error);
     return;
   }
 
   transaction->ScheduleAbortTask(
       base::Bind(&IndexedDBDatabase::RenameIndexAbortOperation,
                  this,
                  object_store_id,
                  index_id,
                  index_metadata.name));
   SetIndexName(object_store_id, index_id, new_name);
 }
 
 void IndexedDBDatabase::RenameIndexAbortOperation(
     int64_t object_store_id,
     int64_t index_id,
     const base::string16& old_name) {
   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 result = transaction->Commit();
     if (!result.ok()) {
-      if (result.IsCorruption()) {
-        IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
-                                     base::ASCIIToUTF16(result.ToString()));
-        factory->HandleBackingStoreCorruption(origin(), error);
-      } else {
-        factory->HandleBackingStoreFailure(origin());
-      }
+      IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
+                                   base::ASCIIToUTF16(result.ToString()));
+      ReportError(result, origin(), factory_.get(), 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);

[cmumford, 2016/12/01 19:14:51]

It looks like callers (like IDBThreadHelper) already check for a null
transaction. Should we define a contract and either delete those other checks,
or turn these into DCHECK's?

[dmurph, 2016/12/01 21:12:23]

I'll do DCHECKs everywhere. It's a safe assumption that a pointer is not null.

   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 16 matching lines @@
 
 void IndexedDBDatabase::SendObservations(
     std::map<int32_t, ::indexed_db::mojom::ObserverChangesPtr> 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 45 matching lines @@
       backing_store_cursor = backing_store_->OpenIndexCursor(
           transaction->BackingStoreTransaction(),
           id(),
           object_store_id,
           index_id,
           *key_range,
           blink::WebIDBCursorDirectionNext,
           &s);
     }
 
-    if (!s.ok()) {
-      DLOG(ERROR) << "Unable to open cursor operation: " << s.ToString();
-      IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
-                                   "Internal error deleting data in range");
-      callbacks->OnError(error);
+    if (!s.ok())
       return s;
-    }
 
     if (!backing_store_cursor) {
       // This means we've run out of data.
       callbacks->OnSuccess();
       return s;
     }
 
     key = &backing_store_cursor->key();
   }
 
   std::unique_ptr<IndexedDBKey> primary_key;
   if (index_id == IndexedDBIndexMetadata::kInvalidId) {
     // Object Store Retrieval Operation
     IndexedDBReturnValue value;
     s = backing_store_->GetRecord(transaction->BackingStoreTransaction(),
                                   id(),
                                   object_store_id,
                                   *key,
                                   &value);
-    if (!s.ok()) {
-      IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
-                                   "Internal error in GetRecord.");
-      callbacks->OnError(error);
+    if (!s.ok())
       return s;
-    }
 
     if (value.empty()) {
       callbacks->OnSuccess();
       return s;
     }
 
     if (cursor_type == indexed_db::CURSOR_KEY_ONLY) {
       callbacks->OnSuccess(*key);
       return s;
     }
 
     if (object_store_metadata.auto_increment &&
         !object_store_metadata.key_path.IsNull()) {
       value.primary_key = *key;
       value.key_path = object_store_metadata.key_path;
     }
 
     callbacks->OnSuccess(&value);
     return s;
   }
 
   // From here we are dealing only with indexes.
   s = backing_store_->GetPrimaryKeyViaIndex(
       transaction->BackingStoreTransaction(),
       id(),
       object_store_id,
       index_id,
       *key,
       &primary_key);
-  if (!s.ok()) {
-    IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
-                                 "Internal error in GetPrimaryKeyViaIndex.");
-    callbacks->OnError(error);
+  if (!s.ok())
     return s;
-  }
+
   if (!primary_key) {
     callbacks->OnSuccess();
     return s;
   }
   if (cursor_type == indexed_db::CURSOR_KEY_ONLY) {
     // Index Value Retrieval Operation
     callbacks->OnSuccess(*primary_key);
     return s;
   }
 
   // Index Referenced Value Retrieval Operation
   IndexedDBReturnValue value;
   s = backing_store_->GetRecord(transaction->BackingStoreTransaction(),
                                 id(),
                                 object_store_id,
                                 *primary_key,
                                 &value);
-  if (!s.ok()) {
-    IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
-                                 "Internal error in GetRecord.");
-    callbacks->OnError(error);
+  if (!s.ok())
     return s;
-  }
 
   if (value.empty()) {
     callbacks->OnSuccess();
     return s;
   }
   if (object_store_metadata.auto_increment &&
       !object_store_metadata.key_path.IsNull()) {
     value.primary_key = *primary_key;
     value.key_path = object_store_metadata.key_path;
   }
@@ skipping 45 matching lines @@
     } else {
       // Object Store: Referenced Value Retrieval Operation
       cursor = backing_store_->OpenIndexCursor(
           transaction->BackingStoreTransaction(), id(), object_store_id,
           index_id, *key_range, blink::WebIDBCursorDirectionNext, &s);
     }
   }
 
   if (!s.ok()) {
     DLOG(ERROR) << "Unable to open cursor operation: " << s.ToString();
-    IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
-                                 "Internal error in GetAllOperation");
-    callbacks->OnError(error);
     return s;
   }
 
   std::vector<IndexedDBKey> found_keys;
   std::vector<IndexedDBReturnValue> found_values;
   if (!cursor) {
     // Doesn't matter if key or value array here - will be empty array when it
     // hits JavaScript.
     callbacks->OnSuccessArray(&found_values);
     return s;
   }
 
   bool did_first_seek = false;
   bool generated_key = object_store_metadata.auto_increment &&
                        !object_store_metadata.key_path.IsNull();
 
   size_t response_size = kMaxIDBMessageOverhead;
   int64_t num_found_items = 0;
   while (num_found_items++ < max_count) {
     bool cursor_valid;
     if (did_first_seek) {
       cursor_valid = cursor->Continue(&s);
     } else {
       cursor_valid = cursor->FirstSeek(&s);
       did_first_seek = true;
     }
-    if (!s.ok()) {
-      IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
-                                   "Internal error in GetAllOperation.");
-      callbacks->OnError(error);
+    if (!s.ok())
       return s;
-    }
 
     if (!cursor_valid)
       break;
 
     IndexedDBReturnValue return_value;
     IndexedDBKey return_key;
 
     if (cursor_type == indexed_db::CURSOR_KEY_ONLY) {
       return_key = cursor->primary_key();
     } else {
@@ skipping 75 matching lines @@
   std::unique_ptr<IndexedDBKey> key;
   blink::WebIDBPutMode put_mode;
   scoped_refptr<IndexedDBCallbacks> callbacks;
   std::vector<IndexedDBIndexKeys> 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<IndexedDBIndexKeys>& 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 43 matching lines @@
   IndexedDBBackingStore::RecordIdentifier record_identifier;
   if (params->put_mode == blink::WebIDBPutModeAddOnly) {
     bool found = false;
     leveldb::Status s = backing_store_->KeyExistsInObjectStore(
         transaction->BackingStoreTransaction(),
         id(),
         params->object_store_id,
         *key,
         &record_identifier,
         &found);
-    if (!s.ok()) {
-      IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
-                                   "Internal error checking key existence.");
-      params->callbacks->OnError(error);
+    if (!s.ok())
       return s;
-    }
     if (found) {
       params->callbacks->OnError(
           IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionConstraintError,
                                  "Key already exists in the object store."));
       return s;
     }
   }
 
   std::vector<std::unique_ptr<IndexWriter>> index_writers;
   base::string16 error_message;
@@ skipping 18 matching lines @@
     params->callbacks->OnError(IndexedDBDatabaseError(
         blink::WebIDBDatabaseExceptionConstraintError, error_message));
     return s;
   }
 
   // Before this point, don't do any mutation. After this point, rollback the
   // transaction in case of error.
   s = backing_store_->PutRecord(transaction->BackingStoreTransaction(), id(),
                                 params->object_store_id, *key, &params->value,
                                 &params->handles, &record_identifier);
-  if (!s.ok()) {
-    IndexedDBDatabaseError error(
-        blink::WebIDBDatabaseExceptionUnknownError,
-        "Internal error: backing store error performing put/add.");
-    params->callbacks->OnError(error);
+  if (!s.ok())
     return s;
-  }
+
   {
     IDB_TRACE1("IndexedDBDatabase::PutOperation.UpdateIndexes", "txn.id",
                transaction->id());
     for (const auto& writer : index_writers) {
       writer->WriteIndexKeys(record_identifier, backing_store_.get(),
                              transaction->BackingStoreTransaction(), id(),
                              params->object_store_id);
     }
   }
 
   if (object_store.auto_increment &&
       params->put_mode != blink::WebIDBPutModeCursorUpdate &&
       key->type() == WebIDBKeyTypeNumber) {
     IDB_TRACE1("IndexedDBDatabase::PutOperation.AutoIncrement", "txn.id",
                transaction->id());
     s = UpdateKeyGenerator(backing_store_.get(), transaction, id(),
                            params->object_store_id, *key, !key_was_generated);
-    if (!s.ok()) {
-      IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
-                                   "Internal error updating key generator.");
-      params->callbacks->OnError(error);
+    if (!s.ok())
       return s;
-    }
   }
   {
     IDB_TRACE1("IndexedDBDatabase::PutOperation.Callbacks", "txn.id",
                transaction->id());
     params->callbacks->OnSuccess(*key);
   }
   FilterObservation(transaction, params->object_store_id,
                     params->put_mode == blink::WebIDBPutModeAddOnly
                         ? blink::WebIDBAdd
                         : blink::WebIDBPut,
                     IndexedDBKeyRange(*key));
   return s;
 }
 
 void IndexedDBDatabase::SetIndexKeys(
-    int64_t transaction_id,
+    IndexedDBTransaction* transaction,
     int64_t object_store_id,
     std::unique_ptr<IndexedDBKey> primary_key,
     const std::vector<IndexedDBIndexKeys>& 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,
       *primary_key,
       &record_identifier,
       &found);
   if (!s.ok()) {
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  "Internal error setting index keys.");
-    transaction->Abort(error);
-    if (s.IsCorruption())
-      factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
+    ReportError(s, origin(), factory_.get(), error);

[cmumford, 2016/12/01 19:14:51]

Why can't we still use backing_store_->origin()?

All other calls to ReportError in this file also pass in the default origin.

[dmurph, 2016/12/01 21:12:23]

... aren't they the same? Which would you rather me use?

[cmumford, 2016/12/01 22:25:45]

If the other callers to ReportError have no origin, then I'm certainly OK with
passing in origin(), but at least this function should pass in
backing_store_->origin() - or are you saying that's also a default value?

     return;
   }
   if (!found) {
     transaction->Abort(IndexedDBDatabaseError(
         blink::WebIDBDatabaseExceptionUnknownError,
         "Internal error setting index keys for object store."));
     return;
   }
 
   std::vector<std::unique_ptr<IndexWriter>> index_writers;
@@ skipping 25 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 14 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 57 matching lines @@
           params->object_store_id,
           params->index_id,
           *params->key_range,
           params->direction,
           &s);
     }
   }
 
   if (!s.ok()) {
     DLOG(ERROR) << "Unable to open cursor operation: " << s.ToString();
-    IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
-                                 "Internal error opening cursor operation");
     return s;
   }
 
   if (!backing_store_cursor) {
     // Occurs when we've reached the end of cursor's data.
     params->callbacks->OnSuccess(nullptr);
     return s;
   }
 
-  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());
   return s;
 }
 
-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 23 matching lines @@
         transaction->BackingStoreTransaction(),
         id(),
         object_store_id,
         index_id,
         *key_range,
         blink::WebIDBCursorDirectionNext,
         &s);
   }
   if (!s.ok()) {
     DLOG(ERROR) << "Unable perform count operation: " << s.ToString();
-    IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
-                                 "Internal error performing count operation");
     return s;
   }
   if (!backing_store_cursor) {
     callbacks->OnSuccess(count);
     return s;
   }
 
   do {
     if (!s.ok())
       return s;
     ++count;
   } while (backing_store_cursor->Continue(&s));
 
   callbacks->OnSuccess(count);
   return s;
 }
 
 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));
 }
 
 leveldb::Status IndexedDBDatabase::DeleteRangeOperation(
     int64_t object_store_id,
     std::unique_ptr<IndexedDBKeyRange> key_range,
     scoped_refptr<IndexedDBCallbacks> callbacks,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1("IndexedDBDatabase::DeleteRangeOperation", "txn.id",
              transaction->id());
   size_t delete_count = 0;
   leveldb::Status s =
       backing_store_->DeleteRange(transaction->BackingStoreTransaction(), id(),
                                   object_store_id, *key_range, &delete_count);
-  if (!s.ok()) {
-    base::string16 error_string =
-        ASCIIToUTF16("Internal error deleting data in range");
-    IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
-                                 error_string);
-    transaction->Abort(error);
+  if (!s.ok())
     return s;
-  }
   callbacks->OnSuccess();
   FilterObservation(transaction, object_store_id, blink::WebIDBDelete,
                     *key_range);
   return s;
 }
 
-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));
 }
 
 leveldb::Status IndexedDBDatabase::ClearOperation(
     int64_t object_store_id,
     scoped_refptr<IndexedDBCallbacks> callbacks,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1("IndexedDBDatabase::ClearOperation", "txn.id", transaction->id());
   leveldb::Status s = backing_store_->ClearObjectStore(
       transaction->BackingStoreTransaction(), id(), object_store_id);
-  if (!s.ok()) {
-    IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
-                                 "Internal error clearing object store");
-    callbacks->OnError(error);
+  if (!s.ok())
     return s;
-  }
   callbacks->OnSuccess();
 
   FilterObservation(transaction, object_store_id, blink::WebIDBClear,
                     IndexedDBKeyRange());
   return s;
 }
 
 leveldb::Status IndexedDBDatabase::DeleteObjectStoreOperation(
     int64_t object_store_id,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1("IndexedDBDatabase::DeleteObjectStoreOperation",
              "txn.id",
              transaction->id());
 
   const IndexedDBObjectStoreMetadata object_store_metadata =
       metadata_.object_stores[object_store_id];
   leveldb::Status s =
       backing_store_->DeleteObjectStore(transaction->BackingStoreTransaction(),
                                         transaction->database()->id(),
                                         object_store_id);
-  if (!s.ok()) {
-    base::string16 error_string =
-        ASCIIToUTF16("Internal error deleting object store '") +
-        object_store_metadata.name + ASCIIToUTF16("'.");
-    IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
-                                 error_string);
-    transaction->Abort(error);
+  if (!s.ok())
     return s;
-  }
 
   RemoveObjectStore(object_store_id);
   transaction->ScheduleAbortTask(
       base::Bind(&IndexedDBDatabase::DeleteObjectStoreAbortOperation,
                  this,
                  object_store_metadata));
   return s;
 }
 
 leveldb::Status IndexedDBDatabase::VersionChangeOperation(
     int64_t version,
     scoped_refptr<IndexedDBCallbacks> callbacks,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1(
       "IndexedDBDatabase::VersionChangeOperation", "txn.id", transaction->id());
   int64_t old_version = metadata_.version;
   DCHECK_GT(version, old_version);
 
   backing_store_->UpdateIDBDatabaseIntVersion(
       transaction->BackingStoreTransaction(), id(), version);
 
   transaction->ScheduleAbortTask(
       base::Bind(&IndexedDBDatabase::VersionChangeAbortOperation, this,
                  metadata_.version));
   metadata_.version = version;
 
-  active_request_->UpgradeTransactionStarted(old_version);
+  active_request_->UpgradeTransactionStarted(old_version, transaction);
   return leveldb::Status::OK();
 }
 
 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_GE(transaction_count_, 0);
 
   // 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 32 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) {
   IDB_TRACE("IndexedDBDatabase::CreateObjectStoreAbortOperation");
   RemoveObjectStore(object_store_id);
 }
@@ skipping 11 matching lines @@
   IDB_TRACE("IndexedDBDatabase::RenameObjectStoreAbortOperation");
   SetObjectStoreName(object_store_id, old_name);
 }
 
 void IndexedDBDatabase::VersionChangeAbortOperation(int64_t previous_version) {
   IDB_TRACE("IndexedDBDatabase::VersionChangeAbortOperation");
   metadata_.version = previous_version;
 }
 
 }  // namespace content