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; }