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