void IDBFactoryBackendImpl::deleteDatabase(const String& name, PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<SecurityOrigin> securityOrigin, ScriptExecutionContext*, const String& dataDirectory)
{
const String uniqueIdentifier = computeUniqueIdentifier(name, securityOrigin.get());
IDBDatabaseBackendMap::iterator it = m_databaseBackendMap.find(uniqueIdentifier);
if (it != m_databaseBackendMap.end()) {
// If there are any connections to the database, directly delete the
// database.
it->value->deleteDatabase(callbacks);
return;
}
// FIXME: Everything from now on should be done on another thread.
RefPtr<IDBBackingStore> backingStore = openBackingStore(securityOrigin, dataDirectory);
if (!backingStore) {
callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::UnknownError, "Internal error."));
return;
}
RefPtr<IDBDatabaseBackendImpl> databaseBackend = IDBDatabaseBackendImpl::create(name, backingStore.get(), this, uniqueIdentifier);
if (databaseBackend) {
m_databaseBackendMap.set(uniqueIdentifier, databaseBackend.get());
databaseBackend->deleteDatabase(callbacks);
m_databaseBackendMap.remove(uniqueIdentifier);
} else
callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::UnknownError, "Internal error."));
}
void IDBFactoryBackendImpl::open(const String& name, int64_t version, int64_t transactionId, PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<IDBDatabaseCallbacks> databaseCallbacks, PassRefPtr<SecurityOrigin> prpSecurityOrigin, ScriptExecutionContext*, const String& dataDirectory)
{
RefPtr<SecurityOrigin> securityOrigin = prpSecurityOrigin;
const String uniqueIdentifier = computeUniqueIdentifier(name, securityOrigin.get());
RefPtr<IDBDatabaseBackendImpl> databaseBackend;
IDBDatabaseBackendMap::iterator it = m_databaseBackendMap.find(uniqueIdentifier);
if (it == m_databaseBackendMap.end()) {
RefPtr<IDBBackingStore> backingStore = openBackingStore(securityOrigin, dataDirectory);
if (!backingStore) {
callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::UnknownError, "Internal error."));
return;
}
databaseBackend = IDBDatabaseBackendImpl::create(name, backingStore.get(), this, uniqueIdentifier);
if (databaseBackend)
m_databaseBackendMap.set(uniqueIdentifier, databaseBackend.get());
else {
callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::UnknownError, "Internal error."));
return;
}
} else
databaseBackend = it->value;
if (version == IDBDatabaseMetadata::NoIntVersion)
databaseBackend->openConnection(callbacks, databaseCallbacks, transactionId);
else
databaseBackend->openConnectionWithVersion(callbacks, databaseCallbacks, transactionId, version);
}
void IDBFactoryBackendLevelDB::open(const String& name, int64_t version, int64_t transactionId, PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<IDBDatabaseCallbacks> databaseCallbacks, PassRefPtr<SecurityOrigin> prpSecurityOrigin, ScriptExecutionContext*, const String& dataDirectory)
{
LOG(StorageAPI, "IDBFactoryBackendLevelDB::open");
RefPtr<SecurityOrigin> securityOrigin = prpSecurityOrigin;
const String uniqueIdentifier = computeUniqueIdentifier(name, securityOrigin.get());
RefPtr<IDBDatabaseBackendLevelDB> databaseBackend;
IDBDatabaseBackendMap::iterator it = m_databaseBackendMap.find(uniqueIdentifier);
if (it == m_databaseBackendMap.end()) {
RefPtr<IDBBackingStore> backingStore = openBackingStore(securityOrigin, dataDirectory);
if (!backingStore) {
callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::UnknownError, "Internal error opening backing store for indexedDB.open."));
return;
}
databaseBackend = IDBDatabaseBackendLevelDB::create(name, backingStore.get(), this, uniqueIdentifier);
if (databaseBackend)
m_databaseBackendMap.set(uniqueIdentifier, databaseBackend.get());
else {
callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::UnknownError, "Internal error creating database backend for indexeddb.open."));
return;
}
} else
databaseBackend = it->value;
databaseBackend->openConnection(callbacks, databaseCallbacks, transactionId, version);
}
void IDBFactoryBackendImpl::open(const String& name, PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<SecurityOrigin> prpSecurityOrigin, ScriptExecutionContext*, const String& dataDirectory)
{
// FIXME: Make this a parameter and plumb through from javascript.
int64_t version = IDBDatabaseMetadata::NoIntVersion;
RefPtr<SecurityOrigin> securityOrigin = prpSecurityOrigin;
const String uniqueIdentifier = computeUniqueIdentifier(name, securityOrigin.get());
RefPtr<IDBDatabaseBackendImpl> databaseBackend;
IDBDatabaseBackendMap::iterator it = m_databaseBackendMap.find(uniqueIdentifier);
if (it == m_databaseBackendMap.end()) {
RefPtr<IDBBackingStore> backingStore = openBackingStore(securityOrigin, dataDirectory);
if (!backingStore) {
callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::UNKNOWN_ERR, "Internal error."));
return;
}
databaseBackend = IDBDatabaseBackendImpl::create(name, backingStore.get(), m_transactionCoordinator.get(), this, uniqueIdentifier);
if (databaseBackend)
m_databaseBackendMap.set(uniqueIdentifier, databaseBackend.get());
else {
callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::UNKNOWN_ERR, "Internal error."));
return;
}
} else
databaseBackend = it->second;
if (version == IDBDatabaseMetadata::NoIntVersion)
databaseBackend->openConnection(callbacks);
else
databaseBackend->openConnectionWithVersion(callbacks, version);
}
void IDBFactoryBackendImpl::open(const String& name, PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<SecurityOrigin> securityOrigin, Frame*, const String& dataDir, int64_t maximumSize, BackingStoreType backingStoreType)
{
ASSERT(backingStoreType != DefaultBackingStore);
const String fileIdentifier = computeFileIdentifier(securityOrigin.get(), backingStoreType);
const String uniqueIdentifier = computeUniqueIdentifier(name, securityOrigin.get(), backingStoreType);
IDBDatabaseBackendMap::iterator it = m_databaseBackendMap.find(uniqueIdentifier);
if (it != m_databaseBackendMap.end()) {
callbacks->onSuccess(it->second);
return;
}
// FIXME: Everything from now on should be done on another thread.
#if ENABLE(LEVELDB)
if (backingStoreType == LevelDBBackingStore) {
bool hasSQLBackingStore = IDBSQLiteBackingStore::backingStoreExists(securityOrigin.get(), name, dataDir);
// LayoutTests: SQLite backing store may not exist on disk but may exist in cache.
String cachedSqliteBackingStoreIdentifier = computeFileIdentifier(securityOrigin.get(), SQLiteBackingStore);
if (!hasSQLBackingStore && (m_backingStoreMap.end() != m_backingStoreMap.find(cachedSqliteBackingStoreIdentifier)))
hasSQLBackingStore = true;
if (hasSQLBackingStore) {
bool migrationSucceeded = migrateFromSQLiteToLevelDB(name, securityOrigin.get(), dataDir, maximumSize);
UNUSED_PARAM(migrationSucceeded); // FIXME: When migration is actually implemented, we need error handling here.
}
}
#endif
RefPtr<IDBBackingStore> backingStore;
IDBBackingStoreMap::iterator it2 = m_backingStoreMap.find(fileIdentifier);
if (it2 != m_backingStoreMap.end() && (backingStoreType == it2->second->backingStoreType()))
backingStore = it2->second;
else {
if (backingStoreType == SQLiteBackingStore)
backingStore = IDBSQLiteBackingStore::open(securityOrigin.get(), dataDir, maximumSize, fileIdentifier, this);
#if ENABLE(LEVELDB)
else if (backingStoreType == LevelDBBackingStore)
backingStore = IDBLevelDBBackingStore::open(securityOrigin.get(), dataDir, maximumSize, fileIdentifier, this);
#endif
if (!backingStore) {
callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::UNKNOWN_ERR, "Internal error."));
return;
}
}
RefPtr<IDBDatabaseBackendImpl> databaseBackend = IDBDatabaseBackendImpl::create(name, backingStore.get(), m_transactionCoordinator.get(), this, uniqueIdentifier);
callbacks->onSuccess(databaseBackend.get());
m_databaseBackendMap.set(uniqueIdentifier, databaseBackend.get());
}
bool IDBFactoryBackendImpl::migrateFromSQLiteToLevelDB(const String& name, SecurityOrigin* securityOrigin, const String& dataDir, int64_t maximumSize)
{
#if ENABLE(LEVELDB)
String fromUniqueIdentifier = computeUniqueIdentifier(name, securityOrigin, SQLiteBackingStore);
String fromFileIdentifier = computeFileIdentifier(securityOrigin, SQLiteBackingStore);
String toUniqueIdentifier = computeUniqueIdentifier(name, securityOrigin, LevelDBBackingStore);
String toFileIdentifier = computeFileIdentifier(securityOrigin, LevelDBBackingStore);
RefPtr<IDBTransactionCoordinator> transactionCoordinator = IDBTransactionCoordinator::create();
RefPtr<IDBBackingStore> fromBackingStore;
RefPtr<IDBDatabaseBackendImpl> fromDatabaseBackend;
RefPtr<IDBBackingStore> toBackingStore;
// Open "From" backing store and backend. When running LayoutTests, the
// "from" database may be cached in this class instance, so look for it there first.
IDBBackingStoreMap::iterator it = m_backingStoreMap.find(fromFileIdentifier);
if (it != m_backingStoreMap.end())
fromBackingStore = it->second;
else
fromBackingStore = IDBSQLiteBackingStore::open(securityOrigin, dataDir, maximumSize, fromFileIdentifier, this);
if (!fromBackingStore)
return false;
IDBDatabaseBackendMap::iterator it2 = m_databaseBackendMap.find(fromUniqueIdentifier);
if (it2 != m_databaseBackendMap.end())
fromDatabaseBackend = it2->second;
else {
fromDatabaseBackend = IDBDatabaseBackendImpl::create(name, fromBackingStore.get(), transactionCoordinator.get(), this, fromUniqueIdentifier);
m_databaseBackendMap.set(fromUniqueIdentifier, fromDatabaseBackend.get());
}
if (!fromDatabaseBackend)
return false;
// Open "To" database. First find out if it already exists -- this will determine if
// it is safe to call IDBLevelDBBackingStore::extractIDBDatabaseMetaData.
it = m_backingStoreMap.find(toFileIdentifier);
if (it != m_backingStoreMap.end())
toBackingStore = it->second;
else
toBackingStore = IDBLevelDBBackingStore::open(securityOrigin, dataDir, maximumSize, toFileIdentifier, this);
if (!toBackingStore)
return false;
String toDatabaseName = fromDatabaseBackend->name();
String toDatabaseVersion = fromDatabaseBackend->version();
int64_t toDatabaseId = -1;
if (!toBackingStore->extractIDBDatabaseMetaData(toDatabaseName, toDatabaseVersion, toDatabaseId)) {
if (!toBackingStore->setIDBDatabaseMetaData(toDatabaseName, toDatabaseVersion, toDatabaseId, true))
return false;
}
return migrateObjectStores(fromBackingStore, fromDatabaseBackend->id(), toBackingStore, toDatabaseId);
#endif // ENABLE(LEVELDB)
return false;
}
