Diff
Modified: trunk/Source/WebKit2/ChangeLog (160677 => 160678)
--- trunk/Source/WebKit2/ChangeLog 2013-12-17 00:55:47 UTC (rev 160677)
+++ trunk/Source/WebKit2/ChangeLog 2013-12-17 01:12:23 UTC (rev 160678)
@@ -1,3 +1,66 @@
+2013-12-16 Brady Eidson <beid...@apple.com>
+
+ DatabaseProcess: Plumb through messaging for the 4 basic transaction operations
+ https://bugs.webkit.org/show_bug.cgi?id=125816
+
+ Reviewed by Alexey Proskuryakov.
+
+ The messaging begins and ends in the WebProcess:
+ * WebProcess/Databases/IndexedDB/WebIDBServerConnection.cpp:
+ (WebKit::WebIDBServerConnection::beginTransaction):
+ (WebKit::WebIDBServerConnection::didBeginTransaction):
+ (WebKit::WebIDBServerConnection::commitTransaction):
+ (WebKit::WebIDBServerConnection::didCommitTransaction):
+ (WebKit::WebIDBServerConnection::resetTransaction):
+ (WebKit::WebIDBServerConnection::didResetTransaction):
+ (WebKit::WebIDBServerConnection::rollbackTransaction):
+ (WebKit::WebIDBServerConnection::didRollbackTransaction):
+ * WebProcess/Databases/IndexedDB/WebIDBServerConnection.h:
+ * WebProcess/Databases/IndexedDB/WebIDBServerConnection.messages.in:
+
+ It travels from the WebProcess to the DatabaseProcess connection:
+ * DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.cpp:
+ (WebKit::DatabaseProcessIDBConnection::beginTransaction):
+ (WebKit::DatabaseProcessIDBConnection::commitTransaction):
+ (WebKit::DatabaseProcessIDBConnection::resetTransaction):
+ (WebKit::DatabaseProcessIDBConnection::rollbackTransaction):
+ * DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.h:
+ * DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.messages.in:
+
+ It travels from the connection to the appropriate UniqueIDBDatabase:
+ * DatabaseProcess/IndexedDB/UniqueIDBDatabase.cpp:
+ (WebKit::UniqueIDBDatabase::openTransaction):
+ (WebKit::UniqueIDBDatabase::beginTransaction):
+ (WebKit::UniqueIDBDatabase::commitTransaction):
+ (WebKit::UniqueIDBDatabase::resetTransaction):
+ (WebKit::UniqueIDBDatabase::rollbackTransaction):
+ (WebKit::UniqueIDBDatabase::postTransactionOperation):
+ (WebKit::UniqueIDBDatabase::didCompleteTransactionOperation):
+ (WebKit::UniqueIDBDatabase::openBackingStoreTransaction):
+ (WebKit::UniqueIDBDatabase::beginBackingStoreTransaction):
+ (WebKit::UniqueIDBDatabase::commitBackingStoreTransaction):
+ (WebKit::UniqueIDBDatabase::resetBackingStoreTransaction):
+ (WebKit::UniqueIDBDatabase::rollbackBackingStoreTransaction):
+ * DatabaseProcess/IndexedDB/UniqueIDBDatabase.h:
+
+ The UniqueIDBDatabase object performs the operation with the backing store:
+ * DatabaseProcess/IndexedDB/UniqueIDBDatabaseBackingStore.h:
+ * DatabaseProcess/IndexedDB/sqlite/UniqueIDBDatabaseBackingStoreSQLite.cpp:
+ (WebKit::UniqueIDBDatabaseBackingStoreSQLite::establishTransaction):
+ (WebKit::UniqueIDBDatabaseBackingStoreSQLite::beginTransaction):
+ (WebKit::UniqueIDBDatabaseBackingStoreSQLite::commitTransaction):
+ (WebKit::UniqueIDBDatabaseBackingStoreSQLite::resetTransaction):
+ (WebKit::UniqueIDBDatabaseBackingStoreSQLite::rollbackTransaction):
+ * DatabaseProcess/IndexedDB/sqlite/UniqueIDBDatabaseBackingStoreSQLite.h:
+
+ And the SQLite backing store calls the appropriate method on the SQLite transaction:
+ * DatabaseProcess/IndexedDB/sqlite/SQLiteIDBTransaction.cpp:
+ (WebKit::SQLiteIDBTransaction::begin): Stubbed for now.
+ (WebKit::SQLiteIDBTransaction::commit): Ditto.
+ (WebKit::SQLiteIDBTransaction::reset): Ditto.
+ (WebKit::SQLiteIDBTransaction::rollback): Ditto.
+ * DatabaseProcess/IndexedDB/sqlite/SQLiteIDBTransaction.h:
+
2013-12-16 Ryuan Choi <ryuan.c...@samsung.com>
Unreviewed build fix on EFL port after r160653
Modified: trunk/Source/WebKit2/DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.cpp (160677 => 160678)
--- trunk/Source/WebKit2/DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.cpp 2013-12-17 00:55:47 UTC (rev 160677)
+++ trunk/Source/WebKit2/DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.cpp 2013-12-17 01:12:23 UTC (rev 160678)
@@ -83,6 +83,46 @@
});
}
+void DatabaseProcessIDBConnection::beginTransaction(uint64_t requestID, int64_t transactionID)
+{
+ ASSERT(m_uniqueIDBDatabase);
+
+ RefPtr<DatabaseProcessIDBConnection> connection(this);
+ m_uniqueIDBDatabase->beginTransaction(IDBTransactionIdentifier(*this, transactionID), [connection, requestID](bool success) {
+ connection->send(Messages::WebIDBServerConnection::DidBeginTransaction(requestID, success));
+ });
+}
+
+void DatabaseProcessIDBConnection::commitTransaction(uint64_t requestID, int64_t transactionID)
+{
+ ASSERT(m_uniqueIDBDatabase);
+
+ RefPtr<DatabaseProcessIDBConnection> connection(this);
+ m_uniqueIDBDatabase->commitTransaction(IDBTransactionIdentifier(*this, transactionID), [connection, requestID](bool success) {
+ connection->send(Messages::WebIDBServerConnection::DidCommitTransaction(requestID, success));
+ });
+}
+
+void DatabaseProcessIDBConnection::resetTransaction(uint64_t requestID, int64_t transactionID)
+{
+ ASSERT(m_uniqueIDBDatabase);
+
+ RefPtr<DatabaseProcessIDBConnection> connection(this);
+ m_uniqueIDBDatabase->resetTransaction(IDBTransactionIdentifier(*this, transactionID), [connection, requestID](bool success) {
+ connection->send(Messages::WebIDBServerConnection::DidResetTransaction(requestID, success));
+ });
+}
+
+void DatabaseProcessIDBConnection::rollbackTransaction(uint64_t requestID, int64_t transactionID)
+{
+ ASSERT(m_uniqueIDBDatabase);
+
+ RefPtr<DatabaseProcessIDBConnection> connection(this);
+ m_uniqueIDBDatabase->rollbackTransaction(IDBTransactionIdentifier(*this, transactionID), [connection, requestID](bool success) {
+ connection->send(Messages::WebIDBServerConnection::DidRollbackTransaction(requestID, success));
+ });
+}
+
CoreIPC::Connection* DatabaseProcessIDBConnection::messageSenderConnection()
{
return m_connection->connection();
Modified: trunk/Source/WebKit2/DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.h (160677 => 160678)
--- trunk/Source/WebKit2/DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.h 2013-12-17 00:55:47 UTC (rev 160677)
+++ trunk/Source/WebKit2/DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.h 2013-12-17 01:12:23 UTC (rev 160678)
@@ -64,6 +64,10 @@
void establishConnection(const String& databaseName, const SecurityOriginData& openingOrigin, const SecurityOriginData& mainFrameOrigin);
void getOrEstablishIDBDatabaseMetadata(uint64_t requestID);
void openTransaction(uint64_t requestID, int64_t transactionID, int64_t transactionMode);
+ void beginTransaction(uint64_t requestID, int64_t transactionID);
+ void commitTransaction(uint64_t requestID, int64_t transactionID);
+ void resetTransaction(uint64_t requestID, int64_t transactionID);
+ void rollbackTransaction(uint64_t requestID, int64_t transactionID);
Ref<DatabaseToWebProcessConnection> m_connection;
uint64_t m_serverConnectionIdentifier;
Modified: trunk/Source/WebKit2/DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.messages.in (160677 => 160678)
--- trunk/Source/WebKit2/DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.messages.in 2013-12-17 00:55:47 UTC (rev 160677)
+++ trunk/Source/WebKit2/DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.messages.in 2013-12-17 01:12:23 UTC (rev 160678)
@@ -25,7 +25,12 @@
messages -> DatabaseProcessIDBConnection LegacyReceiver {
EstablishConnection(String databaseName, WebKit::SecurityOriginData openingOrigin, WebKit::SecurityOriginData mainFrameOrigin)
GetOrEstablishIDBDatabaseMetadata(uint64_t requestID)
+
OpenTransaction(uint64_t requestID, int64_t transactionID, int64_t transactionMode)
+ BeginTransaction(uint64_t requestID, int64_t transactionID)
+ CommitTransaction(uint64_t requestID, int64_t transactionID)
+ ResetTransaction(uint64_t requestID, int64_t transactionID)
+ RollbackTransaction(uint64_t requestID, int64_t transactionID)
}
#endif // ENABLE(INDEXED_DATABASE) && ENABLE(DATABASE_PROCESS)
Modified: trunk/Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabase.cpp (160677 => 160678)
--- trunk/Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabase.cpp 2013-12-17 00:55:47 UTC (rev 160677)
+++ trunk/Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabase.cpp 2013-12-17 01:12:23 UTC (rev 160678)
@@ -198,6 +198,31 @@
void UniqueIDBDatabase::openTransaction(const IDBTransactionIdentifier& identifier, std::function<void(bool)> successCallback)
{
+ postTransactionOperation(&UniqueIDBDatabase::openBackingStoreTransaction, identifier, successCallback);
+}
+
+void UniqueIDBDatabase::beginTransaction(const IDBTransactionIdentifier& identifier, std::function<void(bool)> successCallback)
+{
+ postTransactionOperation(&UniqueIDBDatabase::beginBackingStoreTransaction, identifier, successCallback);
+}
+
+void UniqueIDBDatabase::commitTransaction(const IDBTransactionIdentifier& identifier, std::function<void(bool)> successCallback)
+{
+ postTransactionOperation(&UniqueIDBDatabase::commitBackingStoreTransaction, identifier, successCallback);
+}
+
+void UniqueIDBDatabase::resetTransaction(const IDBTransactionIdentifier& identifier, std::function<void(bool)> successCallback)
+{
+ postTransactionOperation(&UniqueIDBDatabase::resetBackingStoreTransaction, identifier, successCallback);
+}
+
+void UniqueIDBDatabase::rollbackTransaction(const IDBTransactionIdentifier& identifier, std::function<void(bool)> successCallback)
+{
+ postTransactionOperation(&UniqueIDBDatabase::rollbackBackingStoreTransaction, identifier, successCallback);
+}
+
+void UniqueIDBDatabase::postTransactionOperation(TransactionOperationFunction function, const IDBTransactionIdentifier& identifier, std::function<void(bool)> successCallback)
+{
ASSERT(isMainThread());
if (!m_acceptingNewRequests) {
@@ -205,17 +230,34 @@
return;
}
- postDatabaseTask(createAsyncTask(*this, &UniqueIDBDatabase::openBackingStoreTransaction, identifier));
+ if (m_pendingTransactionRequests.contains(identifier)) {
+ LOG_ERROR("Attempting to queue an operation for a transaction that already has an operation pending. Each transaction should only have one operation pending at a time.");
+ successCallback(false);
+ return;
+ }
+ postDatabaseTask(createAsyncTask(*this, function, identifier));
+
RefPtr<AsyncRequest> request = AsyncRequestImpl<bool>::create([successCallback](bool success) {
successCallback(success);
}, [successCallback]() {
successCallback(false);
});
- m_pendingOpenTransactionRequests.set(identifier, request.release());
+ m_pendingTransactionRequests.add(identifier, request.release());
}
+void UniqueIDBDatabase::didCompleteTransactionOperation(const IDBTransactionIdentifier& identifier, bool success)
+{
+ ASSERT(isMainThread());
+
+ RefPtr<AsyncRequest> request = m_pendingTransactionRequests.take(identifier);
+ if (!request)
+ return;
+
+ request->completeRequest(success);
+}
+
void UniqueIDBDatabase::openBackingStoreTransaction(const IDBTransactionIdentifier& identifier)
{
ASSERT(!isMainThread());
@@ -223,21 +265,49 @@
bool success = m_backingStore->establishTransaction(identifier);
- postMainThreadTask(createAsyncTask(*this, &UniqueIDBDatabase::didOpenBackingStoreTransaction, identifier, success));
+ postMainThreadTask(createAsyncTask(*this, &UniqueIDBDatabase::didCompleteTransactionOperation, identifier, success));
}
-void UniqueIDBDatabase::didOpenBackingStoreTransaction(const IDBTransactionIdentifier& identifier, bool success)
+void UniqueIDBDatabase::beginBackingStoreTransaction(const IDBTransactionIdentifier& identifier)
{
- ASSERT(isMainThread());
+ ASSERT(!isMainThread());
+ ASSERT(m_backingStore);
- RefPtr<AsyncRequest> request = m_pendingOpenTransactionRequests.take(identifier);
+ bool success = m_backingStore->beginTransaction(identifier);
- if (!request)
- return;
+ postMainThreadTask(createAsyncTask(*this, &UniqueIDBDatabase::didCompleteTransactionOperation, identifier, success));
+}
- request->completeRequest(success);
+void UniqueIDBDatabase::commitBackingStoreTransaction(const IDBTransactionIdentifier& identifier)
+{
+ ASSERT(!isMainThread());
+ ASSERT(m_backingStore);
+
+ bool success = m_backingStore->commitTransaction(identifier);
+
+ postMainThreadTask(createAsyncTask(*this, &UniqueIDBDatabase::didCompleteTransactionOperation, identifier, success));
}
+void UniqueIDBDatabase::resetBackingStoreTransaction(const IDBTransactionIdentifier& identifier)
+{
+ ASSERT(!isMainThread());
+ ASSERT(m_backingStore);
+
+ bool success = m_backingStore->resetTransaction(identifier);
+
+ postMainThreadTask(createAsyncTask(*this, &UniqueIDBDatabase::didCompleteTransactionOperation, identifier, success));
+}
+
+void UniqueIDBDatabase::rollbackBackingStoreTransaction(const IDBTransactionIdentifier& identifier)
+{
+ ASSERT(!isMainThread());
+ ASSERT(m_backingStore);
+
+ bool success = m_backingStore->rollbackTransaction(identifier);
+
+ postMainThreadTask(createAsyncTask(*this, &UniqueIDBDatabase::didCompleteTransactionOperation, identifier, success));
+}
+
String UniqueIDBDatabase::absoluteDatabaseDirectory() const
{
ASSERT(isMainThread());
Modified: trunk/Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabase.h (160677 => 160678)
--- trunk/Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabase.h 2013-12-17 00:55:47 UTC (rev 160677)
+++ trunk/Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabase.h 2013-12-17 01:12:23 UTC (rev 160678)
@@ -65,7 +65,12 @@
void unregisterConnection(DatabaseProcessIDBConnection&);
void getOrEstablishIDBDatabaseMetadata(std::function<void(bool, const WebCore::IDBDatabaseMetadata&)> completionCallback);
+
void openTransaction(const IDBTransactionIdentifier&, std::function<void(bool)> successCallback);
+ void beginTransaction(const IDBTransactionIdentifier&, std::function<void(bool)> successCallback);
+ void commitTransaction(const IDBTransactionIdentifier&, std::function<void(bool)> successCallback);
+ void resetTransaction(const IDBTransactionIdentifier&, std::function<void(bool)> successCallback);
+ void rollbackTransaction(const IDBTransactionIdentifier&, std::function<void(bool)> successCallback);
private:
UniqueIDBDatabase(const UniqueIDBDatabaseIdentifier&);
@@ -91,22 +96,29 @@
// Returns true if this origin can use the same databases as the given origin.
bool canShareDatabases(const SecurityOriginData&, const SecurityOriginData&) const;
+
+ typedef void (UniqueIDBDatabase::*TransactionOperationFunction)(const IDBTransactionIdentifier&);
+ void postTransactionOperation(TransactionOperationFunction, const IDBTransactionIdentifier&, std::function<void(bool)> successCallback);
// To be called from the database workqueue thread only
void performNextDatabaseTask();
void postMainThreadTask(std::unique_ptr<AsyncTask>);
void openBackingStoreAndReadMetadata(const UniqueIDBDatabaseIdentifier&, const String& databaseDirectory);
void openBackingStoreTransaction(const IDBTransactionIdentifier&);
+ void beginBackingStoreTransaction(const IDBTransactionIdentifier&);
+ void commitBackingStoreTransaction(const IDBTransactionIdentifier&);
+ void resetBackingStoreTransaction(const IDBTransactionIdentifier&);
+ void rollbackBackingStoreTransaction(const IDBTransactionIdentifier&);
// Callbacks from the database workqueue thread, to be performed on the main thread only
void performNextMainThreadTask();
void didOpenBackingStoreAndReadMetadata(const WebCore::IDBDatabaseMetadata&, bool success);
- void didOpenBackingStoreTransaction(const IDBTransactionIdentifier&, bool success);
+ void didCompleteTransactionOperation(const IDBTransactionIdentifier&, bool success);
bool m_acceptingNewRequests;
Deque<RefPtr<AsyncRequest>> m_pendingMetadataRequests;
- HashMap<IDBTransactionIdentifier, RefPtr<AsyncRequest>> m_pendingOpenTransactionRequests;
+ HashMap<IDBTransactionIdentifier, RefPtr<AsyncRequest>> m_pendingTransactionRequests;
std::unique_ptr<WebCore::IDBDatabaseMetadata> m_metadata;
bool m_didGetMetadataFromBackingStore;
Modified: trunk/Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabaseBackingStore.h (160677 => 160678)
--- trunk/Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabaseBackingStore.h 2013-12-17 00:55:47 UTC (rev 160677)
+++ trunk/Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabaseBackingStore.h 2013-12-17 01:12:23 UTC (rev 160678)
@@ -43,7 +43,12 @@
virtual ~UniqueIDBDatabaseBackingStore() { }
virtual std::unique_ptr<WebCore::IDBDatabaseMetadata> getOrEstablishMetadata() = 0;
+
virtual bool establishTransaction(const IDBTransactionIdentifier&) = 0;
+ virtual bool beginTransaction(const IDBTransactionIdentifier&) = 0;
+ virtual bool commitTransaction(const IDBTransactionIdentifier&) = 0;
+ virtual bool resetTransaction(const IDBTransactionIdentifier&) = 0;
+ virtual bool rollbackTransaction(const IDBTransactionIdentifier&) = 0;
};
} // namespace WebKit
Modified: trunk/Source/WebKit2/DatabaseProcess/IndexedDB/sqlite/SQLiteIDBTransaction.cpp (160677 => 160678)
--- trunk/Source/WebKit2/DatabaseProcess/IndexedDB/sqlite/SQLiteIDBTransaction.cpp 2013-12-17 00:55:47 UTC (rev 160677)
+++ trunk/Source/WebKit2/DatabaseProcess/IndexedDB/sqlite/SQLiteIDBTransaction.cpp 2013-12-17 01:12:23 UTC (rev 160678)
@@ -34,6 +34,26 @@
{
}
+bool SQLiteIDBTransaction::begin()
+{
+ return false;
+}
+
+bool SQLiteIDBTransaction::commit()
+{
+ return false;
+}
+
+bool SQLiteIDBTransaction::reset()
+{
+ return false;
+}
+
+bool SQLiteIDBTransaction::rollback()
+{
+ return false;
+}
+
} // namespace WebKit
#endif // ENABLE(INDEXED_DATABASE) && ENABLE(DATABASE_PROCESS)
Modified: trunk/Source/WebKit2/DatabaseProcess/IndexedDB/sqlite/SQLiteIDBTransaction.h (160677 => 160678)
--- trunk/Source/WebKit2/DatabaseProcess/IndexedDB/sqlite/SQLiteIDBTransaction.h 2013-12-17 00:55:47 UTC (rev 160677)
+++ trunk/Source/WebKit2/DatabaseProcess/IndexedDB/sqlite/SQLiteIDBTransaction.h 2013-12-17 01:12:23 UTC (rev 160678)
@@ -43,6 +43,11 @@
const IDBTransactionIdentifier& identifier() const { return m_identifier; }
+ bool begin();
+ bool commit();
+ bool reset();
+ bool rollback();
+
private:
SQLiteIDBTransaction(const IDBTransactionIdentifier&);
Modified: trunk/Source/WebKit2/DatabaseProcess/IndexedDB/sqlite/UniqueIDBDatabaseBackingStoreSQLite.cpp (160677 => 160678)
--- trunk/Source/WebKit2/DatabaseProcess/IndexedDB/sqlite/UniqueIDBDatabaseBackingStoreSQLite.cpp 2013-12-17 00:55:47 UTC (rev 160677)
+++ trunk/Source/WebKit2/DatabaseProcess/IndexedDB/sqlite/UniqueIDBDatabaseBackingStoreSQLite.cpp 2013-12-17 01:12:23 UTC (rev 160678)
@@ -196,13 +196,67 @@
bool UniqueIDBDatabaseBackingStoreSQLite::establishTransaction(const IDBTransactionIdentifier& identifier)
{
ASSERT(!isMainThread());
- ASSERT(!m_transactions.contains(identifier));
+
+ if (!m_transactions.add(identifier, SQLiteIDBTransaction::create(identifier)).isNewEntry) {
+ LOG_ERROR("Attempt to establish transaction identifier that already exists");
+ return false;
+ }
- m_transactions.add(identifier, SQLiteIDBTransaction::create(identifier));
-
return true;
}
+bool UniqueIDBDatabaseBackingStoreSQLite::beginTransaction(const IDBTransactionIdentifier& identifier)
+{
+ ASSERT(!isMainThread());
+
+ SQLiteIDBTransaction* transaction = m_transactions.get(identifier);
+ if (!transaction) {
+ LOG_ERROR("Attempt to begin a transaction that hasn't been established");
+ return false;
+ }
+
+ return transaction->begin();
+}
+
+bool UniqueIDBDatabaseBackingStoreSQLite::commitTransaction(const IDBTransactionIdentifier& identifier)
+{
+ ASSERT(!isMainThread());
+
+ SQLiteIDBTransaction* transaction = m_transactions.get(identifier);
+ if (!transaction) {
+ LOG_ERROR("Attempt to commit a transaction that hasn't been established");
+ return false;
+ }
+
+ return transaction->commit();
+}
+
+bool UniqueIDBDatabaseBackingStoreSQLite::resetTransaction(const IDBTransactionIdentifier& identifier)
+{
+ ASSERT(!isMainThread());
+
+ SQLiteIDBTransaction* transaction = m_transactions.get(identifier);
+ if (!transaction) {
+ LOG_ERROR("Attempt to reset a transaction that hasn't been established");
+ return false;
+ }
+
+ return transaction->reset();
+}
+
+bool UniqueIDBDatabaseBackingStoreSQLite::rollbackTransaction(const IDBTransactionIdentifier& identifier)
+{
+ ASSERT(!isMainThread());
+
+ SQLiteIDBTransaction* transaction = m_transactions.get(identifier);
+ if (!transaction) {
+ LOG_ERROR("Attempt to rollback a transaction that hasn't been established");
+ return false;
+ }
+
+ return transaction->rollback();
+}
+
} // namespace WebKit
#endif // ENABLE(INDEXED_DATABASE) && ENABLE(DATABASE_PROCESS)
Modified: trunk/Source/WebKit2/DatabaseProcess/IndexedDB/sqlite/UniqueIDBDatabaseBackingStoreSQLite.h (160677 => 160678)
--- trunk/Source/WebKit2/DatabaseProcess/IndexedDB/sqlite/UniqueIDBDatabaseBackingStoreSQLite.h 2013-12-17 00:55:47 UTC (rev 160677)
+++ trunk/Source/WebKit2/DatabaseProcess/IndexedDB/sqlite/UniqueIDBDatabaseBackingStoreSQLite.h 2013-12-17 01:12:23 UTC (rev 160678)
@@ -52,7 +52,12 @@
virtual ~UniqueIDBDatabaseBackingStoreSQLite();
virtual std::unique_ptr<WebCore::IDBDatabaseMetadata> getOrEstablishMetadata() OVERRIDE;
+
virtual bool establishTransaction(const IDBTransactionIdentifier&) OVERRIDE;
+ virtual bool beginTransaction(const IDBTransactionIdentifier&) OVERRIDE;
+ virtual bool commitTransaction(const IDBTransactionIdentifier&) OVERRIDE;
+ virtual bool resetTransaction(const IDBTransactionIdentifier&) OVERRIDE;
+ virtual bool rollbackTransaction(const IDBTransactionIdentifier&) OVERRIDE;
private:
UniqueIDBDatabaseBackingStoreSQLite(const UniqueIDBDatabaseIdentifier&, const String& databaseDirectory);
Modified: trunk/Source/WebKit2/WebProcess/Databases/IndexedDB/WebIDBServerConnection.cpp (160677 => 160678)
--- trunk/Source/WebKit2/WebProcess/Databases/IndexedDB/WebIDBServerConnection.cpp 2013-12-17 00:55:47 UTC (rev 160677)
+++ trunk/Source/WebKit2/WebProcess/Databases/IndexedDB/WebIDBServerConnection.cpp 2013-12-17 01:12:23 UTC (rev 160678)
@@ -139,20 +139,92 @@
void WebIDBServerConnection::beginTransaction(int64_t transactionID, std::function<void()> completionCallback)
{
+ RefPtr<AsyncRequest> serverRequest = AsyncRequestImpl<>::create(completionCallback, completionCallback);
+
+ uint64_t requestID = serverRequest->requestID();
+ ASSERT(!m_serverRequests.contains(requestID));
+ m_serverRequests.add(requestID, serverRequest.release());
+
+ send(Messages::DatabaseProcessIDBConnection::BeginTransaction(requestID, transactionID));
}
+void WebIDBServerConnection::didBeginTransaction(uint64_t requestID, bool)
+{
+ RefPtr<AsyncRequest> serverRequest = m_serverRequests.take(requestID);
+
+ if (!serverRequest)
+ return;
+
+ serverRequest->completeRequest();
+}
+
void WebIDBServerConnection::commitTransaction(int64_t transactionID, BoolCallbackFunction successCallback)
{
+ RefPtr<AsyncRequest> serverRequest = AsyncRequestImpl<bool>::create(successCallback);
+
+ serverRequest->setAbortHandler([successCallback]() {
+ successCallback(false);
+ });
+
+ uint64_t requestID = serverRequest->requestID();
+ ASSERT(!m_serverRequests.contains(requestID));
+ m_serverRequests.add(requestID, serverRequest.release());
+
+ send(Messages::DatabaseProcessIDBConnection::CommitTransaction(requestID, transactionID));
}
+void WebIDBServerConnection::didCommitTransaction(uint64_t requestID, bool success)
+{
+ RefPtr<AsyncRequest> serverRequest = m_serverRequests.take(requestID);
+
+ if (!serverRequest)
+ return;
+
+ serverRequest->completeRequest(success);
+}
+
void WebIDBServerConnection::resetTransaction(int64_t transactionID, std::function<void()> completionCallback)
{
+ RefPtr<AsyncRequest> serverRequest = AsyncRequestImpl<>::create(completionCallback, completionCallback);
+
+ uint64_t requestID = serverRequest->requestID();
+ ASSERT(!m_serverRequests.contains(requestID));
+ m_serverRequests.add(requestID, serverRequest.release());
+
+ send(Messages::DatabaseProcessIDBConnection::ResetTransaction(requestID, transactionID));
}
+void WebIDBServerConnection::didResetTransaction(uint64_t requestID, bool)
+{
+ RefPtr<AsyncRequest> serverRequest = m_serverRequests.take(requestID);
+
+ if (!serverRequest)
+ return;
+
+ serverRequest->completeRequest();
+}
+
void WebIDBServerConnection::rollbackTransaction(int64_t transactionID, std::function<void()> completionCallback)
{
+ RefPtr<AsyncRequest> serverRequest = AsyncRequestImpl<>::create(completionCallback, completionCallback);
+
+ uint64_t requestID = serverRequest->requestID();
+ ASSERT(!m_serverRequests.contains(requestID));
+ m_serverRequests.add(requestID, serverRequest.release());
+
+ send(Messages::DatabaseProcessIDBConnection::RollbackTransaction(requestID, transactionID));
}
+void WebIDBServerConnection::didRollbackTransaction(uint64_t requestID, bool)
+{
+ RefPtr<AsyncRequest> serverRequest = m_serverRequests.take(requestID);
+
+ if (!serverRequest)
+ return;
+
+ serverRequest->completeRequest();
+}
+
void WebIDBServerConnection::setIndexKeys(int64_t transactionID, int64_t databaseID, int64_t objectStoreID, const IDBObjectStoreMetadata&, IDBKey& primaryKey, const Vector<int64_t>& indexIDs, const Vector<Vector<RefPtr<IDBKey>>>& indexKeys, std::function<void(PassRefPtr<IDBDatabaseError>)> completionCallback)
{
}
Modified: trunk/Source/WebKit2/WebProcess/Databases/IndexedDB/WebIDBServerConnection.h (160677 => 160678)
--- trunk/Source/WebKit2/WebProcess/Databases/IndexedDB/WebIDBServerConnection.h 2013-12-17 00:55:47 UTC (rev 160677)
+++ trunk/Source/WebKit2/WebProcess/Databases/IndexedDB/WebIDBServerConnection.h 2013-12-17 01:12:23 UTC (rev 160678)
@@ -95,6 +95,10 @@
void didGetOrEstablishIDBDatabaseMetadata(uint64_t requestID, bool success, const WebCore::IDBDatabaseMetadata&);
void didOpenTransaction(uint64_t requestID, bool success);
+ void didBeginTransaction(uint64_t requestID, bool success);
+ void didCommitTransaction(uint64_t requestID, bool success);
+ void didResetTransaction(uint64_t requestID, bool success);
+ void didRollbackTransaction(uint64_t requestID, bool success);
uint64_t m_serverConnectionIdentifier;
Modified: trunk/Source/WebKit2/WebProcess/Databases/IndexedDB/WebIDBServerConnection.messages.in (160677 => 160678)
--- trunk/Source/WebKit2/WebProcess/Databases/IndexedDB/WebIDBServerConnection.messages.in 2013-12-17 00:55:47 UTC (rev 160677)
+++ trunk/Source/WebKit2/WebProcess/Databases/IndexedDB/WebIDBServerConnection.messages.in 2013-12-17 01:12:23 UTC (rev 160678)
@@ -24,7 +24,12 @@
messages -> WebIDBServerConnection LegacyReceiver {
DidGetOrEstablishIDBDatabaseMetadata(uint64_t requestID, bool success, WebCore::IDBDatabaseMetadata metadata)
+
DidOpenTransaction(uint64_t requestID, bool success)
+ DidBeginTransaction(uint64_t requestID, bool success)
+ DidCommitTransaction(uint64_t requestID, bool success)
+ DidResetTransaction(uint64_t requestID, bool success)
+ DidRollbackTransaction(uint64_t requestID, bool success)
}
#endif // ENABLE(INDEXED_DATABASE) && ENABLE(DATABASE_PROCESS)
