Merge IDBTransactionBackendInterface and IDBTransactionBackendImpl
authorbeidson@apple.com <beidson@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sat, 9 Nov 2013 00:09:04 +0000 (00:09 +0000)
committerbeidson@apple.com <beidson@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sat, 9 Nov 2013 00:09:04 +0000 (00:09 +0000)
https://bugs.webkit.org/show_bug.cgi?id=124077

Reviewed by Alexey Proskuryakov.

Source/WebCore:

The abstraction is no longer needed.

* CMakeLists.txt:
* GNUmakefile.list.am:
* WebCore.xcodeproj/project.pbxproj:

* Modules/indexeddb/IDBTransactionBackendInterface.h: Removed.

* Modules/indexeddb/IDBTransactionBackend.cpp: Renamed from Source/WebCore/Modules/indexeddb/IDBTransactionBackendImpl.cpp.
* Modules/indexeddb/IDBTransactionBackend.h: Renamed from Source/WebCore/Modules/indexeddb/IDBTransactionBackendImpl.h.

* Modules/indexeddb/IDBBackingStoreInterface.h:
* Modules/indexeddb/IDBCursorBackend.cpp:
* Modules/indexeddb/IDBCursorBackend.h:
* Modules/indexeddb/IDBDatabaseBackendImpl.cpp:
* Modules/indexeddb/IDBDatabaseBackendImpl.h:
* Modules/indexeddb/IDBFactoryBackendInterface.h:
* Modules/indexeddb/IDBTransactionBackendOperations.h:
* Modules/indexeddb/IDBTransactionCoordinator.cpp:
* Modules/indexeddb/IDBTransactionCoordinator.h:
* Modules/indexeddb/leveldb/IDBBackingStoreLevelDB.cpp:
* Modules/indexeddb/leveldb/IDBBackingStoreLevelDB.h:
* Modules/indexeddb/leveldb/IDBFactoryBackendLevelDB.cpp:
* Modules/indexeddb/leveldb/IDBFactoryBackendLevelDB.h:

Source/WebKit2:

* WebProcess/Databases/IndexedDB/WebIDBFactoryBackend.cpp:
* WebProcess/Databases/IndexedDB/WebIDBFactoryBackend.h:

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@158969 268f45cc-cd09-0410-ab3c-d52691b4dbfc

24 files changed:
Source/WebCore/CMakeLists.txt
Source/WebCore/ChangeLog
Source/WebCore/GNUmakefile.list.am
Source/WebCore/Modules/indexeddb/IDBBackingStoreInterface.h
Source/WebCore/Modules/indexeddb/IDBCursorBackend.cpp
Source/WebCore/Modules/indexeddb/IDBCursorBackend.h
Source/WebCore/Modules/indexeddb/IDBDatabaseBackendImpl.cpp
Source/WebCore/Modules/indexeddb/IDBDatabaseBackendImpl.h
Source/WebCore/Modules/indexeddb/IDBFactoryBackendInterface.h
Source/WebCore/Modules/indexeddb/IDBTransactionBackend.cpp [moved from Source/WebCore/Modules/indexeddb/IDBTransactionBackendImpl.cpp with 70% similarity]
Source/WebCore/Modules/indexeddb/IDBTransactionBackend.h [new file with mode: 0644]
Source/WebCore/Modules/indexeddb/IDBTransactionBackendImpl.h [deleted file]
Source/WebCore/Modules/indexeddb/IDBTransactionBackendInterface.h [deleted file]
Source/WebCore/Modules/indexeddb/IDBTransactionBackendOperations.h
Source/WebCore/Modules/indexeddb/IDBTransactionCoordinator.cpp
Source/WebCore/Modules/indexeddb/IDBTransactionCoordinator.h
Source/WebCore/Modules/indexeddb/leveldb/IDBBackingStoreLevelDB.cpp
Source/WebCore/Modules/indexeddb/leveldb/IDBBackingStoreLevelDB.h
Source/WebCore/Modules/indexeddb/leveldb/IDBFactoryBackendLevelDB.cpp
Source/WebCore/Modules/indexeddb/leveldb/IDBFactoryBackendLevelDB.h
Source/WebCore/WebCore.xcodeproj/project.pbxproj
Source/WebKit2/ChangeLog
Source/WebKit2/WebProcess/Databases/IndexedDB/WebIDBFactoryBackend.cpp
Source/WebKit2/WebProcess/Databases/IndexedDB/WebIDBFactoryBackend.h

index 85a54c9..a9e218a 100644 (file)
@@ -780,7 +780,7 @@ set(WebCore_SOURCES
     Modules/indexeddb/IDBPendingTransactionMonitor.cpp
     Modules/indexeddb/IDBRequest.cpp
     Modules/indexeddb/IDBTransaction.cpp
-    Modules/indexeddb/IDBTransactionBackendImpl.cpp
+    Modules/indexeddb/IDBTransactionBackend.cpp
     Modules/indexeddb/IDBTransactionBackendOperations.cpp
     Modules/indexeddb/IDBTransactionCoordinator.cpp
     Modules/indexeddb/IDBVersionChangeEvent.cpp
index e500b4a..0d2da23 100644 (file)
@@ -1,3 +1,35 @@
+2013-11-08  Brady Eidson  <beidson@apple.com>
+
+        Merge IDBTransactionBackendInterface and IDBTransactionBackendImpl
+        https://bugs.webkit.org/show_bug.cgi?id=124077
+
+        Reviewed by Alexey Proskuryakov.
+
+        The abstraction is no longer needed.
+
+        * CMakeLists.txt:
+        * GNUmakefile.list.am:
+        * WebCore.xcodeproj/project.pbxproj:
+
+        * Modules/indexeddb/IDBTransactionBackendInterface.h: Removed.
+
+        * Modules/indexeddb/IDBTransactionBackend.cpp: Renamed from Source/WebCore/Modules/indexeddb/IDBTransactionBackendImpl.cpp.
+        * Modules/indexeddb/IDBTransactionBackend.h: Renamed from Source/WebCore/Modules/indexeddb/IDBTransactionBackendImpl.h.
+
+        * Modules/indexeddb/IDBBackingStoreInterface.h:
+        * Modules/indexeddb/IDBCursorBackend.cpp:
+        * Modules/indexeddb/IDBCursorBackend.h:
+        * Modules/indexeddb/IDBDatabaseBackendImpl.cpp:
+        * Modules/indexeddb/IDBDatabaseBackendImpl.h:
+        * Modules/indexeddb/IDBFactoryBackendInterface.h:
+        * Modules/indexeddb/IDBTransactionBackendOperations.h:
+        * Modules/indexeddb/IDBTransactionCoordinator.cpp:
+        * Modules/indexeddb/IDBTransactionCoordinator.h:
+        * Modules/indexeddb/leveldb/IDBBackingStoreLevelDB.cpp:
+        * Modules/indexeddb/leveldb/IDBBackingStoreLevelDB.h:
+        * Modules/indexeddb/leveldb/IDBFactoryBackendLevelDB.cpp:
+        * Modules/indexeddb/leveldb/IDBFactoryBackendLevelDB.h:
+
 2013-11-08  Simon Fraser  <simon.fraser@apple.com>
 
         REGRESSION (r155660): Some Etherpad pages not scrollable with overlay scrollbars
index 79fc901..bc846f4 100644 (file)
@@ -1847,9 +1847,8 @@ webcore_modules_sources += \
        Source/WebCore/Modules/indexeddb/IDBRequest.h \
        Source/WebCore/Modules/indexeddb/IDBTransaction.cpp \
        Source/WebCore/Modules/indexeddb/IDBTransaction.h \
-       Source/WebCore/Modules/indexeddb/IDBTransactionBackendImpl.cpp \
-       Source/WebCore/Modules/indexeddb/IDBTransactionBackendImpl.h \
-       Source/WebCore/Modules/indexeddb/IDBTransactionBackendInterface.h \
+       Source/WebCore/Modules/indexeddb/IDBTransactionBackend.cpp \
+       Source/WebCore/Modules/indexeddb/IDBTransactionBackend.h \
        Source/WebCore/Modules/indexeddb/IDBTransactionBackendOperations.cpp \
        Source/WebCore/Modules/indexeddb/IDBTransactionBackendOperations.h \
        Source/WebCore/Modules/indexeddb/IDBTransactionCoordinator.cpp \
index 450b043..b920864 100644 (file)
@@ -46,7 +46,7 @@ class IDBKey;
 class IDBKeyPath;
 class IDBKeyRange;
 class IDBRecordIdentifier;
-class IDBTransactionBackendInterface;
+class IDBTransactionBackend;
 class SharedBuffer;
 
 class IDBBackingStoreInterface : public RefCounted<IDBBackingStoreInterface> {
@@ -91,10 +91,10 @@ public:
     virtual bool getKeyGeneratorCurrentNumber(IDBBackingStoreTransactionInterface&, int64_t databaseId, int64_t objectStoreId, int64_t& keyGeneratorCurrentNumber) = 0;
     virtual bool maybeUpdateKeyGeneratorCurrentNumber(IDBBackingStoreTransactionInterface&, int64_t databaseId, int64_t objectStoreId, int64_t newState, bool checkCurrent) = 0;
 
-    virtual bool makeIndexWriters(IDBTransactionBackendInterface&, int64_t databaseId, const IDBObjectStoreMetadata&, IDBKey& primaryKey, bool keyWasGenerated, const Vector<int64_t>& indexIds, const Vector<IndexKeys>&, Vector<RefPtr<IDBIndexWriter>>& indexWriters, String* errorMessage, bool& completed) = 0;
+    virtual bool makeIndexWriters(IDBTransactionBackend&, int64_t databaseId, const IDBObjectStoreMetadata&, IDBKey& primaryKey, bool keyWasGenerated, const Vector<int64_t>& indexIds, const Vector<IndexKeys>&, Vector<RefPtr<IDBIndexWriter>>& indexWriters, String* errorMessage, bool& completed) = 0;
 
-    virtual PassRefPtr<IDBKey> generateKey(IDBTransactionBackendInterface&, int64_t databaseId, int64_t objectStoreId) = 0;
-    virtual bool updateKeyGenerator(IDBTransactionBackendInterface&, int64_t databaseId, int64_t objectStoreId, const IDBKey&, bool checkCurrent) = 0;
+    virtual PassRefPtr<IDBKey> generateKey(IDBTransactionBackend&, int64_t databaseId, int64_t objectStoreId) = 0;
+    virtual bool updateKeyGenerator(IDBTransactionBackend&, int64_t databaseId, int64_t objectStoreId, const IDBKey&, bool checkCurrent) = 0;
 
 };
 
index 801b316..f164e38 100644 (file)
@@ -101,7 +101,7 @@ private:
     RefPtr<IDBCallbacks> m_callbacks;
 };
 
-IDBCursorBackend::IDBCursorBackend(PassRefPtr<IDBBackingStoreCursorInterface> cursor, IndexedDB::CursorType cursorType, IDBDatabaseBackendInterface::TaskType taskType, IDBTransactionBackendInterface* transaction, int64_t objectStoreId)
+IDBCursorBackend::IDBCursorBackend(PassRefPtr<IDBBackingStoreCursorInterface> cursor, IndexedDB::CursorType cursorType, IDBDatabaseBackendInterface::TaskType taskType, IDBTransactionBackend* transaction, int64_t objectStoreId)
     : m_taskType(taskType)
     , m_cursorType(cursorType)
     , m_database(&(transaction->database()))
index b43ff79..314c5bf 100644 (file)
@@ -31,7 +31,7 @@
 
 #include "IDBBackingStoreInterface.h"
 #include "IDBDatabaseBackendImpl.h"
-#include "IDBTransactionBackendImpl.h"
+#include "IDBTransactionBackend.h"
 #include "SharedBuffer.h"
 #include <wtf/OwnPtr.h>
 #include <wtf/PassOwnPtr.h>
