IndexedDB: IDBTransaction::abort() should throw DOMException
[WebKit-https.git] / 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_state(Unused)
89     , m_contextStopped(false)
90 {
91     ASSERT(m_backend);
92
93     if (mode == VERSION_CHANGE) {
94         // Not active until the callback.
95         m_active = false;
96         // Implicitly used by the version change itself.
97         m_state = Used;
98     }
99
100     // We pass a reference of this object before it can be adopted.
101     relaxAdoptionRequirement();
102     if (m_active)
103         IDBPendingTransactionMonitor::addNewTransaction(this);
104     m_database->transactionCreated(this);
105 }
106
107 IDBTransaction::~IDBTransaction()
108 {
109     ASSERT(m_state == Finished);
110 }
111
112 IDBTransactionBackendInterface* IDBTransaction::backend() const
113 {
114     return m_backend.get();
115 }
116
117 const String& IDBTransaction::mode() const
118 {
119     ExceptionCode ec = 0;
120     const AtomicString& mode = modeToString(m_mode, ec);
121     ASSERT(!ec);
122     return mode;
123 }
124
125 void IDBTransaction::setError(PassRefPtr<DOMError> error)
126 {
127     ASSERT(m_state != Finished);
128     ASSERT(error);
129
130     // The first error to be set is the true cause of the
131     // transaction abort.
132     if (!m_error)
133         m_error = error;
134 }
135
136 PassRefPtr<IDBObjectStore> IDBTransaction::objectStore(const String& name, ExceptionCode& ec)
137 {
138     if (m_state == Finished) {
139         ec = IDBDatabaseException::IDB_INVALID_STATE_ERR;
140         return 0;
141     }
142
143     IDBObjectStoreMap::iterator it = m_objectStoreMap.find(name);
144     if (it != m_objectStoreMap.end())
145         return it->second;
146
147     RefPtr<IDBObjectStoreBackendInterface> objectStoreBackend = m_backend->objectStore(name, ec);
148     ASSERT(!objectStoreBackend != !ec); // If we didn't get a store, we should have gotten an exception code. And vice versa.
149     if (ec)
150         return 0;
151
152     const IDBDatabaseMetadata& metadata = m_database->metadata();
153     IDBDatabaseMetadata::ObjectStoreMap::const_iterator mdit = metadata.objectStores.find(name);
154     ASSERT(mdit != metadata.objectStores.end());
155
156     RefPtr<IDBObjectStore> objectStore = IDBObjectStore::create(mdit->second, objectStoreBackend, this);
157     objectStoreCreated(name, objectStore);
158     return objectStore.release();
159 }
160
161 void IDBTransaction::objectStoreCreated(const String& name, PassRefPtr<IDBObjectStore> prpObjectStore)
162 {
163     ASSERT(m_state != Finished);
164     RefPtr<IDBObjectStore> objectStore = prpObjectStore;
165     m_objectStoreMap.set(name, objectStore);
166     if (isVersionChange())
167         m_objectStoreCleanupMap.set(objectStore, objectStore->metadata());
168 }
169
170 void IDBTransaction::objectStoreDeleted(const String& name)
171 {
172     ASSERT(m_state != Finished);
173     ASSERT(isVersionChange());
174     IDBObjectStoreMap::iterator it = m_objectStoreMap.find(name);
175     if (it != m_objectStoreMap.end()) {
176         RefPtr<IDBObjectStore> objectStore = it->second;
177         m_objectStoreMap.remove(name);
178         objectStore->markDeleted();
179         m_objectStoreCleanupMap.set(objectStore, objectStore->metadata());
180     }
181 }
182
183 void IDBTransaction::setActive(bool active)
184 {
185     ASSERT(m_state != Finished);
186     if (m_state == Finishing)
187         return;
188     ASSERT(m_state == Unused || m_state == Used);
189     ASSERT(active != m_active);
190     m_active = active;
191
192     if (!active && m_state == Unused)
193         m_backend->commit();
194 }
195
196 void IDBTransaction::abort(ExceptionCode& ec)
197 {
198     if (m_state == Finishing || m_state == Finished) {
199         ec = IDBDatabaseException::IDB_INVALID_STATE_ERR;
200         return;
201     }
202
203     m_state = Finishing;
204     m_active = false;
205
206     while (!m_requestList.isEmpty()) {
207         IDBRequest* request = *m_requestList.begin();
208         m_requestList.remove(request);
209         request->abort();
210     }
211
212     RefPtr<IDBTransaction> selfRef = this;
213     if (m_backend)
214         m_backend->abort();
215 }
216
217 IDBTransaction::OpenCursorNotifier::OpenCursorNotifier(PassRefPtr<IDBTransaction> transaction, IDBCursor* cursor)
218     : m_transaction(transaction),
219       m_cursor(cursor)
220 {
221     m_transaction->registerOpenCursor(m_cursor);
222 }
223
224 IDBTransaction::OpenCursorNotifier::~OpenCursorNotifier()
225 {
226     m_transaction->unregisterOpenCursor(m_cursor);
227 }
228
229 void IDBTransaction::registerOpenCursor(IDBCursor* cursor)
230 {
231     m_openCursors.add(cursor);
232 }
233
234 void IDBTransaction::unregisterOpenCursor(IDBCursor* cursor)
235 {
236     m_openCursors.remove(cursor);
237 }
238
239 void IDBTransaction::closeOpenCursors()
240 {
241     HashSet<IDBCursor*> cursors;
242     cursors.swap(m_openCursors);
243     for (HashSet<IDBCursor*>::iterator i = cursors.begin(); i != cursors.end(); ++i)
244         (*i)->close();
245 }
246
247 void IDBTransaction::registerRequest(IDBRequest* request)
248 {
249     ASSERT(request);
250     ASSERT(m_state == Unused || m_state == Used);
251     ASSERT(m_active);
252     m_requestList.add(request);
253     m_state = Used;
254 }
255
256 void IDBTransaction::unregisterRequest(IDBRequest* request)
257 {
258     ASSERT(request);
259     // If we aborted the request, it will already have been removed.
260     m_requestList.remove(request);
261 }
262
263 void IDBTransaction::onAbort()
264 {
265     ASSERT(m_state != Finished);
266
267     if (m_state != Finishing) {
268         // FIXME: Propagate true cause from back end (e.g. QuotaError, UnknownError, etc.)
269         setError(DOMError::create(IDBDatabaseException::getErrorName(IDBDatabaseException::UNKNOWN_ERR)));
270
271         // Abort was not triggered by front-end, so outstanding requests must
272         // be aborted now.
273         while (!m_requestList.isEmpty()) {
274             IDBRequest* request = *m_requestList.begin();
275             m_requestList.remove(request);
276             request->abort();
277         }
278         m_state = Finishing;
279     }
280
281     if (isVersionChange()) {
282         for (IDBObjectStoreMetadataMap::iterator it = m_objectStoreCleanupMap.begin(); it != m_objectStoreCleanupMap.end(); ++it)
283             it->first->setMetadata(it->second);
284     }
285     m_objectStoreCleanupMap.clear();
286     closeOpenCursors();
287     m_database->transactionFinished(this);
288
289     if (m_contextStopped || !scriptExecutionContext())
290         return;
291
292     enqueueEvent(Event::create(eventNames().abortEvent, true, false));
293 }
294
295 void IDBTransaction::onComplete()
296 {
297     ASSERT(m_state != Finished);
298     m_state = Finishing;
299     m_objectStoreCleanupMap.clear();
300     closeOpenCursors();
301     m_database->transactionFinished(this);
302
303     if (m_contextStopped || !scriptExecutionContext())
304         return;
305
306     enqueueEvent(Event::create(eventNames().completeEvent, false, false));
307 }
308
309 bool IDBTransaction::hasPendingActivity() const
310 {
311     // FIXME: In an ideal world, we should return true as long as anyone has a or can
312     //        get a handle to us or any child request object and any of those have
313     //        event listeners. This is  in order to handle user generated events properly.
314     return m_state != Finished || ActiveDOMObject::hasPendingActivity();
315 }
316
317 IDBTransaction::Mode IDBTransaction::stringToMode(const String& modeString, ExceptionCode& ec)
318 {
319     if (modeString.isNull()
320         || modeString == IDBTransaction::modeReadOnly())
321         return IDBTransaction::READ_ONLY;
322     if (modeString == IDBTransaction::modeReadWrite())
323         return IDBTransaction::READ_WRITE;
324     ec = NATIVE_TYPE_ERR;
325     return IDBTransaction::READ_ONLY;
326 }
327
328 const AtomicString& IDBTransaction::modeToString(IDBTransaction::Mode mode, ExceptionCode& ec)
329 {
330     switch (mode) {
331     case IDBTransaction::READ_ONLY:
332         return IDBTransaction::modeReadOnly();
333         break;
334
335     case IDBTransaction::READ_WRITE:
336         return IDBTransaction::modeReadWrite();
337         break;
338
339     case IDBTransaction::VERSION_CHANGE:
340         return IDBTransaction::modeVersionChange();
341         break;
342
343     default:
344         ec = NATIVE_TYPE_ERR;
345         return IDBTransaction::modeReadOnly();
346     }
347 }
348
349 const AtomicString& IDBTransaction::interfaceName() const
350 {
351     return eventNames().interfaceForIDBTransaction;
352 }
353
354 ScriptExecutionContext* IDBTransaction::scriptExecutionContext() const
355 {
356     return ActiveDOMObject::scriptExecutionContext();
357 }
358
359 bool IDBTransaction::dispatchEvent(PassRefPtr<Event> event)
360 {
361     IDB_TRACE("IDBTransaction::dispatchEvent");
362     ASSERT(m_state != Finished);
363     ASSERT(scriptExecutionContext());
364     ASSERT(event->target() == this);
365     m_state = Finished;
366
367     // Break reference cycles.
368     for (IDBObjectStoreMap::iterator it = m_objectStoreMap.begin(); it != m_objectStoreMap.end(); ++it)
369         it->second->transactionFinished();
370     m_objectStoreMap.clear();
371
372     Vector<RefPtr<EventTarget> > targets;
373     targets.append(this);
374     targets.append(db());
375
376     // FIXME: When we allow custom event dispatching, this will probably need to change.
377     ASSERT(event->type() == eventNames().completeEvent || event->type() == eventNames().abortEvent);
378     return IDBEventDispatcher::dispatch(event.get(), targets);
379 }
380
381 bool IDBTransaction::canSuspend() const
382 {
383     // FIXME: Technically we can suspend before the first request is schedule
384     //        and after the complete/abort event is enqueued.
385     return m_state == Finished;
386 }
387
388 void IDBTransaction::stop()
389 {
390     ActiveDOMObject::stop();
391     m_contextStopped = true;
392
393     ExceptionCode unused;
394     abort(unused);
395 }
396
397 void IDBTransaction::enqueueEvent(PassRefPtr<Event> event)
398 {
399     ASSERT_WITH_MESSAGE(m_state != Finished, "A finished transaction tried to enqueue an event of type %s.", event->type().string().utf8().data());
400     if (m_contextStopped || !scriptExecutionContext())
401         return;
402
403     EventQueue* eventQueue = scriptExecutionContext()->eventQueue();
404     event->setTarget(this);
405     eventQueue->enqueueEvent(event);
406 }
407
408 EventTargetData* IDBTransaction::eventTargetData()
409 {
410     return &m_eventTargetData;
411 }
412
413 EventTargetData* IDBTransaction::ensureEventTargetData()
414 {
415     return &m_eventTargetData;
416 }
417
418 }
419
420 #endif // ENABLE(INDEXED_DATABASE)