webkitgtk-2.16.5HEADwebkitgtk-2.16.5master

1 files changed, 1233 insertions, 259 deletions

diff --git a/Source/WebCore/Modules/indexeddb/IDBTransaction.cpp b/Source/WebCore/Modules/indexeddb/IDBTransaction.cpp
index 5d2f3f875..1ee73d28d 100644
--- a/Source/WebCore/Modules/indexeddb/IDBTransaction.cpp
+++ b/Source/WebCore/Modules/indexeddb/IDBTransaction.cpp
@@ -1,26 +1,26 @@
 /*
- * Copyright (C) 2010 Google Inc. All rights reserved.
+ * Copyright (C) 2015, 2016 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
  *
- * 1.  Redistributions of source code must retain the above copyright
- *     notice, this list of conditions and the following disclaimer.
- * 2.  Redistributions in binary form must reproduce the above copyright
- *     notice, this list of conditions and the following disclaimer in the
- *     documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
@@ -28,404 +28,1378 @@
 
 #if ENABLE(INDEXED_DATABASE)
 
-#include "EventException.h"
+#include "DOMError.h"
+#include "DOMStringList.h"
+#include "DOMWindow.h"
+#include "Event.h"
+#include "EventNames.h"
 #include "EventQueue.h"
-#include "ExceptionCodePlaceholder.h"
+#include "IDBCursorWithValue.h"
 #include "IDBDatabase.h"
 #include "IDBDatabaseException.h"
+#include "IDBError.h"
 #include "IDBEventDispatcher.h"
+#include "IDBGetRecordData.h"
 #include "IDBIndex.h"
+#include "IDBIterateCursorData.h"
+#include "IDBKeyData.h"
+#include "IDBKeyRangeData.h"
 #include "IDBObjectStore.h"
 #include "IDBOpenDBRequest.h"
-#include "IDBPendingTransactionMonitor.h"
+#include "IDBRequest.h"
+#include "IDBResultData.h"
+#include "IDBValue.h"
+#include "JSDOMWindowBase.h"
 #include "Logging.h"
-#include "ScriptCallStack.h"
 #include "ScriptExecutionContext.h"
+#include "ScriptState.h"
+#include "SerializedScriptValue.h"
+#include "TransactionOperation.h"
+#include <wtf/NeverDestroyed.h>
+
+using namespace JSC;
 
 namespace WebCore {
 
-PassRefPtr<IDBTransaction> IDBTransaction::create(ScriptExecutionContext* context, int64_t id, const Vector<String>& objectStoreNames, IndexedDB::TransactionMode mode, IDBDatabase* db)
+Ref<IDBTransaction> IDBTransaction::create(IDBDatabase& database, const IDBTransactionInfo& info)
 {
-    IDBOpenDBRequest* openDBRequest = 0;
-    RefPtr<IDBTransaction> transaction(adoptRef(new IDBTransaction(context, id, objectStoreNames, mode, db, openDBRequest, IDBDatabaseMetadata())));
-    transaction->suspendIfNeeded();
-    return transaction.release();
+    return adoptRef(*new IDBTransaction(database, info, nullptr));
 }
 
-PassRefPtr<IDBTransaction> IDBTransaction::create(ScriptExecutionContext* context, int64_t id, IDBDatabase* db, IDBOpenDBRequest* openDBRequest, const IDBDatabaseMetadata& previousMetadata)
+Ref<IDBTransaction> IDBTransaction::create(IDBDatabase& database, const IDBTransactionInfo& info, IDBOpenDBRequest& request)
 {
-    RefPtr<IDBTransaction> transaction(adoptRef(new IDBTransaction(context, id, Vector<String>(), IndexedDB::TransactionMode::VersionChange, db, openDBRequest, previousMetadata)));
-    transaction->suspendIfNeeded();
-    return transaction.release();
+    return adoptRef(*new IDBTransaction(database, info, &request));
 }
 
-const AtomicString& IDBTransaction::modeReadOnly()
+IDBTransaction::IDBTransaction(IDBDatabase& database, const IDBTransactionInfo& info, IDBOpenDBRequest* request)
+    : IDBActiveDOMObject(database.scriptExecutionContext())
+    , m_database(database)
+    , m_info(info)
+    , m_pendingOperationTimer(*this, &IDBTransaction::pendingOperationTimerFired)
+    , m_completedOperationTimer(*this, &IDBTransaction::completedOperationTimerFired)
+    , m_openDBRequest(request)
+    , m_currentlyCompletingRequest(request)
+
 {
-    DEFINE_STATIC_LOCAL(AtomicString, readonly, ("readonly", AtomicString::ConstructFromLiteral));
-    return readonly;
+    LOG(IndexedDB, "IDBTransaction::IDBTransaction - %s", m_info.loggingString().utf8().data());
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    if (m_info.mode() == IDBTransactionMode::Versionchange) {
+        ASSERT(m_openDBRequest);
+        m_openDBRequest->setVersionChangeTransaction(*this);
+        m_startedOnServer = true;
+    } else {
+        activate();
+
+        auto* context = scriptExecutionContext();
+        ASSERT(context);
+
+        RefPtr<IDBTransaction> self;
+        JSC::VM& vm = context->vm();
+        vm.whenIdle([self, this]() {
+            deactivate();
+        });
+
+        establishOnServer();
+    }
+
+    suspendIfNeeded();
 }
 
-const AtomicString& IDBTransaction::modeReadWrite()
+IDBTransaction::~IDBTransaction()
 {
-    DEFINE_STATIC_LOCAL(AtomicString, readwrite, ("readwrite", AtomicString::ConstructFromLiteral));
-    return readwrite;
+    ASSERT(currentThread() == m_database->originThreadID());
 }
 
-const AtomicString& IDBTransaction::modeVersionChange()
+IDBClient::IDBConnectionProxy& IDBTransaction::connectionProxy()
 {
-    DEFINE_STATIC_LOCAL(AtomicString, versionchange, ("versionchange", AtomicString::ConstructFromLiteral));
-    return versionchange;
+    return m_database->connectionProxy();
 }
 
-const AtomicString& IDBTransaction::modeReadOnlyLegacy()
+Ref<DOMStringList> IDBTransaction::objectStoreNames() const
 {
-    DEFINE_STATIC_LOCAL(AtomicString, readonly, ("0", AtomicString::ConstructFromLiteral));
-    return readonly;
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    const Vector<String> names = isVersionChange() ? m_database->info().objectStoreNames() : m_info.objectStores();
+
+    Ref<DOMStringList> objectStoreNames = DOMStringList::create();
+    for (auto& name : names)
+        objectStoreNames->append(name);
+
+    objectStoreNames->sort();
+    return objectStoreNames;
 }
 
-const AtomicString& IDBTransaction::modeReadWriteLegacy()
+IDBDatabase* IDBTransaction::db()
 {
-    DEFINE_STATIC_LOCAL(AtomicString, readwrite, ("1", AtomicString::ConstructFromLiteral));
-    return readwrite;
+    ASSERT(currentThread() == m_database->originThreadID());
+    return m_database.ptr();
 }
 
+DOMError* IDBTransaction::error() const
+{
+    ASSERT(currentThread() == m_database->originThreadID());
+    return m_domError.get();
+}
 
-IDBTransaction::IDBTransaction(ScriptExecutionContext* context, int64_t id, const Vector<String>& objectStoreNames, IndexedDB::TransactionMode mode, IDBDatabase* db, IDBOpenDBRequest* openDBRequest, const IDBDatabaseMetadata& previousMetadata)
-    : ActiveDOMObject(context)
-    , m_id(id)
-    , m_database(db)
-    , m_objectStoreNames(objectStoreNames)
-    , m_openDBRequest(openDBRequest)
-    , m_mode(mode)
-    , m_state(Active)
-    , m_hasPendingActivity(true)
-    , m_contextStopped(false)
-    , m_previousMetadata(previousMetadata)
+ExceptionOr<Ref<IDBObjectStore>> IDBTransaction::objectStore(const String& objectStoreName)
 {
-    if (mode == IndexedDB::TransactionMode::VersionChange) {
-        // Not active until the callback.
-        m_state = Inactive;
+    LOG(IndexedDB, "IDBTransaction::objectStore");
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    if (!scriptExecutionContext())
+        return Exception { IDBDatabaseException::InvalidStateError };
+
+    if (isFinishedOrFinishing())
+        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'objectStore' on 'IDBTransaction': The transaction finished.") };
+
+    Locker<Lock> locker(m_referencedObjectStoreLock);
+
+    auto iterator = m_referencedObjectStores.find(objectStoreName);
+    if (iterator != m_referencedObjectStores.end())
+        return Ref<IDBObjectStore> { *iterator->value };
+
+    bool found = false;
+    for (auto& objectStore : m_info.objectStores()) {
+        if (objectStore == objectStoreName) {
+            found = true;
+            break;
+        }
     }
 
-    // We pass a reference of this object before it can be adopted.
-    relaxAdoptionRequirement();
-    if (m_state == Active)
-        IDBPendingTransactionMonitor::addNewTransaction(this);
-    m_database->transactionCreated(this);
+    auto* info = m_database->info().infoForExistingObjectStore(objectStoreName);
+    if (!info)
+        return Exception { IDBDatabaseException::NotFoundError, ASCIILiteral("Failed to execute 'objectStore' on 'IDBTransaction': The specified object store was not found.") };
+
+    // Version change transactions are scoped to every object store in the database.
+    if (!info || (!found && !isVersionChange()))
+        return Exception { IDBDatabaseException::NotFoundError, ASCIILiteral("Failed to execute 'objectStore' on 'IDBTransaction': The specified object store was not found.") };
+
+    auto objectStore = std::make_unique<IDBObjectStore>(*scriptExecutionContext(), *info, *this);
+    auto* rawObjectStore = objectStore.get();
+    m_referencedObjectStores.set(objectStoreName, WTFMove(objectStore));
+
+    return Ref<IDBObjectStore>(*rawObjectStore);
 }
 
-IDBTransaction::~IDBTransaction()
+
+void IDBTransaction::abortDueToFailedRequest(DOMError& error)
 {
-    ASSERT(m_state == Finished || m_contextStopped);
-    ASSERT(m_requestList.isEmpty() || m_contextStopped);
+    LOG(IndexedDB, "IDBTransaction::abortDueToFailedRequest");
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    if (isFinishedOrFinishing())
+        return;
+
+    m_domError = &error;
+    internalAbort();
+}
+
+void IDBTransaction::transitionedToFinishing(IndexedDB::TransactionState state)
+{
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    ASSERT(!isFinishedOrFinishing());
+    m_state = state;
+    ASSERT(isFinishedOrFinishing());
 }
 
-const String& IDBTransaction::mode() const
+ExceptionOr<void> IDBTransaction::abort()
 {
-    return modeToString(m_mode);
+    LOG(IndexedDB, "IDBTransaction::abort");
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    if (isFinishedOrFinishing())
+        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'abort' on 'IDBTransaction': The transaction is inactive or finished.") };
+
+    internalAbort();
+
+    return { };
 }
 
-void IDBTransaction::setError(PassRefPtr<DOMError> error, const String& errorMessage)
+void IDBTransaction::internalAbort()
 {
-    ASSERT(m_state != Finished);
-    ASSERT(error);
+    LOG(IndexedDB, "IDBTransaction::internalAbort");
+    ASSERT(currentThread() == m_database->originThreadID());
+    ASSERT(!isFinishedOrFinishing());
+
+    m_database->willAbortTransaction(*this);
+
+    if (isVersionChange()) {
+        Locker<Lock> locker(m_referencedObjectStoreLock);
+
+        auto& info = m_database->info();
+        Vector<uint64_t> identifiersToRemove;
+        for (auto& iterator : m_deletedObjectStores) {
+            if (info.infoForExistingObjectStore(iterator.key)) {
+                auto name = iterator.value->info().name();
+                m_referencedObjectStores.set(name, WTFMove(iterator.value));
+                identifiersToRemove.append(iterator.key);
+            }
+        }
+
+        for (auto identifier : identifiersToRemove)
+            m_deletedObjectStores.remove(identifier);
 
-    // The first error to be set is the true cause of the
-    // transaction abort.
-    if (!m_error) {
-        m_error = error;
-        m_errorMessage = errorMessage;
+        for (auto& objectStore : m_referencedObjectStores.values())
+            objectStore->rollbackForVersionChangeAbort();
     }
+
+    transitionedToFinishing(IndexedDB::TransactionState::Aborting);
+    
+    m_abortQueue.swap(m_pendingTransactionOperationQueue);
+
+    LOG(IndexedDBOperations, "IDB abort-on-server operation: Transaction %s", info().identifier().loggingString().utf8().data());
+    scheduleOperation(IDBClient::createTransactionOperation(*this, nullptr, &IDBTransaction::abortOnServerAndCancelRequests));
 }
 
-PassRefPtr<IDBObjectStore> IDBTransaction::objectStore(const String& name, ExceptionCode& ec)
+void IDBTransaction::abortInProgressOperations(const IDBError& error)
 {
-    if (m_state == Finished) {
-        ec = IDBDatabaseException::InvalidStateError;
-        return 0;
+    LOG(IndexedDB, "IDBTransaction::abortInProgressOperations");
+
+    Vector<RefPtr<IDBClient::TransactionOperation>> inProgressAbortVector;
+    inProgressAbortVector.reserveInitialCapacity(m_transactionOperationsInProgressQueue.size());
+    while (!m_transactionOperationsInProgressQueue.isEmpty())
+        inProgressAbortVector.uncheckedAppend(m_transactionOperationsInProgressQueue.takeFirst());
+
+    for (auto& operation : inProgressAbortVector) {
+        m_transactionOperationsInProgressQueue.append(operation.get());
+        m_currentlyCompletingRequest = nullptr;
+        operation->doComplete(IDBResultData::error(operation->identifier(), error));
     }
 
-    IDBObjectStoreMap::iterator it = m_objectStoreMap.find(name);
-    if (it != m_objectStoreMap.end())
-        return it->value;
+    Vector<RefPtr<IDBClient::TransactionOperation>> completedOnServerAbortVector;
+    completedOnServerAbortVector.reserveInitialCapacity(m_completedOnServerQueue.size());
+    while (!m_completedOnServerQueue.isEmpty())
+        completedOnServerAbortVector.uncheckedAppend(m_completedOnServerQueue.takeFirst().first);
 
-    if (!isVersionChange() && !m_objectStoreNames.contains(name)) {
-        ec = IDBDatabaseException::NotFoundError;
-        return 0;
+    for (auto& operation : completedOnServerAbortVector) {
+        m_currentlyCompletingRequest = nullptr;
+        operation->doComplete(IDBResultData::error(operation->identifier(), error));
     }
 
-    int64_t objectStoreId = m_database->findObjectStoreId(name);
-    if (objectStoreId == IDBObjectStoreMetadata::InvalidId) {
-        ASSERT(isVersionChange());
-        ec = IDBDatabaseException::NotFoundError;
-        return 0;
+    connectionProxy().forgetActiveOperations(inProgressAbortVector);
+}
+
+void IDBTransaction::abortOnServerAndCancelRequests(IDBClient::TransactionOperation& operation)
+{
+    LOG(IndexedDB, "IDBTransaction::abortOnServerAndCancelRequests");
+    ASSERT(currentThread() == m_database->originThreadID());
+    ASSERT(m_pendingTransactionOperationQueue.isEmpty());
+
+    m_database->connectionProxy().abortTransaction(*this);
+
+    ASSERT(m_transactionOperationMap.contains(operation.identifier()));
+    ASSERT(m_transactionOperationsInProgressQueue.last() == &operation);
+    m_transactionOperationMap.remove(operation.identifier());
+    m_transactionOperationsInProgressQueue.removeLast();
+
+    m_currentlyCompletingRequest = nullptr;
+    
+    IDBError error(IDBDatabaseException::AbortError);
+
+    abortInProgressOperations(error);
+
+    for (auto& operation : m_abortQueue) {
+        m_currentlyCompletingRequest = nullptr;
+        m_transactionOperationsInProgressQueue.append(operation.get());
+        operation->doComplete(IDBResultData::error(operation->identifier(), error));
     }
 
-    const IDBDatabaseMetadata& metadata = m_database->metadata();
+    // Since we're aborting, it should be impossible to have queued any further operations.
+    ASSERT(m_pendingTransactionOperationQueue.isEmpty());
+}
 
-    RefPtr<IDBObjectStore> objectStore = IDBObjectStore::create(metadata.objectStores.get(objectStoreId), this);
-    objectStoreCreated(name, objectStore);
-    return objectStore.release();
+const char* IDBTransaction::activeDOMObjectName() const
+{
+    ASSERT(currentThread() == m_database->originThreadID());
+    return "IDBTransaction";
 }
 
-void IDBTransaction::objectStoreCreated(const String& name, PassRefPtr<IDBObjectStore> prpObjectStore)
+bool IDBTransaction::canSuspendForDocumentSuspension() const
 {
-    ASSERT(m_state != Finished);
-    RefPtr<IDBObjectStore> objectStore = prpObjectStore;
-    m_objectStoreMap.set(name, objectStore);
-    if (isVersionChange())
-        m_objectStoreCleanupMap.set(objectStore, objectStore->metadata());
+    ASSERT(currentThread() == m_database->originThreadID());
+    return false;
 }
 
-void IDBTransaction::objectStoreDeleted(const String& name)
+bool IDBTransaction::hasPendingActivity() const
 {
-    ASSERT(m_state != Finished);
-    ASSERT(isVersionChange());
-    IDBObjectStoreMap::iterator it = m_objectStoreMap.find(name);
-    if (it != m_objectStoreMap.end()) {
-        RefPtr<IDBObjectStore> objectStore = it->value;
-        m_objectStoreMap.remove(name);
-        objectStore->markDeleted();
-        m_objectStoreCleanupMap.set(objectStore, objectStore->metadata());
-        m_deletedObjectStores.add(objectStore);
-    }
+    ASSERT(currentThread() == m_database->originThreadID() || mayBeGCThread());
+    return !m_contextStopped && m_state != IndexedDB::TransactionState::Finished;
 }
 
-void IDBTransaction::setActive(bool active)
+void IDBTransaction::stop()
 {
-    ASSERT_WITH_MESSAGE(m_state != Finished, "A finished transaction tried to setActive(%s)", active ? "true" : "false");
-    if (m_state == Finishing)
+    LOG(IndexedDB, "IDBTransaction::stop - %s", m_info.loggingString().utf8().data());
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    // IDBDatabase::stop() calls IDBTransaction::stop() for each of its active transactions.
+    // Since the order of calling ActiveDOMObject::stop() is random, we might already have been stopped.
+    if (m_contextStopped)
         return;
-    ASSERT(active != (m_state == Active));
-    m_state = active ? Active : Inactive;
 
-    if (!active && m_requestList.isEmpty())
-        backendDB()->commit(m_id);
+    removeAllEventListeners();
+
+    m_contextStopped = true;
+
+    if (isFinishedOrFinishing())
+        return;
+
+    internalAbort();
+}
+
+bool IDBTransaction::isActive() const
+{
+    ASSERT(currentThread() == m_database->originThreadID());
+    return m_state == IndexedDB::TransactionState::Active;
 }
 
-void IDBTransaction::abort(ExceptionCode& ec)
+bool IDBTransaction::isFinishedOrFinishing() const
 {
-    if (m_state == Finishing || m_state == Finished) {
-        ec = IDBDatabaseException::InvalidStateError;
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    return m_state == IndexedDB::TransactionState::Committing
+        || m_state == IndexedDB::TransactionState::Aborting
+        || m_state == IndexedDB::TransactionState::Finished;
+}
+
+void IDBTransaction::addRequest(IDBRequest& request)
+{
+    ASSERT(currentThread() == m_database->originThreadID());
+    m_openRequests.add(&request);
+}
+
+void IDBTransaction::removeRequest(IDBRequest& request)
+{
+    ASSERT(currentThread() == m_database->originThreadID());
+    ASSERT(m_openRequests.contains(&request));
+    m_openRequests.remove(&request);
+}
+
+void IDBTransaction::scheduleOperation(RefPtr<IDBClient::TransactionOperation>&& operation)
+{
+    ASSERT(!m_transactionOperationMap.contains(operation->identifier()));
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    m_pendingTransactionOperationQueue.append(operation);
+    m_transactionOperationMap.set(operation->identifier(), WTFMove(operation));
+
+    schedulePendingOperationTimer();
+}
+
+void IDBTransaction::schedulePendingOperationTimer()
+{
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    if (!m_pendingOperationTimer.isActive())
+        m_pendingOperationTimer.startOneShot(0);
+}
+
+void IDBTransaction::pendingOperationTimerFired()
+{
+    LOG(IndexedDB, "IDBTransaction::pendingOperationTimerFired (%p)", this);
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    if (!m_startedOnServer)
+        return;
+
+    // If the last in-progress operation we've sent to the server is not an IDBRequest operation,
+    // then we have to wait until it completes before sending any more.
+    if (!m_transactionOperationsInProgressQueue.isEmpty() && !m_transactionOperationsInProgressQueue.last()->nextRequestCanGoToServer())
         return;
-    }
 
-    m_state = Finishing;
+    // We want to batch operations together without spinning the runloop for performance,
+    // but don't want to affect responsiveness of the main thread.
+    // This number is a good compromise in ad-hoc testing.
+    static const size_t operationBatchLimit = 128;
+
+    for (size_t iterations = 0; !m_pendingTransactionOperationQueue.isEmpty() && iterations < operationBatchLimit; ++iterations) {
+        auto operation = m_pendingTransactionOperationQueue.takeFirst();
+        m_transactionOperationsInProgressQueue.append(operation.get());
+        operation->perform();
+
+        if (!operation->nextRequestCanGoToServer())
+            break;
 
-    while (!m_requestList.isEmpty()) {
-        RefPtr<IDBRequest> request = *m_requestList.begin();
-        m_requestList.remove(request);
-        request->abort();
     }
 
-    RefPtr<IDBTransaction> selfRef = this;
-    backendDB()->abort(m_id);
+    if (!m_transactionOperationMap.isEmpty() || !m_openRequests.isEmpty())
+        return;
+
+    if (!isFinishedOrFinishing())
+        commit();
 }
 
-IDBTransaction::OpenCursorNotifier::OpenCursorNotifier(PassRefPtr<IDBTransaction> transaction, IDBCursor* cursor)
-    : m_transaction(transaction),
-      m_cursor(cursor)
+void IDBTransaction::operationCompletedOnServer(const IDBResultData& data, IDBClient::TransactionOperation& operation)
 {
-    m_transaction->registerOpenCursor(m_cursor);
+    ASSERT(currentThread() == m_database->originThreadID());
+    ASSERT(currentThread() == operation.originThreadID());
+
+    m_completedOnServerQueue.append({ &operation, data });
+    scheduleCompletedOperationTimer();
 }
 
-IDBTransaction::OpenCursorNotifier::~OpenCursorNotifier()
+void IDBTransaction::scheduleCompletedOperationTimer()
 {
-    if (m_cursor)
-        m_transaction->unregisterOpenCursor(m_cursor);
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    if (!m_completedOperationTimer.isActive())
+        m_completedOperationTimer.startOneShot(0);
 }
 
-void IDBTransaction::OpenCursorNotifier::cursorFinished()
+void IDBTransaction::completedOperationTimerFired()
 {
-    if (m_cursor) {
-        m_transaction->unregisterOpenCursor(m_cursor);
-        m_cursor = 0;
-        m_transaction.clear();
-    }
+    LOG(IndexedDB, "IDBTransaction::completedOperationTimerFired (%p)", this);
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    if (m_completedOnServerQueue.isEmpty() || m_currentlyCompletingRequest)
+        return;
+
+    auto iterator = m_completedOnServerQueue.takeFirst();
+    iterator.first->doComplete(iterator.second);
+
+    if (!m_completedOnServerQueue.isEmpty() && !m_currentlyCompletingRequest)
+        scheduleCompletedOperationTimer();
+}
+
+void IDBTransaction::completeNoncursorRequest(IDBRequest& request, const IDBResultData& result)
+{
+    ASSERT(!m_currentlyCompletingRequest);
+
+    request.completeRequestAndDispatchEvent(result);
+
+    m_currentlyCompletingRequest = &request;
 }
 
-void IDBTransaction::registerOpenCursor(IDBCursor* cursor)
+void IDBTransaction::completeCursorRequest(IDBRequest& request, const IDBResultData& result)
 {
-    m_openCursors.add(cursor);
+    ASSERT(!m_currentlyCompletingRequest);
+
+    request.didOpenOrIterateCursor(result);
+
+    m_currentlyCompletingRequest = &request;
 }
 
-void IDBTransaction::unregisterOpenCursor(IDBCursor* cursor)
+void IDBTransaction::finishedDispatchEventForRequest(IDBRequest& request)
 {
-    m_openCursors.remove(cursor);
+    if (isFinishedOrFinishing())
+        return;
+
+    ASSERT_UNUSED(request, !m_currentlyCompletingRequest || m_currentlyCompletingRequest == &request);
+
+    m_currentlyCompletingRequest = nullptr;
+    scheduleCompletedOperationTimer();
 }
 
-void IDBTransaction::closeOpenCursors()
+void IDBTransaction::commit()
 {
-    HashSet<IDBCursor*> cursors;
-    cursors.swap(m_openCursors);
-    for (HashSet<IDBCursor*>::iterator i = cursors.begin(); i != cursors.end(); ++i)
-        (*i)->close();
+    LOG(IndexedDB, "IDBTransaction::commit");
+    ASSERT(currentThread() == m_database->originThreadID());
+    ASSERT(!isFinishedOrFinishing());
+
+    transitionedToFinishing(IndexedDB::TransactionState::Committing);
+    m_database->willCommitTransaction(*this);
+
+    LOG(IndexedDBOperations, "IDB commit operation: Transaction %s", info().identifier().loggingString().utf8().data());
+    scheduleOperation(IDBClient::createTransactionOperation(*this, nullptr, &IDBTransaction::commitOnServer));
 }
 
-void IDBTransaction::registerRequest(IDBRequest* request)
+void IDBTransaction::commitOnServer(IDBClient::TransactionOperation& operation)
 {
-    ASSERT(request);
-    ASSERT(m_state == Active);
-    m_requestList.add(request);
+    LOG(IndexedDB, "IDBTransaction::commitOnServer");
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    m_database->connectionProxy().commitTransaction(*this);
+
+    ASSERT(!m_transactionOperationsInProgressQueue.isEmpty());
+    ASSERT(m_transactionOperationsInProgressQueue.last() == &operation);
+    m_transactionOperationsInProgressQueue.removeLast();
+
+    ASSERT(m_transactionOperationMap.contains(operation.identifier()));
+    m_transactionOperationMap.remove(operation.identifier());
 }
 
-void IDBTransaction::unregisterRequest(IDBRequest* request)
+void IDBTransaction::finishAbortOrCommit()
 {
-    ASSERT(request);
-    // If we aborted the request, it will already have been removed.
-    m_requestList.remove(request);
+    ASSERT(m_state != IndexedDB::TransactionState::Finished);
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    m_state = IndexedDB::TransactionState::Finished;
 }
 
-void IDBTransaction::onAbort(PassRefPtr<IDBDatabaseError> prpError)
+void IDBTransaction::didStart(const IDBError& error)
 {
-    LOG(StorageAPI, "IDBTransaction::onAbort");
-    RefPtr<IDBDatabaseError> error = prpError;
-    ASSERT(m_state != Finished);
+    LOG(IndexedDB, "IDBTransaction::didStart");
+    ASSERT(currentThread() == m_database->originThreadID());
 
-    if (m_state != Finishing) {
-        ASSERT(error.get());
-        setError(DOMError::create(error->name()), error->message());
+    m_database->didStartTransaction(*this);
 
-        // Abort was not triggered by front-end, so outstanding requests must
-        // be aborted now.
-        while (!m_requestList.isEmpty()) {
-            RefPtr<IDBRequest> request = *m_requestList.begin();
-            m_requestList.remove(request);
-            request->abort();
-        }
-        m_state = Finishing;
+    m_startedOnServer = true;
+
+    // It's possible the transaction failed to start on the server.
+    // That equates to an abort.
+    if (!error.isNull()) {
+        didAbort(error);
+        return;
     }
 
+    schedulePendingOperationTimer();
+}
+
+void IDBTransaction::notifyDidAbort(const IDBError& error)
+{
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    m_database->didAbortTransaction(*this);
+    m_idbError = error;
+    fireOnAbort();
+
     if (isVersionChange()) {
-        for (IDBObjectStoreMetadataMap::iterator it = m_objectStoreCleanupMap.begin(); it != m_objectStoreCleanupMap.end(); ++it)
-            it->key->setMetadata(it->value);
-        m_database->setMetadata(m_previousMetadata);
-        m_database->close();
+        ASSERT(m_openDBRequest);
+        m_openDBRequest->fireErrorAfterVersionChangeCompletion();
     }
-    m_objectStoreCleanupMap.clear();
-    closeOpenCursors();
+}
 
-    // Enqueue events before notifying database, as database may close which enqueues more events and order matters.
-    enqueueEvent(Event::create(eventNames().abortEvent, true, false));
-    m_database->transactionFinished(this);
+void IDBTransaction::didAbort(const IDBError& error)
+{
+    LOG(IndexedDB, "IDBTransaction::didAbort");
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    if (m_state == IndexedDB::TransactionState::Finished)
+        return;
+
+    notifyDidAbort(error);
+
+    finishAbortOrCommit();
 }
 
-void IDBTransaction::onComplete()
+void IDBTransaction::didCommit(const IDBError& error)
 {
-    LOG(StorageAPI, "IDBTransaction::onComplete");
-    ASSERT(m_state != Finished);
-    m_state = Finishing;
-    m_objectStoreCleanupMap.clear();
-    closeOpenCursors();
+    LOG(IndexedDB, "IDBTransaction::didCommit");
+    ASSERT(currentThread() == m_database->originThreadID());
+    ASSERT(m_state == IndexedDB::TransactionState::Committing);
+
+    if (error.isNull()) {
+        m_database->didCommitTransaction(*this);
+        fireOnComplete();
+    } else {
+        m_database->willAbortTransaction(*this);
+        notifyDidAbort(error);
+    }
 
-    // Enqueue events before notifying database, as database may close which enqueues more events and order matters.
+    finishAbortOrCommit();
+}
+
+void IDBTransaction::fireOnComplete()
+{
+    LOG(IndexedDB, "IDBTransaction::fireOnComplete");
+    ASSERT(currentThread() == m_database->originThreadID());
     enqueueEvent(Event::create(eventNames().completeEvent, false, false));
-    m_database->transactionFinished(this);
 }
 
-bool IDBTransaction::hasPendingActivity() const
+void IDBTransaction::fireOnAbort()
 {
-    // FIXME: In an ideal world, we should return true as long as anyone has a or can
-    //        get a handle to us or any child request object and any of those have
-    //        event listeners. This is  in order to handle user generated events properly.
-    return m_hasPendingActivity && !m_contextStopped;
+    LOG(IndexedDB, "IDBTransaction::fireOnAbort");
+    ASSERT(currentThread() == m_database->originThreadID());
+    enqueueEvent(Event::create(eventNames().abortEvent, true, false));
 }
 
-IndexedDB::TransactionMode IDBTransaction::stringToMode(const String& modeString, ExceptionCode& ec)
+void IDBTransaction::enqueueEvent(Ref<Event>&& event)
 {
-    if (modeString.isNull()
-        || modeString == IDBTransaction::modeReadOnly())
-        return IndexedDB::TransactionMode::ReadOnly;
-    if (modeString == IDBTransaction::modeReadWrite())
-        return IndexedDB::TransactionMode::ReadWrite;
+    ASSERT(m_state != IndexedDB::TransactionState::Finished);
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    if (!scriptExecutionContext() || m_contextStopped)
+        return;
 
-    ec = TypeError;
-    return IndexedDB::TransactionMode::ReadOnly;
+    event->setTarget(this);
+    scriptExecutionContext()->eventQueue().enqueueEvent(WTFMove(event));
 }
 
-const AtomicString& IDBTransaction::modeToString(IndexedDB::TransactionMode mode)
+bool IDBTransaction::dispatchEvent(Event& event)
 {
-    switch (mode) {
-    case IndexedDB::TransactionMode::ReadOnly:
-        return IDBTransaction::modeReadOnly();
-        break;
+    LOG(IndexedDB, "IDBTransaction::dispatchEvent");
 
-    case IndexedDB::TransactionMode::ReadWrite:
-        return IDBTransaction::modeReadWrite();
-        break;
+    ASSERT(currentThread() == m_database->originThreadID());
+    ASSERT(scriptExecutionContext());
+    ASSERT(!m_contextStopped);
+    ASSERT(event.target() == this);
+    ASSERT(event.type() == eventNames().completeEvent || event.type() == eventNames().abortEvent);
 
-    case IndexedDB::TransactionMode::VersionChange:
-        return IDBTransaction::modeVersionChange();
-        break;
+    Vector<RefPtr<EventTarget>> targets;
+    targets.append(this);
+    targets.append(db());
+
+    bool result = IDBEventDispatcher::dispatch(event, targets);
+
+    if (isVersionChange()) {
+        ASSERT(m_openDBRequest);
+        m_openDBRequest->versionChangeTransactionDidFinish();
+
+        if (event.type() == eventNames().completeEvent) {
+            if (m_database->isClosingOrClosed())
+                m_openDBRequest->fireErrorAfterVersionChangeCompletion();
+            else
+                m_openDBRequest->fireSuccessAfterVersionChangeCommit();
+        }
+
+        m_openDBRequest = nullptr;
     }
 
-    ASSERT_NOT_REACHED();
-    return IDBTransaction::modeReadOnly();
+    return result;
 }
 
-bool IDBTransaction::dispatchEvent(PassRefPtr<Event> event)
+Ref<IDBObjectStore> IDBTransaction::createObjectStore(const IDBObjectStoreInfo& info)
 {
-    LOG(StorageAPI, "IDBTransaction::dispatchEvent");
-    ASSERT(m_state != Finished);
-    ASSERT(m_hasPendingActivity);
+    LOG(IndexedDB, "IDBTransaction::createObjectStore");
+    ASSERT(isVersionChange());
     ASSERT(scriptExecutionContext());
-    ASSERT(event->target() == this);
-    m_state = Finished;
+    ASSERT(currentThread() == m_database->originThreadID());
 
-    // Break reference cycles.
-    for (IDBObjectStoreMap::iterator it = m_objectStoreMap.begin(); it != m_objectStoreMap.end(); ++it)
-        it->value->transactionFinished();
-    m_objectStoreMap.clear();
-    for (IDBObjectStoreSet::iterator it = m_deletedObjectStores.begin(); it != m_deletedObjectStores.end(); ++it)
-        (*it)->transactionFinished();
-    m_deletedObjectStores.clear();
+    Locker<Lock> locker(m_referencedObjectStoreLock);
 
-    Vector<RefPtr<EventTarget>> targets;
-    targets.append(this);
-    targets.append(db());
+    auto objectStore = std::make_unique<IDBObjectStore>(*scriptExecutionContext(), info, *this);
+    auto* rawObjectStore = objectStore.get();
+    m_referencedObjectStores.set(info.name(), WTFMove(objectStore));
+
+    LOG(IndexedDBOperations, "IDB create object store operation: %s", info.condensedLoggingString().utf8().data());
+    scheduleOperation(IDBClient::createTransactionOperation(*this, &IDBTransaction::didCreateObjectStoreOnServer, &IDBTransaction::createObjectStoreOnServer, info));
+
+    return *rawObjectStore;
+}
+
+void IDBTransaction::createObjectStoreOnServer(IDBClient::TransactionOperation& operation, const IDBObjectStoreInfo& info)
+{
+    LOG(IndexedDB, "IDBTransaction::createObjectStoreOnServer");
+    ASSERT(currentThread() == m_database->originThreadID());
+    ASSERT(isVersionChange());
+
+    m_database->connectionProxy().createObjectStore(operation, info);
+}
+
+void IDBTransaction::didCreateObjectStoreOnServer(const IDBResultData& resultData)
+{
+    LOG(IndexedDB, "IDBTransaction::didCreateObjectStoreOnServer");
+    ASSERT(currentThread() == m_database->originThreadID());
+    ASSERT_UNUSED(resultData, resultData.type() == IDBResultType::CreateObjectStoreSuccess || resultData.type() == IDBResultType::Error);
+}
+
+void IDBTransaction::renameObjectStore(IDBObjectStore& objectStore, const String& newName)
+{
+    LOG(IndexedDB, "IDBTransaction::renameObjectStore");
+
+    Locker<Lock> locker(m_referencedObjectStoreLock);
+
+    ASSERT(isVersionChange());
+    ASSERT(scriptExecutionContext());
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    ASSERT(m_referencedObjectStores.contains(objectStore.info().name()));
+    ASSERT(!m_referencedObjectStores.contains(newName));
+    ASSERT(m_referencedObjectStores.get(objectStore.info().name()) == &objectStore);
 
-    // FIXME: When we allow custom event dispatching, this will probably need to change.
-    ASSERT(event->type() == eventNames().completeEvent || event->type() == eventNames().abortEvent);
-    bool returnValue = IDBEventDispatcher::dispatch(event.get(), targets);
-    // FIXME: Try to construct a test where |this| outlives openDBRequest and we
-    // get a crash.
-    if (m_openDBRequest) {
-        ASSERT(isVersionChange());
-        m_openDBRequest->transactionDidFinishAndDispatch();
+    uint64_t objectStoreIdentifier = objectStore.info().identifier();
+
+    LOG(IndexedDBOperations, "IDB rename object store operation: %s to %s", objectStore.info().condensedLoggingString().utf8().data(), newName.utf8().data());
+    scheduleOperation(IDBClient::createTransactionOperation(*this, &IDBTransaction::didRenameObjectStoreOnServer, &IDBTransaction::renameObjectStoreOnServer, objectStoreIdentifier, newName));
+
+    m_referencedObjectStores.set(newName, m_referencedObjectStores.take(objectStore.info().name()));
+}
+
+void IDBTransaction::renameObjectStoreOnServer(IDBClient::TransactionOperation& operation, const uint64_t& objectStoreIdentifier, const String& newName)
+{
+    LOG(IndexedDB, "IDBTransaction::renameObjectStoreOnServer");
+    ASSERT(currentThread() == m_database->originThreadID());
+    ASSERT(isVersionChange());
+
+    m_database->connectionProxy().renameObjectStore(operation, objectStoreIdentifier, newName);
+}
+
+void IDBTransaction::didRenameObjectStoreOnServer(const IDBResultData& resultData)
+{
+    LOG(IndexedDB, "IDBTransaction::didRenameObjectStoreOnServer");
+    ASSERT(currentThread() == m_database->originThreadID());
+    ASSERT_UNUSED(resultData, resultData.type() == IDBResultType::RenameObjectStoreSuccess || resultData.type() == IDBResultType::Error);
+}
+
+std::unique_ptr<IDBIndex> IDBTransaction::createIndex(IDBObjectStore& objectStore, const IDBIndexInfo& info)
+{
+    LOG(IndexedDB, "IDBTransaction::createIndex");
+    ASSERT(isVersionChange());
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    if (!scriptExecutionContext())
+        return nullptr;
+
+    LOG(IndexedDBOperations, "IDB create index operation: %s under object store %s", info.condensedLoggingString().utf8().data(), objectStore.info().condensedLoggingString().utf8().data());
+    scheduleOperation(IDBClient::createTransactionOperation(*this, &IDBTransaction::didCreateIndexOnServer, &IDBTransaction::createIndexOnServer, info));
+
+    return std::make_unique<IDBIndex>(*scriptExecutionContext(), info, objectStore);
+}
+
+void IDBTransaction::createIndexOnServer(IDBClient::TransactionOperation& operation, const IDBIndexInfo& info)
+{
+    LOG(IndexedDB, "IDBTransaction::createIndexOnServer");
+    ASSERT(currentThread() == m_database->originThreadID());
+    ASSERT(isVersionChange());
+
+    m_database->connectionProxy().createIndex(operation, info);
+}
+
+void IDBTransaction::didCreateIndexOnServer(const IDBResultData& resultData)
+{
+    LOG(IndexedDB, "IDBTransaction::didCreateIndexOnServer");
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    if (resultData.type() == IDBResultType::CreateIndexSuccess)
+        return;
+
+    ASSERT(resultData.type() == IDBResultType::Error);
+
+    // This operation might have failed because the transaction is already aborting.
+    if (m_state == IndexedDB::TransactionState::Aborting)
+        return;
+
+    // Otherwise, failure to create an index forced abortion of the transaction.
+    abortDueToFailedRequest(DOMError::create(IDBDatabaseException::getErrorName(resultData.error().code()), resultData.error().message()));
+}
+
+void IDBTransaction::renameIndex(IDBIndex& index, const String& newName)
+{
+    LOG(IndexedDB, "IDBTransaction::renameIndex");
+    Locker<Lock> locker(m_referencedObjectStoreLock);
+
+    ASSERT(isVersionChange());
+    ASSERT(scriptExecutionContext());
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    ASSERT(m_referencedObjectStores.contains(index.objectStore().info().name()));
+    ASSERT(m_referencedObjectStores.get(index.objectStore().info().name()) == &index.objectStore());
+
+    index.objectStore().renameReferencedIndex(index, newName);
+
+    uint64_t objectStoreIdentifier = index.objectStore().info().identifier();
+    uint64_t indexIdentifier = index.info().identifier();
+
+    LOG(IndexedDBOperations, "IDB rename index operation: %s to %s under object store %" PRIu64, index.info().condensedLoggingString().utf8().data(), newName.utf8().data(), index.info().objectStoreIdentifier());
+    scheduleOperation(IDBClient::createTransactionOperation(*this, &IDBTransaction::didRenameIndexOnServer, &IDBTransaction::renameIndexOnServer, objectStoreIdentifier, indexIdentifier, newName));
+}
+
+void IDBTransaction::renameIndexOnServer(IDBClient::TransactionOperation& operation, const uint64_t& objectStoreIdentifier, const uint64_t& indexIdentifier, const String& newName)
+{
+    LOG(IndexedDB, "IDBTransaction::renameIndexOnServer");
+    ASSERT(currentThread() == m_database->originThreadID());
+    ASSERT(isVersionChange());
+
+    m_database->connectionProxy().renameIndex(operation, objectStoreIdentifier, indexIdentifier, newName);
+}
+
+void IDBTransaction::didRenameIndexOnServer(const IDBResultData& resultData)
+{
+    LOG(IndexedDB, "IDBTransaction::didRenameIndexOnServer");
+    ASSERT(currentThread() == m_database->originThreadID());
+    ASSERT_UNUSED(resultData, resultData.type() == IDBResultType::RenameIndexSuccess || resultData.type() == IDBResultType::Error);
+}
+
+Ref<IDBRequest> IDBTransaction::requestOpenCursor(ExecState& state, IDBObjectStore& objectStore, const IDBCursorInfo& info)
+{
+    LOG(IndexedDB, "IDBTransaction::requestOpenCursor");
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    if (info.cursorType() == IndexedDB::CursorType::KeyOnly)
+        return doRequestOpenCursor(state, IDBCursor::create(*this, objectStore, info));
+
+    return doRequestOpenCursor(state, IDBCursorWithValue::create(*this, objectStore, info));
+}
+
+Ref<IDBRequest> IDBTransaction::requestOpenCursor(ExecState& state, IDBIndex& index, const IDBCursorInfo& info)
+{
+    LOG(IndexedDB, "IDBTransaction::requestOpenCursor");
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    if (info.cursorType() == IndexedDB::CursorType::KeyOnly)
+        return doRequestOpenCursor(state, IDBCursor::create(*this, index, info));
+
+    return doRequestOpenCursor(state, IDBCursorWithValue::create(*this, index, info));
+}
+
+Ref<IDBRequest> IDBTransaction::doRequestOpenCursor(ExecState& state, Ref<IDBCursor>&& cursor)
+{
+    ASSERT(isActive());
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    ASSERT_UNUSED(state, scriptExecutionContext() == scriptExecutionContextFromExecState(&state));
+
+    auto request = IDBRequest::create(*scriptExecutionContext(), cursor.get(), *this);
+    addRequest(request.get());
+
+    LOG(IndexedDBOperations, "IDB open cursor operation: %s", cursor->info().loggingString().utf8().data());
+    scheduleOperation(IDBClient::createTransactionOperation(*this, request.get(), &IDBTransaction::didOpenCursorOnServer, &IDBTransaction::openCursorOnServer, cursor->info()));
+
+    return request;
+}
+
+void IDBTransaction::openCursorOnServer(IDBClient::TransactionOperation& operation, const IDBCursorInfo& info)
+{
+    LOG(IndexedDB, "IDBTransaction::openCursorOnServer");
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    m_database->connectionProxy().openCursor(operation, info);
+}
+
+void IDBTransaction::didOpenCursorOnServer(IDBRequest& request, const IDBResultData& resultData)
+{
+    LOG(IndexedDB, "IDBTransaction::didOpenCursorOnServer");
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    completeCursorRequest(request, resultData);
+}
+
+void IDBTransaction::iterateCursor(IDBCursor& cursor, const IDBIterateCursorData& data)
+{
+    LOG(IndexedDB, "IDBTransaction::iterateCursor");
+    ASSERT(isActive());
+    ASSERT(cursor.request());
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    addRequest(*cursor.request());
+
+    LOG(IndexedDBOperations, "IDB iterate cursor operation: %s %s", cursor.info().loggingString().utf8().data(), data.loggingString().utf8().data());
+    scheduleOperation(IDBClient::createTransactionOperation(*this, *cursor.request(), &IDBTransaction::didIterateCursorOnServer, &IDBTransaction::iterateCursorOnServer, data));
+}
+
+// FIXME: changes here
+void IDBTransaction::iterateCursorOnServer(IDBClient::TransactionOperation& operation, const IDBIterateCursorData& data)
+{
+    LOG(IndexedDB, "IDBTransaction::iterateCursorOnServer");
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    m_database->connectionProxy().iterateCursor(operation, data);
+}
+
+void IDBTransaction::didIterateCursorOnServer(IDBRequest& request, const IDBResultData& resultData)
+{
+    LOG(IndexedDB, "IDBTransaction::didIterateCursorOnServer");
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    completeCursorRequest(request, resultData);
+}
+
+Ref<IDBRequest> IDBTransaction::requestGetAllObjectStoreRecords(JSC::ExecState& state, IDBObjectStore& objectStore, const IDBKeyRangeData& keyRangeData, IndexedDB::GetAllType getAllType, std::optional<uint32_t> count)
+{
+    LOG(IndexedDB, "IDBTransaction::requestGetAllObjectStoreRecords");
+    ASSERT(isActive());
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    ASSERT_UNUSED(state, scriptExecutionContext() == scriptExecutionContextFromExecState(&state));
+
+    auto request = IDBRequest::create(*scriptExecutionContext(), objectStore, *this);
+    addRequest(request.get());
+
+    IDBGetAllRecordsData getAllRecordsData { keyRangeData, getAllType, count, objectStore.info().identifier(), 0 };
+
+    LOG(IndexedDBOperations, "IDB get all object store records operation: %s", getAllRecordsData.loggingString().utf8().data());
+    scheduleOperation(IDBClient::createTransactionOperation(*this, request.get(), &IDBTransaction::didGetAllRecordsOnServer, &IDBTransaction::getAllRecordsOnServer, getAllRecordsData));
+
+    return request;
+}
+
+Ref<IDBRequest> IDBTransaction::requestGetAllIndexRecords(JSC::ExecState& state, IDBIndex& index, const IDBKeyRangeData& keyRangeData, IndexedDB::GetAllType getAllType, std::optional<uint32_t> count)
+{
+    LOG(IndexedDB, "IDBTransaction::requestGetAllIndexRecords");
+    ASSERT(isActive());
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    ASSERT_UNUSED(state, scriptExecutionContext() == scriptExecutionContextFromExecState(&state));
+
+    auto request = IDBRequest::create(*scriptExecutionContext(), index, *this);
+    addRequest(request.get());
+
+    IDBGetAllRecordsData getAllRecordsData { keyRangeData, getAllType, count, index.objectStore().info().identifier(), index.info().identifier() };
+
+    LOG(IndexedDBOperations, "IDB get all index records operation: %s", getAllRecordsData.loggingString().utf8().data());
+    scheduleOperation(IDBClient::createTransactionOperation(*this, request.get(), &IDBTransaction::didGetAllRecordsOnServer, &IDBTransaction::getAllRecordsOnServer, getAllRecordsData));
+
+    return request;
+}
+
+void IDBTransaction::getAllRecordsOnServer(IDBClient::TransactionOperation& operation, const IDBGetAllRecordsData& getAllRecordsData)
+{
+    LOG(IndexedDB, "IDBTransaction::getAllRecordsOnServer");
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    m_database->connectionProxy().getAllRecords(operation, getAllRecordsData);
+}
+
+void IDBTransaction::didGetAllRecordsOnServer(IDBRequest& request, const IDBResultData& resultData)
+{
+    LOG(IndexedDB, "IDBTransaction::didGetAllRecordsOnServer");
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    if (resultData.type() == IDBResultType::Error) {
+        completeNoncursorRequest(request, resultData);
+        return;
+    }
+
+    ASSERT(resultData.type() == IDBResultType::GetAllRecordsSuccess);
+
+    auto& getAllResult = resultData.getAllResult();
+    switch (getAllResult.type()) {
+    case IndexedDB::GetAllType::Keys:
+        request.setResult(getAllResult.keys());
+        break;
+    case IndexedDB::GetAllType::Values:
+        request.setResult(getAllResult.values());
+        break;
     }
-    m_hasPendingActivity = false;
-    return returnValue;
+
+    completeNoncursorRequest(request, resultData);
 }
 
-bool IDBTransaction::canSuspend() const
+Ref<IDBRequest> IDBTransaction::requestGetRecord(ExecState& state, IDBObjectStore& objectStore, const IDBGetRecordData& getRecordData)
 {
-    // FIXME: Technically we can suspend before the first request is schedule
-    //        and after the complete/abort event is enqueued.
-    return m_state == Finished;
+    LOG(IndexedDB, "IDBTransaction::requestGetRecord");
+    ASSERT(isActive());
+    ASSERT(!getRecordData.keyRangeData.isNull);
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    ASSERT_UNUSED(state, scriptExecutionContext() == scriptExecutionContextFromExecState(&state));
+
+    IndexedDB::ObjectStoreRecordType type = getRecordData.type == IDBGetRecordDataType::KeyAndValue ? IndexedDB::ObjectStoreRecordType::ValueOnly : IndexedDB::ObjectStoreRecordType::KeyOnly;
+
+    auto request = IDBRequest::createObjectStoreGet(*scriptExecutionContext(), objectStore, type, *this);
+    addRequest(request.get());
+
+    LOG(IndexedDBOperations, "IDB get record operation: %s %s", objectStore.info().condensedLoggingString().utf8().data(), getRecordData.loggingString().utf8().data());
+    scheduleOperation(IDBClient::createTransactionOperation(*this, request.get(), &IDBTransaction::didGetRecordOnServer, &IDBTransaction::getRecordOnServer, getRecordData));
+
+    return request;
 }
 
-void IDBTransaction::stop()
+Ref<IDBRequest> IDBTransaction::requestGetValue(ExecState& state, IDBIndex& index, const IDBKeyRangeData& range)
 {
-    m_contextStopped = true;
+    LOG(IndexedDB, "IDBTransaction::requestGetValue");
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    return requestIndexRecord(state, index, IndexedDB::IndexRecordType::Value, range);
+}
+
+Ref<IDBRequest> IDBTransaction::requestGetKey(ExecState& state, IDBIndex& index, const IDBKeyRangeData& range)
+{
+    LOG(IndexedDB, "IDBTransaction::requestGetValue");
+    ASSERT(currentThread() == m_database->originThreadID());
 
-    abort(IGNORE_EXCEPTION);
+    return requestIndexRecord(state, index, IndexedDB::IndexRecordType::Key, range);
 }
 
-void IDBTransaction::enqueueEvent(PassRefPtr<Event> event)
+Ref<IDBRequest> IDBTransaction::requestIndexRecord(ExecState& state, IDBIndex& index, IndexedDB::IndexRecordType type, const IDBKeyRangeData& range)
 {
-    ASSERT_WITH_MESSAGE(m_state != Finished, "A finished transaction tried to enqueue an event of type %s.", event->type().string().utf8().data());
-    if (m_contextStopped || !scriptExecutionContext())
+    LOG(IndexedDB, "IDBTransaction::requestGetValue");
+    ASSERT(isActive());
+    ASSERT(!range.isNull);
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    ASSERT_UNUSED(state, scriptExecutionContext() == scriptExecutionContextFromExecState(&state));
+
+    auto request = IDBRequest::createIndexGet(*scriptExecutionContext(), index, type, *this);
+    addRequest(request.get());
+
+    IDBGetRecordData getRecordData = { range, IDBGetRecordDataType::KeyAndValue };
+
+    LOG(IndexedDBOperations, "IDB get index record operation: %s %s", index.info().condensedLoggingString().utf8().data(), getRecordData.loggingString().utf8().data());
+    scheduleOperation(IDBClient::createTransactionOperation(*this, request.get(), &IDBTransaction::didGetRecordOnServer, &IDBTransaction::getRecordOnServer, getRecordData));
+
+    return request;
+}
+
+void IDBTransaction::getRecordOnServer(IDBClient::TransactionOperation& operation, const IDBGetRecordData& getRecordData)
+{
+    LOG(IndexedDB, "IDBTransaction::getRecordOnServer");
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    m_database->connectionProxy().getRecord(operation, getRecordData);
+}
+
+void IDBTransaction::didGetRecordOnServer(IDBRequest& request, const IDBResultData& resultData)
+{
+    LOG(IndexedDB, "IDBTransaction::didGetRecordOnServer");
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    if (resultData.type() == IDBResultType::Error) {
+        completeNoncursorRequest(request, resultData);
         return;
+    }
 
-    event->setTarget(this);
-    scriptExecutionContext()->eventQueue().enqueueEvent(event);
+    ASSERT(resultData.type() == IDBResultType::GetRecordSuccess);
+
+    bool useResultKey = request.sourceIndexIdentifier() && request.requestedIndexRecordType() == IndexedDB::IndexRecordType::Key;
+    if (!useResultKey)
+        useResultKey = request.requestedObjectStoreRecordType() == IndexedDB::ObjectStoreRecordType::KeyOnly;
+
+    const IDBGetResult& result = resultData.getResult();
+
+    if (useResultKey) {
+        if (!result.keyData().isNull())
+            request.setResult(result.keyData());
+        else
+            request.setResultToUndefined();
+    } else {
+        if (resultData.getResult().value().data().data())
+            request.setResultToStructuredClone(resultData.getResult().value());
+        else
+            request.setResultToUndefined();
+    }
+
+    completeNoncursorRequest(request, resultData);
+}
+
+Ref<IDBRequest> IDBTransaction::requestCount(ExecState& state, IDBObjectStore& objectStore, const IDBKeyRangeData& range)
+{
+    LOG(IndexedDB, "IDBTransaction::requestCount (IDBObjectStore)");
+    ASSERT(isActive());
+    ASSERT(!range.isNull);
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    ASSERT_UNUSED(state, scriptExecutionContext() == scriptExecutionContextFromExecState(&state));
+
+    auto request = IDBRequest::create(*scriptExecutionContext(), objectStore, *this);
+    addRequest(request.get());
+
+    LOG(IndexedDBOperations, "IDB object store count operation: %s, range %s", objectStore.info().condensedLoggingString().utf8().data(), range.loggingString().utf8().data());
+    scheduleOperation(IDBClient::createTransactionOperation(*this, request.get(), &IDBTransaction::didGetCountOnServer, &IDBTransaction::getCountOnServer, range));
+
+    return request;
+}
+
+Ref<IDBRequest> IDBTransaction::requestCount(ExecState& state, IDBIndex& index, const IDBKeyRangeData& range)
+{
+    LOG(IndexedDB, "IDBTransaction::requestCount (IDBIndex)");
+    ASSERT(isActive());
+    ASSERT(!range.isNull);
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    ASSERT_UNUSED(state, scriptExecutionContext() == scriptExecutionContextFromExecState(&state));
+
+    auto request = IDBRequest::create(*scriptExecutionContext(), index, *this);
+    addRequest(request.get());
+
+    LOG(IndexedDBOperations, "IDB index count operation: %s, range %s", index.info().condensedLoggingString().utf8().data(), range.loggingString().utf8().data());
+    scheduleOperation(IDBClient::createTransactionOperation(*this, request.get(), &IDBTransaction::didGetCountOnServer, &IDBTransaction::getCountOnServer, range));
+
+    return request;
+}
+
+void IDBTransaction::getCountOnServer(IDBClient::TransactionOperation& operation, const IDBKeyRangeData& keyRange)
+{
+    LOG(IndexedDB, "IDBTransaction::getCountOnServer");
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    m_database->connectionProxy().getCount(operation, keyRange);
+}
+
+void IDBTransaction::didGetCountOnServer(IDBRequest& request, const IDBResultData& resultData)
+{
+    LOG(IndexedDB, "IDBTransaction::didGetCountOnServer");
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    request.setResult(resultData.resultInteger());
+    completeNoncursorRequest(request, resultData);
 }
 
-IDBDatabaseBackend* IDBTransaction::backendDB() const
+Ref<IDBRequest> IDBTransaction::requestDeleteRecord(ExecState& state, IDBObjectStore& objectStore, const IDBKeyRangeData& range)
 {
-    return db()->backend();
+    LOG(IndexedDB, "IDBTransaction::requestDeleteRecord");
+    ASSERT(isActive());
+    ASSERT(!range.isNull);
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    ASSERT_UNUSED(state, scriptExecutionContext() == scriptExecutionContextFromExecState(&state));
+
+    auto request = IDBRequest::create(*scriptExecutionContext(), objectStore, *this);
+    addRequest(request.get());
+
+    LOG(IndexedDBOperations, "IDB delete record operation: %s, range %s", objectStore.info().condensedLoggingString().utf8().data(), range.loggingString().utf8().data());
+    scheduleOperation(IDBClient::createTransactionOperation(*this, request.get(), &IDBTransaction::didDeleteRecordOnServer, &IDBTransaction::deleteRecordOnServer, range));
+    return request;
+}
+
+void IDBTransaction::deleteRecordOnServer(IDBClient::TransactionOperation& operation, const IDBKeyRangeData& keyRange)
+{
+    LOG(IndexedDB, "IDBTransaction::deleteRecordOnServer");
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    m_database->connectionProxy().deleteRecord(operation, keyRange);
+}
+
+void IDBTransaction::didDeleteRecordOnServer(IDBRequest& request, const IDBResultData& resultData)
+{
+    LOG(IndexedDB, "IDBTransaction::didDeleteRecordOnServer");
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    request.setResultToUndefined();
+    completeNoncursorRequest(request, resultData);
+}
+
+Ref<IDBRequest> IDBTransaction::requestClearObjectStore(ExecState& state, IDBObjectStore& objectStore)
+{
+    LOG(IndexedDB, "IDBTransaction::requestClearObjectStore");
+    ASSERT(isActive());
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    ASSERT_UNUSED(state, scriptExecutionContext() == scriptExecutionContextFromExecState(&state));
+
+    auto request = IDBRequest::create(*scriptExecutionContext(), objectStore, *this);
+    addRequest(request.get());
+
+    uint64_t objectStoreIdentifier = objectStore.info().identifier();
+
+    LOG(IndexedDBOperations, "IDB clear object store operation: %s", objectStore.info().condensedLoggingString().utf8().data());
+    scheduleOperation(IDBClient::createTransactionOperation(*this, request.get(), &IDBTransaction::didClearObjectStoreOnServer, &IDBTransaction::clearObjectStoreOnServer, objectStoreIdentifier));
+
+    return request;
+}
+
+void IDBTransaction::clearObjectStoreOnServer(IDBClient::TransactionOperation& operation, const uint64_t& objectStoreIdentifier)
+{
+    LOG(IndexedDB, "IDBTransaction::clearObjectStoreOnServer");
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    m_database->connectionProxy().clearObjectStore(operation, objectStoreIdentifier);
+}
+
+void IDBTransaction::didClearObjectStoreOnServer(IDBRequest& request, const IDBResultData& resultData)
+{
+    LOG(IndexedDB, "IDBTransaction::didClearObjectStoreOnServer");
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    request.setResultToUndefined();
+    completeNoncursorRequest(request, resultData);
+}
+
+Ref<IDBRequest> IDBTransaction::requestPutOrAdd(ExecState& state, IDBObjectStore& objectStore, IDBKey* key, SerializedScriptValue& value, IndexedDB::ObjectStoreOverwriteMode overwriteMode)
+{
+    LOG(IndexedDB, "IDBTransaction::requestPutOrAdd");
+    ASSERT(isActive());
+    ASSERT(!isReadOnly());
+    ASSERT(objectStore.info().autoIncrement() || key);
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    ASSERT_UNUSED(state, scriptExecutionContext() == scriptExecutionContextFromExecState(&state));
+
+    auto request = IDBRequest::create(*scriptExecutionContext(), objectStore, *this);
+    addRequest(request.get());
+
+    LOG(IndexedDBOperations, "IDB putOrAdd operation: %s key: %s", objectStore.info().condensedLoggingString().utf8().data(), key ? key->loggingString().utf8().data() : "<null key>");
+    scheduleOperation(IDBClient::createTransactionOperation(*this, request.get(), &IDBTransaction::didPutOrAddOnServer, &IDBTransaction::putOrAddOnServer, key, &value, overwriteMode));
+
+    return request;
+}
+
+void IDBTransaction::putOrAddOnServer(IDBClient::TransactionOperation& operation, RefPtr<IDBKey> key, RefPtr<SerializedScriptValue> value, const IndexedDB::ObjectStoreOverwriteMode& overwriteMode)
+{
+    LOG(IndexedDB, "IDBTransaction::putOrAddOnServer");
+    ASSERT(currentThread() == originThreadID());
+    ASSERT(!isReadOnly());
+    ASSERT(value);
+
+    if (!value->hasBlobURLs()) {
+        m_database->connectionProxy().putOrAdd(operation, key.get(), *value, overwriteMode);
+        return;
+    }
+
+    // Due to current limitations on our ability to post tasks back to a worker thread,
+    // workers currently write blobs to disk synchronously.
+    // FIXME: https://bugs.webkit.org/show_bug.cgi?id=157958 - Make this asynchronous after refactoring allows it.
+    if (!isMainThread()) {
+        auto idbValue = value->writeBlobsToDiskForIndexedDBSynchronously();
+        if (idbValue.data().data())
+            m_database->connectionProxy().putOrAdd(operation, key.get(), idbValue, overwriteMode);
+        else {
+            // If the IDBValue doesn't have any data, then something went wrong writing the blobs to disk.
+            // In that case, we cannot successfully store this record, so we callback with an error.
+            RefPtr<IDBClient::TransactionOperation> protectedOperation(&operation);
+            auto result = IDBResultData::error(operation.identifier(), { IDBDatabaseException::UnknownError, ASCIILiteral("Error preparing Blob/File data to be stored in object store") });
+            scriptExecutionContext()->postTask([protectedOperation = WTFMove(protectedOperation), result = WTFMove(result)](ScriptExecutionContext&) {
+                protectedOperation->doComplete(result);
+            });
+        }
+        return;
+    }
+
+    // Since this request won't actually go to the server until the blob writes are complete,
+    // stop future requests from going to the server ahead of it.
+    operation.setNextRequestCanGoToServer(false);
+
+    value->writeBlobsToDiskForIndexedDB([protectedThis = makeRef(*this), this, protectedOperation = Ref<IDBClient::TransactionOperation>(operation), keyData = IDBKeyData(key.get()).isolatedCopy(), overwriteMode](const IDBValue& idbValue) mutable {
+        ASSERT(currentThread() == originThreadID());
+        ASSERT(isMainThread());
+        if (idbValue.data().data()) {
+            m_database->connectionProxy().putOrAdd(protectedOperation.get(), WTFMove(keyData), idbValue, overwriteMode);
+            return;
+        }
+
+        // If the IDBValue doesn't have any data, then something went wrong writing the blobs to disk.
+        // In that case, we cannot successfully store this record, so we callback with an error.
+        auto result = IDBResultData::error(protectedOperation->identifier(), { IDBDatabaseException::UnknownError, ASCIILiteral("Error preparing Blob/File data to be stored in object store") });
+        callOnMainThread([protectedThis = WTFMove(protectedThis), protectedOperation = WTFMove(protectedOperation), result = WTFMove(result)]() mutable {
+            protectedOperation->doComplete(result);
+        });
+    });
+}
+
+void IDBTransaction::didPutOrAddOnServer(IDBRequest& request, const IDBResultData& resultData)
+{
+    LOG(IndexedDB, "IDBTransaction::didPutOrAddOnServer");
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    if (auto* result = resultData.resultKey())
+        request.setResult(*result);
+    else
+        request.setResultToUndefined();
+    completeNoncursorRequest(request, resultData);
+}
+
+void IDBTransaction::deleteObjectStore(const String& objectStoreName)
+{
+    LOG(IndexedDB, "IDBTransaction::deleteObjectStore");
+    ASSERT(currentThread() == m_database->originThreadID());
+    ASSERT(isVersionChange());
+
+    Locker<Lock> locker(m_referencedObjectStoreLock);
+
+    if (auto objectStore = m_referencedObjectStores.take(objectStoreName)) {
+        objectStore->markAsDeleted();
+        auto identifier = objectStore->info().identifier();
+        m_deletedObjectStores.set(identifier, WTFMove(objectStore));
+    }
+
+    LOG(IndexedDBOperations, "IDB delete object store operation: %s", objectStoreName.utf8().data());
+    scheduleOperation(IDBClient::createTransactionOperation(*this, &IDBTransaction::didDeleteObjectStoreOnServer, &IDBTransaction::deleteObjectStoreOnServer, objectStoreName));
+}
+
+void IDBTransaction::deleteObjectStoreOnServer(IDBClient::TransactionOperation& operation, const String& objectStoreName)
+{
+    LOG(IndexedDB, "IDBTransaction::deleteObjectStoreOnServer");
+    ASSERT(isVersionChange());
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    m_database->connectionProxy().deleteObjectStore(operation, objectStoreName);
 }
 
+void IDBTransaction::didDeleteObjectStoreOnServer(const IDBResultData& resultData)
+{
+    LOG(IndexedDB, "IDBTransaction::didDeleteObjectStoreOnServer");
+    ASSERT(currentThread() == m_database->originThreadID());
+    ASSERT_UNUSED(resultData, resultData.type() == IDBResultType::DeleteObjectStoreSuccess || resultData.type() == IDBResultType::Error);
 }
 
+void IDBTransaction::deleteIndex(uint64_t objectStoreIdentifier, const String& indexName)
+{
+    LOG(IndexedDB, "IDBTransaction::deleteIndex");
+    ASSERT(currentThread() == m_database->originThreadID());
+    ASSERT(isVersionChange());
+
+    LOG(IndexedDBOperations, "IDB delete index operation: %s (%" PRIu64 ")", indexName.utf8().data(), objectStoreIdentifier);
+    scheduleOperation(IDBClient::createTransactionOperation(*this, &IDBTransaction::didDeleteIndexOnServer, &IDBTransaction::deleteIndexOnServer, objectStoreIdentifier, indexName));
+}
+
+void IDBTransaction::deleteIndexOnServer(IDBClient::TransactionOperation& operation, const uint64_t& objectStoreIdentifier, const String& indexName)
+{
+    LOG(IndexedDB, "IDBTransaction::deleteIndexOnServer");
+    ASSERT(isVersionChange());
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    m_database->connectionProxy().deleteIndex(operation, objectStoreIdentifier, indexName);
+}
+
+void IDBTransaction::didDeleteIndexOnServer(const IDBResultData& resultData)
+{
+    LOG(IndexedDB, "IDBTransaction::didDeleteIndexOnServer");
+    ASSERT(currentThread() == m_database->originThreadID());
+    ASSERT_UNUSED(resultData, resultData.type() == IDBResultType::DeleteIndexSuccess || resultData.type() == IDBResultType::Error);
+}
+
+void IDBTransaction::operationCompletedOnClient(IDBClient::TransactionOperation& operation)
+{
+    LOG(IndexedDB, "IDBTransaction::operationCompletedOnClient");
+
+    ASSERT(currentThread() == m_database->originThreadID());
+    ASSERT(currentThread() == operation.originThreadID());
+    ASSERT(m_transactionOperationMap.get(operation.identifier()) == &operation);
+    ASSERT(m_transactionOperationsInProgressQueue.first() == &operation);
+
+    m_transactionOperationMap.remove(operation.identifier());
+    m_transactionOperationsInProgressQueue.removeFirst();
+
+    schedulePendingOperationTimer();
+}
+
+void IDBTransaction::establishOnServer()
+{
+    LOG(IndexedDB, "IDBTransaction::establishOnServer");
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    m_database->connectionProxy().establishTransaction(*this);
+}
+
+void IDBTransaction::activate()
+{
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    if (isFinishedOrFinishing())
+        return;
+
+    m_state = IndexedDB::TransactionState::Active;
+}
+
+void IDBTransaction::deactivate()
+{
+    ASSERT(currentThread() == m_database->originThreadID());
+
+    if (m_state == IndexedDB::TransactionState::Active)
+        m_state = IndexedDB::TransactionState::Inactive;
+
+    schedulePendingOperationTimer();
+}
+
+void IDBTransaction::connectionClosedFromServer(const IDBError& error)
+{
+    LOG(IndexedDB, "IDBTransaction::connectionClosedFromServer - %s", error.message().utf8().data());
+
+    m_state = IndexedDB::TransactionState::Aborting;
+
+    abortInProgressOperations(error);
+
+    Vector<RefPtr<IDBClient::TransactionOperation>> operations;
+    copyValuesToVector(m_transactionOperationMap, operations);
+
+    for (auto& operation : operations) {
+        m_currentlyCompletingRequest = nullptr;
+        m_transactionOperationsInProgressQueue.append(operation.get());
+        ASSERT(m_transactionOperationsInProgressQueue.first() == operation.get());
+        operation->doComplete(IDBResultData::error(operation->identifier(), error));
+    }
+
+    connectionProxy().forgetActiveOperations(operations);
+
+    m_pendingTransactionOperationQueue.clear();
+    m_abortQueue.clear();
+    m_transactionOperationMap.clear();
+
+    m_idbError = error;
+    m_domError = error.toDOMError();
+    fireOnAbort();
+}
+
+void IDBTransaction::visitReferencedObjectStores(JSC::SlotVisitor& visitor) const
+{
+    Locker<Lock> locker(m_referencedObjectStoreLock);
+    for (auto& objectStore : m_referencedObjectStores.values())
+        visitor.addOpaqueRoot(objectStore.get());
+    for (auto& objectStore : m_deletedObjectStores.values())
+        visitor.addOpaqueRoot(objectStore.get());
+}
+
+} // namespace WebCore
+
 #endif // ENABLE(INDEXED_DATABASE)