#include "config.h"
#include "IDBDatabase.h"
#include "Document.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 "IDBObjectStore.h"
#include "IDBVersionChangeEvent.h"
#include "IDBVersionChangeRequest.h"
#include "IDBTransaction.h"
#include "ScriptExecutionContext.h"
#include <limits>
#if ENABLE(INDEXED_DATABASE)
namespace WebCore {
PassRefPtr<IDBDatabase> IDBDatabase::create(ScriptExecutionContext* context, PassRefPtr<IDBDatabaseBackendInterface> database)
{
return adoptRef(new IDBDatabase(context, database));
}
IDBDatabase::IDBDatabase(ScriptExecutionContext* context, PassRefPtr<IDBDatabaseBackendInterface> backend)
: ActiveDOMObject(context, this)
, m_backend(backend)
, m_noNewTransactions(false)
, m_stopped(false)
{
relaxAdoptionRequirement();
m_databaseCallbacks = IDBDatabaseCallbacksImpl::create(this);
}
IDBDatabase::~IDBDatabase()
{
m_databaseCallbacks->unregisterDatabase(this);
}
void IDBDatabase::setSetVersionTransaction(IDBTransaction* transaction)
{
m_setVersionTransaction = transaction;
}
PassRefPtr<IDBObjectStore> IDBDatabase::createObjectStore(const String& name, const OptionsObject& options, ExceptionCode& ec)
{
if (!m_setVersionTransaction) {
ec = IDBDatabaseException::NOT_ALLOWED_ERR;
return 0;
}
String keyPath;
options.getKeyString("keyPath", keyPath);
bool autoIncrement = false;
options.getKeyBool("autoIncrement", autoIncrement);
RefPtr<IDBObjectStoreBackendInterface> objectStore = m_backend->createObjectStore(name, keyPath, autoIncrement, m_setVersionTransaction->backend(), ec);
if (!objectStore) {
ASSERT(ec);
return 0;
}
return IDBObjectStore::create(objectStore.release(), m_setVersionTransaction.get());
}
void IDBDatabase::deleteObjectStore(const String& name, ExceptionCode& ec)
{
if (!m_setVersionTransaction) {
ec = IDBDatabaseException::NOT_ALLOWED_ERR;
return;
}
m_backend->deleteObjectStore(name, m_setVersionTransaction->backend(), ec);
}
PassRefPtr<IDBVersionChangeRequest> IDBDatabase::setVersion(ScriptExecutionContext* context, const String& version, ExceptionCode& ec)
{
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, PassRefPtr<DOMStringList> prpStoreNames, unsigned short mode, ExceptionCode& ec)
{
RefPtr<DOMStringList> storeNames = prpStoreNames;
if (!storeNames)
storeNames = DOMStringList::create();
if (mode != IDBTransaction::READ_WRITE && mode != IDBTransaction::READ_ONLY) {
ec = IDBDatabaseException::CONSTRAINT_ERR;
return 0;
}
if (m_noNewTransactions) {
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_noNewTransactions)
return;
ASSERT(scriptExecutionContext()->isDocument());
EventQueue* eventQueue = static_cast<Document*>(scriptExecutionContext())->eventQueue();
for (size_t i = 0; i < m_enqueuedEvents.size(); ++i) {
bool removed = eventQueue->cancelEvent(m_enqueuedEvents[i].get());
ASSERT_UNUSED(removed, removed);
}
m_noNewTransactions = true;
m_backend->close(m_databaseCallbacks);
}
void IDBDatabase::onVersionChange(const String& version)
{
enqueueEvent(IDBVersionChangeEvent::create(version, eventNames().versionchangeEvent));
}
bool IDBDatabase::hasPendingActivity() const
{
return !m_stopped || ActiveDOMObject::hasPendingActivity();
}
void IDBDatabase::open()
{
m_backend->open(m_databaseCallbacks);
}
void IDBDatabase::enqueueEvent(PassRefPtr<Event> event)
{
ASSERT(scriptExecutionContext()->isDocument());
EventQueue* eventQueue = static_cast<Document*>(scriptExecutionContext())->eventQueue();
event->setTarget(this);
eventQueue->enqueueEvent(event.get());
m_enqueuedEvents.append(event);
}
bool IDBDatabase::dispatchEvent(PassRefPtr<Event> event)
{
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()
{
close();
m_stopped = true;
}
ScriptExecutionContext* IDBDatabase::scriptExecutionContext() const
{
return ActiveDOMObject::scriptExecutionContext();
}
EventTargetData* IDBDatabase::eventTargetData()
{
return &m_eventTargetData;
}
EventTargetData* IDBDatabase::ensureEventTargetData()
{
return &m_eventTargetData;
}
}
#endif // ENABLE(INDEXED_DATABASE)