Source/WebCore/Modules/indexeddb/IDBTransaction.cpp

   1 /*
   2  * Copyright (C) 2010 Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *
   8  * 1.  Redistributions of source code must retain the above copyright
   9  *     notice, this list of conditions and the following disclaimer.
  10  * 2.  Redistributions in binary form must reproduce the above copyright
  11  *     notice, this list of conditions and the following disclaimer in the
  12  *     documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  16  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  17  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  18  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  19  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  20  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  21  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "config.h"
  27 #include "IDBTransaction.h"
  28
  29 #if ENABLE(INDEXED_DATABASE)
  30
  31 #include "EventException.h"
  32 #include "EventQueue.h"
  33 #include "IDBDatabase.h"
  34 #include "IDBDatabaseException.h"
  35 #include "IDBEventDispatcher.h"
  36 #include "IDBIndex.h"
  37 #include "IDBObjectStore.h"
  38 #include "IDBObjectStoreBackendInterface.h"
  39 #include "IDBPendingTransactionMonitor.h"
  40 #include "IDBTracing.h"
  41
  42 namespace WebCore {
  43
  44 PassRefPtr<IDBTransaction> IDBTransaction::create(ScriptExecutionContext* context, PassRefPtr<IDBTransactionBackendInterface> backend, IDBTransaction::Mode mode, IDBDatabase* db)
  45 {
  46     RefPtr<IDBTransaction> transaction(adoptRef(new IDBTransaction(context, backend, mode, db)));
  47     transaction->suspendIfNeeded();
  48     return transaction.release();
  49 }
  50
  51 const AtomicString& IDBTransaction::modeReadOnly()
  52 {
  53     DEFINE_STATIC_LOCAL(AtomicString, readonly, ("readonly"));
  54     return readonly;
  55 }
  56
  57 const AtomicString& IDBTransaction::modeReadWrite()
  58 {
  59     DEFINE_STATIC_LOCAL(AtomicString, readwrite, ("readwrite"));
  60     return readwrite;
  61 }
  62
  63 const AtomicString& IDBTransaction::modeVersionChange()
  64 {
  65     DEFINE_STATIC_LOCAL(AtomicString, versionchange, ("versionchange"));
  66     return versionchange;
  67 }
  68
  69 const AtomicString& IDBTransaction::modeReadOnlyLegacy()
  70 {
  71     DEFINE_STATIC_LOCAL(AtomicString, readonly, ("0"));
  72     return readonly;
  73 }
  74
  75 const AtomicString& IDBTransaction::modeReadWriteLegacy()
  76 {
  77     DEFINE_STATIC_LOCAL(AtomicString, readwrite, ("1"));
  78     return readwrite;
  79 }
  80
  81
  82 IDBTransaction::IDBTransaction(ScriptExecutionContext* context, PassRefPtr<IDBTransactionBackendInterface> backend, IDBTransaction::Mode mode, IDBDatabase* db)
  83     : ActiveDOMObject(context, this)
  84     , m_backend(backend)
  85     , m_database(db)
  86     , m_mode(mode)
  87     , m_active(true)
  88     , m_transactionFinished(false)
  89     , m_contextStopped(false)
  90 {
  91     ASSERT(m_backend);
  92     ASSERT(m_mode == m_backend->mode());
  93     IDBPendingTransactionMonitor::addPendingTransaction(m_backend.get());
  94     // We pass a reference of this object before it can be adopted.
  95     relaxAdoptionRequirement();
  96     m_database->transactionCreated(this);
  97 }
  98
  99 IDBTransaction::~IDBTransaction()
 100 {
 101 }
 102
 103 IDBTransactionBackendInterface* IDBTransaction::backend() const
 104 {
 105     return m_backend.get();
 106 }
 107
 108 bool IDBTransaction::isFinished() const
 109 {
 110     return m_transactionFinished;
 111 }
 112
 113 const String& IDBTransaction::mode() const
 114 {
 115     ExceptionCode ec = 0;
 116     const AtomicString& mode = modeToString(m_mode, ec);
 117     ASSERT(!ec);
 118     return mode;
 119 }
 120
 121 IDBDatabase* IDBTransaction::db() const
 122 {
 123     return m_database.get();
 124 }
 125
 126 PassRefPtr<DOMError> IDBTransaction::error(ExceptionCode& ec) const
 127 {
 128     if (!m_transactionFinished) {
 129         ec = IDBDatabaseException::IDB_INVALID_STATE_ERR;
 130         return 0;
 131     }
 132     return m_error;
 133 }
 134
 135 void IDBTransaction::setError(PassRefPtr<DOMError> error)
 136 {
 137     ASSERT(!m_transactionFinished);
 138     ASSERT(error);
 139
 140     // The first error to be set is the true cause of the
 141     // transaction abort.
 142     if (!m_error)
 143         m_error = error;
 144 }
 145
 146 PassRefPtr<IDBObjectStore> IDBTransaction::objectStore(const String& name, ExceptionCode& ec)
 147 {
 148     if (m_transactionFinished) {
 149         ec = IDBDatabaseException::IDB_INVALID_STATE_ERR;
 150         return 0;
 151     }
 152
 153     IDBObjectStoreMap::iterator it = m_objectStoreMap.find(name);
 154     if (it != m_objectStoreMap.end())
 155         return it->second;
 156
 157     RefPtr<IDBObjectStoreBackendInterface> objectStoreBackend = m_backend->objectStore(name, ec);
 158     ASSERT(!objectStoreBackend != !ec); // If we didn't get a store, we should have gotten an exception code. And vice versa.
 159     if (ec)
 160         return 0;
 161
 162     const IDBDatabaseMetadata& metadata = m_database->metadata();
 163     IDBDatabaseMetadata::ObjectStoreMap::const_iterator mdit = metadata.objectStores.find(name);
 164     ASSERT(mdit != metadata.objectStores.end());
 165
 166     RefPtr<IDBObjectStore> objectStore = IDBObjectStore::create(mdit->second, objectStoreBackend, this);
 167     objectStoreCreated(name, objectStore);
 168     return objectStore.release();
 169 }
 170
 171 void IDBTransaction::objectStoreCreated(const String& name, PassRefPtr<IDBObjectStore> prpObjectStore)
 172 {
 173     ASSERT(!m_transactionFinished);
 174     RefPtr<IDBObjectStore> objectStore = prpObjectStore;
 175     m_objectStoreMap.set(name, objectStore);
 176     if (isVersionChange())
 177         m_objectStoreCleanupMap.set(objectStore, objectStore->metadata());
 178 }
 179
 180 void IDBTransaction::objectStoreDeleted(const String& name)
 181 {
 182     ASSERT(!m_transactionFinished);
 183     ASSERT(isVersionChange());
 184     IDBObjectStoreMap::iterator it = m_objectStoreMap.find(name);
 185     if (it != m_objectStoreMap.end()) {
 186         RefPtr<IDBObjectStore> objectStore = it->second;
 187         m_objectStoreMap.remove(name);
 188         objectStore->markDeleted();
 189         m_objectStoreCleanupMap.set(objectStore, objectStore->metadata());
 190     }
 191 }
 192
 193 void IDBTransaction::abort()
 194 {
 195     if (m_transactionFinished)
 196         return;
 197     m_active = false;
 198     RefPtr<IDBTransaction> selfRef = this;
 199     if (m_backend)
 200         m_backend->abort();
 201 }
 202
 203 IDBTransaction::OpenCursorNotifier::OpenCursorNotifier(PassRefPtr<IDBTransaction> transaction, IDBCursor* cursor)
 204     : m_transaction(transaction),
 205       m_cursor(cursor)
 206 {
 207     m_transaction->registerOpenCursor(m_cursor);
 208 }
 209
 210 IDBTransaction::OpenCursorNotifier::~OpenCursorNotifier()
 211 {
 212     m_transaction->unregisterOpenCursor(m_cursor);
 213 }
 214
 215 void IDBTransaction::registerOpenCursor(IDBCursor* cursor)
 216 {
 217     m_openCursors.add(cursor);
 218 }
 219
 220 void IDBTransaction::unregisterOpenCursor(IDBCursor* cursor)
 221 {
 222     m_openCursors.remove(cursor);
 223 }
 224
 225 void IDBTransaction::closeOpenCursors()
 226 {
 227     HashSet<IDBCursor*> cursors;
 228     cursors.swap(m_openCursors);
 229     for (HashSet<IDBCursor*>::iterator i = cursors.begin(); i != cursors.end(); ++i)
 230         (*i)->close();
 231 }
 232
 233 void IDBTransaction::registerRequest(IDBRequest* request)
 234 {
 235     m_childRequests.add(request);
 236 }
 237
 238 void IDBTransaction::unregisterRequest(IDBRequest* request)
 239 {
 240     // If we aborted the request, it will already have been removed.
 241     m_childRequests.remove(request);
 242 }
 243
 244 void IDBTransaction::onAbort()
 245 {
 246     ASSERT(!m_transactionFinished);
 247     m_active = false;
 248     while (!m_childRequests.isEmpty()) {
 249         IDBRequest* request = *m_childRequests.begin();
 250         m_childRequests.remove(request);
 251         request->abort();
 252     }
 253
 254     if (isVersionChange()) {
 255         for (IDBObjectStoreMetadataMap::iterator it = m_objectStoreCleanupMap.begin(); it != m_objectStoreCleanupMap.end(); ++it)
 256             it->first->setMetadata(it->second);
 257     }
 258     m_objectStoreCleanupMap.clear();
 259     closeOpenCursors();
 260     m_database->transactionFinished(this);
 261
 262     if (m_contextStopped || !scriptExecutionContext())
 263         return;
 264
 265     enqueueEvent(Event::create(eventNames().abortEvent, true, false));
 266 }
 267
 268 void IDBTransaction::onComplete()
 269 {
 270     ASSERT(!m_transactionFinished);
 271     m_active = false;
 272     m_objectStoreCleanupMap.clear();
 273     closeOpenCursors();
 274     m_database->transactionFinished(this);
 275
 276     if (m_contextStopped || !scriptExecutionContext())
 277         return;
 278
 279     enqueueEvent(Event::create(eventNames().completeEvent, false, false));
 280 }
 281
 282 bool IDBTransaction::hasPendingActivity() const
 283 {
 284     // FIXME: In an ideal world, we should return true as long as anyone has a or can
 285     //        get a handle to us or any child request object and any of those have
 286     //        event listeners. This is  in order to handle user generated events properly.
 287     return !m_transactionFinished || ActiveDOMObject::hasPendingActivity();
 288 }
 289
 290 IDBTransaction::Mode IDBTransaction::stringToMode(const String& modeString, ExceptionCode& ec)
 291 {
 292     if (modeString.isNull()
 293         || modeString == IDBTransaction::modeReadOnly())
 294         return IDBTransaction::READ_ONLY;
 295     if (modeString == IDBTransaction::modeReadWrite())
 296         return IDBTransaction::READ_WRITE;
 297     ec = IDBDatabaseException::IDB_TYPE_ERR;
 298     return IDBTransaction::READ_ONLY;
 299 }
 300
 301 const AtomicString& IDBTransaction::modeToString(IDBTransaction::Mode mode, ExceptionCode& ec)
 302 {
 303     switch (mode) {
 304     case IDBTransaction::READ_ONLY:
 305         return IDBTransaction::modeReadOnly();
 306         break;
 307
 308     case IDBTransaction::READ_WRITE:
 309         return IDBTransaction::modeReadWrite();
 310         break;
 311
 312     case IDBTransaction::VERSION_CHANGE:
 313         return IDBTransaction::modeVersionChange();
 314         break;
 315
 316     default:
 317         ec = IDBDatabaseException::IDB_TYPE_ERR;
 318         return IDBTransaction::modeReadOnly();
 319     }
 320 }
 321
 322 const AtomicString& IDBTransaction::interfaceName() const
 323 {
 324     return eventNames().interfaceForIDBTransaction;
 325 }
 326
 327 ScriptExecutionContext* IDBTransaction::scriptExecutionContext() const
 328 {
 329     return ActiveDOMObject::scriptExecutionContext();
 330 }
 331
 332 bool IDBTransaction::dispatchEvent(PassRefPtr<Event> event)
 333 {
 334     IDB_TRACE("IDBTransaction::dispatchEvent");
 335     ASSERT(!m_transactionFinished);
 336     ASSERT(scriptExecutionContext());
 337     ASSERT(event->target() == this);
 338     m_transactionFinished = true;
 339
 340     // Break reference cycles.
 341     for (IDBObjectStoreMap::iterator it = m_objectStoreMap.begin(); it != m_objectStoreMap.end(); ++it)
 342         it->second->transactionFinished();
 343     m_objectStoreMap.clear();
 344
 345     Vector<RefPtr<EventTarget> > targets;
 346     targets.append(this);
 347     targets.append(db());
 348
 349     // FIXME: When we allow custom event dispatching, this will probably need to change.
 350     ASSERT(event->type() == eventNames().completeEvent || event->type() == eventNames().abortEvent);
 351     return IDBEventDispatcher::dispatch(event.get(), targets);
 352 }
 353
 354 bool IDBTransaction::canSuspend() const
 355 {
 356     // FIXME: Technically we can suspend before the first request is schedule
 357     //        and after the complete/abort event is enqueued.
 358     return m_transactionFinished;
 359 }
 360
 361 void IDBTransaction::stop()
 362 {
 363     ActiveDOMObject::stop();
 364     m_contextStopped = true;
 365
 366     abort();
 367 }
 368
 369 void IDBTransaction::enqueueEvent(PassRefPtr<Event> event)
 370 {
 371     ASSERT_WITH_MESSAGE(!m_transactionFinished, "A finished transaction tried to enqueue an event of type %s.", event->type().string().utf8().data());
 372     if (m_contextStopped || !scriptExecutionContext())
 373         return;
 374
 375     EventQueue* eventQueue = scriptExecutionContext()->eventQueue();
 376     event->setTarget(this);
 377     eventQueue->enqueueEvent(event);
 378 }
 379
 380 EventTargetData* IDBTransaction::eventTargetData()
 381 {
 382     return &m_eventTargetData;
 383 }
 384
 385 EventTargetData* IDBTransaction::ensureEventTargetData()
 386 {
 387     return &m_eventTargetData;
 388 }
 389
 390 }
 391
 392 #endif // ENABLE(INDEXED_DATABASE)