641e576416d6716f2df2be9f128256c0595726bf
[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_transactionFinished(false)
88     , m_contextStopped(false)
89 {
90     ASSERT(m_backend);
91     ASSERT(m_mode == m_backend->mode());
92     IDBPendingTransactionMonitor::addPendingTransaction(m_backend.get());
93     // We pass a reference of this object before it can be adopted.
94     relaxAdoptionRequirement();
95     m_database->transactionCreated(this);
96 }
97
98 IDBTransaction::~IDBTransaction()
99 {
100 }
101
102 IDBTransactionBackendInterface* IDBTransaction::backend() const
103 {
104     return m_backend.get();
105 }
106
107 bool IDBTransaction::isFinished() const
108 {
109     return m_transactionFinished;
110 }
111
112 const String& IDBTransaction::mode() const
113 {
114     ExceptionCode ec = 0;
115     const AtomicString& mode = modeToString(m_mode, ec);
116     ASSERT(!ec);
117     return mode;
118 }
119
120 IDBDatabase* IDBTransaction::db() const
121 {
122     return m_database.get();
123 }
124
125 PassRefPtr<DOMError> IDBTransaction::error(ExceptionCode& ec) const
126 {
127     if (!m_transactionFinished) {
128         ec = IDBDatabaseException::IDB_INVALID_STATE_ERR;
129         return 0;
130     }
131     return m_error;
132 }
133
134 void IDBTransaction::setError(PassRefPtr<DOMError> error)
135 {
136     ASSERT(!m_transactionFinished);
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_transactionFinished) {
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     RefPtr<IDBObjectStore> objectStore = IDBObjectStore::create(objectStoreBackend, this);
162     objectStoreCreated(name, objectStore);
163     return objectStore.release();
164 }
165
166 void IDBTransaction::objectStoreCreated(const String& name, PassRefPtr<IDBObjectStore> objectStore)
167 {
168     ASSERT(!m_transactionFinished);
169     m_objectStoreMap.set(name, objectStore);
170 }
171
172 void IDBTransaction::objectStoreDeleted(const String& name)
173 {
174     ASSERT(!m_transactionFinished);
175     IDBObjectStoreMap::iterator it = m_objectStoreMap.find(name);
176     if (it != m_objectStoreMap.end()) {
177         RefPtr<IDBObjectStore> objectStore = it->second;
178         m_objectStoreMap.remove(name);
179         objectStore->markDeleted();
180     }
181 }
182
183 void IDBTransaction::abort()
184 {
185     if (m_transactionFinished)
186         return;
187     RefPtr<IDBTransaction> selfRef = this;
188     if (m_backend)
189         m_backend->abort();
190 }
191
192 IDBTransaction::OpenCursorNotifier::OpenCursorNotifier(PassRefPtr<IDBTransaction> transaction, IDBCursor* cursor)
193     : m_transaction(transaction),
194       m_cursor(cursor)
195 {
196     m_transaction->registerOpenCursor(m_cursor);
197 }
198
199 IDBTransaction::OpenCursorNotifier::~OpenCursorNotifier()
200 {
201     m_transaction->unregisterOpenCursor(m_cursor);
202 }
203
204 void IDBTransaction::registerOpenCursor(IDBCursor* cursor)
205 {
206     m_openCursors.add(cursor);
207 }
208
209 void IDBTransaction::unregisterOpenCursor(IDBCursor* cursor)
210 {
211     m_openCursors.remove(cursor);
212 }
213
214 void IDBTransaction::closeOpenCursors()
215 {
216     HashSet<IDBCursor*> cursors;
217     cursors.swap(m_openCursors);
218     for (HashSet<IDBCursor*>::iterator i = cursors.begin(); i != cursors.end(); ++i)
219         (*i)->close();
220 }
221
222 void IDBTransaction::registerRequest(IDBRequest* request)
223 {
224     m_childRequests.add(request);
225 }
226
227 void IDBTransaction::unregisterRequest(IDBRequest* request)
228 {
229     // If we aborted the request, it will already have been removed.
230     m_childRequests.remove(request);
231 }
232
233 void IDBTransaction::onAbort()
234 {
235     ASSERT(!m_transactionFinished);
236     while (!m_childRequests.isEmpty()) {
237         IDBRequest* request = *m_childRequests.begin();
238         m_childRequests.remove(request);
239         request->abort();
240     }
241
242     closeOpenCursors();
243     m_database->transactionFinished(this);
244
245     if (m_contextStopped || !scriptExecutionContext())
246         return;
247
248     enqueueEvent(Event::create(eventNames().abortEvent, true, false));
249 }
250
251 void IDBTransaction::onComplete()
252 {
253     ASSERT(!m_transactionFinished);
254     closeOpenCursors();
255     m_database->transactionFinished(this);
256
257     if (m_contextStopped || !scriptExecutionContext())
258         return;
259
260     enqueueEvent(Event::create(eventNames().completeEvent, false, false));
261 }
262
263 bool IDBTransaction::hasPendingActivity() const
264 {
265     // FIXME: In an ideal world, we should return true as long as anyone has a or can
266     //        get a handle to us or any child request object and any of those have
267     //        event listeners. This is  in order to handle user generated events properly.
268     return !m_transactionFinished || ActiveDOMObject::hasPendingActivity();
269 }
270
271 IDBTransaction::Mode IDBTransaction::stringToMode(const String& modeString, ExceptionCode& ec)
272 {
273     if (modeString.isNull()
274         || modeString == IDBTransaction::modeReadOnly())
275         return IDBTransaction::READ_ONLY;
276     if (modeString == IDBTransaction::modeReadWrite())
277         return IDBTransaction::READ_WRITE;
278     ec = IDBDatabaseException::IDB_TYPE_ERR;
279     return IDBTransaction::READ_ONLY;
280 }
281
282 const AtomicString& IDBTransaction::modeToString(IDBTransaction::Mode mode, ExceptionCode& ec)
283 {
284     switch (mode) {
285     case IDBTransaction::READ_ONLY:
286         return IDBTransaction::modeReadOnly();
287         break;
288
289     case IDBTransaction::READ_WRITE:
290         return IDBTransaction::modeReadWrite();
291         break;
292
293     case IDBTransaction::VERSION_CHANGE:
294         return IDBTransaction::modeVersionChange();
295         break;
296
297     default:
298         ec = IDBDatabaseException::IDB_TYPE_ERR;
299         return IDBTransaction::modeReadOnly();
300     }
301 }
302
303 const AtomicString& IDBTransaction::interfaceName() const
304 {
305     return eventNames().interfaceForIDBTransaction;
306 }
307
308 ScriptExecutionContext* IDBTransaction::scriptExecutionContext() const
309 {
310     return ActiveDOMObject::scriptExecutionContext();
311 }
312
313 bool IDBTransaction::dispatchEvent(PassRefPtr<Event> event)
314 {
315     IDB_TRACE("IDBTransaction::dispatchEvent");
316     ASSERT(!m_transactionFinished);
317     ASSERT(scriptExecutionContext());
318     ASSERT(event->target() == this);
319     m_transactionFinished = true;
320
321     // Break reference cycles.
322     for (IDBObjectStoreMap::iterator it = m_objectStoreMap.begin(); it != m_objectStoreMap.end(); ++it)
323         it->second->transactionFinished();
324     m_objectStoreMap.clear();
325
326     Vector<RefPtr<EventTarget> > targets;
327     targets.append(this);
328     targets.append(db());
329
330     // FIXME: When we allow custom event dispatching, this will probably need to change.
331     ASSERT(event->type() == eventNames().completeEvent || event->type() == eventNames().abortEvent);
332     return IDBEventDispatcher::dispatch(event.get(), targets);
333 }
334
335 bool IDBTransaction::canSuspend() const
336 {
337     // FIXME: Technically we can suspend before the first request is schedule
338     //        and after the complete/abort event is enqueued.
339     return m_transactionFinished;
340 }
341
342 void IDBTransaction::stop()
343 {
344     ActiveDOMObject::stop();
345     m_contextStopped = true;
346
347     abort();
348 }
349
350 void IDBTransaction::enqueueEvent(PassRefPtr<Event> event)
351 {
352     ASSERT_WITH_MESSAGE(!m_transactionFinished, "A finished transaction tried to enqueue an event of type %s.", event->type().string().utf8().data());
353     if (m_contextStopped || !scriptExecutionContext())
354         return;
355
356     EventQueue* eventQueue = scriptExecutionContext()->eventQueue();
357     event->setTarget(this);
358     eventQueue->enqueueEvent(event);
359 }
360
361 EventTargetData* IDBTransaction::eventTargetData()
362 {
363     return &m_eventTargetData;
364 }
365
366 EventTargetData* IDBTransaction::ensureEventTargetData()
367 {
368     return &m_eventTargetData;
369 }
370
371 }
372
373 #endif // ENABLE(INDEXED_DATABASE)