#include "config.h"
#include "IDBDatabase.h"
#if ENABLE(INDEXED_DATABASE)
#include "EventQueue.h"
#include "ExceptionCode.h"
#include "EventQueue.h"
#include "IDBAny.h"
#include "IDBDatabaseCallbacksImpl.h"
#include "IDBDatabaseError.h"
#include "IDBDatabaseException.h"
#include "IDBEventDispatcher.h"
#include "IDBFactoryBackendInterface.h"
#include "IDBIndex.h"
#include "IDBKeyPath.h"
#include "IDBObjectStore.h"
#include "IDBTracing.h"
#include "IDBTransaction.h"
#include "IDBVersionChangeEvent.h"
#include "IDBVersionChangeRequest.h"
#include "ScriptExecutionContext.h"
#include <limits>
namespace WebCore {
PassRefPtr<IDBDatabase> IDBDatabase::create(ScriptExecutionContext* context, PassRefPtr<IDBDatabaseBackendInterface> database)
{
RefPtr<IDBDatabase> idbDatabase(adoptRef(new IDBDatabase(context, database)));
idbDatabase->suspendIfNeeded();
return idbDatabase.release();
}
IDBDatabase::IDBDatabase(ScriptExecutionContext* context, PassRefPtr<IDBDatabaseBackendInterface> backend)
: ActiveDOMObject(context, this)
, m_backend(backend)
, m_closePending(false)
, m_contextStopped(false)
{
relaxAdoptionRequirement();
m_databaseCallbacks = IDBDatabaseCallbacksImpl::create(this);
}
IDBDatabase::~IDBDatabase()
{
close();
m_databaseCallbacks->unregisterDatabase(this);
}
void IDBDatabase::setVersionChangeTransaction(IDBTransaction* transaction)
{
ASSERT(!m_versionChangeTransaction);
m_versionChangeTransaction = transaction;
}
void IDBDatabase::clearVersionChangeTransaction(IDBTransaction* transaction)
{
ASSERT_UNUSED(transaction, m_versionChangeTransaction == transaction);
m_versionChangeTransaction = 0;
}
PassRefPtr<IDBObjectStore> IDBDatabase::createObjectStore(const String& name, const Dictionary& options, ExceptionCode& ec)
{
if (!m_versionChangeTransaction) {
ec = IDBDatabaseException::NOT_ALLOWED_ERR;
return 0;
}
String keyPath;
bool keyPathExists = options.getWithUndefinedOrNullCheck("keyPath", keyPath);
if (keyPathExists && !IDBIsValidKeyPath(keyPath)) {
ec = IDBDatabaseException::NON_TRANSIENT_ERR;
return 0;
}
bool autoIncrement = false;
options.get("autoIncrement", autoIncrement);
RefPtr<IDBObjectStoreBackendInterface> objectStoreBackend = m_backend->createObjectStore(name, keyPath, autoIncrement, m_versionChangeTransaction->backend(), ec);
if (!objectStoreBackend) {
ASSERT(ec);
return 0;
}
RefPtr<IDBObjectStore> objectStore = IDBObjectStore::create(objectStoreBackend.release(), m_versionChangeTransaction.get());
m_versionChangeTransaction->objectStoreCreated(name, objectStore);
return objectStore.release();
}
void IDBDatabase::deleteObjectStore(const String& name, ExceptionCode& ec)
{
if (!m_versionChangeTransaction) {
ec = IDBDatabaseException::NOT_ALLOWED_ERR;
return;
}
m_backend->deleteObjectStore(name, m_versionChangeTransaction->backend(), ec);
m_versionChangeTransaction->objectStoreDeleted(name);
}
PassRefPtr<IDBVersionChangeRequest> IDBDatabase::setVersion(ScriptExecutionContext* context, const String& version, ExceptionCode& ec)
{
if (version.isNull()) {
ec = IDBDatabaseException::NON_TRANSIENT_ERR;
return 0;
}
RefPtr<IDBVersionChangeRequest> request = IDBVersionChangeRequest::create(context, IDBAny::create(this), version);
m_backend->setVersion(version, request, m_databaseCallbacks, ec);
return request;
}
PassRefPtr<IDBTransaction> IDBDatabase::transaction(ScriptExecutionContext* context, const String& storeName, unsigned short mode, ExceptionCode& ec)
{
RefPtr<DOMStringList> storeNames = DOMStringList::create();
storeNames->append(storeName);
return transaction(context, storeNames, mode, ec);
}
PassRefPtr<IDBTransaction> IDBDatabase::transaction(ScriptExecutionContext* context, PassRefPtr<DOMStringList> prpStoreNames, unsigned short mode, ExceptionCode& ec)
{
RefPtr<DOMStringList> storeNames = prpStoreNames;
if (!storeNames || storeNames->isEmpty()) {
ec = INVALID_ACCESS_ERR;
return 0;
}
if (mode != IDBTransaction::READ_WRITE && mode != IDBTransaction::READ_ONLY) {
ec = IDBDatabaseException::NON_TRANSIENT_ERR;
return 0;
}
if (m_closePending) {
ec = IDBDatabaseException::NOT_ALLOWED_ERR;
return 0;
}
RefPtr<IDBTransactionBackendInterface> transactionBackend = m_backend->transaction(storeNames.get(), mode, ec);
if (!transactionBackend) {
ASSERT(ec);
return 0;
}
RefPtr<IDBTransaction> transaction = IDBTransaction::create(context, transactionBackend, this);
transactionBackend->setCallbacks(transaction.get());
return transaction.release();
}
void IDBDatabase::close()
{
if (m_closePending)
return;
m_closePending = true;
m_backend->close(m_databaseCallbacks);
if (m_contextStopped || !scriptExecutionContext())
return;
EventQueue* eventQueue = scriptExecutionContext()->eventQueue();
for (size_t i = 0; i < m_enqueuedEvents.size(); ++i) {
bool removed = eventQueue->cancelEvent(m_enqueuedEvents[i].get());
ASSERT_UNUSED(removed, removed);
}
}
void IDBDatabase::onVersionChange(const String& version)
{
if (m_contextStopped || !scriptExecutionContext())
return;
enqueueEvent(IDBVersionChangeEvent::create(version, eventNames().versionchangeEvent));
}
void IDBDatabase::open()
{
m_backend->open(m_databaseCallbacks);
}
void IDBDatabase::enqueueEvent(PassRefPtr<Event> event)
{
ASSERT(!m_contextStopped);
ASSERT(scriptExecutionContext());
EventQueue* eventQueue = scriptExecutionContext()->eventQueue();
event->setTarget(this);
eventQueue->enqueueEvent(event.get());
m_enqueuedEvents.append(event);
}
bool IDBDatabase::dispatchEvent(PassRefPtr<Event> event)
{
IDB_TRACE("IDBDatabase::dispatchEvent");
ASSERT(event->type() == eventNames().versionchangeEvent);
for (size_t i = 0; i < m_enqueuedEvents.size(); ++i) {
if (m_enqueuedEvents[i].get() == event.get())
m_enqueuedEvents.remove(i);
}
return EventTarget::dispatchEvent(event.get());
}
void IDBDatabase::stop()
{
ActiveDOMObject::stop();
close();
m_contextStopped = true;
}
const AtomicString& IDBDatabase::interfaceName() const
{
return eventNames().interfaceForIDBDatabase;
}
ScriptExecutionContext* IDBDatabase::scriptExecutionContext() const
{
return ActiveDOMObject::scriptExecutionContext();
}
EventTargetData* IDBDatabase::eventTargetData()
{
return &m_eventTargetData;
}
EventTargetData* IDBDatabase::ensureEventTargetData()
{
return &m_eventTargetData;
}
}
#endif // ENABLE(INDEXED_DATABASE)