WebIDBFactoryBackend.cpp [plain text]
#include "config.h"
#include "WebIDBFactoryBackend.h"
#include "IDBUtilities.h"
#include "Logging.h"
#include "WebIDBServerConnection.h"
#include "WebProcess.h"
#include "WebToDatabaseProcessConnection.h"
#include <WebCore/DOMStringList.h>
#include <WebCore/IDBCallbacks.h>
#include <WebCore/IDBCursorBackend.h>
#include <WebCore/IDBDatabaseCallbacks.h>
#include <WebCore/IDBTransactionBackend.h>
#include <WebCore/SecurityOrigin.h>
#include <wtf/MainThread.h>
#include <wtf/NeverDestroyed.h>
#if ENABLE(INDEXED_DATABASE)
#if ENABLE(DATABASE_PROCESS)
using namespace WebCore;
namespace WebKit {
typedef HashMap<String, IDBDatabaseBackend*> IDBDatabaseBackendMap;
static IDBDatabaseBackendMap& sharedDatabaseBackendMap()
{
static NeverDestroyed<IDBDatabaseBackendMap> databaseBackendMap;
return databaseBackendMap;
}
static HashMap<String, HashSet<String>>& sharedRecentDatabaseNameMap()
{
static NeverDestroyed<HashMap<String, HashSet<String>>> recentDatabaseNameMap;
return recentDatabaseNameMap;
}
static String combinedSecurityOriginIdentifier(const WebCore::SecurityOrigin& openingOrigin, const WebCore::SecurityOrigin& mainFrameOrigin)
{
StringBuilder stringBuilder;
String originString = openingOrigin.toString();
if (originString == "null")
return String();
stringBuilder.append(originString);
stringBuilder.append("_");
originString = mainFrameOrigin.toString();
if (originString == "null")
return String();
stringBuilder.append(originString);
return stringBuilder.toString();
}
WebIDBFactoryBackend::WebIDBFactoryBackend(const String&)
{
}
WebIDBFactoryBackend::~WebIDBFactoryBackend()
{
}
void WebIDBFactoryBackend::getDatabaseNames(PassRefPtr<IDBCallbacks> callbacks, const SecurityOrigin& openingOrigin, const SecurityOrigin& mainFrameOrigin, ScriptExecutionContext* context, const String&)
{
LOG(IDB, "WebIDBFactoryBackend::getDatabaseNames");
String securityOriginIdentifier = combinedSecurityOriginIdentifier(openingOrigin, mainFrameOrigin);
if (securityOriginIdentifier.isEmpty()) {
callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::InvalidAccessError, ASCIILiteral("Document is not allowed to use Indexed Databases")));
return;
}
auto recentNameIterator = sharedRecentDatabaseNameMap().find(securityOriginIdentifier);
if (recentNameIterator == sharedRecentDatabaseNameMap().end())
return;
RefPtr<DOMStringList> databaseNames = DOMStringList::create();
HashSet<String>& foundNames = recentNameIterator->value;
for (const String& name : foundNames)
databaseNames->append(name);
callbacks->onSuccess(databaseNames.release());
}
void WebIDBFactoryBackend::open(const String& databaseName, uint64_t version, int64_t transactionId, PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<IDBDatabaseCallbacks> databaseCallbacks, const SecurityOrigin& openingOrigin, const SecurityOrigin& mainFrameOrigin)
{
ASSERT(RunLoop::isMain());
LOG(IDB, "WebIDBFactoryBackend::open");
String databaseIdentifier = uniqueDatabaseIdentifier(databaseName, openingOrigin, mainFrameOrigin);
if (databaseIdentifier.isNull()) {
callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::InvalidAccessError, "Document is not allowed to use Indexed Databases"));
return;
}
String securityOriginIdentifier = combinedSecurityOriginIdentifier(openingOrigin, mainFrameOrigin);
ASSERT(!securityOriginIdentifier.isEmpty());
auto recentNameIterator = sharedRecentDatabaseNameMap().find(securityOriginIdentifier);
if (recentNameIterator == sharedRecentDatabaseNameMap().end()) {
HashSet<String> names;
names.add(databaseName);
sharedRecentDatabaseNameMap().set(securityOriginIdentifier, names);
} else
recentNameIterator->value.add(databaseName);
IDBDatabaseBackendMap::iterator it = sharedDatabaseBackendMap().find(databaseIdentifier);
RefPtr<IDBDatabaseBackend> databaseBackend;
if (it == sharedDatabaseBackendMap().end()) {
RefPtr<IDBServerConnection> serverConnection = WebIDBServerConnection::create(databaseName, openingOrigin, mainFrameOrigin);
databaseBackend = IDBDatabaseBackend::create(databaseName, databaseIdentifier, this, *serverConnection);
sharedDatabaseBackendMap().set(databaseIdentifier, databaseBackend.get());
} else
databaseBackend = it->value;
databaseBackend->openConnection(callbacks, databaseCallbacks, transactionId, version);
}
void WebIDBFactoryBackend::deleteDatabase(const String& databaseName, const SecurityOrigin& openingOrigin, const SecurityOrigin& mainFrameOrigin, PassRefPtr<IDBCallbacks> callbacks, ScriptExecutionContext*, const String&)
{
ASSERT(RunLoop::isMain());
LOG(IDB, "WebIDBFactoryBackend::deleteDatabase");
String databaseIdentifier = uniqueDatabaseIdentifier(databaseName, openingOrigin, mainFrameOrigin);
if (databaseIdentifier.isNull()) {
callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::InvalidAccessError, "Document is not allowed to use Indexed Databases"));
return;
}
String securityOriginIdentifier = combinedSecurityOriginIdentifier(openingOrigin, mainFrameOrigin);
ASSERT(!securityOriginIdentifier.isEmpty());
auto recentNameIterator = sharedRecentDatabaseNameMap().find(securityOriginIdentifier);
if (recentNameIterator != sharedRecentDatabaseNameMap().end()) {
recentNameIterator->value.remove(databaseName);
if (recentNameIterator->value.isEmpty())
sharedRecentDatabaseNameMap().remove(recentNameIterator);
}
IDBDatabaseBackendMap::iterator it = sharedDatabaseBackendMap().find(databaseIdentifier);
if (it != sharedDatabaseBackendMap().end()) {
it->value->deleteDatabase(callbacks);
return;
}
RefPtr<IDBServerConnection> serverConnection = WebIDBServerConnection::create(databaseName, openingOrigin, mainFrameOrigin);
RefPtr<IDBDatabaseBackend> databaseBackend = IDBDatabaseBackend::create(databaseName, databaseIdentifier, this, *serverConnection);
sharedDatabaseBackendMap().set(databaseIdentifier, databaseBackend.get());
databaseBackend->deleteDatabase(callbacks);
sharedDatabaseBackendMap().remove(databaseIdentifier);
}
void WebIDBFactoryBackend::removeIDBDatabaseBackend(const String& identifier)
{
sharedDatabaseBackendMap().remove(identifier);
}
}
#endif // ENABLE(DATABASE_PROCESS)
#endif // ENABLE(INDEXED_DATABASE)