@@ -43,11 +43,11 @@ class IDBKeyRange;
 
 class IDBCursorBackend : public RefCounted<IDBCursorBackend> {
 public:
-    static PassRefPtr<IDBCursorBackend> create(PassRefPtr<IDBBackingStoreCursorInterface> cursor, IndexedDB::CursorType cursorType, IDBTransactionBackendInterface* transaction, int64_t objectStoreId)
+    static PassRefPtr<IDBCursorBackend> create(PassRefPtr<IDBBackingStoreCursorInterface> cursor, IndexedDB::CursorType cursorType, IDBTransactionBackend* transaction, int64_t objectStoreId)
     {
         return adoptRef(new IDBCursorBackend(cursor, cursorType, IDBDatabaseBackendInterface::NormalTask, transaction, objectStoreId));
     }
-    static PassRefPtr<IDBCursorBackend> create(PassRefPtr<IDBBackingStoreCursorInterface> cursor, IndexedDB::CursorType cursorType, IDBDatabaseBackendInterface::TaskType taskType, IDBTransactionBackendInterface* transaction, int64_t objectStoreId)
+    static PassRefPtr<IDBCursorBackend> create(PassRefPtr<IDBBackingStoreCursorInterface> cursor, IndexedDB::CursorType cursorType, IDBDatabaseBackendInterface::TaskType taskType, IDBTransactionBackend* transaction, int64_t objectStoreId)
     {
         return adoptRef(new IDBCursorBackend(cursor, cursorType, taskType, transaction, objectStoreId));
     }
@@ -67,7 +67,7 @@ public:
     void close();
 
 private:
-    IDBCursorBackend(PassRefPtr<IDBBackingStoreCursorInterface>, IndexedDB::CursorType, IDBDatabaseBackendInterface::TaskType, IDBTransactionBackendInterface*, int64_t objectStoreId);
+    IDBCursorBackend(PassRefPtr<IDBBackingStoreCursorInterface>, IndexedDB::CursorType, IDBDatabaseBackendInterface::TaskType, IDBTransactionBackend*, int64_t objectStoreId);
 
     class CursorIterationOperation;
     class CursorAdvanceOperation;
@@ -76,7 +76,7 @@ private:
     IDBDatabaseBackendInterface::TaskType m_taskType;
     IndexedDB::CursorType m_cursorType;
     const RefPtr<IDBDatabaseBackendInterface> m_database;
-    RefPtr<IDBTransactionBackendInterface> m_transaction;
+    RefPtr<IDBTransactionBackend> m_transaction;
     const int64_t m_objectStoreId;
 
     RefPtr<IDBBackingStoreCursorInterface> m_cursor; // Must be destroyed before m_transaction.
index 162e999..7161b70 100644 (file)
@@ -36,7 +36,7 @@
 #include "IDBIndexWriter.h"
 #include "IDBKeyRange.h"
 #include "IDBRecordIdentifier.h"
-#include "IDBTransactionBackendInterface.h"
+#include "IDBTransactionBackend.h"
 #include "IDBTransactionCoordinator.h"
 #include "Logging.h"
 #include "SharedBuffer.h"
@@ -135,7 +135,7 @@ IDBBackingStoreInterface* IDBDatabaseBackendImpl::backingStore() const
 void IDBDatabaseBackendImpl::createObjectStore(int64_t transactionId, int64_t objectStoreId, const String& name, const IDBKeyPath& keyPath, bool autoIncrement)
 {
     LOG(StorageAPI, "IDBDatabaseBackendImpl::createObjectStore");
-    IDBTransactionBackendInterface* transaction = m_transactions.get(transactionId);
+    IDBTransactionBackend* transaction = m_transactions.get(transactionId);
     if (!transaction)
         return;
     ASSERT(transaction->mode() == IndexedDB::TransactionVersionChange);
@@ -150,7 +150,7 @@ void IDBDatabaseBackendImpl::createObjectStore(int64_t transactionId, int64_t ob
 void IDBDatabaseBackendImpl::deleteObjectStore(int64_t transactionId, int64_t objectStoreId)
 {
     LOG(StorageAPI, "IDBDatabaseBackendImpl::deleteObjectStore");
-    IDBTransactionBackendInterface* transaction = m_transactions.get(transactionId);
+    IDBTransactionBackend* transaction = m_transactions.get(transactionId);
     if (!transaction)
         return;
     ASSERT(transaction->mode() == IndexedDB::TransactionVersionChange);
@@ -165,7 +165,7 @@ void IDBDatabaseBackendImpl::deleteObjectStore(int64_t transactionId, int64_t ob
 void IDBDatabaseBackendImpl::createIndex(int64_t transactionId, int64_t objectStoreId, int64_t indexId, const String& name, const IDBKeyPath& keyPath, bool unique, bool multiEntry)
 {
     LOG(StorageAPI, "IDBDatabaseBackendImpl::createIndex");
-    IDBTransactionBackendInterface* transaction = m_transactions.get(transactionId);
+    IDBTransactionBackend* transaction = m_transactions.get(transactionId);
     if (!transaction)
         return;
     ASSERT(transaction->mode() == IndexedDB::TransactionVersionChange);
@@ -184,7 +184,7 @@ void IDBDatabaseBackendImpl::createIndex(int64_t transactionId, int64_t objectSt
 void IDBDatabaseBackendImpl::deleteIndex(int64_t transactionId, int64_t objectStoreId, int64_t indexId)
 {
     LOG(StorageAPI, "IDBDatabaseBackendImpl::deleteIndex");
-    IDBTransactionBackendInterface* transaction = m_transactions.get(transactionId);
+    IDBTransactionBackend* transaction = m_transactions.get(transactionId);
     if (!transaction)
         return;
     ASSERT(transaction->mode() == IndexedDB::TransactionVersionChange);
@@ -224,7 +224,7 @@ void IDBDatabaseBackendImpl::abort(int64_t transactionId, PassRefPtr<IDBDatabase
 void IDBDatabaseBackendImpl::get(int64_t transactionId, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, bool keyOnly, PassRefPtr<IDBCallbacks> callbacks)
 {
     LOG(StorageAPI, "IDBDatabaseBackendImpl::get");
-    IDBTransactionBackendInterface* transaction = m_transactions.get(transactionId);
+    IDBTransactionBackend* transaction = m_transactions.get(transactionId);
     if (!transaction)
         return;
 
@@ -234,7 +234,7 @@ void IDBDatabaseBackendImpl::get(int64_t transactionId, int64_t objectStoreId, i
 void IDBDatabaseBackendImpl::put(int64_t transactionId, int64_t objectStoreId, PassRefPtr<SharedBuffer> value, PassRefPtr<IDBKey> key, PutMode putMode, PassRefPtr<IDBCallbacks> callbacks, const Vector<int64_t>& indexIds, const Vector<IndexKeys>& indexKeys)
 {
     LOG(StorageAPI, "IDBDatabaseBackendImpl::put");
-    IDBTransactionBackendInterface* transaction = m_transactions.get(transactionId);
+    IDBTransactionBackend* transaction = m_transactions.get(transactionId);
     if (!transaction)
         return;
     ASSERT(transaction->mode() != IndexedDB::TransactionReadOnly);
@@ -251,7 +251,7 @@ void IDBDatabaseBackendImpl::setIndexKeys(int64_t transactionId, int64_t objectS
     LOG(StorageAPI, "IDBDatabaseBackendImpl::setIndexKeys");
     ASSERT(prpPrimaryKey);
 
-    IDBTransactionBackendInterface* transaction = m_transactions.get(transactionId);
+    IDBTransactionBackend* transaction = m_transactions.get(transactionId);
     if (!transaction)
         return;
     ASSERT(transaction->mode() == IndexedDB::TransactionVersionChange);
@@ -296,7 +296,7 @@ void IDBDatabaseBackendImpl::setIndexesReady(int64_t transactionId, int64_t, con
 {
     LOG(StorageAPI, "IDBDatabaseBackendImpl::setIndexesReady");
 
-    IDBTransactionBackendInterface* transaction = m_transactions.get(transactionId);
+    IDBTransactionBackend* transaction = m_transactions.get(transactionId);
     if (!transaction)
         return;
 
@@ -306,7 +306,7 @@ void IDBDatabaseBackendImpl::setIndexesReady(int64_t transactionId, int64_t, con
 void IDBDatabaseBackendImpl::openCursor(int64_t transactionId, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, IndexedDB::CursorDirection direction, bool keyOnly, TaskType taskType, PassRefPtr<IDBCallbacks> callbacks)
 {
     LOG(StorageAPI, "IDBDatabaseBackendImpl::openCursor");
-    IDBTransactionBackendInterface* transaction = m_transactions.get(transactionId);
+    IDBTransactionBackend* transaction = m_transactions.get(transactionId);
     if (!transaction)
         return;
 
@@ -316,7 +316,7 @@ void IDBDatabaseBackendImpl::openCursor(int64_t transactionId, int64_t objectSto
 void IDBDatabaseBackendImpl::count(int64_t transactionId, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, PassRefPtr<IDBCallbacks> callbacks)
 {
     LOG(StorageAPI, "IDBDatabaseBackendImpl::count");
-    IDBTransactionBackendInterface* transaction = m_transactions.get(transactionId);
+    IDBTransactionBackend* transaction = m_transactions.get(transactionId);
     if (!transaction)
         return;
 
@@ -328,7 +328,7 @@ void IDBDatabaseBackendImpl::count(int64_t transactionId, int64_t objectStoreId,
 void IDBDatabaseBackendImpl::deleteRange(int64_t transactionId, int64_t objectStoreId, PassRefPtr<IDBKeyRange> keyRange, PassRefPtr<IDBCallbacks> callbacks)
 {
     LOG(StorageAPI, "IDBDatabaseBackendImpl::deleteRange");
-    IDBTransactionBackendInterface* transaction = m_transactions.get(transactionId);
+    IDBTransactionBackend* transaction = m_transactions.get(transactionId);
     if (!transaction)
         return;
     ASSERT(transaction->mode() != IndexedDB::TransactionReadOnly);
@@ -339,7 +339,7 @@ void IDBDatabaseBackendImpl::deleteRange(int64_t transactionId, int64_t objectSt
 void IDBDatabaseBackendImpl::clear(int64_t transactionId, int64_t objectStoreId, PassRefPtr<IDBCallbacks> callbacks)
 {
     LOG(StorageAPI, "IDBDatabaseBackendImpl::clear");
-    IDBTransactionBackendInterface* transaction = m_transactions.get(transactionId);
+    IDBTransactionBackend* transaction = m_transactions.get(transactionId);
     if (!transaction)
         return;
     ASSERT(transaction->mode() != IndexedDB::TransactionReadOnly);
@@ -347,7 +347,7 @@ void IDBDatabaseBackendImpl::clear(int64_t transactionId, int64_t objectStoreId,
     transaction->scheduleClearOperation(objectStoreId, callbacks);
 }
 
-void IDBDatabaseBackendImpl::transactionStarted(IDBTransactionBackendInterface* transaction)
+void IDBDatabaseBackendImpl::transactionStarted(IDBTransactionBackend* transaction)
 {
     if (transaction->mode() == IndexedDB::TransactionVersionChange) {
         ASSERT(!m_runningVersionChangeTransaction);
@@ -355,9 +355,9 @@ void IDBDatabaseBackendImpl::transactionStarted(IDBTransactionBackendInterface*
     }
 }
 
-void IDBDatabaseBackendImpl::transactionFinished(IDBTransactionBackendInterface* rawTransaction)
+void IDBDatabaseBackendImpl::transactionFinished(IDBTransactionBackend* rawTransaction)
 {
-    RefPtr<IDBTransactionBackendInterface> transaction = rawTransaction;
+    RefPtr<IDBTransactionBackend> transaction = rawTransaction;
     ASSERT(m_transactions.contains(transaction->id()));
     ASSERT(m_transactions.get(transaction->id()) == transaction.get());
     m_transactions.remove(transaction->id());
@@ -367,9 +367,9 @@ void IDBDatabaseBackendImpl::transactionFinished(IDBTransactionBackendInterface*
     }
 }
 
-void IDBDatabaseBackendImpl::transactionFinishedAndAbortFired(IDBTransactionBackendInterface* rawTransaction)
+void IDBDatabaseBackendImpl::transactionFinishedAndAbortFired(IDBTransactionBackend* rawTransaction)
 {
-    RefPtr<IDBTransactionBackendInterface> transaction = rawTransaction;
+    RefPtr<IDBTransactionBackend> transaction = rawTransaction;
     if (transaction->mode() == IndexedDB::TransactionVersionChange) {
         // If this was an open-with-version call, there will be a "second
         // half" open call waiting for us in processPendingCalls.
@@ -382,9 +382,9 @@ void IDBDatabaseBackendImpl::transactionFinishedAndAbortFired(IDBTransactionBack
     }
 }
 
-void IDBDatabaseBackendImpl::transactionFinishedAndCompleteFired(IDBTransactionBackendInterface* rawTransaction)
+void IDBDatabaseBackendImpl::transactionFinishedAndCompleteFired(IDBTransactionBackend* rawTransaction)
 {
-    RefPtr<IDBTransactionBackendInterface> transaction = rawTransaction;
+    RefPtr<IDBTransactionBackend> transaction = rawTransaction;
     if (transaction->mode() == IndexedDB::TransactionVersionChange)
         processPendingCalls();
 }
@@ -465,7 +465,7 @@ void IDBDatabaseBackendImpl::processPendingOpenCalls(bool success)
 
 void IDBDatabaseBackendImpl::createTransaction(int64_t transactionId, PassRefPtr<IDBDatabaseCallbacks> callbacks, const Vector<int64_t>& objectStoreIds, unsigned short mode)
 {
-    RefPtr<IDBTransactionBackendInterface> transaction = m_factory->maybeCreateTransactionBackend(this, transactionId, callbacks, objectStoreIds, static_cast<IndexedDB::TransactionMode>(mode));
+    RefPtr<IDBTransactionBackend> transaction = m_factory->maybeCreateTransactionBackend(this, transactionId, callbacks, objectStoreIds, static_cast<IndexedDB::TransactionMode>(mode));
 
     if (!transaction)
         return;
@@ -558,7 +558,7 @@ void IDBDatabaseBackendImpl::runIntVersionChangeTransaction(PassRefPtr<IDBCallba
 
     Vector<int64_t> objectStoreIds;
     createTransaction(transactionId, databaseCallbacks, objectStoreIds, IndexedDB::TransactionVersionChange);
-    RefPtr<IDBTransactionBackendInterface> transaction = m_transactions.get(transactionId);
+    RefPtr<IDBTransactionBackend> transaction = m_transactions.get(transactionId);
 
     transaction->scheduleVersionChangeOperation(transactionId, requestedVersion, callbacks, databaseCallbacks, m_metadata);
 
index f8cf104..4ddbe0c 100644 (file)
@@ -41,7 +41,7 @@ namespace WebCore {
 class IDBBackingStoreInterface;
 class IDBDatabase;
 class IDBFactoryBackendInterface;
-class IDBTransactionBackendInterface;
+class IDBTransactionBackend;
 class IDBTransactionCoordinator;
 
 class IDBDatabaseBackendImpl FINAL : public IDBDatabaseBackendInterface {
@@ -75,10 +75,10 @@ public:
     virtual void deleteIndex(int64_t transactionId, int64_t objectStoreId, int64_t indexId);
 
     IDBTransactionCoordinator* transactionCoordinator() const { return m_transactionCoordinator.get(); }
-    void transactionStarted(IDBTransactionBackendInterface*);
-    void transactionFinished(IDBTransactionBackendInterface*);
-    void transactionFinishedAndCompleteFired(IDBTransactionBackendInterface*);
-    void transactionFinishedAndAbortFired(IDBTransactionBackendInterface*);
+    void transactionStarted(IDBTransactionBackend*);
+    void transactionFinished(IDBTransactionBackend*);
+    void transactionFinishedAndCompleteFired(IDBTransactionBackend*);
+    void transactionFinishedAndAbortFired(IDBTransactionBackend*);
 
     virtual void get(int64_t transactionId, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange>, bool keyOnly, PassRefPtr<IDBCallbacks>) OVERRIDE;
     virtual void put(int64_t transactionId, int64_t objectStoreId, PassRefPtr<SharedBuffer> value, PassRefPtr<IDBKey>, PutMode, PassRefPtr<IDBCallbacks>, const Vector<int64_t>& indexIds, const Vector<IndexKeys>&) OVERRIDE;
@@ -126,9 +126,9 @@ private:
     RefPtr<IDBFactoryBackendInterface> m_factory;
 
     OwnPtr<IDBTransactionCoordinator> m_transactionCoordinator;
-    RefPtr<IDBTransactionBackendInterface> m_runningVersionChangeTransaction;
+    RefPtr<IDBTransactionBackend> m_runningVersionChangeTransaction;
 
-    typedef HashMap<int64_t, IDBTransactionBackendInterface*> TransactionMap;
+    typedef HashMap<int64_t, IDBTransactionBackend*> TransactionMap;
     TransactionMap m_transactions;
 
     Deque<OwnPtr<IDBPendingOpenCall>> m_pendingOpenCalls;
index c8057d7..e1a5fc3 100644 (file)
@@ -43,7 +43,7 @@ class IDBCallbacks;
 class IDBDatabase;
 class IDBDatabaseBackendInterface;
 class IDBDatabaseCallbacks;
-class IDBTransactionBackendInterface;
+class IDBTransactionBackend;
 class SecurityOrigin;
 class ScriptExecutionContext;
 
@@ -64,9 +64,9 @@ public:
 
     virtual void removeIDBDatabaseBackend(const String& uniqueIdentifier) = 0;
 
-    virtual PassRefPtr<IDBTransactionBackendInterface> maybeCreateTransactionBackend(IDBDatabaseBackendInterface*, int64_t transactionId, PassRefPtr<IDBDatabaseCallbacks>, const Vector<int64_t>& objectStoreIds, IndexedDB::TransactionMode) = 0;
+    virtual PassRefPtr<IDBTransactionBackend> maybeCreateTransactionBackend(IDBDatabaseBackendInterface*, int64_t transactionId, PassRefPtr<IDBDatabaseCallbacks>, const Vector<int64_t>& objectStoreIds, IndexedDB::TransactionMode) = 0;
 
-    virtual PassRefPtr<IDBCursorBackend> createCursorBackend(IDBTransactionBackendInterface&, IDBBackingStoreCursorInterface&, IndexedDB::CursorType, IDBDatabaseBackendInterface::TaskType, int64_t objectStoreId) = 0;
+    virtual PassRefPtr<IDBCursorBackend> createCursorBackend(IDBTransactionBackend&, IDBBackingStoreCursorInterface&, IndexedDB::CursorType, IDBDatabaseBackendInterface::TaskType, int64_t objectStoreId) = 0;
 };
 
 } // namespace WebCore
@@ -24,7 +24,7 @@
  */
 
 #include "config.h"
-#include "IDBTransactionBackendImpl.h"
+#include "IDBTransactionBackend.h"
 
 #if ENABLE(INDEXED_DATABASE)
 
 
 namespace WebCore {
 
-PassRefPtr<IDBTransactionBackendImpl> IDBTransactionBackendImpl::create(IDBDatabaseBackendImpl* databaseBackend, int64_t id, PassRefPtr<IDBDatabaseCallbacks> callbacks, const Vector<int64_t>& objectStoreIds, IndexedDB::TransactionMode mode)
+PassRefPtr<IDBTransactionBackend> IDBTransactionBackend::create(IDBDatabaseBackendImpl* databaseBackend, int64_t id, PassRefPtr<IDBDatabaseCallbacks> callbacks, const Vector<int64_t>& objectStoreIds, IndexedDB::TransactionMode mode)
 {
     HashSet<int64_t> objectStoreHashSet;
     for (size_t i = 0; i < objectStoreIds.size(); ++i)
         objectStoreHashSet.add(objectStoreIds[i]);
 
-    return adoptRef(new IDBTransactionBackendImpl(databaseBackend, id, callbacks, objectStoreHashSet, mode));
+    return adoptRef(new IDBTransactionBackend(databaseBackend, id, callbacks, objectStoreHashSet, mode));
 }
 
-IDBTransactionBackendImpl::IDBTransactionBackendImpl(IDBDatabaseBackendImpl* databaseBackend, int64_t id, PassRefPtr<IDBDatabaseCallbacks> callbacks, const HashSet<int64_t>& objectStoreIds, IndexedDB::TransactionMode mode)
-    : IDBTransactionBackendInterface(id)
-    , m_objectStoreIds(objectStoreIds)
+IDBTransactionBackend::IDBTransactionBackend(IDBDatabaseBackendImpl* databaseBackend, int64_t id, PassRefPtr<IDBDatabaseCallbacks> callbacks, const HashSet<int64_t>& objectStoreIds, IndexedDB::TransactionMode mode)
+    : m_objectStoreIds(objectStoreIds)
     , m_mode(mode)
     , m_state(Unused)
     , m_commitPending(false)
     , m_callbacks(callbacks)
     , m_database(databaseBackend)
     , m_backingStoreTransaction(databaseBackend->backingStore()->createBackingStoreTransaction())
-    , m_taskTimer(this, &IDBTransactionBackendImpl::taskTimerFired)
+    , m_taskTimer(this, &IDBTransactionBackend::taskTimerFired)
     , m_pendingPreemptiveEvents(0)
     , m_backingStore(databaseBackend->backingStore())
+    , m_id(id)
 {
     // We pass a reference of this object before it can be adopted.
     relaxAdoptionRequirement();
@@ -68,13 +68,13 @@ IDBTransactionBackendImpl::IDBTransactionBackendImpl(IDBDatabaseBackendImpl* dat
     m_database->transactionCoordinator()->didCreateTransaction(this);
 }
 
-IDBTransactionBackendImpl::~IDBTransactionBackendImpl()
+IDBTransactionBackend::~IDBTransactionBackend()
 {
     // It shouldn't be possible for this object to get deleted until it's either complete or aborted.
     ASSERT(m_state == Finished);
 }
 
-void IDBTransactionBackendImpl::scheduleTask(IDBDatabaseBackendInterface::TaskType type, PassOwnPtr<IDBOperation> task, PassOwnPtr<IDBOperation> abortTask)
+void IDBTransactionBackend::scheduleTask(IDBDatabaseBackendInterface::TaskType type, PassOwnPtr<IDBOperation> task, PassOwnPtr<IDBOperation> abortTask)
 {
     if (m_state == Finished)
         return;
@@ -93,14 +93,14 @@ void IDBTransactionBackendImpl::scheduleTask(IDBDatabaseBackendInterface::TaskTy
         m_taskTimer.startOneShot(0);
 }
 
-void IDBTransactionBackendImpl::abort()
+void IDBTransactionBackend::abort()
 {
     abort(IDBDatabaseError::create(IDBDatabaseException::UnknownError, "Internal error (unknown cause)"));
 }
 
-void IDBTransactionBackendImpl::abort(PassRefPtr<IDBDatabaseError> error)
+void IDBTransactionBackend::abort(PassRefPtr<IDBDatabaseError> error)
 {
-    LOG(StorageAPI, "IDBTransactionBackendImpl::abort");
+    LOG(StorageAPI, "IDBTransactionBackend::abort");
     if (m_state == Finished)
         return;
 
@@ -109,7 +109,7 @@ void IDBTransactionBackendImpl::abort(PassRefPtr<IDBDatabaseError> error)
     // The last reference to this object may be released while performing the
     // abort steps below. We therefore take a self reference to keep ourselves
     // alive while executing this method.
-    Ref<IDBTransactionBackendImpl> protect(*this);
+    Ref<IDBTransactionBackend> protect(*this);
 
     m_state = Finished;
     m_taskTimer.stop();
@@ -143,27 +143,27 @@ void IDBTransactionBackendImpl::abort(PassRefPtr<IDBDatabaseError> error)
     m_database = 0;
 }
 
-bool IDBTransactionBackendImpl::isTaskQueueEmpty() const
+bool IDBTransactionBackend::isTaskQueueEmpty() const
 {
     return m_preemptiveTaskQueue.isEmpty() && m_taskQueue.isEmpty();
 }
 
-bool IDBTransactionBackendImpl::hasPendingTasks() const
+bool IDBTransactionBackend::hasPendingTasks() const
 {
     return m_pendingPreemptiveEvents || !isTaskQueueEmpty();
 }
 
-void IDBTransactionBackendImpl::registerOpenCursor(IDBCursorBackend* cursor)
+void IDBTransactionBackend::registerOpenCursor(IDBCursorBackend* cursor)
 {
     m_openCursors.add(cursor);
 }
 
-void IDBTransactionBackendImpl::unregisterOpenCursor(IDBCursorBackend* cursor)
+void IDBTransactionBackend::unregisterOpenCursor(IDBCursorBackend* cursor)
 {
     m_openCursors.remove(cursor);
 }
 
-void IDBTransactionBackendImpl::run()
+void IDBTransactionBackend::run()
 {
     // TransactionCoordinator has started this transaction. Schedule a timer
     // to process the first task.
@@ -173,7 +173,7 @@ void IDBTransactionBackendImpl::run()
     m_taskTimer.startOneShot(0);
 }
 
-void IDBTransactionBackendImpl::start()
+void IDBTransactionBackend::start()
 {
     ASSERT(m_state == Unused);
 
@@ -182,9 +182,9 @@ void IDBTransactionBackendImpl::start()
     m_database->transactionStarted(this);
 }
 
-void IDBTransactionBackendImpl::commit()
+void IDBTransactionBackend::commit()
 {
-    LOG(StorageAPI, "IDBTransactionBackendImpl::commit");
+    LOG(StorageAPI, "IDBTransactionBackend::commit");
 
     // In multiprocess ports, front-end may have requested a commit but an abort has already
     // been initiated asynchronously by the back-end.
@@ -202,7 +202,7 @@ void IDBTransactionBackendImpl::commit()
     // The last reference to this object may be released while performing the
     // commit steps below. We therefore take a self reference to keep ourselves
     // alive while executing this method.
-    Ref<IDBTransactionBackendImpl> protect(*this);
+    Ref<IDBTransactionBackend> protect(*this);
 
     bool unused = m_state == Unused;
     m_state = Finished;
@@ -232,9 +232,9 @@ void IDBTransactionBackendImpl::commit()
     m_database = 0;
 }
 
-void IDBTransactionBackendImpl::taskTimerFired(Timer<IDBTransactionBackendImpl>*)
+void IDBTransactionBackend::taskTimerFired(Timer<IDBTransactionBackend>*)
 {
-    LOG(StorageAPI, "IDBTransactionBackendImpl::taskTimerFired");
+    LOG(StorageAPI, "IDBTransactionBackend::taskTimerFired");
     ASSERT(!isTaskQueueEmpty());
 
     if (m_state == StartPending) {
@@ -245,7 +245,7 @@ void IDBTransactionBackendImpl::taskTimerFired(Timer<IDBTransactionBackendImpl>*
     // The last reference to this object may be released while performing the
     // tasks. Take take a self reference to keep this object alive so that
     // the loop termination conditions can be checked.
-    Ref<IDBTransactionBackendImpl> protect(*this);
+    Ref<IDBTransactionBackend> protect(*this);
 
     TaskQueue* taskQueue = m_pendingPreemptiveEvents ? &m_preemptiveTaskQueue : &m_taskQueue;
     while (!taskQueue->isEmpty() && m_state != Finished) {
@@ -263,74 +263,74 @@ void IDBTransactionBackendImpl::taskTimerFired(Timer<IDBTransactionBackendImpl>*
         commit();
 }
 
-void IDBTransactionBackendImpl::closeOpenCursors()
+void IDBTransactionBackend::closeOpenCursors()
 {
     for (HashSet<IDBCursorBackend*>::iterator i = m_openCursors.begin(); i != m_openCursors.end(); ++i)
         (*i)->close();
     m_openCursors.clear();
 }
 
-void IDBTransactionBackendImpl::scheduleCreateObjectStoreOperation(const IDBObjectStoreMetadata& objectStoreMetadata)
+void IDBTransactionBackend::scheduleCreateObjectStoreOperation(const IDBObjectStoreMetadata& objectStoreMetadata)
 {
     scheduleTask(CreateObjectStoreOperation::create(this, m_backingStore.get(), objectStoreMetadata), CreateObjectStoreAbortOperation::create(this, objectStoreMetadata.id));
 }
 
-void IDBTransactionBackendImpl::scheduleDeleteObjectStoreOperation(const IDBObjectStoreMetadata& objectStoreMetadata)
+void IDBTransactionBackend::scheduleDeleteObjectStoreOperation(const IDBObjectStoreMetadata& objectStoreMetadata)
 {
     scheduleTask(DeleteObjectStoreOperation::create(this, m_backingStore.get(), objectStoreMetadata), DeleteObjectStoreAbortOperation::create(this, objectStoreMetadata));
 }
 
-void IDBTransactionBackendImpl::scheduleVersionChangeOperation(int64_t transactionId, int64_t requestedVersion, PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<IDBDatabaseCallbacks> databaseCallbacks, const IDBDatabaseMetadata& metadata)
+void IDBTransactionBackend::scheduleVersionChangeOperation(int64_t transactionId, int64_t requestedVersion, PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<IDBDatabaseCallbacks> databaseCallbacks, const IDBDatabaseMetadata& metadata)
 {
     scheduleTask(IDBDatabaseBackendImpl::VersionChangeOperation::create(this, transactionId, requestedVersion, callbacks, databaseCallbacks), IDBDatabaseBackendImpl::VersionChangeAbortOperation::create(this, String::number(metadata.version), metadata.version));
 }
 
-void IDBTransactionBackendImpl::scheduleCreateIndexOperation(int64_t objectStoreId, const IDBIndexMetadata& indexMetadata)
+void IDBTransactionBackend::scheduleCreateIndexOperation(int64_t objectStoreId, const IDBIndexMetadata& indexMetadata)
 {
     scheduleTask(CreateIndexOperation::create(this, m_backingStore.get(), objectStoreId, indexMetadata), CreateIndexAbortOperation::create(this, objectStoreId, indexMetadata.id));
 }
 
-void IDBTransactionBackendImpl::scheduleDeleteIndexOperation(int64_t objectStoreId, const IDBIndexMetadata& indexMetadata)
+void IDBTransactionBackend::scheduleDeleteIndexOperation(int64_t objectStoreId, const IDBIndexMetadata& indexMetadata)
 {
     scheduleTask(DeleteIndexOperation::create(this, m_backingStore.get(), objectStoreId, indexMetadata), DeleteIndexAbortOperation::create(this, objectStoreId, indexMetadata));
 }
 
-void IDBTransactionBackendImpl::scheduleGetOperation(const IDBDatabaseMetadata& metadata, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, IndexedDB::CursorType cursorType, PassRefPtr<IDBCallbacks> callbacks)
+void IDBTransactionBackend::scheduleGetOperation(const IDBDatabaseMetadata& metadata, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, IndexedDB::CursorType cursorType, PassRefPtr<IDBCallbacks> callbacks)
 {
     scheduleTask(GetOperation::create(this, m_backingStore.get(), metadata, objectStoreId, indexId, keyRange, cursorType, callbacks));
 }
 
-void IDBTransactionBackendImpl::schedulePutOperation(const IDBObjectStoreMetadata& objectStoreMetadata, PassRefPtr<SharedBuffer> value, PassRefPtr<IDBKey> key, IDBDatabaseBackendInterface::PutMode putMode, PassRefPtr<IDBCallbacks> callbacks, const Vector<int64_t>& indexIds, const Vector<IndexKeys>& indexKeys)
+void IDBTransactionBackend::schedulePutOperation(const IDBObjectStoreMetadata& objectStoreMetadata, PassRefPtr<SharedBuffer> value, PassRefPtr<IDBKey> key, IDBDatabaseBackendInterface::PutMode putMode, PassRefPtr<IDBCallbacks> callbacks, const Vector<int64_t>& indexIds, const Vector<IndexKeys>& indexKeys)
 {
     scheduleTask(PutOperation::create(this, m_backingStore.get(), database().id(), objectStoreMetadata, value, key, putMode, callbacks, indexIds, indexKeys));
 }
 
-void IDBTransactionBackendImpl::scheduleSetIndexesReadyOperation(size_t indexCount)
+void IDBTransactionBackend::scheduleSetIndexesReadyOperation(size_t indexCount)
 {
     scheduleTask(IDBDatabaseBackendInterface::PreemptiveTask, SetIndexesReadyOperation::create(this, indexCount));
 }
 
-void IDBTransactionBackendImpl::scheduleOpenCursorOperation(int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, IndexedDB::CursorDirection direction, IndexedDB::CursorType cursorType, IDBDatabaseBackendInterface::TaskType taskType, PassRefPtr<IDBCallbacks> callbacks)
+void IDBTransactionBackend::scheduleOpenCursorOperation(int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, IndexedDB::CursorDirection direction, IndexedDB::CursorType cursorType, IDBDatabaseBackendInterface::TaskType taskType, PassRefPtr<IDBCallbacks> callbacks)
 {
     scheduleTask(OpenCursorOperation::create(this, m_backingStore.get(), database().id(), objectStoreId, indexId, keyRange, direction, cursorType, taskType, callbacks));
 }
 
-void IDBTransactionBackendImpl::scheduleCountOperation(int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, PassRefPtr<IDBCallbacks> callbacks)
+void IDBTransactionBackend::scheduleCountOperation(int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, PassRefPtr<IDBCallbacks> callbacks)
 {
     scheduleTask(CountOperation::create(this, m_backingStore.get(), database().id(), objectStoreId, indexId, keyRange, callbacks));
 }
 
-void IDBTransactionBackendImpl::scheduleDeleteRangeOperation(int64_t objectStoreId, PassRefPtr<IDBKeyRange> keyRange, PassRefPtr<IDBCallbacks> callbacks)
+void IDBTransactionBackend::scheduleDeleteRangeOperation(int64_t objectStoreId, PassRefPtr<IDBKeyRange> keyRange, PassRefPtr<IDBCallbacks> callbacks)
 {
     scheduleTask(DeleteRangeOperation::create(this, m_backingStore.get(), database().id(), objectStoreId, keyRange, callbacks));
 }
 
-void IDBTransactionBackendImpl::scheduleClearOperation(int64_t objectStoreId, PassRefPtr<IDBCallbacks> callbacks)
+void IDBTransactionBackend::scheduleClearOperation(int64_t objectStoreId, PassRefPtr<IDBCallbacks> callbacks)
 {
     scheduleTask(ClearOperation::create(this, m_backingStore.get(), database().id(), objectStoreId, callbacks));
 }
 
-PassRefPtr<IDBCursorBackend> IDBTransactionBackendImpl::createCursorBackend(IDBBackingStoreCursorInterface& cursor, IndexedDB::CursorType cursorType, IDBDatabaseBackendInterface::TaskType taskType, int64_t objectStoreId)
+PassRefPtr<IDBCursorBackend> IDBTransactionBackend::createCursorBackend(IDBBackingStoreCursorInterface& cursor, IndexedDB::CursorType cursorType, IDBDatabaseBackendInterface::TaskType taskType, int64_t objectStoreId)
 {
     return m_database->factoryBackend().createCursorBackend(*this, cursor, cursorType, taskType, objectStoreId);
 }
diff --git a/Source/WebCore/Modules/indexeddb/IDBTransactionBackend.h b/Source/WebCore/Modules/indexeddb/IDBTransactionBackend.h
new file mode 100644 (file)
index 0000000..ec296bf
--- /dev/null
@@ -0,0 +1,136 @@
+/*
+ * Copyright (C) 2010 Google 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.
+ *
+ * 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.
+ */
+
+#ifndef IDBTransactionBackend_h
+#define IDBTransactionBackend_h
+
+#if ENABLE(INDEXED_DATABASE)
+
+#include "IDBBackingStoreInterface.h"
+#include "IDBDatabaseBackendImpl.h"
+#include "IDBDatabaseBackendInterface.h"
+#include "IDBDatabaseError.h"
+#include "IDBOperation.h"
+#include "IDBTransactionBackend.h"
+#include "Timer.h"
+#include <wtf/Deque.h>
+#include <wtf/HashSet.h>
+#include <wtf/RefPtr.h>
+
+namespace WebCore {
+
+class IDBDatabaseCallbacks;
+
+class IDBTransactionBackend : public RefCounted<IDBTransactionBackend> {
+public:
+    static PassRefPtr<IDBTransactionBackend> create(IDBDatabaseBackendImpl*, int64_t transactionId, PassRefPtr<IDBDatabaseCallbacks>, const Vector<int64_t>& objectStoreIds, IndexedDB::TransactionMode);
+    ~IDBTransactionBackend();
+
+    void commit();
+    void abort();
+    void abort(PassRefPtr<IDBDatabaseError>);
+
+    void run();
+    IndexedDB::TransactionMode mode() const  { return m_mode; }
+    const HashSet<int64_t>& scope() const  { return m_objectStoreIds; }
+
+    void scheduleTask(PassOwnPtr<IDBOperation> task, PassOwnPtr<IDBOperation> abortTask = nullptr) { scheduleTask(IDBDatabaseBackendInterface::NormalTask, task, abortTask); }
+    void scheduleTask(IDBDatabaseBackendInterface::TaskType, PassOwnPtr<IDBOperation>, PassOwnPtr<IDBOperation> abortTask = nullptr);
+
+    void registerOpenCursor(IDBCursorBackend*);
+    void unregisterOpenCursor(IDBCursorBackend*);
+
+    void addPreemptiveEvent()  { m_pendingPreemptiveEvents++; }
+    void didCompletePreemptiveEvent()  { m_pendingPreemptiveEvents--; ASSERT(m_pendingPreemptiveEvents >= 0); }
+    IDBBackingStoreTransactionInterface& backingStoreTransaction() { return *m_backingStoreTransaction; }
+
+    IDBDatabaseBackendInterface& database() const  { return *m_database; }
+
+    void scheduleCreateObjectStoreOperation(const IDBObjectStoreMetadata&);
+    void scheduleDeleteObjectStoreOperation(const IDBObjectStoreMetadata&);
+    void scheduleVersionChangeOperation(int64_t transactionId, int64_t requestedVersion, PassRefPtr<IDBCallbacks>, PassRefPtr<IDBDatabaseCallbacks>, const IDBDatabaseMetadata&);
+    void scheduleCreateIndexOperation(int64_t objectStoreId, const IDBIndexMetadata&);
+    void scheduleDeleteIndexOperation(int64_t objectStoreId, const IDBIndexMetadata&);
+    void scheduleGetOperation(const IDBDatabaseMetadata&, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange>, IndexedDB::CursorType, PassRefPtr<IDBCallbacks>);
+    void schedulePutOperation(const IDBObjectStoreMetadata&, PassRefPtr<SharedBuffer> value, PassRefPtr<IDBKey>, IDBDatabaseBackendInterface::PutMode, PassRefPtr<IDBCallbacks>, const Vector<int64_t>& indexIds, const Vector<IndexKeys>&);
+    void scheduleSetIndexesReadyOperation(size_t indexCount);
+    void scheduleOpenCursorOperation(int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange>, IndexedDB::CursorDirection, IndexedDB::CursorType, IDBDatabaseBackendInterface::TaskType, PassRefPtr<IDBCallbacks>);
+    void scheduleCountOperation(int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange>, PassRefPtr<IDBCallbacks>);
+    void scheduleDeleteRangeOperation(int64_t objectStoreId, PassRefPtr<IDBKeyRange>, PassRefPtr<IDBCallbacks>);
+    void scheduleClearOperation(int64_t objectStoreId, PassRefPtr<IDBCallbacks>);
+
+    PassRefPtr<IDBCursorBackend> createCursorBackend(IDBBackingStoreCursorInterface&, IndexedDB::CursorType, IDBDatabaseBackendInterface::TaskType, int64_t objectStoreId);
+
+    int64_t id() const { return m_id; }
+
+private:
+    IDBTransactionBackend(IDBDatabaseBackendImpl*, int64_t id, PassRefPtr<IDBDatabaseCallbacks>, const HashSet<int64_t>& objectStoreIds, IndexedDB::TransactionMode);
+
+    enum State {
+        Unused, // Created, but no tasks yet.
+        StartPending, // Enqueued tasks, but backing store transaction not yet started.
+        Running, // Backing store transaction started but not yet finished.
+        Finished, // Either aborted or committed.
+    };
+
+    void start();
+
+    bool isTaskQueueEmpty() const;
+    bool hasPendingTasks() const;
+
+    void taskTimerFired(Timer<IDBTransactionBackend>*);
+    void closeOpenCursors();
+
+    const HashSet<int64_t> m_objectStoreIds;
+    const IndexedDB::TransactionMode m_mode;
+
+    State m_state;
+    bool m_commitPending;
+    RefPtr<IDBDatabaseCallbacks> m_callbacks;
+    RefPtr<IDBDatabaseBackendImpl> m_database;
+
+    typedef Deque<OwnPtr<IDBOperation>> TaskQueue;
+    TaskQueue m_taskQueue;
+    TaskQueue m_preemptiveTaskQueue;
+    TaskQueue m_abortTaskQueue;
+
+    std::unique_ptr<IDBBackingStoreTransactionInterface> m_backingStoreTransaction;
+
+    // FIXME: delete the timer once we have threads instead.
+    Timer<IDBTransactionBackend> m_taskTimer;
+    int m_pendingPreemptiveEvents;
+
+    HashSet<IDBCursorBackend*> m_openCursors;
+    
+    RefPtr<IDBBackingStoreInterface> m_backingStore;
+
+    int64_t m_id;
+};
+
+} // namespace WebCore
+
+#endif // ENABLE(INDEXED_DATABASE)
+
+#endif // IDBTransactionBackend_h
diff --git a/Source/WebCore/Modules/indexeddb/IDBTransactionBackendImpl.h b/Source/WebCore/Modules/indexeddb/IDBTransactionBackendImpl.h
deleted file mode 100644 (file)
index 619a612..0000000
+++ /dev/null
@@ -1,132 +0,0 @@
-/*
- * Copyright (C) 2010 Google 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.
- *
- * 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.
- */
-
-#ifndef IDBTransactionBackendImpl_h
-#define IDBTransactionBackendImpl_h
-
-#if ENABLE(INDEXED_DATABASE)
-
-#include "IDBBackingStoreInterface.h"
-#include "IDBDatabaseBackendImpl.h"
-#include "IDBDatabaseBackendInterface.h"
-#include "IDBDatabaseError.h"
-#include "IDBOperation.h"
-#include "IDBTransactionBackendInterface.h"
-#include "Timer.h"
-#include <wtf/Deque.h>
-#include <wtf/HashSet.h>
-#include <wtf/RefPtr.h>
-
-namespace WebCore {
-
-class IDBDatabaseCallbacks;
-
-class IDBTransactionBackendImpl FINAL : public IDBTransactionBackendInterface {
-public:
-    static PassRefPtr<IDBTransactionBackendImpl> create(IDBDatabaseBackendImpl*, int64_t transactionId, PassRefPtr<IDBDatabaseCallbacks>, const Vector<int64_t>& objectStoreIds, IndexedDB::TransactionMode);
-    virtual ~IDBTransactionBackendImpl();
-
-    virtual void commit() OVERRIDE FINAL;
-    virtual void abort() OVERRIDE FINAL;
-    virtual void abort(PassRefPtr<IDBDatabaseError>) OVERRIDE FINAL;
-
-    virtual void run() OVERRIDE;
-    virtual IndexedDB::TransactionMode mode() const OVERRIDE FINAL { return m_mode; }
-    const HashSet<int64_t>& scope() const OVERRIDE { return m_objectStoreIds; }
-
-    virtual void scheduleTask(PassOwnPtr<IDBOperation> task, PassOwnPtr<IDBOperation> abortTask = nullptr) { scheduleTask(IDBDatabaseBackendInterface::NormalTask, task, abortTask); }
-    virtual void scheduleTask(IDBDatabaseBackendInterface::TaskType, PassOwnPtr<IDBOperation>, PassOwnPtr<IDBOperation> abortTask = nullptr) OVERRIDE;
-
-    virtual void registerOpenCursor(IDBCursorBackend*) OVERRIDE;
-    virtual void unregisterOpenCursor(IDBCursorBackend*) OVERRIDE;
-
-    virtual void addPreemptiveEvent() OVERRIDE { m_pendingPreemptiveEvents++; }
-    virtual void didCompletePreemptiveEvent() OVERRIDE { m_pendingPreemptiveEvents--; ASSERT(m_pendingPreemptiveEvents >= 0); }
-    virtual IDBBackingStoreTransactionInterface& backingStoreTransaction() { return *m_backingStoreTransaction; }
-
-    virtual IDBDatabaseBackendInterface& database() const OVERRIDE { return *m_database; }
-
-    virtual void scheduleCreateObjectStoreOperation(const IDBObjectStoreMetadata&) OVERRIDE FINAL;
-    virtual void scheduleDeleteObjectStoreOperation(const IDBObjectStoreMetadata&) OVERRIDE FINAL;
-    virtual void scheduleVersionChangeOperation(int64_t transactionId, int64_t requestedVersion, PassRefPtr<IDBCallbacks>, PassRefPtr<IDBDatabaseCallbacks>, const IDBDatabaseMetadata&) OVERRIDE FINAL;
-    virtual void scheduleCreateIndexOperation(int64_t objectStoreId, const IDBIndexMetadata&) OVERRIDE FINAL;
-    virtual void scheduleDeleteIndexOperation(int64_t objectStoreId, const IDBIndexMetadata&) OVERRIDE FINAL;
-    virtual void scheduleGetOperation(const IDBDatabaseMetadata&, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange>, IndexedDB::CursorType, PassRefPtr<IDBCallbacks>) OVERRIDE FINAL;
-    virtual void schedulePutOperation(const IDBObjectStoreMetadata&, PassRefPtr<SharedBuffer> value, PassRefPtr<IDBKey>, IDBDatabaseBackendInterface::PutMode, PassRefPtr<IDBCallbacks>, const Vector<int64_t>& indexIds, const Vector<IndexKeys>&) OVERRIDE FINAL;
-    virtual void scheduleSetIndexesReadyOperation(size_t indexCount) OVERRIDE FINAL;
-    virtual void scheduleOpenCursorOperation(int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange>, IndexedDB::CursorDirection, IndexedDB::CursorType, IDBDatabaseBackendInterface::TaskType, PassRefPtr<IDBCallbacks>) OVERRIDE FINAL;
-    virtual void scheduleCountOperation(int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange>, PassRefPtr<IDBCallbacks>) OVERRIDE FINAL;
-    virtual void scheduleDeleteRangeOperation(int64_t objectStoreId, PassRefPtr<IDBKeyRange>, PassRefPtr<IDBCallbacks>) OVERRIDE FINAL;
-    virtual void scheduleClearOperation(int64_t objectStoreId, PassRefPtr<IDBCallbacks>) OVERRIDE FINAL;
-
-    virtual PassRefPtr<IDBCursorBackend> createCursorBackend(IDBBackingStoreCursorInterface&, IndexedDB::CursorType, IDBDatabaseBackendInterface::TaskType, int64_t objectStoreId) OVERRIDE;
-
-private:
-    IDBTransactionBackendImpl(IDBDatabaseBackendImpl*, int64_t id, PassRefPtr<IDBDatabaseCallbacks>, const HashSet<int64_t>& objectStoreIds, IndexedDB::TransactionMode);
-
-    enum State {
-        Unused, // Created, but no tasks yet.
-        StartPending, // Enqueued tasks, but backing store transaction not yet started.
-        Running, // Backing store transaction started but not yet finished.
-        Finished, // Either aborted or committed.
-    };
-
-    void start();
-
-    bool isTaskQueueEmpty() const;
-    bool hasPendingTasks() const;
-
-    void taskTimerFired(Timer<IDBTransactionBackendImpl>*);
-    void closeOpenCursors();
-
-    const HashSet<int64_t> m_objectStoreIds;
-    const IndexedDB::TransactionMode m_mode;
-
-    State m_state;
-    bool m_commitPending;
-    RefPtr<IDBDatabaseCallbacks> m_callbacks;
-    RefPtr<IDBDatabaseBackendImpl> m_database;
-
-    typedef Deque<OwnPtr<IDBOperation>> TaskQueue;
-    TaskQueue m_taskQueue;
-    TaskQueue m_preemptiveTaskQueue;
-    TaskQueue m_abortTaskQueue;
-
-    std::unique_ptr<IDBBackingStoreTransactionInterface> m_backingStoreTransaction;
-
-    // FIXME: delete the timer once we have threads instead.
-    Timer<IDBTransactionBackendImpl> m_taskTimer;
-    int m_pendingPreemptiveEvents;
-
-    HashSet<IDBCursorBackend*> m_openCursors;
-    
-    RefPtr<IDBBackingStoreInterface> m_backingStore;
-};
-
-} // namespace WebCore
-
-#endif // ENABLE(INDEXED_DATABASE)
-
-#endif // IDBTransactionBackendImpl_h
diff --git a/Source/WebCore/Modules/indexeddb/IDBTransactionBackendInterface.h b/Source/WebCore/Modules/indexeddb/IDBTransactionBackendInterface.h
deleted file mode 100644 (file)
index 5902c61..0000000
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
- * Copyright (C) 2013 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.
- *
- * 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.
- */
-
-#ifndef IDBTransactionBackendInterface_h
-#define IDBTransactionBackendInterface_h
-
-#include "IDBBackingStoreInterface.h"
-#include "IDBDatabaseBackendInterface.h"
-#include "IndexedDB.h"
-#include <wtf/HashSet.h>
-#include <wtf/RefCounted.h>
-#include <wtf/Vector.h>
-
-#if ENABLE(INDEXED_DATABASE)
-
-namespace WebCore {
-
-class IDBCallbacks;
-class IDBDatabaseCallbacks;
-class IDBDatabaseError;
-class IDBKey;
-class IDBKeyRange;
-class IDBOperation;
-
-struct IDBDatabaseMetadata;
-struct IDBIndexMetadata;
-struct IDBObjectStoreMetadata;
-
-class IDBTransactionBackendInterface : public RefCounted<IDBTransactionBackendInterface> {
-public:
-    virtual ~IDBTransactionBackendInterface() { }
-
-    virtual IndexedDB::TransactionMode mode() const = 0;
-
-    virtual void run() = 0;
-    virtual void commit() = 0;
-    virtual void abort() = 0;
-    virtual void abort(PassRefPtr<IDBDatabaseError>) = 0;
-    virtual const HashSet<int64_t>& scope() const = 0;
-
-    virtual void scheduleTask(PassOwnPtr<IDBOperation>, PassOwnPtr<IDBOperation> abortTask = nullptr) = 0;
-    virtual void scheduleTask(IDBDatabaseBackendInterface::TaskType, PassOwnPtr<IDBOperation>, PassOwnPtr<IDBOperation> abortTask = nullptr) = 0;
-
-    virtual void registerOpenCursor(IDBCursorBackend*) = 0;
-    virtual void unregisterOpenCursor(IDBCursorBackend*) = 0;
-
-    virtual void scheduleCreateObjectStoreOperation(const IDBObjectStoreMetadata&) = 0;
-    virtual void scheduleDeleteObjectStoreOperation(const IDBObjectStoreMetadata&) = 0;
-    virtual void scheduleVersionChangeOperation(int64_t transactionId, int64_t requestedVersion, PassRefPtr<IDBCallbacks>, PassRefPtr<IDBDatabaseCallbacks>, const IDBDatabaseMetadata&) = 0;
-    virtual void scheduleCreateIndexOperation(int64_t objectStoreId, const IDBIndexMetadata&) = 0;
-    virtual void scheduleDeleteIndexOperation(int64_t objectStoreId, const IDBIndexMetadata&) = 0;
-    virtual void scheduleGetOperation(const IDBDatabaseMetadata&, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange>, IndexedDB::CursorType, PassRefPtr<IDBCallbacks>) = 0;
-    virtual void schedulePutOperation(const IDBObjectStoreMetadata&, PassRefPtr<SharedBuffer> value, PassRefPtr<IDBKey>, IDBDatabaseBackendInterface::PutMode, PassRefPtr<IDBCallbacks>, const Vector<int64_t>& indexIds, const Vector<IndexKeys>&) = 0;
-    virtual void scheduleSetIndexesReadyOperation(size_t indexCount) = 0;
-    virtual void scheduleOpenCursorOperation(int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange>, IndexedDB::CursorDirection, IndexedDB::CursorType, IDBDatabaseBackendInterface::TaskType, PassRefPtr<IDBCallbacks>) = 0;
-    virtual void scheduleCountOperation(int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange>, PassRefPtr<IDBCallbacks>) = 0;
-    virtual void scheduleDeleteRangeOperation(int64_t objectStoreId, PassRefPtr<IDBKeyRange>, PassRefPtr<IDBCallbacks>) = 0;
-    virtual void scheduleClearOperation(int64_t objectStoreId, PassRefPtr<IDBCallbacks>) = 0;
-
-    virtual void addPreemptiveEvent() = 0;
-    virtual void didCompletePreemptiveEvent() = 0;
-
-    virtual IDBBackingStoreTransactionInterface& backingStoreTransaction() = 0;
-    virtual IDBDatabaseBackendInterface& database() const = 0;
-
-    virtual PassRefPtr<IDBCursorBackend> createCursorBackend(IDBBackingStoreCursorInterface&, IndexedDB::CursorType, IDBDatabaseBackendInterface::TaskType, int64_t objectStoreId) = 0;
-
-    int64_t id() const { return m_id; }
-
-protected:
-    IDBTransactionBackendInterface(int64_t id)
-        : m_id(id)
-    {
-    }
-
-private:
-    int64_t m_id;
-};
-
-} // namespace WebCore
-
-#endif // ENABLE(INDEXED_DATABASE)
-#endif // IDBTransactionBackendInterface_h
index 443b6e5..2065f46 100644 (file)
@@ -28,7 +28,7 @@
 
 #include "IDBDatabaseBackendImpl.h"
 #include "IDBOperation.h"
-#include "IDBTransactionBackendInterface.h"
+#include "IDBTransactionBackend.h"
 
 #if ENABLE(INDEXED_DATABASE)
 
@@ -36,53 +36,53 @@ namespace WebCore {
 
 class CreateObjectStoreOperation : public IDBOperation {
 public:
-    static PassOwnPtr<IDBOperation> create(IDBTransactionBackendInterface* transaction, IDBBackingStoreInterface* backingStore, const IDBObjectStoreMetadata& objectStoreMetadata)
+    static PassOwnPtr<IDBOperation> create(IDBTransactionBackend* transaction, IDBBackingStoreInterface* backingStore, const IDBObjectStoreMetadata& objectStoreMetadata)
     {
         return adoptPtr(new CreateObjectStoreOperation(transaction, backingStore, objectStoreMetadata));
     }
     virtual void perform() OVERRIDE FINAL;
 private:
-    CreateObjectStoreOperation(IDBTransactionBackendInterface* transaction, IDBBackingStoreInterface* backingStore, const IDBObjectStoreMetadata& objectStoreMetadata)
+    CreateObjectStoreOperation(IDBTransactionBackend* transaction, IDBBackingStoreInterface* backingStore, const IDBObjectStoreMetadata& objectStoreMetadata)
         : m_transaction(transaction)
         , m_backingStore(backingStore)
         , m_objectStoreMetadata(objectStoreMetadata)
     {
     }
     
-    RefPtr<IDBTransactionBackendInterface> m_transaction;
+    RefPtr<IDBTransactionBackend> m_transaction;
     const RefPtr<IDBBackingStoreInterface> m_backingStore;
     const IDBObjectStoreMetadata m_objectStoreMetadata;
 };
 
 class DeleteObjectStoreOperation : public IDBOperation {
 public:
-    static PassOwnPtr<IDBOperation> create(IDBTransactionBackendInterface* transaction, IDBBackingStoreInterface* backingStore, const IDBObjectStoreMetadata& objectStoreMetadata)
+    static PassOwnPtr<IDBOperation> create(IDBTransactionBackend* transaction, IDBBackingStoreInterface* backingStore, const IDBObjectStoreMetadata& objectStoreMetadata)
     {
         return adoptPtr(new DeleteObjectStoreOperation(transaction, backingStore, objectStoreMetadata));
     }
     virtual void perform() OVERRIDE FINAL;
 private:
-    DeleteObjectStoreOperation(IDBTransactionBackendInterface* transaction, IDBBackingStoreInterface* backingStore, const IDBObjectStoreMetadata& objectStoreMetadata)
+    DeleteObjectStoreOperation(IDBTransactionBackend* transaction, IDBBackingStoreInterface* backingStore, const IDBObjectStoreMetadata& objectStoreMetadata)
         : m_transaction(transaction)
         , m_backingStore(backingStore)
         , m_objectStoreMetadata(objectStoreMetadata)
     {
     }
 
-    RefPtr<IDBTransactionBackendInterface> m_transaction;
+    RefPtr<IDBTransactionBackend> m_transaction;
     const RefPtr<IDBBackingStoreInterface> m_backingStore;
     const IDBObjectStoreMetadata m_objectStoreMetadata;
 };
 
 class IDBDatabaseBackendImpl::VersionChangeOperation : public IDBOperation {
 public:
-    static PassOwnPtr<IDBOperation> create(IDBTransactionBackendInterface* transaction, int64_t transactionId, int64_t version, PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<IDBDatabaseCallbacks> databaseCallbacks)
+    static PassOwnPtr<IDBOperation> create(IDBTransactionBackend* transaction, int64_t transactionId, int64_t version, PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<IDBDatabaseCallbacks> databaseCallbacks)
     {
         return adoptPtr(new VersionChangeOperation(transaction, transactionId, version, callbacks, databaseCallbacks));
     }
     virtual void perform() OVERRIDE FINAL;
 private:
-    VersionChangeOperation(IDBTransactionBackendInterface* transaction, int64_t transactionId, int64_t version, PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<IDBDatabaseCallbacks> databaseCallbacks)
+    VersionChangeOperation(IDBTransactionBackend* transaction, int64_t transactionId, int64_t version, PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<IDBDatabaseCallbacks> databaseCallbacks)
         : m_transaction(transaction)
         , m_transactionId(transactionId)
         , m_version(version)
@@ -91,7 +91,7 @@ private:
     {
     }
 
-    RefPtr<IDBTransactionBackendInterface> m_transaction;
+    RefPtr<IDBTransactionBackend> m_transaction;
     int64_t m_transactionId;
     int64_t m_version;
     RefPtr<IDBCallbacks> m_callbacks;
@@ -100,69 +100,69 @@ private:
 
 class CreateObjectStoreAbortOperation : public IDBOperation {
 public:
-    static PassOwnPtr<IDBOperation> create(IDBTransactionBackendInterface* transaction, int64_t objectStoreId)
+    static PassOwnPtr<IDBOperation> create(IDBTransactionBackend* transaction, int64_t objectStoreId)
     {
         return adoptPtr(new CreateObjectStoreAbortOperation(transaction, objectStoreId));
     }
     virtual void perform() OVERRIDE FINAL;
 private:
-    CreateObjectStoreAbortOperation(IDBTransactionBackendInterface* transaction, int64_t objectStoreId)
+    CreateObjectStoreAbortOperation(IDBTransactionBackend* transaction, int64_t objectStoreId)
         : m_transaction(transaction)
         , m_objectStoreId(objectStoreId)
     {
     }
 
-    RefPtr<IDBTransactionBackendInterface> m_transaction;
+    RefPtr<IDBTransactionBackend> m_transaction;
     const int64_t m_objectStoreId;
 };
 
 class DeleteObjectStoreAbortOperation : public IDBOperation {
 public:
-    static PassOwnPtr<IDBOperation> create(IDBTransactionBackendInterface* transaction, const IDBObjectStoreMetadata& objectStore)
+    static PassOwnPtr<IDBOperation> create(IDBTransactionBackend* transaction, const IDBObjectStoreMetadata& objectStore)
     {
         return adoptPtr(new DeleteObjectStoreAbortOperation(transaction, objectStore));
     }
     virtual void perform() OVERRIDE FINAL;
 private:
-    DeleteObjectStoreAbortOperation(IDBTransactionBackendInterface* transaction, const IDBObjectStoreMetadata& objectStoreMetadata)
+    DeleteObjectStoreAbortOperation(IDBTransactionBackend* transaction, const IDBObjectStoreMetadata& objectStoreMetadata)
         : m_transaction(transaction)
         , m_objectStoreMetadata(objectStoreMetadata)
     {
     }
 
-    RefPtr<IDBTransactionBackendInterface> m_transaction;
+    RefPtr<IDBTransactionBackend> m_transaction;
     IDBObjectStoreMetadata m_objectStoreMetadata;
 };
 
 class IDBDatabaseBackendImpl::VersionChangeAbortOperation : public IDBOperation {
 public:
-    static PassOwnPtr<IDBOperation> create(IDBTransactionBackendInterface* transaction, const String& previousVersion, int64_t previousIntVersion)
+    static PassOwnPtr<IDBOperation> create(IDBTransactionBackend* transaction, const String& previousVersion, int64_t previousIntVersion)
     {
         return adoptPtr(new VersionChangeAbortOperation(transaction, previousVersion, previousIntVersion));
     }
     virtual void perform() OVERRIDE FINAL;
 private:
-    VersionChangeAbortOperation(IDBTransactionBackendInterface* transaction, const String& previousVersion, int64_t previousIntVersion)
+    VersionChangeAbortOperation(IDBTransactionBackend* transaction, const String& previousVersion, int64_t previousIntVersion)
         : m_transaction(transaction)
         , m_previousVersion(previousVersion)
         , m_previousIntVersion(previousIntVersion)
     {
     }
 
-    RefPtr<IDBTransactionBackendInterface> m_transaction;
+    RefPtr<IDBTransactionBackend> m_transaction;
     String m_previousVersion;
     int64_t m_previousIntVersion;
 };
 
 class CreateIndexOperation : public IDBOperation {
 public:
-    static PassOwnPtr<IDBOperation> create(IDBTransactionBackendInterface* transaction, IDBBackingStoreInterface* backingStore, int64_t objectStoreId, const IDBIndexMetadata& indexMetadata)
+    static PassOwnPtr<IDBOperation> create(IDBTransactionBackend* transaction, IDBBackingStoreInterface* backingStore, int64_t objectStoreId, const IDBIndexMetadata& indexMetadata)
     {
         return adoptPtr(new CreateIndexOperation(transaction, backingStore, objectStoreId, indexMetadata));
     }
     virtual void perform() OVERRIDE FINAL;
 private:
-    CreateIndexOperation(IDBTransactionBackendInterface* transaction, IDBBackingStoreInterface* backingStore, int64_t objectStoreId, const IDBIndexMetadata& indexMetadata)
+    CreateIndexOperation(IDBTransactionBackend* transaction, IDBBackingStoreInterface* backingStore, int64_t objectStoreId, const IDBIndexMetadata& indexMetadata)
         : m_transaction(transaction)
         , m_backingStore(backingStore)
         , m_objectStoreId(objectStoreId)
@@ -170,7 +170,7 @@ private:
     {
     }
 
-    RefPtr<IDBTransactionBackendInterface> m_transaction;
+    RefPtr<IDBTransactionBackend> m_transaction;
     const RefPtr<IDBBackingStoreInterface> m_backingStore;
     const int64_t m_objectStoreId;
     const IDBIndexMetadata m_indexMetadata;
@@ -178,33 +178,33 @@ private:
 
 class CreateIndexAbortOperation : public IDBOperation {
 public:
-    static PassOwnPtr<IDBOperation> create(IDBTransactionBackendInterface* transaction, int64_t objectStoreId, int64_t indexId)
+    static PassOwnPtr<IDBOperation> create(IDBTransactionBackend* transaction, int64_t objectStoreId, int64_t indexId)
     {
         return adoptPtr(new CreateIndexAbortOperation(transaction, objectStoreId, indexId));
     }
     virtual void perform() OVERRIDE FINAL;
 private:
-    CreateIndexAbortOperation(IDBTransactionBackendInterface* transaction, int64_t objectStoreId, int64_t indexId)
+    CreateIndexAbortOperation(IDBTransactionBackend* transaction, int64_t objectStoreId, int64_t indexId)
         : m_transaction(transaction)
         , m_objectStoreId(objectStoreId)
         , m_indexId(indexId)
     {
     }
 
-    const RefPtr<IDBTransactionBackendInterface> m_transaction;
+    const RefPtr<IDBTransactionBackend> m_transaction;
     const int64_t m_objectStoreId;
     const int64_t m_indexId;
 };
 
 class DeleteIndexOperation : public IDBOperation {
 public:
-    static PassOwnPtr<IDBOperation> create(IDBTransactionBackendInterface* transaction, IDBBackingStoreInterface* backingStore, int64_t objectStoreId, const IDBIndexMetadata& indexMetadata)
+    static PassOwnPtr<IDBOperation> create(IDBTransactionBackend* transaction, IDBBackingStoreInterface* backingStore, int64_t objectStoreId, const IDBIndexMetadata& indexMetadata)
     {
         return adoptPtr(new DeleteIndexOperation(transaction, backingStore, objectStoreId, indexMetadata));
     }
     virtual void perform() OVERRIDE FINAL;
 private:
-    DeleteIndexOperation(IDBTransactionBackendInterface* transaction, IDBBackingStoreInterface* backingStore, int64_t objectStoreId, const IDBIndexMetadata& indexMetadata)
+    DeleteIndexOperation(IDBTransactionBackend* transaction, IDBBackingStoreInterface* backingStore, int64_t objectStoreId, const IDBIndexMetadata& indexMetadata)
         : m_transaction(transaction)
         , m_backingStore(backingStore)
         , m_objectStoreId(objectStoreId)
@@ -212,7 +212,7 @@ private:
     {
     }
 
-    RefPtr<IDBTransactionBackendInterface> m_transaction;
+    RefPtr<IDBTransactionBackend> m_transaction;
     const RefPtr<IDBBackingStoreInterface> m_backingStore;
     const int64_t m_objectStoreId;
     const IDBIndexMetadata m_indexMetadata;
@@ -220,33 +220,33 @@ private:
 
 class DeleteIndexAbortOperation : public IDBOperation {
 public:
-    static PassOwnPtr<IDBOperation> create(IDBTransactionBackendInterface* transaction, int64_t objectStoreId, const IDBIndexMetadata& indexMetadata)
+    static PassOwnPtr<IDBOperation> create(IDBTransactionBackend* transaction, int64_t objectStoreId, const IDBIndexMetadata& indexMetadata)
     {
         return adoptPtr(new DeleteIndexAbortOperation(transaction, objectStoreId, indexMetadata));
     }
     virtual void perform() OVERRIDE FINAL;
 private:
-    DeleteIndexAbortOperation(IDBTransactionBackendInterface* transaction, int64_t objectStoreId, const IDBIndexMetadata& indexMetadata)
+    DeleteIndexAbortOperation(IDBTransactionBackend* transaction, int64_t objectStoreId, const IDBIndexMetadata& indexMetadata)
         : m_transaction(transaction)
         , m_objectStoreId(objectStoreId)
         , m_indexMetadata(indexMetadata)
     {
     }
 
-    RefPtr<IDBTransactionBackendInterface> m_transaction;
+    RefPtr<IDBTransactionBackend> m_transaction;
     const int64_t m_objectStoreId;
     const IDBIndexMetadata m_indexMetadata;
 };
 
 class GetOperation : public IDBOperation {
 public:
-    static PassOwnPtr<IDBOperation> create(IDBTransactionBackendInterface* transaction, IDBBackingStoreInterface* backingStore, const IDBDatabaseMetadata& metadata, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, IndexedDB::CursorType cursorType, PassRefPtr<IDBCallbacks> callbacks)
+    static PassOwnPtr<IDBOperation> create(IDBTransactionBackend* transaction, IDBBackingStoreInterface* backingStore, const IDBDatabaseMetadata& metadata, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, IndexedDB::CursorType cursorType, PassRefPtr<IDBCallbacks> callbacks)
     {
         return adoptPtr(new GetOperation(transaction, backingStore, metadata, objectStoreId, indexId, keyRange, cursorType, callbacks));
     }
     virtual void perform() OVERRIDE FINAL;
 private:
-    GetOperation(IDBTransactionBackendInterface* transaction, IDBBackingStoreInterface* backingStore, const IDBDatabaseMetadata& metadata, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, IndexedDB::CursorType cursorType, PassRefPtr<IDBCallbacks> callbacks)
+    GetOperation(IDBTransactionBackend* transaction, IDBBackingStoreInterface* backingStore, const IDBDatabaseMetadata& metadata, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, IndexedDB::CursorType cursorType, PassRefPtr<IDBCallbacks> callbacks)
         : m_transaction(transaction)
         , m_backingStore(backingStore)
         , m_databaseId(metadata.id)
@@ -262,7 +262,7 @@ private:
         ASSERT(metadata.objectStores.get(objectStoreId).id == objectStoreId);
     }
 
-    RefPtr<IDBTransactionBackendInterface> m_transaction;
+    RefPtr<IDBTransactionBackend> m_transaction;
     const RefPtr<IDBBackingStoreInterface> m_backingStore;
     const int64_t m_databaseId;
     const int64_t m_objectStoreId;
@@ -276,13 +276,13 @@ private:
 
 class PutOperation : public IDBOperation {
 public:
-    static PassOwnPtr<IDBOperation> create(IDBTransactionBackendInterface* transaction, IDBBackingStoreInterface* backingStore, int64_t databaseId, const IDBObjectStoreMetadata& objectStore, PassRefPtr<SharedBuffer> value, PassRefPtr<IDBKey> key, IDBDatabaseBackendInterface::PutMode putMode, PassRefPtr<IDBCallbacks> callbacks, const Vector<int64_t>& indexIds, const Vector<IndexKeys>& indexKeys)
+    static PassOwnPtr<IDBOperation> create(IDBTransactionBackend* transaction, IDBBackingStoreInterface* backingStore, int64_t databaseId, const IDBObjectStoreMetadata& objectStore, PassRefPtr<SharedBuffer> value, PassRefPtr<IDBKey> key, IDBDatabaseBackendInterface::PutMode putMode, PassRefPtr<IDBCallbacks> callbacks, const Vector<int64_t>& indexIds, const Vector<IndexKeys>& indexKeys)
     {
         return adoptPtr(new PutOperation(transaction, backingStore, databaseId, objectStore, value, key, putMode, callbacks, indexIds, indexKeys));
     }
     virtual void perform() OVERRIDE FINAL;
 private:
-    PutOperation(IDBTransactionBackendInterface* transaction, IDBBackingStoreInterface* backingStore, int64_t databaseId, const IDBObjectStoreMetadata& objectStore, PassRefPtr<SharedBuffer>& value, PassRefPtr<IDBKey> key, IDBDatabaseBackendInterface::PutMode putMode, PassRefPtr<IDBCallbacks> callbacks, const Vector<int64_t>& indexIds, const Vector<IndexKeys>& indexKeys)
+    PutOperation(IDBTransactionBackend* transaction, IDBBackingStoreInterface* backingStore, int64_t databaseId, const IDBObjectStoreMetadata& objectStore, PassRefPtr<SharedBuffer>& value, PassRefPtr<IDBKey> key, IDBDatabaseBackendInterface::PutMode putMode, PassRefPtr<IDBCallbacks> callbacks, const Vector<int64_t>& indexIds, const Vector<IndexKeys>& indexKeys)
         : m_transaction(transaction)
         , m_backingStore(backingStore)
         , m_databaseId(databaseId)
@@ -296,7 +296,7 @@ private:
     {
     }
 
-    RefPtr<IDBTransactionBackendInterface> m_transaction;
+    RefPtr<IDBTransactionBackend> m_transaction;
     const RefPtr<IDBBackingStoreInterface> m_backingStore;
     const int64_t m_databaseId;
     const IDBObjectStoreMetadata m_objectStore;
@@ -310,31 +310,31 @@ private:
 
 class SetIndexesReadyOperation : public IDBOperation {
 public:
-    static PassOwnPtr<IDBOperation> create(IDBTransactionBackendInterface* transaction, size_t indexCount)
+    static PassOwnPtr<IDBOperation> create(IDBTransactionBackend* transaction, size_t indexCount)
     {
         return adoptPtr(new SetIndexesReadyOperation(transaction, indexCount));
     }
     virtual void perform() OVERRIDE FINAL;
 private:
-    SetIndexesReadyOperation(IDBTransactionBackendInterface* transaction, size_t indexCount)
+    SetIndexesReadyOperation(IDBTransactionBackend* transaction, size_t indexCount)
         : m_transaction(transaction)
         , m_indexCount(indexCount)
     {
     }
 
-    RefPtr<IDBTransactionBackendInterface> m_transaction;
+    RefPtr<IDBTransactionBackend> m_transaction;
     const size_t m_indexCount;
 };
 
 class OpenCursorOperation : public IDBOperation {
 public:
-    static PassOwnPtr<IDBOperation> create(IDBTransactionBackendInterface* transaction, IDBBackingStoreInterface* backingStore, int64_t databaseId, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, IndexedDB::CursorDirection direction, IndexedDB::CursorType cursorType, IDBDatabaseBackendInterface::TaskType taskType, PassRefPtr<IDBCallbacks> callbacks)
+    static PassOwnPtr<IDBOperation> create(IDBTransactionBackend* transaction, IDBBackingStoreInterface* backingStore, int64_t databaseId, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, IndexedDB::CursorDirection direction, IndexedDB::CursorType cursorType, IDBDatabaseBackendInterface::TaskType taskType, PassRefPtr<IDBCallbacks> callbacks)
     {
         return adoptPtr(new OpenCursorOperation(transaction, backingStore, databaseId, objectStoreId, indexId, keyRange, direction, cursorType, taskType, callbacks));
     }
     virtual void perform() OVERRIDE FINAL;
 private:
-    OpenCursorOperation(IDBTransactionBackendInterface* transaction, IDBBackingStoreInterface* backingStore, int64_t databaseId, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, IndexedDB::CursorDirection direction, IndexedDB::CursorType cursorType, IDBDatabaseBackendInterface::TaskType taskType, PassRefPtr<IDBCallbacks> callbacks)
+    OpenCursorOperation(IDBTransactionBackend* transaction, IDBBackingStoreInterface* backingStore, int64_t databaseId, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, IndexedDB::CursorDirection direction, IndexedDB::CursorType cursorType, IDBDatabaseBackendInterface::TaskType taskType, PassRefPtr<IDBCallbacks> callbacks)
         : m_transaction(transaction)
         , m_backingStore(backingStore)
         , m_databaseId(databaseId)
@@ -348,7 +348,7 @@ private:
     {
     }
 
-    RefPtr<IDBTransactionBackendInterface> m_transaction;
+    RefPtr<IDBTransactionBackend> m_transaction;
     const RefPtr<IDBBackingStoreInterface> m_backingStore;
     const int64_t m_databaseId;
     const int64_t m_objectStoreId;
@@ -362,13 +362,13 @@ private:
 
 class CountOperation : public IDBOperation {
 public:
-    static PassOwnPtr<IDBOperation> create(IDBTransactionBackendInterface* transaction, IDBBackingStoreInterface* backingStore, int64_t databaseId, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, PassRefPtr<IDBCallbacks> callbacks)
+    static PassOwnPtr<IDBOperation> create(IDBTransactionBackend* transaction, IDBBackingStoreInterface* backingStore, int64_t databaseId, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, PassRefPtr<IDBCallbacks> callbacks)
     {
         return adoptPtr(new CountOperation(transaction, backingStore, databaseId, objectStoreId, indexId, keyRange, callbacks));
     }
     virtual void perform() OVERRIDE FINAL;
 private:
-    CountOperation(IDBTransactionBackendInterface* transaction, IDBBackingStoreInterface* backingStore, int64_t databaseId, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, PassRefPtr<IDBCallbacks> callbacks)
+    CountOperation(IDBTransactionBackend* transaction, IDBBackingStoreInterface* backingStore, int64_t databaseId, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, PassRefPtr<IDBCallbacks> callbacks)
         : m_transaction(transaction)
         , m_backingStore(backingStore)
         , m_databaseId(databaseId)
@@ -379,7 +379,7 @@ private:
     {
     }
 
-    RefPtr<IDBTransactionBackendInterface> m_transaction;
+    RefPtr<IDBTransactionBackend> m_transaction;
     const RefPtr<IDBBackingStoreInterface> m_backingStore;
     const int64_t m_databaseId;
     const int64_t m_objectStoreId;
@@ -390,13 +390,13 @@ private:
 
 class DeleteRangeOperation : public IDBOperation {
 public:
-    static PassOwnPtr<IDBOperation> create(IDBTransactionBackendInterface* transaction, IDBBackingStoreInterface* backingStore, int64_t databaseId, int64_t objectStoreId, PassRefPtr<IDBKeyRange> keyRange, PassRefPtr<IDBCallbacks> callbacks)
+    static PassOwnPtr<IDBOperation> create(IDBTransactionBackend* transaction, IDBBackingStoreInterface* backingStore, int64_t databaseId, int64_t objectStoreId, PassRefPtr<IDBKeyRange> keyRange, PassRefPtr<IDBCallbacks> callbacks)
     {
         return adoptPtr(new DeleteRangeOperation(transaction, backingStore, databaseId, objectStoreId, keyRange, callbacks));
     }
     virtual void perform() OVERRIDE FINAL;
 private:
-    DeleteRangeOperation(IDBTransactionBackendInterface* transaction, IDBBackingStoreInterface* backingStore, int64_t databaseId, int64_t objectStoreId, PassRefPtr<IDBKeyRange> keyRange, PassRefPtr<IDBCallbacks> callbacks)
+    DeleteRangeOperation(IDBTransactionBackend* transaction, IDBBackingStoreInterface* backingStore, int64_t databaseId, int64_t objectStoreId, PassRefPtr<IDBKeyRange> keyRange, PassRefPtr<IDBCallbacks> callbacks)
         : m_transaction(transaction)
         , m_backingStore(backingStore)
         , m_databaseId(databaseId)
@@ -406,7 +406,7 @@ private:
     {
     }
 
-    RefPtr<IDBTransactionBackendInterface> m_transaction;
+    RefPtr<IDBTransactionBackend> m_transaction;
     const RefPtr<IDBBackingStoreInterface> m_backingStore;
     const int64_t m_databaseId;
     const int64_t m_objectStoreId;
@@ -416,13 +416,13 @@ private:
 
 class ClearOperation : public IDBOperation {
 public:
-    static PassOwnPtr<IDBOperation> create(IDBTransactionBackendInterface* transaction, IDBBackingStoreInterface* backingStore, int64_t databaseId, int64_t objectStoreId, PassRefPtr<IDBCallbacks> callbacks)
+    static PassOwnPtr<IDBOperation> create(IDBTransactionBackend* transaction, IDBBackingStoreInterface* backingStore, int64_t databaseId, int64_t objectStoreId, PassRefPtr<IDBCallbacks> callbacks)
     {
         return adoptPtr(new ClearOperation(transaction, backingStore, databaseId, objectStoreId, callbacks));
     }
     virtual void perform() OVERRIDE FINAL;
 private:
-    ClearOperation(IDBTransactionBackendInterface* transaction, IDBBackingStoreInterface* backingStore, int64_t databaseId, int64_t objectStoreId, PassRefPtr<IDBCallbacks> callbacks)
+    ClearOperation(IDBTransactionBackend* transaction, IDBBackingStoreInterface* backingStore, int64_t databaseId, int64_t objectStoreId, PassRefPtr<IDBCallbacks> callbacks)
         : m_transaction(transaction)
         , m_backingStore(backingStore)
         , m_databaseId(databaseId)
@@ -431,7 +431,7 @@ private:
     {
     }
 
-    RefPtr<IDBTransactionBackendInterface> m_transaction;
+    RefPtr<IDBTransactionBackend> m_transaction;
     const RefPtr<IDBBackingStoreInterface> m_backingStore;
     const int64_t m_databaseId;
     const int64_t m_objectStoreId;
index 9d7b80f..f10d9f5 100644 (file)
@@ -29,7 +29,7 @@
 #if ENABLE(INDEXED_DATABASE)
 
 #include "IDBDatabaseCallbacks.h"
-#include "IDBTransactionBackendInterface.h"
+#include "IDBTransactionBackend.h"
 
 namespace WebCore {
 
@@ -46,13 +46,13 @@ IDBTransactionCoordinator::~IDBTransactionCoordinator()
 {
 }
 
-void IDBTransactionCoordinator::didCreateTransaction(IDBTransactionBackendInterface* transaction)
+void IDBTransactionCoordinator::didCreateTransaction(IDBTransactionBackend* transaction)
 {
     ASSERT(!m_transactions.contains(transaction));
     m_transactions.add(transaction, transaction);
 }
 
-void IDBTransactionCoordinator::didStartTransaction(IDBTransactionBackendInterface* transaction)
+void IDBTransactionCoordinator::didStartTransaction(IDBTransactionBackend* transaction)
 {
     ASSERT(m_transactions.contains(transaction));
 
@@ -60,7 +60,7 @@ void IDBTransactionCoordinator::didStartTransaction(IDBTransactionBackendInterfa
     processStartedTransactions();
 }
 
-void IDBTransactionCoordinator::didFinishTransaction(IDBTransactionBackendInterface* transaction)
+void IDBTransactionCoordinator::didFinishTransaction(IDBTransactionBackend* transaction)
 {
     ASSERT(m_transactions.contains(transaction));
 
@@ -77,7 +77,7 @@ void IDBTransactionCoordinator::didFinishTransaction(IDBTransactionBackendInterf
 
 #ifndef NDEBUG
 // Verifies internal consistiency while returning whether anything is found.
-bool IDBTransactionCoordinator::isActive(IDBTransactionBackendInterface* transaction)
+bool IDBTransactionCoordinator::isActive(IDBTransactionBackend* transaction)
 {
     bool found = false;
     if (m_queuedTransactions.contains(transaction))
@@ -98,9 +98,9 @@ void IDBTransactionCoordinator::processStartedTransactions()
 
     ASSERT(m_startedTransactions.isEmpty() || (*m_startedTransactions.begin())->mode() != IndexedDB::TransactionVersionChange);
 
-    ListHashSet<IDBTransactionBackendInterface*>::const_iterator it = m_queuedTransactions.begin();
+    ListHashSet<IDBTransactionBackend*>::const_iterator it = m_queuedTransactions.begin();
     while (it != m_queuedTransactions.end()) {
-        IDBTransactionBackendInterface* transaction = *it;
+        IDBTransactionBackend* transaction = *it;
         ++it;
         if (canRunTransaction(transaction)) {
             m_queuedTransactions.remove(transaction);
@@ -119,7 +119,7 @@ static bool doScopesOverlap(const HashSet<int64_t>& scope1, const HashSet<int64_
     return false;
 }
 
-bool IDBTransactionCoordinator::canRunTransaction(IDBTransactionBackendInterface* transaction)
+bool IDBTransactionCoordinator::canRunTransaction(IDBTransactionBackend* transaction)
 {
     ASSERT(m_queuedTransactions.contains(transaction));
     switch (transaction->mode()) {
@@ -132,11 +132,11 @@ bool IDBTransactionCoordinator::canRunTransaction(IDBTransactionBackendInterface
         return true;
 
     case IndexedDB::TransactionReadWrite:
-        for (HashSet<IDBTransactionBackendInterface*>::const_iterator it = m_startedTransactions.begin(); it != m_startedTransactions.end(); ++it) {
+        for (HashSet<IDBTransactionBackend*>::const_iterator it = m_startedTransactions.begin(); it != m_startedTransactions.end(); ++it) {
             if ((*it)->mode() == IndexedDB::TransactionReadWrite && doScopesOverlap(transaction->scope(), (*it)->scope()))
                 return false;
         }
-        for (ListHashSet<IDBTransactionBackendInterface*>::const_iterator it = m_queuedTransactions.begin(); *it != transaction; ++it) {
+        for (ListHashSet<IDBTransactionBackend*>::const_iterator it = m_queuedTransactions.begin(); *it != transaction; ++it) {
             ASSERT(it != m_queuedTransactions.end());
             if ((*it)->mode() == IndexedDB::TransactionReadWrite && doScopesOverlap(transaction->scope(), (*it)->scope()))
                 return false;
index 10e2b12..1520232 100644 (file)
@@ -34,7 +34,7 @@
 
 namespace WebCore {
 
-class IDBTransactionBackendInterface;
+class IDBTransactionBackend;
 
 // Transactions are executed in the order the were created.
 class IDBTransactionCoordinator {
@@ -43,25 +43,25 @@ public:
     virtual ~IDBTransactionCoordinator();
 
     // Called by transactions as they start and finish.
-    void didCreateTransaction(IDBTransactionBackendInterface*);
-    void didStartTransaction(IDBTransactionBackendInterface*);
-    void didFinishTransaction(IDBTransactionBackendInterface*);
+    void didCreateTransaction(IDBTransactionBackend*);
+    void didStartTransaction(IDBTransactionBackend*);
+    void didFinishTransaction(IDBTransactionBackend*);
 
 #ifndef NDEBUG
-    bool isActive(IDBTransactionBackendInterface*);
+    bool isActive(IDBTransactionBackend*);
 #endif
 
 private:
     IDBTransactionCoordinator();
 
     void processStartedTransactions();
-    bool canRunTransaction(IDBTransactionBackendInterface*);
+    bool canRunTransaction(IDBTransactionBackend*);
 
     // This is just an efficient way to keep references to all transactions.
-    HashMap<IDBTransactionBackendInterface*, RefPtr<IDBTransactionBackendInterface> > m_transactions;
+    HashMap<IDBTransactionBackend*, RefPtr<IDBTransactionBackend> > m_transactions;
     // Transactions in different states are grouped below.
-    ListHashSet<IDBTransactionBackendInterface*> m_queuedTransactions;
-    HashSet<IDBTransactionBackendInterface*> m_startedTransactions;
+    ListHashSet<IDBTransactionBackend*> m_queuedTransactions;
+    HashSet<IDBTransactionBackend*> m_startedTransactions;
 };
 
 } // namespace WebCore
index 68a7e11..bc68152 100644 (file)
@@ -38,7 +38,7 @@
 #include "IDBKeyRange.h"
 #include "IDBLevelDBCoding.h"
 #include "IDBMetadata.h"
-#include "IDBTransactionBackendInterface.h"
+#include "IDBTransactionBackend.h"
 #include "LevelDBComparator.h"
 #include "LevelDBDatabase.h"
 #include "LevelDBIterator.h"
@@ -1383,7 +1383,7 @@ bool IDBBackingStoreLevelDB::keyExistsInIndex(IDBBackingStoreTransactionInterfac
 }
 
 
-bool IDBBackingStoreLevelDB::makeIndexWriters(IDBTransactionBackendInterface& transaction, int64_t databaseId, const IDBObjectStoreMetadata& objectStore, IDBKey& primaryKey, bool keyWasGenerated, const Vector<int64_t>& indexIds, const Vector<IndexKeys>& indexKeys, Vector<RefPtr<IDBIndexWriter>>& indexWriters, String* errorMessage, bool& completed)
+bool IDBBackingStoreLevelDB::makeIndexWriters(IDBTransactionBackend& transaction, int64_t databaseId, const IDBObjectStoreMetadata& objectStore, IDBKey& primaryKey, bool keyWasGenerated, const Vector<int64_t>& indexIds, const Vector<IndexKeys>& indexKeys, Vector<RefPtr<IDBIndexWriter>>& indexWriters, String* errorMessage, bool& completed)
 {
     ASSERT(indexIds.size() == indexKeys.size());
     completed = false;
@@ -1415,7 +1415,7 @@ bool IDBBackingStoreLevelDB::makeIndexWriters(IDBTransactionBackendInterface& tr
     return true;
 }
 
-PassRefPtr<IDBKey> IDBBackingStoreLevelDB::generateKey(IDBTransactionBackendInterface& transaction, int64_t databaseId, int64_t objectStoreId)
+PassRefPtr<IDBKey> IDBBackingStoreLevelDB::generateKey(IDBTransactionBackend& transaction, int64_t databaseId, int64_t objectStoreId)
 {
     const int64_t maxGeneratorValue = 9007199254740992LL; // Maximum integer storable as ECMAScript number.
     int64_t currentNumber;
@@ -1431,7 +1431,7 @@ PassRefPtr<IDBKey> IDBBackingStoreLevelDB::generateKey(IDBTransactionBackendInte
 }
 
 
-bool IDBBackingStoreLevelDB::updateKeyGenerator(IDBTransactionBackendInterface& transaction, int64_t databaseId, int64_t objectStoreId, const IDBKey& key, bool checkCurrent)
+bool IDBBackingStoreLevelDB::updateKeyGenerator(IDBTransactionBackend& transaction, int64_t databaseId, int64_t objectStoreId, const IDBKey& key, bool checkCurrent)
 {
     ASSERT(key.type() == IDBKey::NumberType);
     return maybeUpdateKeyGeneratorCurrentNumber(transaction.backingStoreTransaction(), databaseId, objectStoreId, static_cast<int64_t>(floor(key.number())) + 1, checkCurrent);
index 9e15621..c12fe75 100644 (file)
@@ -100,10 +100,10 @@ public:
     virtual PassRefPtr<IDBBackingStoreCursorInterface> openIndexKeyCursor(IDBBackingStoreTransactionInterface&, int64_t databaseId, int64_t objectStoreId, int64_t indexId, const IDBKeyRange*, IndexedDB::CursorDirection) OVERRIDE;
     virtual PassRefPtr<IDBBackingStoreCursorInterface> openIndexCursor(IDBBackingStoreTransactionInterface&, int64_t databaseId, int64_t objectStoreId, int64_t indexId, const IDBKeyRange*, IndexedDB::CursorDirection) OVERRIDE;
 
-    virtual bool makeIndexWriters(IDBTransactionBackendInterface&, int64_t databaseId, const IDBObjectStoreMetadata&, IDBKey& primaryKey, bool keyWasGenerated, const Vector<int64_t>& indexIds, const Vector<IndexKeys>&, Vector<RefPtr<IDBIndexWriter>>& indexWriters, String* errorMessage, bool& completed) OVERRIDE WARN_UNUSED_RETURN;
+    virtual bool makeIndexWriters(IDBTransactionBackend&, int64_t databaseId, const IDBObjectStoreMetadata&, IDBKey& primaryKey, bool keyWasGenerated, const Vector<int64_t>& indexIds, const Vector<IndexKeys>&, Vector<RefPtr<IDBIndexWriter>>& indexWriters, String* errorMessage, bool& completed) OVERRIDE WARN_UNUSED_RETURN;
 
-    virtual PassRefPtr<IDBKey> generateKey(IDBTransactionBackendInterface&, int64_t databaseId, int64_t objectStoreId) OVERRIDE;
-    virtual bool updateKeyGenerator(IDBTransactionBackendInterface&, int64_t databaseId, int64_t objectStoreId, const IDBKey&, bool checkCurrent) OVERRIDE;
+    virtual PassRefPtr<IDBKey> generateKey(IDBTransactionBackend&, int64_t databaseId, int64_t objectStoreId) OVERRIDE;
+    virtual bool updateKeyGenerator(IDBTransactionBackend&, int64_t databaseId, int64_t objectStoreId, const IDBKey&, bool checkCurrent) OVERRIDE;
 
     LevelDBDatabase* levelDBDatabase() { return m_db.get(); }
 
index dfbcbf0..497c4a6 100644 (file)
@@ -34,7 +34,7 @@
 #include "IDBCursorBackend.h"
 #include "IDBDatabaseBackendImpl.h"
 #include "IDBDatabaseException.h"
-#include "IDBTransactionBackendImpl.h"
+#include "IDBTransactionBackend.h"
 #include "IDBTransactionCoordinator.h"
 #include "Logging.h"
 #include "SecurityOrigin.h"
@@ -189,15 +189,15 @@ void IDBFactoryBackendLevelDB::open(const String& name, uint64_t version, int64_
     databaseBackend->openConnection(callbacks, databaseCallbacks, transactionId, version);
 }
 
-PassRefPtr<IDBTransactionBackendInterface> IDBFactoryBackendLevelDB::maybeCreateTransactionBackend(IDBDatabaseBackendInterface* backend, int64_t transactionId, PassRefPtr<IDBDatabaseCallbacks> databaseCallbacks, const Vector<int64_t>& objectStoreIds, IndexedDB::TransactionMode mode)
+PassRefPtr<IDBTransactionBackend> IDBFactoryBackendLevelDB::maybeCreateTransactionBackend(IDBDatabaseBackendInterface* backend, int64_t transactionId, PassRefPtr<IDBDatabaseCallbacks> databaseCallbacks, const Vector<int64_t>& objectStoreIds, IndexedDB::TransactionMode mode)
 {
     if (!backend->isIDBDatabaseBackendImpl())
         return 0;
 
-    return IDBTransactionBackendImpl::create(static_cast<IDBDatabaseBackendImpl*>(backend), transactionId, databaseCallbacks, objectStoreIds, mode);
+    return IDBTransactionBackend::create(static_cast<IDBDatabaseBackendImpl*>(backend), transactionId, databaseCallbacks, objectStoreIds, mode);
 }
 
-PassRefPtr<IDBCursorBackend> IDBFactoryBackendLevelDB::createCursorBackend(IDBTransactionBackendInterface& transactionBackend, IDBBackingStoreCursorInterface& backingStoreCursor, IndexedDB::CursorType cursorType, IDBDatabaseBackendInterface::TaskType taskType, int64_t objectStoreId)
+PassRefPtr<IDBCursorBackend> IDBFactoryBackendLevelDB::createCursorBackend(IDBTransactionBackend& transactionBackend, IDBBackingStoreCursorInterface& backingStoreCursor, IndexedDB::CursorType cursorType, IDBDatabaseBackendInterface::TaskType taskType, int64_t objectStoreId)
 {
     return IDBCursorBackend::create(&backingStoreCursor, cursorType, taskType, &transactionBackend, objectStoreId);
 }
index 86f5024..3c3c776 100644 (file)
@@ -63,9 +63,9 @@ public:
 
     virtual void deleteDatabase(const String& name, PassRefPtr<IDBCallbacks>, PassRefPtr<SecurityOrigin>, ScriptExecutionContext*, const String& dataDir) OVERRIDE FINAL;
 
-    virtual PassRefPtr<IDBTransactionBackendInterface> maybeCreateTransactionBackend(IDBDatabaseBackendInterface*, int64_t transactionId, PassRefPtr<IDBDatabaseCallbacks>, const Vector<int64_t>&, IndexedDB::TransactionMode) OVERRIDE FINAL;
+    virtual PassRefPtr<IDBTransactionBackend> maybeCreateTransactionBackend(IDBDatabaseBackendInterface*, int64_t transactionId, PassRefPtr<IDBDatabaseCallbacks>, const Vector<int64_t>&, IndexedDB::TransactionMode) OVERRIDE FINAL;
 
-    virtual PassRefPtr<IDBCursorBackend> createCursorBackend(IDBTransactionBackendInterface&, IDBBackingStoreCursorInterface&, IndexedDB::CursorType, IDBDatabaseBackendInterface::TaskType, int64_t objectStoreId);
+    virtual PassRefPtr<IDBCursorBackend> createCursorBackend(IDBTransactionBackend&, IDBBackingStoreCursorInterface&, IndexedDB::CursorType, IDBDatabaseBackendInterface::TaskType, int64_t objectStoreId);
 
 protected:
     virtual PassRefPtr<IDBBackingStoreLevelDB> openBackingStore(const SecurityOrigin&, const String& dataDir);
index 07a446f..4c64eb2 100644 (file)
                50E18CDA16F9285800C65486 /* StyleCustomFilterProgramCache.h in Headers */ = {isa = PBXBuildFile; fileRef = 50E18CD716F9285800C65486 /* StyleCustomFilterProgramCache.h */; };
                510184690B08602A004A825F /* CachedPage.h in Headers */ = {isa = PBXBuildFile; fileRef = 510184670B08602A004A825F /* CachedPage.h */; settings = {ATTRIBUTES = (Private, ); }; };
                5101846A0B08602A004A825F /* CachedPage.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 510184680B08602A004A825F /* CachedPage.cpp */; };
-               51059DDB1820B17600DFF9B1 /* IDBTransactionBackendImpl.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 51059DD71820B17600DFF9B1 /* IDBTransactionBackendImpl.cpp */; };
-               51059DDC1820B17600DFF9B1 /* IDBTransactionBackendImpl.h in Headers */ = {isa = PBXBuildFile; fileRef = 51059DD81820B17600DFF9B1 /* IDBTransactionBackendImpl.h */; settings = {ATTRIBUTES = (Private, ); }; };
                51059DDD1820B17600DFF9B1 /* IDBTransactionBackendOperations.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 51059DD91820B17600DFF9B1 /* IDBTransactionBackendOperations.cpp */; };
                51059DDE1820B17600DFF9B1 /* IDBTransactionBackendOperations.h in Headers */ = {isa = PBXBuildFile; fileRef = 51059DDA1820B17600DFF9B1 /* IDBTransactionBackendOperations.h */; };
+               510B7DB7182D9F5D009BF957 /* IDBTransactionBackend.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 510B7DB5182D9F5D009BF957 /* IDBTransactionBackend.cpp */; };
+               510B7DB8182D9F5D009BF957 /* IDBTransactionBackend.h in Headers */ = {isa = PBXBuildFile; fileRef = 510B7DB6182D9F5D009BF957 /* IDBTransactionBackend.h */; settings = {ATTRIBUTES = (Private, ); }; };
                510D4A33103165EE0049EA54 /* SocketStreamErrorBase.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 510D4A2D103165EE0049EA54 /* SocketStreamErrorBase.cpp */; };
                510D4A34103165EE0049EA54 /* SocketStreamErrorBase.h in Headers */ = {isa = PBXBuildFile; fileRef = 510D4A2E103165EE0049EA54 /* SocketStreamErrorBase.h */; };
                510D4A36103165EE0049EA54 /* SocketStreamHandleBase.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 510D4A30103165EE0049EA54 /* SocketStreamHandleBase.cpp */; };
                51EAC5681815ED3E004F1BA4 /* IDBTransactionCoordinator.h in Headers */ = {isa = PBXBuildFile; fileRef = 51EAC5661815ED3E004F1BA4 /* IDBTransactionCoordinator.h */; settings = {ATTRIBUTES = (Private, ); }; };
                51EAC5B218163F4E004F1BA4 /* IDBRecordIdentifier.h in Headers */ = {isa = PBXBuildFile; fileRef = 51EAC5B018163F4E004F1BA4 /* IDBRecordIdentifier.h */; };
                51EC92650CE90DD400F90308 /* JSCustomSQLStatementErrorCallback.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 51EC925D0CE90DD400F90308 /* JSCustomSQLStatementErrorCallback.cpp */; };
-               51F6E0A31811D2520058A00A /* IDBTransactionBackendInterface.h in Headers */ = {isa = PBXBuildFile; fileRef = 51F6E08F1811D2520058A00A /* IDBTransactionBackendInterface.h */; settings = {ATTRIBUTES = (Private, ); }; };
                51FA2D78152132B300C1BA0B /* DOMWindowExtension.h in Headers */ = {isa = PBXBuildFile; fileRef = 517FBA18151AA71B00B57959 /* DOMWindowExtension.h */; settings = {ATTRIBUTES = (Private, ); }; };
                51FB5504113E3E9100821176 /* JSCloseEvent.h in Headers */ = {isa = PBXBuildFile; fileRef = 51FB5502113E3E9100821176 /* JSCloseEvent.h */; };
                51FB5505113E3E9100821176 /* JSCloseEvent.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 51FB5503113E3E9100821176 /* JSCloseEvent.cpp */; };
                50E18CD716F9285800C65486 /* StyleCustomFilterProgramCache.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = StyleCustomFilterProgramCache.h; path = style/StyleCustomFilterProgramCache.h; sourceTree = "<group>"; };
                510184670B08602A004A825F /* CachedPage.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CachedPage.h; sourceTree = "<group>"; };
                510184680B08602A004A825F /* CachedPage.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CachedPage.cpp; sourceTree = "<group>"; };
-               51059DD71820B17600DFF9B1 /* IDBTransactionBackendImpl.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = IDBTransactionBackendImpl.cpp; sourceTree = "<group>"; };
-               51059DD81820B17600DFF9B1 /* IDBTransactionBackendImpl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = IDBTransactionBackendImpl.h; sourceTree = "<group>"; };
                51059DD91820B17600DFF9B1 /* IDBTransactionBackendOperations.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = IDBTransactionBackendOperations.cpp; sourceTree = "<group>"; };
                51059DDA1820B17600DFF9B1 /* IDBTransactionBackendOperations.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = IDBTransactionBackendOperations.h; sourceTree = "<group>"; };
+               510B7DB5182D9F5D009BF957 /* IDBTransactionBackend.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = IDBTransactionBackend.cpp; sourceTree = "<group>"; };
+               510B7DB6182D9F5D009BF957 /* IDBTransactionBackend.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = IDBTransactionBackend.h; sourceTree = "<group>"; };
                510D4A2D103165EE0049EA54 /* SocketStreamErrorBase.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SocketStreamErrorBase.cpp; sourceTree = "<group>"; };
                510D4A2E103165EE0049EA54 /* SocketStreamErrorBase.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SocketStreamErrorBase.h; sourceTree = "<group>"; };
                510D4A30103165EE0049EA54 /* SocketStreamHandleBase.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SocketStreamHandleBase.cpp; sourceTree = "<group>"; };
                51EC925D0CE90DD400F90308 /* JSCustomSQLStatementErrorCallback.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSCustomSQLStatementErrorCallback.cpp; sourceTree = "<group>"; };
                51F6A3D50663BF04004D2919 /* HTMLCanvasElement.cpp */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.cpp.cpp; path = HTMLCanvasElement.cpp; sourceTree = "<group>"; tabWidth = 8; usesTabs = 0; };
                51F6A3D60663BF04004D2919 /* HTMLCanvasElement.h */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.c.h; path = HTMLCanvasElement.h; sourceTree = "<group>"; tabWidth = 8; usesTabs = 0; };
-               51F6E08F1811D2520058A00A /* IDBTransactionBackendInterface.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = IDBTransactionBackendInterface.h; sourceTree = "<group>"; };
                51FB5502113E3E9100821176 /* JSCloseEvent.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSCloseEvent.h; sourceTree = "<group>"; };
                51FB5503113E3E9100821176 /* JSCloseEvent.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSCloseEvent.cpp; sourceTree = "<group>"; };
                521D46F511AEC98100514613 /* KillRingMac.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = KillRingMac.mm; sourceTree = "<group>"; };
                                51D719A4181106E00016DC51 /* IDBTransaction.cpp */,
                                51D719A5181106E00016DC51 /* IDBTransaction.h */,
                                51D719A6181106E00016DC51 /* IDBTransaction.idl */,
-                               51059DD71820B17600DFF9B1 /* IDBTransactionBackendImpl.cpp */,
-                               51059DD81820B17600DFF9B1 /* IDBTransactionBackendImpl.h */,
-                               51F6E08F1811D2520058A00A /* IDBTransactionBackendInterface.h */,
+                               510B7DB5182D9F5D009BF957 /* IDBTransactionBackend.cpp */,
+                               510B7DB6182D9F5D009BF957 /* IDBTransactionBackend.h */,
                                51059DD91820B17600DFF9B1 /* IDBTransactionBackendOperations.cpp */,
                                51059DDA1820B17600DFF9B1 /* IDBTransactionBackendOperations.h */,
                                51EAC5651815ED3E004F1BA4 /* IDBTransactionCoordinator.cpp */,
                                85ECBEF50AA7626900544F0B /* DOMHTMLModElement.h in Headers */,
                                85E711BC0AC5D5350053270F /* DOMHTMLModElementInternal.h in Headers */,
                                85DF812B0AA7787200486AD7 /* DOMHTMLObjectElement.h in Headers */,
+                               510B7DB8182D9F5D009BF957 /* IDBTransactionBackend.h in Headers */,
                                85E711BD0AC5D5350053270F /* DOMHTMLObjectElementInternal.h in Headers */,
                                85BA4D150AA688680088052D /* DOMHTMLOListElement.h in Headers */,
                                85E711BE0AC5D5350053270F /* DOMHTMLOListElementInternal.h in Headers */,
                                2EDF369F122C94C8002F7D4E /* FileException.h in Headers */,
                                0F099D0917B968A100FF84B9 /* WebCoreTypedArrayController.h in Headers */,
                                1A88A90517553CD7000C74F9 /* FileIconLoader.h in Headers */,
-                               51059DDC1820B17600DFF9B1 /* IDBTransactionBackendImpl.h in Headers */,
                                F55B3DBE1251F12D003EF269 /* FileInputType.h in Headers */,
                                976D6C86122B8A3D001FD1F7 /* FileList.h in Headers */,
                                4689F1AF1267BAE100E8D380 /* FileMetadata.h in Headers */,
                                77A17A7212F28182004E02F6 /* OESVertexArrayObject.h in Headers */,
                                FDA3E95A134A49EF008D4B5A /* OfflineAudioCompletionEvent.h in Headers */,
                                FDA9325E16703B2A008982DC /* OfflineAudioContext.h in Headers */,
-                               51F6E0A31811D2520058A00A /* IDBTransactionBackendInterface.h in Headers */,
                                FDA3E95C134A49EF008D4B5A /* OfflineAudioDestinationNode.h in Headers */,
                                F4EAF4AF10C742B1009100D3 /* OpenTypeSanitizer.h in Headers */,
                                0014628B103CD1DE000B20DB /* OriginAccessEntry.h in Headers */,
                                FD23A12513F5FA5900F67001 /* JSMediaElementAudioSourceNode.cpp in Sources */,
                                E44614180CD6826900FADA75 /* JSMediaError.cpp in Sources */,
                                E19AC3F41824DC7900349426 /* CryptoAlgorithmSHA512.cpp in Sources */,
+                               510B7DB7182D9F5D009BF957 /* IDBTransactionBackend.cpp in Sources */,
                                CDA98DA31601464100FEA3B1 /* JSMediaKeyError.cpp in Sources */,
                                CDB859FA160D494900E5B07F /* JSMediaKeyEvent.cpp in Sources */,
                                CDA98DDF16026A3700FEA3B1 /* JSMediaKeyMessageEvent.cpp in Sources */,
                                AA4C3A760B2B1679002334A2 /* InlineStyleSheetOwner.cpp in Sources */,
                                319AE063142D6B24006563A1 /* StyleFilterData.cpp in Sources */,
                                5317612213C516690026E454 /* StyleFlexibleBoxData.cpp in Sources */,
-                               51059DDB1820B17600DFF9B1 /* IDBTransactionBackendImpl.cpp in Sources */,
                                BCEF447D0E674806001C1287 /* StyleGeneratedImage.cpp in Sources */,
                                A10DC76A14747BAB005E2471 /* StyleGridData.cpp in Sources */,
                                A110DB9D14F5DF8700A03B93 /* StyleGridItemData.cpp in Sources */,
index da7c328..b2def07 100644 (file)
@@ -1,5 +1,15 @@
 2013-11-08  Brady Eidson  <beidson@apple.com>
 
+        Merge IDBTransactionBackendInterface and IDBTransactionBackendImpl
+        https://bugs.webkit.org/show_bug.cgi?id=124077
+
+        Reviewed by Alexey Proskuryakov.
+
+        * WebProcess/Databases/IndexedDB/WebIDBFactoryBackend.cpp:
+        * WebProcess/Databases/IndexedDB/WebIDBFactoryBackend.h:
+
+2013-11-08  Brady Eidson  <beidson@apple.com>
+
         Merge IDBCursorBackendInterface and IDBCursorBackendImpl
         https://bugs.webkit.org/show_bug.cgi?id=124068
 
index 0c16f66..4dd1d2c 100644 (file)
@@ -35,7 +35,7 @@
 #include <WebCore/IDBCallbacks.h>
 #include <WebCore/IDBCursorBackend.h>
 #include <WebCore/IDBDatabaseCallbacks.h>
-#include <WebCore/IDBTransactionBackendInterface.h>
+#include <WebCore/IDBTransactionBackend.h>
 #include <WebCore/NotImplemented.h>
 #include <WebCore/SecurityOrigin.h>
 #include <wtf/MainThread.h>
@@ -100,13 +100,13 @@ void WebIDBFactoryBackend::removeIDBDatabaseBackend(const String&)
     notImplemented();
 }
 
-PassRefPtr<IDBTransactionBackendInterface> WebIDBFactoryBackend::maybeCreateTransactionBackend(IDBDatabaseBackendInterface*, int64_t transactionId, PassRefPtr<IDBDatabaseCallbacks>, const Vector<int64_t>&, IndexedDB::TransactionMode)
+PassRefPtr<IDBTransactionBackend> WebIDBFactoryBackend::maybeCreateTransactionBackend(IDBDatabaseBackendInterface*, int64_t transactionId, PassRefPtr<IDBDatabaseCallbacks>, const Vector<int64_t>&, IndexedDB::TransactionMode)
 {
     notImplemented();
     return 0;
 }
 
-PassRefPtr<IDBCursorBackend> WebIDBFactoryBackend::createCursorBackend(IDBTransactionBackendInterface&, IDBBackingStoreCursorInterface&, IndexedDB::CursorType, IDBDatabaseBackendInterface::TaskType, int64_t)
+PassRefPtr<IDBCursorBackend> WebIDBFactoryBackend::createCursorBackend(IDBTransactionBackend&, IDBBackingStoreCursorInterface&, IndexedDB::CursorType, IDBDatabaseBackendInterface::TaskType, int64_t)
 {
     notImplemented();
     return 0;
index 24e025a..06417b1 100644 (file)
@@ -45,9 +45,9 @@ public:
 
     virtual void removeIDBDatabaseBackend(const String& uniqueIdentifier) OVERRIDE;
 
-    virtual PassRefPtr<WebCore::IDBTransactionBackendInterface> maybeCreateTransactionBackend(WebCore::IDBDatabaseBackendInterface*, int64_t transactionId, PassRefPtr<WebCore::IDBDatabaseCallbacks>, const Vector<int64_t>&, WebCore::IndexedDB::TransactionMode) OVERRIDE;
+    virtual PassRefPtr<WebCore::IDBTransactionBackend> maybeCreateTransactionBackend(WebCore::IDBDatabaseBackendInterface*, int64_t transactionId, PassRefPtr<WebCore::IDBDatabaseCallbacks>, const Vector<int64_t>&, WebCore::IndexedDB::TransactionMode) OVERRIDE;
 
-    virtual PassRefPtr<WebCore::IDBCursorBackend> createCursorBackend(WebCore::IDBTransactionBackendInterface&, WebCore::IDBBackingStoreCursorInterface&, WebCore::IndexedDB::CursorType, WebCore::IDBDatabaseBackendInterface::TaskType, int64_t objectStoreId) OVERRIDE;
+    virtual PassRefPtr<WebCore::IDBCursorBackend> createCursorBackend(WebCore::IDBTransactionBackend&, WebCore::IDBBackingStoreCursorInterface&, WebCore::IndexedDB::CursorType, WebCore::IDBDatabaseBackendInterface::TaskType, int64_t objectStoreId) OVERRIDE;
 
 private:
     explicit WebIDBFactoryBackend(const String& databaseDirectoryIdentifier);