Diff
Modified: trunk/Source/WebCore/ChangeLog (200484 => 200485)
--- trunk/Source/WebCore/ChangeLog 2016-05-05 22:14:02 UTC (rev 200484)
+++ trunk/Source/WebCore/ChangeLog 2016-05-05 22:14:08 UTC (rev 200485)
@@ -1,5 +1,89 @@
2016-05-04 Brady Eidson <[email protected]>
+ Modern IDB: Move all IDB DOM object management from IDBConnectionToServer to IDBConnectionProxy.
+ https://bugs.webkit.org/show_bug.cgi?id=157348
+
+ Reviewed by Alex Christensen.
+
+ No new tests (Refactor, no change in behavior yet).
+
+ This is in-progress IDB-in-Workers code that is isolated enough to land right now.
+
+ The goal is to have IDBConnectionToServer be a main-thread-only object, leaving IDBConnectionProxy
+ as the threading bridge between the worker thread and the main thread.
+
+ As such, IDBConnectionToServer no longer maintains maps of IDB DOM objects, but instead the proxy
+ does and guards that access with locks.
+
+ No threading changes takes place in this patch but it does scatter some isMainThread() checks and FIXMEs
+ accurately representing where threading changes will take place once I can return to this.
+
+ * Modules/indexeddb/IDBDatabase.cpp:
+ (WebCore::IDBDatabase::IDBDatabase):
+ (WebCore::IDBDatabase::~IDBDatabase):
+ (WebCore::IDBDatabase::maybeCloseInServer):
+
+ * Modules/indexeddb/IDBOpenDBRequest.cpp:
+ (WebCore::IDBOpenDBRequest::dispatchEvent):
+
+ * Modules/indexeddb/IDBTransaction.cpp:
+ (WebCore::IDBTransaction::abortOnServerAndCancelRequests):
+ (WebCore::IDBTransaction::commitOnServer):
+ (WebCore::IDBTransaction::establishOnServer):
+
+ * Modules/indexeddb/client/IDBConnectionProxy.cpp:
+ (WebCore::IDBClient::IDBConnectionProxy::openDatabase):
+ (WebCore::IDBClient::IDBConnectionProxy::deleteDatabase):
+ (WebCore::IDBClient::IDBConnectionProxy::didOpenDatabase):
+ (WebCore::IDBClient::IDBConnectionProxy::didDeleteDatabase):
+ (WebCore::IDBClient::IDBConnectionProxy::completeOpenDBRequest):
+ (WebCore::IDBClient::IDBConnectionProxy::fireVersionChangeEvent):
+ (WebCore::IDBClient::IDBConnectionProxy::didFireVersionChangeEvent):
+ (WebCore::IDBClient::IDBConnectionProxy::notifyOpenDBRequestBlocked):
+ (WebCore::IDBClient::IDBConnectionProxy::establishTransaction):
+ (WebCore::IDBClient::IDBConnectionProxy::didStartTransaction):
+ (WebCore::IDBClient::IDBConnectionProxy::commitTransaction):
+ (WebCore::IDBClient::IDBConnectionProxy::didCommitTransaction):
+ (WebCore::IDBClient::IDBConnectionProxy::abortTransaction):
+ (WebCore::IDBClient::IDBConnectionProxy::didAbortTransaction):
+ (WebCore::IDBClient::IDBConnectionProxy::hasRecordOfTransaction):
+ (WebCore::IDBClient::IDBConnectionProxy::didFinishHandlingVersionChangeTransaction):
+ (WebCore::IDBClient::IDBConnectionProxy::databaseConnectionClosed):
+ (WebCore::IDBClient::IDBConnectionProxy::registerDatabaseConnection):
+ (WebCore::IDBClient::IDBConnectionProxy::unregisterDatabaseConnection):
+ * Modules/indexeddb/client/IDBConnectionProxy.h:
+
+ * Modules/indexeddb/client/IDBConnectionToServer.cpp:
+ (WebCore::IDBClient::IDBConnectionToServer::deleteDatabase):
+ (WebCore::IDBClient::IDBConnectionToServer::didDeleteDatabase):
+ (WebCore::IDBClient::IDBConnectionToServer::openDatabase):
+ (WebCore::IDBClient::IDBConnectionToServer::didOpenDatabase):
+ (WebCore::IDBClient::IDBConnectionToServer::establishTransaction):
+ (WebCore::IDBClient::IDBConnectionToServer::commitTransaction):
+ (WebCore::IDBClient::IDBConnectionToServer::didCommitTransaction):
+ (WebCore::IDBClient::IDBConnectionToServer::didFinishHandlingVersionChangeTransaction):
+ (WebCore::IDBClient::IDBConnectionToServer::abortTransaction):
+ (WebCore::IDBClient::IDBConnectionToServer::didAbortTransaction):
+ (WebCore::IDBClient::IDBConnectionToServer::fireVersionChangeEvent):
+ (WebCore::IDBClient::IDBConnectionToServer::didFireVersionChangeEvent):
+ (WebCore::IDBClient::IDBConnectionToServer::didStartTransaction):
+ (WebCore::IDBClient::IDBConnectionToServer::notifyOpenDBRequestBlocked):
+ (WebCore::IDBClient::IDBConnectionToServer::databaseConnectionClosed):
+ (WebCore::IDBClient::IDBConnectionToServer::registerDatabaseConnection): Deleted.
+ (WebCore::IDBClient::IDBConnectionToServer::unregisterDatabaseConnection): Deleted.
+ (WebCore::IDBClient::IDBConnectionToServer::hasRecordOfTransaction): Deleted.
+ * Modules/indexeddb/client/IDBConnectionToServer.h:
+
+ * Modules/indexeddb/shared/IDBRequestData.cpp:
+ (WebCore::IDBRequestData::IDBRequestData):
+ * Modules/indexeddb/shared/IDBRequestData.h:
+
+ * Modules/indexeddb/shared/IDBResourceIdentifier.cpp:
+ (WebCore::IDBResourceIdentifier::IDBResourceIdentifier):
+ * Modules/indexeddb/shared/IDBResourceIdentifier.h:
+
+2016-05-04 Brady Eidson <[email protected]>
+
Modern IDB: Add isolatedCopy to a few more objects.
https://bugs.webkit.org/show_bug.cgi?id=157330
Modified: trunk/Source/WebCore/Modules/indexeddb/IDBDatabase.cpp (200484 => 200485)
--- trunk/Source/WebCore/Modules/indexeddb/IDBDatabase.cpp 2016-05-05 22:14:02 UTC (rev 200484)
+++ trunk/Source/WebCore/Modules/indexeddb/IDBDatabase.cpp 2016-05-05 22:14:08 UTC (rev 200485)
@@ -56,14 +56,13 @@
{
LOG(IndexedDB, "IDBDatabase::IDBDatabase - Creating database %s with version %" PRIu64 " connection %" PRIu64, m_info.name().utf8().data(), m_info.version(), m_databaseConnectionIdentifier);
suspendIfNeeded();
- relaxAdoptionRequirement();
- m_connectionProxy->connectionToServer().registerDatabaseConnection(*this);
+ m_connectionProxy->registerDatabaseConnection(*this);
}
IDBDatabase::~IDBDatabase()
{
ASSERT(currentThread() == m_originThreadID);
- m_connectionProxy->connectionToServer().unregisterDatabaseConnection(*this);
+ m_connectionProxy->unregisterDatabaseConnection(*this);
}
bool IDBDatabase::hasPendingActivity() const
@@ -262,7 +261,7 @@
return;
m_closedInServer = true;
- m_connectionProxy->connectionToServer().databaseConnectionClosed(*this);
+ m_connectionProxy->databaseConnectionClosed(*this);
}
const char* IDBDatabase::activeDOMObjectName() const
Modified: trunk/Source/WebCore/Modules/indexeddb/IDBDatabase.h (200484 => 200485)
--- trunk/Source/WebCore/Modules/indexeddb/IDBDatabase.h 2016-05-05 22:14:02 UTC (rev 200484)
+++ trunk/Source/WebCore/Modules/indexeddb/IDBDatabase.h 2016-05-05 22:14:08 UTC (rev 200485)
@@ -43,7 +43,7 @@
class IDBTransaction;
class IDBTransactionInfo;
-class IDBDatabase : public RefCounted<IDBDatabase>, public EventTargetWithInlineData, public ActiveDOMObject {
+class IDBDatabase : public ThreadSafeRefCounted<IDBDatabase>, public EventTargetWithInlineData, public ActiveDOMObject {
public:
static Ref<IDBDatabase> create(ScriptExecutionContext&, IDBClient::IDBConnectionProxy&, const IDBResultData&);
@@ -64,11 +64,11 @@
// EventTarget
EventTargetInterface eventTargetInterface() const final { return IDBDatabaseEventTargetInterfaceType; }
ScriptExecutionContext* scriptExecutionContext() const final { return ActiveDOMObject::scriptExecutionContext(); }
- void refEventTarget() final { RefCounted<IDBDatabase>::ref(); }
- void derefEventTarget() final { RefCounted<IDBDatabase>::deref(); }
+ void refEventTarget() final { ThreadSafeRefCounted<IDBDatabase>::ref(); }
+ void derefEventTarget() final { ThreadSafeRefCounted<IDBDatabase>::deref(); }
- using RefCounted<IDBDatabase>::ref;
- using RefCounted<IDBDatabase>::deref;
+ using ThreadSafeRefCounted<IDBDatabase>::ref;
+ using ThreadSafeRefCounted<IDBDatabase>::deref;
const char* activeDOMObjectName() const final;
bool canSuspendForDocumentSuspension() const final;
Modified: trunk/Source/WebCore/Modules/indexeddb/IDBOpenDBRequest.cpp (200484 => 200485)
--- trunk/Source/WebCore/Modules/indexeddb/IDBOpenDBRequest.cpp 2016-05-05 22:14:02 UTC (rev 200484)
+++ trunk/Source/WebCore/Modules/indexeddb/IDBOpenDBRequest.cpp 2016-05-05 22:14:08 UTC (rev 200485)
@@ -118,7 +118,7 @@
bool result = IDBRequest::dispatchEvent(event);
if (m_transaction && m_transaction->isVersionChange() && (event.type() == eventNames().errorEvent || event.type() == eventNames().successEvent))
- m_transaction->database().serverConnection().didFinishHandlingVersionChangeTransaction(*m_transaction);
+ m_transaction->database().connectionProxy().didFinishHandlingVersionChangeTransaction(*m_transaction);
return result;
}
Modified: trunk/Source/WebCore/Modules/indexeddb/IDBTransaction.cpp (200484 => 200485)
--- trunk/Source/WebCore/Modules/indexeddb/IDBTransaction.cpp 2016-05-05 22:14:02 UTC (rev 200484)
+++ trunk/Source/WebCore/Modules/indexeddb/IDBTransaction.cpp 2016-05-05 22:14:08 UTC (rev 200485)
@@ -133,8 +133,6 @@
LOG(IndexedDB, "IDBTransaction::IDBTransaction - %s", m_info.loggingString().utf8().data());
ASSERT(currentThread() == m_database->originThreadID());
- relaxAdoptionRequirement();
-
if (m_info.mode() == IndexedDB::TransactionMode::VersionChange) {
ASSERT(m_openDBRequest);
m_openDBRequest->setVersionChangeTransaction(*this);
@@ -295,7 +293,7 @@
ASSERT(currentThread() == m_database->originThreadID());
ASSERT(m_transactionOperationQueue.isEmpty());
- serverConnection().abortTransaction(*this);
+ m_database->connectionProxy().abortTransaction(*this);
ASSERT(m_transactionOperationMap.contains(operation.identifier()));
m_transactionOperationMap.remove(operation.identifier());
@@ -432,7 +430,7 @@
LOG(IndexedDB, "IDBTransaction::commitOnServer");
ASSERT(currentThread() == m_database->originThreadID());
- serverConnection().commitTransaction(*this);
+ m_database->connectionProxy().commitTransaction(*this);
ASSERT(m_transactionOperationMap.contains(operation.identifier()));
m_transactionOperationMap.remove(operation.identifier());
@@ -1044,7 +1042,7 @@
LOG(IndexedDB, "IDBTransaction::establishOnServer");
ASSERT(currentThread() == m_database->originThreadID());
- serverConnection().establishTransaction(*this);
+ m_database->connectionProxy().establishTransaction(*this);
}
void IDBTransaction::activate()
Modified: trunk/Source/WebCore/Modules/indexeddb/IDBTransaction.h (200484 => 200485)
--- trunk/Source/WebCore/Modules/indexeddb/IDBTransaction.h 2016-05-05 22:14:02 UTC (rev 200484)
+++ trunk/Source/WebCore/Modules/indexeddb/IDBTransaction.h 2016-05-05 22:14:08 UTC (rev 200485)
@@ -58,7 +58,7 @@
class TransactionOperation;
}
-class IDBTransaction : public RefCounted<IDBTransaction>, public EventTargetWithInlineData, private ActiveDOMObject {
+class IDBTransaction : public ThreadSafeRefCounted<IDBTransaction>, public EventTargetWithInlineData, private ActiveDOMObject {
public:
static const AtomicString& modeReadOnly();
static const AtomicString& modeReadWrite();
@@ -83,13 +83,13 @@
EventTargetInterface eventTargetInterface() const final { return IDBTransactionEventTargetInterfaceType; }
ScriptExecutionContext* scriptExecutionContext() const final { return ActiveDOMObject::scriptExecutionContext(); }
- void refEventTarget() final { RefCounted::ref(); }
- void derefEventTarget() final { RefCounted::deref(); }
+ void refEventTarget() final { ThreadSafeRefCounted::ref(); }
+ void derefEventTarget() final { ThreadSafeRefCounted::deref(); }
using EventTarget::dispatchEvent;
bool dispatchEvent(Event&) final;
- using RefCounted<IDBTransaction>::ref;
- using RefCounted<IDBTransaction>::deref;
+ using ThreadSafeRefCounted<IDBTransaction>::ref;
+ using ThreadSafeRefCounted<IDBTransaction>::deref;
const char* activeDOMObjectName() const final;
bool canSuspendForDocumentSuspension() const final;
Modified: trunk/Source/WebCore/Modules/indexeddb/client/IDBConnectionProxy.cpp (200484 => 200485)
--- trunk/Source/WebCore/Modules/indexeddb/client/IDBConnectionProxy.cpp 2016-05-05 22:14:02 UTC (rev 200484)
+++ trunk/Source/WebCore/Modules/indexeddb/client/IDBConnectionProxy.cpp 2016-05-05 22:14:08 UTC (rev 200485)
@@ -28,7 +28,10 @@
#if ENABLE(INDEXED_DATABASE)
+#include "IDBDatabase.h"
#include "IDBOpenDBRequest.h"
+#include "IDBRequestData.h"
+#include "IDBResultData.h"
#include <wtf/MainThread.h>
namespace WebCore {
@@ -66,9 +69,21 @@
if (!isMainThread())
return nullptr;
- auto request = IDBOpenDBRequest::createOpenRequest(context, *this, databaseIdentifier, version);
- m_connectionToServer.openDatabase(request.get());
- return WTFMove(request);
+ RefPtr<IDBOpenDBRequest> request;
+ {
+ Locker<Lock> locker(m_openDBRequestMapLock);
+
+ request = IDBOpenDBRequest::createOpenRequest(context, *this, databaseIdentifier, version);
+ ASSERT(!m_openDBRequestMap.contains(request->resourceIdentifier()));
+ m_openDBRequestMap.set(request->resourceIdentifier(), request.get());
+ }
+
+ IDBRequestData requestData(*this, *request);
+
+ // FIXME: For workers, marshall this to the main thread if necessary.
+ m_connectionToServer.openDatabase(requestData);
+
+ return request;
}
RefPtr<IDBOpenDBRequest> IDBConnectionProxy::deleteDatabase(ScriptExecutionContext& context, const IDBDatabaseIdentifier& databaseIdentifier)
@@ -77,11 +92,203 @@
if (!isMainThread())
return nullptr;
- auto request = IDBOpenDBRequest::createDeleteRequest(context, *this, databaseIdentifier);
- m_connectionToServer.deleteDatabase(request.get());
- return WTFMove(request);
+ RefPtr<IDBOpenDBRequest> request;
+ {
+ Locker<Lock> locker(m_openDBRequestMapLock);
+
+ request = IDBOpenDBRequest::createDeleteRequest(context, *this, databaseIdentifier);
+ ASSERT(!m_openDBRequestMap.contains(request->resourceIdentifier()));
+ m_openDBRequestMap.set(request->resourceIdentifier(), request.get());
+ }
+
+ IDBRequestData requestData(*this, *request);
+
+ // FIXME: For workers, marshall this to the main thread if necessary.
+ m_connectionToServer.deleteDatabase(requestData);
+
+ return request;
}
+void IDBConnectionProxy::didOpenDatabase(const IDBResultData& resultData)
+{
+ completeOpenDBRequest(resultData);
+}
+
+void IDBConnectionProxy::didDeleteDatabase(const IDBResultData& resultData)
+{
+ completeOpenDBRequest(resultData);
+}
+
+void IDBConnectionProxy::completeOpenDBRequest(const IDBResultData& resultData)
+{
+ ASSERT(isMainThread());
+
+ RefPtr<IDBOpenDBRequest> request;
+ {
+ Locker<Lock> locker(m_openDBRequestMapLock);
+ request = m_openDBRequestMap.get(resultData.requestIdentifier());
+ ASSERT(request);
+ }
+
+ request->requestCompleted(resultData);
+}
+
+void IDBConnectionProxy::fireVersionChangeEvent(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& requestIdentifier, uint64_t requestedVersion)
+{
+ ASSERT(isMainThread());
+
+ RefPtr<IDBDatabase> database;
+ {
+ Locker<Lock> locker(m_databaseConnectionMapLock);
+ database = m_databaseConnectionMap.get(databaseConnectionIdentifier);
+ }
+
+ if (!database)
+ return;
+
+ database->fireVersionChangeEvent(requestIdentifier, requestedVersion);
+}
+
+void IDBConnectionProxy::didFireVersionChangeEvent(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& requestIdentifier)
+{
+ // FIXME: Handle Workers
+ if (!isMainThread())
+ return;
+
+ m_connectionToServer.didFireVersionChangeEvent(databaseConnectionIdentifier, requestIdentifier);
+}
+
+void IDBConnectionProxy::notifyOpenDBRequestBlocked(const IDBResourceIdentifier& requestIdentifier, uint64_t oldVersion, uint64_t newVersion)
+{
+ ASSERT(isMainThread());
+
+ RefPtr<IDBOpenDBRequest> request;
+ {
+ Locker<Lock> locker(m_openDBRequestMapLock);
+ request = m_openDBRequestMap.get(requestIdentifier);
+ }
+
+ ASSERT(request);
+
+ request->requestBlocked(oldVersion, newVersion);
+}
+
+void IDBConnectionProxy::establishTransaction(IDBTransaction& transaction)
+{
+ {
+ Locker<Lock> locker(m_transactionMapLock);
+ ASSERT(!hasRecordOfTransaction(transaction));
+ m_pendingTransactions.set(transaction.info().identifier(), &transaction);
+ }
+
+ // FIXME: Handle Workers
+ if (!isMainThread())
+ return;
+
+ m_connectionToServer.establishTransaction(transaction.database().databaseConnectionIdentifier(), transaction.info());
+}
+
+void IDBConnectionProxy::didStartTransaction(const IDBResourceIdentifier& transactionIdentifier, const IDBError& error)
+{
+ RefPtr<IDBTransaction> transaction;
+ {
+ Locker<Lock> locker(m_transactionMapLock);
+ transaction = m_pendingTransactions.take(transactionIdentifier);
+ }
+
+ ASSERT(transaction);
+
+ // FIXME: Handle hopping to the Worker thread here if necessary.
+
+ transaction->didStart(error);
+}
+
+void IDBConnectionProxy::commitTransaction(IDBTransaction& transaction)
+{
+ {
+ Locker<Lock> locker(m_transactionMapLock);
+ ASSERT(!m_committingTransactions.contains(transaction.info().identifier()));
+ m_committingTransactions.set(transaction.info().identifier(), &transaction);
+ }
+
+ // FIXME: Handle Workers
+ if (!isMainThread())
+ return;
+
+ m_connectionToServer.commitTransaction(transaction.info().identifier());
+}
+
+void IDBConnectionProxy::didCommitTransaction(const IDBResourceIdentifier& transactionIdentifier, const IDBError& error)
+{
+ RefPtr<IDBTransaction> transaction;
+ {
+ Locker<Lock> locker(m_transactionMapLock);
+ transaction = m_committingTransactions.take(transactionIdentifier);
+ }
+
+ ASSERT(transaction);
+
+ // FIXME: Handle hopping to the Worker thread here if necessary.
+
+ transaction->didCommit(error);
+}
+
+void IDBConnectionProxy::abortTransaction(IDBTransaction& transaction)
+{
+ {
+ Locker<Lock> locker(m_transactionMapLock);
+ ASSERT(!m_abortingTransactions.contains(transaction.info().identifier()));
+ m_abortingTransactions.set(transaction.info().identifier(), &transaction);
+ }
+
+ // FIXME: Handle Workers
+ if (!isMainThread())
+ return;
+
+ m_connectionToServer.abortTransaction(transaction.info().identifier());
+}
+
+void IDBConnectionProxy::didAbortTransaction(const IDBResourceIdentifier& transactionIdentifier, const IDBError& error)
+{
+ RefPtr<IDBTransaction> transaction;
+ {
+ Locker<Lock> locker(m_transactionMapLock);
+ transaction = m_abortingTransactions.take(transactionIdentifier);
+ }
+
+ ASSERT(transaction);
+
+ // FIXME: Handle hopping to the Worker thread here if necessary.
+
+ transaction->didAbort(error);
+}
+
+bool IDBConnectionProxy::hasRecordOfTransaction(const IDBTransaction& transaction) const
+{
+ ASSERT(m_transactionMapLock.isLocked());
+
+ auto identifier = transaction.info().identifier();
+ return m_pendingTransactions.contains(identifier) || m_committingTransactions.contains(identifier) || m_abortingTransactions.contains(identifier);
+}
+
+void IDBConnectionProxy::didFinishHandlingVersionChangeTransaction(IDBTransaction& transaction)
+{
+ // FIXME: Handle Workers
+ if (!isMainThread())
+ return;
+
+ m_connectionToServer.didFinishHandlingVersionChangeTransaction(transaction.info().identifier());
+}
+
+void IDBConnectionProxy::databaseConnectionClosed(IDBDatabase& database)
+{
+ // FIXME: Handle Workers
+ if (!isMainThread())
+ return;
+
+ m_connectionToServer.databaseConnectionClosed(database.databaseConnectionIdentifier());
+}
+
void IDBConnectionProxy::getAllDatabaseNames(const SecurityOrigin& mainFrameOrigin, const SecurityOrigin& openingOrigin, std::function<void (const Vector<String>&)> callback)
{
// This method is only meant to be called by the web inspector on the main thread.
@@ -90,7 +297,23 @@
m_connectionToServer.getAllDatabaseNames(mainFrameOrigin, openingOrigin, callback);
}
+void IDBConnectionProxy::registerDatabaseConnection(IDBDatabase& database)
+{
+ Locker<Lock> locker(m_databaseConnectionMapLock);
+ ASSERT(!m_databaseConnectionMap.contains(database.databaseConnectionIdentifier()));
+ m_databaseConnectionMap.set(database.databaseConnectionIdentifier(), &database);
+}
+
+void IDBConnectionProxy::unregisterDatabaseConnection(IDBDatabase& database)
+{
+ Locker<Lock> locker(m_databaseConnectionMapLock);
+
+ ASSERT(m_databaseConnectionMap.contains(database.databaseConnectionIdentifier()));
+ ASSERT(m_databaseConnectionMap.get(database.databaseConnectionIdentifier()) == &database);
+ m_databaseConnectionMap.remove(database.databaseConnectionIdentifier());
+}
+
} // namesapce IDBClient
} // namespace WebCore
Modified: trunk/Source/WebCore/Modules/indexeddb/client/IDBConnectionProxy.h (200484 => 200485)
--- trunk/Source/WebCore/Modules/indexeddb/client/IDBConnectionProxy.h 2016-05-05 22:14:02 UTC (rev 200484)
+++ trunk/Source/WebCore/Modules/indexeddb/client/IDBConnectionProxy.h 2016-05-05 22:14:08 UTC (rev 200485)
@@ -28,15 +28,21 @@
#if ENABLE(INDEXED_DATABASE)
#include "IDBConnectionToServer.h"
+#include "IDBResourceIdentifier.h"
#include <functional>
+#include <wtf/HashMap.h>
#include <wtf/RefPtr.h>
#include <wtf/Vector.h>
#include <wtf/text/WTFString.h>
namespace WebCore {
+class IDBDatabase;
class IDBDatabaseIdentifier;
+class IDBError;
class IDBOpenDBRequest;
+class IDBResultData;
+class IDBTransaction;
class ScriptExecutionContext;
class SecurityOrigin;
@@ -49,8 +55,27 @@
IDBConnectionProxy(IDBConnectionToServer&);
RefPtr<IDBOpenDBRequest> openDatabase(ScriptExecutionContext&, const IDBDatabaseIdentifier&, uint64_t version);
+ void didOpenDatabase(const IDBResultData&);
+
RefPtr<IDBOpenDBRequest> deleteDatabase(ScriptExecutionContext&, const IDBDatabaseIdentifier&);
+ void didDeleteDatabase(const IDBResultData&);
+ void fireVersionChangeEvent(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& requestIdentifier, uint64_t requestedVersion);
+ void didFireVersionChangeEvent(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& requestIdentifier);
+
+ void notifyOpenDBRequestBlocked(const IDBResourceIdentifier& requestIdentifier, uint64_t oldVersion, uint64_t newVersion);
+
+ void establishTransaction(IDBTransaction&);
+ void commitTransaction(IDBTransaction&);
+ void abortTransaction(IDBTransaction&);
+
+ void didStartTransaction(const IDBResourceIdentifier& transactionIdentifier, const IDBError&);
+ void didCommitTransaction(const IDBResourceIdentifier& transactionIdentifier, const IDBError&);
+ void didAbortTransaction(const IDBResourceIdentifier& transactionIdentifier, const IDBError&);
+
+ void didFinishHandlingVersionChangeTransaction(IDBTransaction&);
+ void databaseConnectionClosed(IDBDatabase&);
+
uint64_t serverConnectionIdentifier() const { return m_serverConnectionIdentifier; }
// FIXME: Temporarily required during bringup of IDB-in-Workers.
@@ -63,9 +88,26 @@
void getAllDatabaseNames(const SecurityOrigin& mainFrameOrigin, const SecurityOrigin& openingOrigin, std::function<void (const Vector<String>&)>);
+ void registerDatabaseConnection(IDBDatabase&);
+ void unregisterDatabaseConnection(IDBDatabase&);
+
private:
+ void completeOpenDBRequest(const IDBResultData&);
+ bool hasRecordOfTransaction(const IDBTransaction&) const;
+
IDBConnectionToServer& m_connectionToServer;
uint64_t m_serverConnectionIdentifier;
+
+ HashMap<uint64_t, IDBDatabase*> m_databaseConnectionMap;
+ Lock m_databaseConnectionMapLock;
+
+ HashMap<IDBResourceIdentifier, RefPtr<IDBOpenDBRequest>> m_openDBRequestMap;
+ Lock m_openDBRequestMapLock;
+
+ HashMap<IDBResourceIdentifier, RefPtr<IDBTransaction>> m_pendingTransactions;
+ HashMap<IDBResourceIdentifier, RefPtr<IDBTransaction>> m_committingTransactions;
+ HashMap<IDBResourceIdentifier, RefPtr<IDBTransaction>> m_abortingTransactions;
+ Lock m_transactionMapLock;
};
} // namespace IDBClient
Modified: trunk/Source/WebCore/Modules/indexeddb/client/IDBConnectionToServer.cpp (200484 => 200485)
--- trunk/Source/WebCore/Modules/indexeddb/client/IDBConnectionToServer.cpp 2016-05-05 22:14:02 UTC (rev 200484)
+++ trunk/Source/WebCore/Modules/indexeddb/client/IDBConnectionToServer.cpp 2016-05-05 22:14:08 UTC (rev 200485)
@@ -36,6 +36,7 @@
#include "IDBResultData.h"
#include "Logging.h"
#include "TransactionOperation.h"
+#include <wtf/MainThread.h>
namespace WebCore {
namespace IDBClient {
@@ -62,46 +63,28 @@
return *m_proxy;
}
-void IDBConnectionToServer::deleteDatabase(IDBOpenDBRequest& request)
+void IDBConnectionToServer::deleteDatabase(const IDBRequestData& request)
{
LOG(IndexedDB, "IDBConnectionToServer::deleteDatabase - %s", request.databaseIdentifier().debugString().utf8().data());
-
- ASSERT(!m_openDBRequestMap.contains(request.resourceIdentifier()));
- m_openDBRequestMap.set(request.resourceIdentifier(), &request);
-
- IDBRequestData requestData(*this, request);
- m_delegate->deleteDatabase(requestData);
+ m_delegate->deleteDatabase(request);
}
void IDBConnectionToServer::didDeleteDatabase(const IDBResultData& resultData)
{
LOG(IndexedDB, "IDBConnectionToServer::didDeleteDatabase");
-
- auto request = m_openDBRequestMap.take(resultData.requestIdentifier());
- ASSERT(request);
-
- request->requestCompleted(resultData);
+ m_proxy->didDeleteDatabase(resultData);
}
-void IDBConnectionToServer::openDatabase(IDBOpenDBRequest& request)
+void IDBConnectionToServer::openDatabase(const IDBRequestData& request)
{
- LOG(IndexedDB, "IDBConnectionToServer::openDatabase - %s (%" PRIu64 ")", request.databaseIdentifier().debugString().utf8().data(), request.version());
-
- ASSERT(!m_openDBRequestMap.contains(request.resourceIdentifier()));
- m_openDBRequestMap.set(request.resourceIdentifier(), &request);
-
- IDBRequestData requestData(*this, request);
- m_delegate->openDatabase(requestData);
+ LOG(IndexedDB, "IDBConnectionToServer::openDatabase - %s (%" PRIu64 ")", request.databaseIdentifier().debugString().utf8().data(), request.requestedVersion());
+ m_delegate->openDatabase(request);
}
void IDBConnectionToServer::didOpenDatabase(const IDBResultData& resultData)
{
LOG(IndexedDB, "IDBConnectionToServer::didOpenDatabase");
-
- auto request = m_openDBRequestMap.take(resultData.requestIdentifier());
- ASSERT(request);
-
- request->requestCompleted(resultData);
+ m_proxy->didOpenDatabase(resultData);
}
void IDBConnectionToServer::createObjectStore(TransactionOperation& operation, const IDBObjectStoreInfo& info)
@@ -269,77 +252,66 @@
completeOperation(resultData);
}
-void IDBConnectionToServer::establishTransaction(IDBTransaction& transaction)
+void IDBConnectionToServer::establishTransaction(uint64_t databaseConnectionIdentifier, const IDBTransactionInfo& info)
{
LOG(IndexedDB, "IDBConnectionToServer::establishTransaction");
+ ASSERT(isMainThread());
- ASSERT(!hasRecordOfTransaction(transaction));
- m_pendingTransactions.set(transaction.info().identifier(), &transaction);
-
- m_delegate->establishTransaction(transaction.database().databaseConnectionIdentifier(), transaction.info());
+ m_delegate->establishTransaction(databaseConnectionIdentifier, info);
}
-void IDBConnectionToServer::commitTransaction(IDBTransaction& transaction)
+void IDBConnectionToServer::commitTransaction(const IDBResourceIdentifier& transactionIdentifier)
{
LOG(IndexedDB, "IDBConnectionToServer::commitTransaction");
- ASSERT(!m_committingTransactions.contains(transaction.info().identifier()));
- m_committingTransactions.set(transaction.info().identifier(), &transaction);
+ ASSERT(isMainThread());
- auto identifier = transaction.info().identifier();
- m_delegate->commitTransaction(identifier);
+ m_delegate->commitTransaction(transactionIdentifier);
}
void IDBConnectionToServer::didCommitTransaction(const IDBResourceIdentifier& transactionIdentifier, const IDBError& error)
{
LOG(IndexedDB, "IDBConnectionToServer::didCommitTransaction");
+ ASSERT(isMainThread());
- auto transaction = m_committingTransactions.take(transactionIdentifier);
- ASSERT(transaction);
-
- transaction->didCommit(error);
+ m_proxy->didCommitTransaction(transactionIdentifier, error);
}
-void IDBConnectionToServer::didFinishHandlingVersionChangeTransaction(IDBTransaction& transaction)
+void IDBConnectionToServer::didFinishHandlingVersionChangeTransaction(const IDBResourceIdentifier& transactionIdentifier)
{
LOG(IndexedDB, "IDBConnectionToServer::didFinishHandlingVersionChangeTransaction");
- auto identifier = transaction.info().identifier();
- m_delegate->didFinishHandlingVersionChangeTransaction(identifier);
+ ASSERT(isMainThread());
+
+ m_delegate->didFinishHandlingVersionChangeTransaction(transactionIdentifier);
}
-void IDBConnectionToServer::abortTransaction(IDBTransaction& transaction)
+void IDBConnectionToServer::abortTransaction(const IDBResourceIdentifier& transactionIdentifier)
{
LOG(IndexedDB, "IDBConnectionToServer::abortTransaction");
- ASSERT(!m_abortingTransactions.contains(transaction.info().identifier()));
- m_abortingTransactions.set(transaction.info().identifier(), &transaction);
+ ASSERT(isMainThread());
- auto identifier = transaction.info().identifier();
- m_delegate->abortTransaction(identifier);
+ m_delegate->abortTransaction(transactionIdentifier);
}
void IDBConnectionToServer::didAbortTransaction(const IDBResourceIdentifier& transactionIdentifier, const IDBError& error)
{
LOG(IndexedDB, "IDBConnectionToServer::didAbortTransaction");
+ ASSERT(isMainThread());
- auto transaction = m_abortingTransactions.take(transactionIdentifier);
- ASSERT(transaction);
-
- transaction->didAbort(error);
+ m_proxy->didAbortTransaction(transactionIdentifier, error);
}
void IDBConnectionToServer::fireVersionChangeEvent(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& requestIdentifier, uint64_t requestedVersion)
{
LOG(IndexedDB, "IDBConnectionToServer::fireVersionChangeEvent");
+ ASSERT(isMainThread());
- auto connection = m_databaseConnectionMap.get(databaseConnectionIdentifier);
- if (!connection)
- return;
-
- connection->fireVersionChangeEvent(requestIdentifier, requestedVersion);
+ m_proxy->fireVersionChangeEvent(databaseConnectionIdentifier, requestIdentifier, requestedVersion);
}
void IDBConnectionToServer::didFireVersionChangeEvent(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& requestIdentifier)
{
LOG(IndexedDB, "IDBConnectionToServer::didFireVersionChangeEvent");
+ ASSERT(isMainThread());
m_delegate->didFireVersionChangeEvent(databaseConnectionIdentifier, requestIdentifier);
}
@@ -347,28 +319,25 @@
void IDBConnectionToServer::didStartTransaction(const IDBResourceIdentifier& transactionIdentifier, const IDBError& error)
{
LOG(IndexedDB, "IDBConnectionToServer::didStartTransaction");
+ ASSERT(isMainThread());
- auto transaction = m_pendingTransactions.take(transactionIdentifier);
- ASSERT(transaction);
-
- transaction->didStart(error);
+ m_proxy->didStartTransaction(transactionIdentifier, error);
}
void IDBConnectionToServer::notifyOpenDBRequestBlocked(const IDBResourceIdentifier& requestIdentifier, uint64_t oldVersion, uint64_t newVersion)
{
LOG(IndexedDB, "IDBConnectionToServer::didStartTransaction");
+ ASSERT(isMainThread());
- auto openDBRequest = m_openDBRequestMap.get(requestIdentifier);
- ASSERT(openDBRequest);
-
- openDBRequest->requestBlocked(oldVersion, newVersion);
+ m_proxy->notifyOpenDBRequestBlocked(requestIdentifier, oldVersion, newVersion);
}
-void IDBConnectionToServer::databaseConnectionClosed(IDBDatabase& database)
+void IDBConnectionToServer::databaseConnectionClosed(uint64_t databaseConnectionIdentifier)
{
LOG(IndexedDB, "IDBConnectionToServer::databaseConnectionClosed");
+ ASSERT(isMainThread());
- m_delegate->databaseConnectionClosed(database.databaseConnectionIdentifier());
+ m_delegate->databaseConnectionClosed(databaseConnectionIdentifier);
}
void IDBConnectionToServer::abortOpenAndUpgradeNeeded(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& transactionIdentifier)
@@ -378,19 +347,6 @@
m_delegate->abortOpenAndUpgradeNeeded(databaseConnectionIdentifier, transactionIdentifier);
}
-void IDBConnectionToServer::registerDatabaseConnection(IDBDatabase& database)
-{
- ASSERT(!m_databaseConnectionMap.contains(database.databaseConnectionIdentifier()));
- m_databaseConnectionMap.set(database.databaseConnectionIdentifier(), &database);
-}
-
-void IDBConnectionToServer::unregisterDatabaseConnection(IDBDatabase& database)
-{
- ASSERT(m_databaseConnectionMap.contains(database.databaseConnectionIdentifier()));
- ASSERT(m_databaseConnectionMap.get(database.databaseConnectionIdentifier()) == &database);
- m_databaseConnectionMap.remove(database.databaseConnectionIdentifier());
-}
-
void IDBConnectionToServer::saveOperation(TransactionOperation& operation)
{
ASSERT(!m_activeOperations.contains(operation.identifier()));
@@ -405,12 +361,6 @@
operation->completed(resultData);
}
-bool IDBConnectionToServer::hasRecordOfTransaction(const IDBTransaction& transaction) const
-{
- auto identifier = transaction.info().identifier();
- return m_pendingTransactions.contains(identifier) || m_committingTransactions.contains(identifier) || m_abortingTransactions.contains(identifier);
-}
-
void IDBConnectionToServer::getAllDatabaseNames(const SecurityOrigin& mainFrameOrigin, const SecurityOrigin& openingOrigin, std::function<void (const Vector<String>&)> callback)
{
static uint64_t callbackID = 0;
Modified: trunk/Source/WebCore/Modules/indexeddb/client/IDBConnectionToServer.h (200484 => 200485)
--- trunk/Source/WebCore/Modules/indexeddb/client/IDBConnectionToServer.h 2016-05-05 22:14:02 UTC (rev 200484)
+++ trunk/Source/WebCore/Modules/indexeddb/client/IDBConnectionToServer.h 2016-05-05 22:14:08 UTC (rev 200485)
@@ -42,9 +42,7 @@
class IDBDatabase;
class IDBError;
class IDBObjectStoreInfo;
-class IDBOpenDBRequest;
class IDBResultData;
-class IDBTransaction;
class IDBValue;
namespace IDBClient {
@@ -59,10 +57,10 @@
IDBConnectionProxy& proxy();
- void deleteDatabase(IDBOpenDBRequest&);
+ void deleteDatabase(const IDBRequestData&);
WEBCORE_EXPORT void didDeleteDatabase(const IDBResultData&);
- void openDatabase(IDBOpenDBRequest&);
+ void openDatabase(const IDBRequestData&);
WEBCORE_EXPORT void didOpenDatabase(const IDBResultData&);
void createObjectStore(TransactionOperation&, const IDBObjectStoreInfo&);
@@ -98,12 +96,12 @@
void iterateCursor(TransactionOperation&, const IDBKeyData&, unsigned long count);
WEBCORE_EXPORT void didIterateCursor(const IDBResultData&);
- void commitTransaction(IDBTransaction&);
+ void commitTransaction(const IDBResourceIdentifier& transactionIdentifier);
WEBCORE_EXPORT void didCommitTransaction(const IDBResourceIdentifier& transactionIdentifier, const IDBError&);
- void didFinishHandlingVersionChangeTransaction(IDBTransaction&);
+ void didFinishHandlingVersionChangeTransaction(const IDBResourceIdentifier&);
- void abortTransaction(IDBTransaction&);
+ void abortTransaction(const IDBResourceIdentifier& transactionIdentifier);
WEBCORE_EXPORT void didAbortTransaction(const IDBResourceIdentifier& transactionIdentifier, const IDBError&);
WEBCORE_EXPORT void fireVersionChangeEvent(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& requestIdentifier, uint64_t requestedVersion);
@@ -112,16 +110,13 @@
WEBCORE_EXPORT void didStartTransaction(const IDBResourceIdentifier& transactionIdentifier, const IDBError&);
WEBCORE_EXPORT void notifyOpenDBRequestBlocked(const IDBResourceIdentifier& requestIdentifier, uint64_t oldVersion, uint64_t newVersion);
- void establishTransaction(IDBTransaction&);
+ void establishTransaction(uint64_t databaseConnectionIdentifier, const IDBTransactionInfo&);
- void databaseConnectionClosed(IDBDatabase&);
+ void databaseConnectionClosed(uint64_t databaseConnectionIdentifier);
// To be used when an IDBOpenDBRequest gets a new database connection, optionally with a
// versionchange transaction, but the page is already torn down.
void abortOpenAndUpgradeNeeded(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& transactionIdentifier);
-
- void registerDatabaseConnection(IDBDatabase&);
- void unregisterDatabaseConnection(IDBDatabase&);
void getAllDatabaseNames(const SecurityOrigin& mainFrameOrigin, const SecurityOrigin& openingOrigin, std::function<void (const Vector<String>&)>);
WEBCORE_EXPORT void didGetAllDatabaseNames(uint64_t callbackID, const Vector<String>& databaseNames);
@@ -132,15 +127,8 @@
void saveOperation(TransactionOperation&);
void completeOperation(const IDBResultData&);
- bool hasRecordOfTransaction(const IDBTransaction&) const;
-
Ref<IDBConnectionToServerDelegate> m_delegate;
- HashMap<IDBResourceIdentifier, RefPtr<IDBOpenDBRequest>> m_openDBRequestMap;
- HashMap<uint64_t, IDBDatabase*> m_databaseConnectionMap;
- HashMap<IDBResourceIdentifier, RefPtr<IDBTransaction>> m_pendingTransactions;
- HashMap<IDBResourceIdentifier, RefPtr<IDBTransaction>> m_committingTransactions;
- HashMap<IDBResourceIdentifier, RefPtr<IDBTransaction>> m_abortingTransactions;
HashMap<IDBResourceIdentifier, RefPtr<TransactionOperation>> m_activeOperations;
HashMap<uint64_t, std::function<void (const Vector<String>&)>> m_getAllDatabaseNamesCallbacks;
Modified: trunk/Source/WebCore/Modules/indexeddb/shared/IDBRequestData.cpp (200484 => 200485)
--- trunk/Source/WebCore/Modules/indexeddb/shared/IDBRequestData.cpp 2016-05-05 22:14:02 UTC (rev 200484)
+++ trunk/Source/WebCore/Modules/indexeddb/shared/IDBRequestData.cpp 2016-05-05 22:14:08 UTC (rev 200485)
@@ -38,9 +38,9 @@
{
}
-IDBRequestData::IDBRequestData(const IDBClient::IDBConnectionToServer& connection, const IDBOpenDBRequest& request)
- : m_serverConnectionIdentifier(connection.identifier())
- , m_requestIdentifier(std::make_unique<IDBResourceIdentifier>(connection, request))
+IDBRequestData::IDBRequestData(const IDBClient::IDBConnectionProxy& connectionProxy, const IDBOpenDBRequest& request)
+ : m_serverConnectionIdentifier(connectionProxy.serverConnectionIdentifier())
+ , m_requestIdentifier(std::make_unique<IDBResourceIdentifier>(connectionProxy, request))
, m_databaseIdentifier(request.databaseIdentifier())
, m_requestedVersion(request.version())
, m_requestType(request.requestType())
Modified: trunk/Source/WebCore/Modules/indexeddb/shared/IDBRequestData.h (200484 => 200485)
--- trunk/Source/WebCore/Modules/indexeddb/shared/IDBRequestData.h 2016-05-05 22:14:02 UTC (rev 200484)
+++ trunk/Source/WebCore/Modules/indexeddb/shared/IDBRequestData.h 2016-05-05 22:14:08 UTC (rev 200485)
@@ -42,13 +42,13 @@
}
namespace IDBClient {
-class IDBConnectionToServer;
+class IDBConnectionProxy;
class TransactionOperation;
}
class IDBRequestData {
public:
- IDBRequestData(const IDBClient::IDBConnectionToServer&, const IDBOpenDBRequest&);
+ IDBRequestData(const IDBClient::IDBConnectionProxy&, const IDBOpenDBRequest&);
explicit IDBRequestData(IDBClient::TransactionOperation&);
IDBRequestData(const IDBRequestData&);
Modified: trunk/Source/WebCore/Modules/indexeddb/shared/IDBResourceIdentifier.cpp (200484 => 200485)
--- trunk/Source/WebCore/Modules/indexeddb/shared/IDBResourceIdentifier.cpp 2016-05-05 22:14:02 UTC (rev 200484)
+++ trunk/Source/WebCore/Modules/indexeddb/shared/IDBResourceIdentifier.cpp 2016-05-05 22:14:08 UTC (rev 200485)
@@ -72,8 +72,8 @@
{
}
-IDBResourceIdentifier::IDBResourceIdentifier(const IDBClient::IDBConnectionToServer& connection, const IDBRequest& request)
- : m_idbConnectionIdentifier(connection.identifier())
+IDBResourceIdentifier::IDBResourceIdentifier(const IDBClient::IDBConnectionProxy& connectionProxy, const IDBRequest& request)
+ : m_idbConnectionIdentifier(connectionProxy.serverConnectionIdentifier())
, m_resourceNumber(request.resourceIdentifier().m_resourceNumber)
{
}
Modified: trunk/Source/WebCore/Modules/indexeddb/shared/IDBResourceIdentifier.h (200484 => 200485)
--- trunk/Source/WebCore/Modules/indexeddb/shared/IDBResourceIdentifier.h 2016-05-05 22:14:02 UTC (rev 200484)
+++ trunk/Source/WebCore/Modules/indexeddb/shared/IDBResourceIdentifier.h 2016-05-05 22:14:08 UTC (rev 200485)
@@ -34,6 +34,7 @@
class IDBRequest;
namespace IDBClient {
+class IDBConnectionProxy;
class IDBConnectionToServer;
}
@@ -44,7 +45,7 @@
class IDBResourceIdentifier {
public:
explicit IDBResourceIdentifier(const IDBClient::IDBConnectionToServer&);
- IDBResourceIdentifier(const IDBClient::IDBConnectionToServer&, const IDBRequest&);
+ IDBResourceIdentifier(const IDBClient::IDBConnectionProxy&, const IDBRequest&);
explicit IDBResourceIdentifier(const IDBServer::IDBConnectionToClient&);
// FIXME: This constructor will be needed during the development of IDB-in-Workers.
