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 "modules/indexeddb/IDBCursor.h"
28
29 #include "bindings/core/v8/ExceptionState.h"
30 #include "bindings/core/v8/ScriptState.h"
31 #include "bindings/modules/v8/IDBBindingUtilities.h"
32 #include "core/dom/ExceptionCode.h"
33 #include "core/dom/ExecutionContext.h"
34 #include "core/inspector/ScriptCallStack.h"
35 #include "modules/IndexedDBNames.h"
36 #include "modules/indexeddb/IDBAny.h"
37 #include "modules/indexeddb/IDBDatabase.h"
38 #include "modules/indexeddb/IDBObjectStore.h"
39 #include "modules/indexeddb/IDBTracing.h"
40 #include "modules/indexeddb/IDBTransaction.h"
41 #include "modules/indexeddb/WebIDBCallbacksImpl.h"
42 #include "public/platform/WebBlobInfo.h"
43 #include "public/platform/WebIDBDatabase.h"
44 #include "public/platform/WebIDBKeyRange.h"
45 #include <limits>
46
47 using blink::WebIDBCursor;
48 using blink::WebIDBDatabase;
49
50 namespace blink {
51
create(PassOwnPtr<WebIDBCursor> backend,WebIDBCursorDirection direction,IDBRequest * request,IDBAny * source,IDBTransaction * transaction)52 IDBCursor* IDBCursor::create(PassOwnPtr<WebIDBCursor> backend, WebIDBCursorDirection direction, IDBRequest* request, IDBAny* source, IDBTransaction* transaction)
53 {
54 return new IDBCursor(backend, direction, request, source, transaction);
55 }
56
IDBCursor(PassOwnPtr<WebIDBCursor> backend,WebIDBCursorDirection direction,IDBRequest * request,IDBAny * source,IDBTransaction * transaction)57 IDBCursor::IDBCursor(PassOwnPtr<WebIDBCursor> backend, WebIDBCursorDirection direction, IDBRequest* request, IDBAny* source, IDBTransaction* transaction)
58 : m_backend(backend)
59 , m_request(request)
60 , m_direction(direction)
61 , m_source(source)
62 , m_transaction(transaction)
63 , m_gotValue(false)
64 , m_keyDirty(true)
65 , m_primaryKeyDirty(true)
66 , m_valueDirty(true)
67 {
68 ASSERT(m_backend);
69 ASSERT(m_request);
70 ASSERT(m_source->type() == IDBAny::IDBObjectStoreType || m_source->type() == IDBAny::IDBIndexType);
71 ASSERT(m_transaction);
72 }
73
~IDBCursor()74 IDBCursor::~IDBCursor()
75 {
76 ASSERT(!m_blobInfo || m_blobInfo->size() == 0);
77 }
78
dispose()79 void IDBCursor::dispose()
80 {
81 handleBlobAcks();
82 }
83
trace(Visitor * visitor)84 void IDBCursor::trace(Visitor* visitor)
85 {
86 visitor->trace(m_request);
87 visitor->trace(m_source);
88 visitor->trace(m_transaction);
89 visitor->trace(m_key);
90 visitor->trace(m_primaryKey);
91 }
92
update(ScriptState * scriptState,const ScriptValue & value,ExceptionState & exceptionState)93 IDBRequest* IDBCursor::update(ScriptState* scriptState, const ScriptValue& value, ExceptionState& exceptionState)
94 {
95 IDB_TRACE("IDBCursor::update");
96
97 if (!m_gotValue) {
98 exceptionState.throwDOMException(InvalidStateError, IDBDatabase::noValueErrorMessage);
99 return 0;
100 }
101 if (isKeyCursor()) {
102 exceptionState.throwDOMException(InvalidStateError, IDBDatabase::isKeyCursorErrorMessage);
103 return 0;
104 }
105 if (isDeleted()) {
106 exceptionState.throwDOMException(InvalidStateError, IDBDatabase::sourceDeletedErrorMessage);
107 return 0;
108 }
109 if (m_transaction->isFinished() || m_transaction->isFinishing()) {
110 exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionFinishedErrorMessage);
111 return 0;
112 }
113 if (!m_transaction->isActive()) {
114 exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionInactiveErrorMessage);
115 return 0;
116 }
117 if (m_transaction->isReadOnly()) {
118 exceptionState.throwDOMException(ReadOnlyError, "The record may not be updated inside a read-only transaction.");
119 return 0;
120 }
121
122 IDBObjectStore* objectStore = effectiveObjectStore();
123 return objectStore->put(scriptState, WebIDBPutModeCursorUpdate, IDBAny::create(this), value, m_primaryKey, exceptionState);
124 }
125
advance(unsigned long count,ExceptionState & exceptionState)126 void IDBCursor::advance(unsigned long count, ExceptionState& exceptionState)
127 {
128 IDB_TRACE("IDBCursor::advance");
129 if (!count) {
130 exceptionState.throwTypeError("A count argument with value 0 (zero) was supplied, must be greater than 0.");
131 return;
132 }
133 if (!m_gotValue) {
134 exceptionState.throwDOMException(InvalidStateError, IDBDatabase::noValueErrorMessage);
135 return;
136 }
137 if (isDeleted()) {
138 exceptionState.throwDOMException(InvalidStateError, IDBDatabase::sourceDeletedErrorMessage);
139 return;
140 }
141
142 if (m_transaction->isFinished() || m_transaction->isFinishing()) {
143 exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionFinishedErrorMessage);
144 return;
145 }
146 if (!m_transaction->isActive()) {
147 exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionInactiveErrorMessage);
148 return;
149 }
150
151 m_request->setPendingCursor(this);
152 m_gotValue = false;
153 m_backend->advance(count, WebIDBCallbacksImpl::create(m_request).leakPtr());
154 }
155
continueFunction(ScriptState * scriptState,const ScriptValue & keyValue,ExceptionState & exceptionState)156 void IDBCursor::continueFunction(ScriptState* scriptState, const ScriptValue& keyValue, ExceptionState& exceptionState)
157 {
158 IDB_TRACE("IDBCursor::continue");
159 IDBKey* key = keyValue.isUndefined() || keyValue.isNull() ? nullptr : scriptValueToIDBKey(scriptState->isolate(), keyValue);
160 if (key && !key->isValid()) {
161 exceptionState.throwDOMException(DataError, IDBDatabase::notValidKeyErrorMessage);
162 return;
163 }
164 continueFunction(key, 0, exceptionState);
165 }
166
continuePrimaryKey(ScriptState * scriptState,const ScriptValue & keyValue,const ScriptValue & primaryKeyValue,ExceptionState & exceptionState)167 void IDBCursor::continuePrimaryKey(ScriptState* scriptState, const ScriptValue& keyValue, const ScriptValue& primaryKeyValue, ExceptionState& exceptionState)
168 {
169 IDB_TRACE("IDBCursor::continuePrimaryKey");
170 IDBKey* key = scriptValueToIDBKey(scriptState->isolate(), keyValue);
171 IDBKey* primaryKey = scriptValueToIDBKey(scriptState->isolate(), primaryKeyValue);
172 if (!key->isValid() || !primaryKey->isValid()) {
173 exceptionState.throwDOMException(DataError, IDBDatabase::notValidKeyErrorMessage);
174 return;
175 }
176 continueFunction(key, primaryKey, exceptionState);
177 }
178
continueFunction(IDBKey * key,IDBKey * primaryKey,ExceptionState & exceptionState)179 void IDBCursor::continueFunction(IDBKey* key, IDBKey* primaryKey, ExceptionState& exceptionState)
180 {
181 ASSERT(!primaryKey || (key && primaryKey));
182
183 if (m_transaction->isFinished() || m_transaction->isFinishing()) {
184 exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionFinishedErrorMessage);
185 return;
186 }
187 if (!m_transaction->isActive()) {
188 exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionInactiveErrorMessage);
189 return;
190 }
191
192 if (!m_gotValue) {
193 exceptionState.throwDOMException(InvalidStateError, IDBDatabase::noValueErrorMessage);
194 return;
195 }
196
197 if (isDeleted()) {
198 exceptionState.throwDOMException(InvalidStateError, IDBDatabase::sourceDeletedErrorMessage);
199 return;
200 }
201
202 if (key) {
203 ASSERT(m_key);
204 if (m_direction == WebIDBCursorDirectionNext || m_direction == WebIDBCursorDirectionNextNoDuplicate) {
205 const bool ok = m_key->isLessThan(key)
206 || (primaryKey && m_key->isEqual(key) && m_primaryKey->isLessThan(primaryKey));
207 if (!ok) {
208 exceptionState.throwDOMException(DataError, "The parameter is less than or equal to this cursor's position.");
209 return;
210 }
211
212 } else {
213 const bool ok = key->isLessThan(m_key.get())
214 || (primaryKey && key->isEqual(m_key.get()) && primaryKey->isLessThan(m_primaryKey.get()));
215 if (!ok) {
216 exceptionState.throwDOMException(DataError, "The parameter is greater than or equal to this cursor's position.");
217 return;
218 }
219 }
220 }
221
222 // FIXME: We're not using the context from when continue was called, which means the callback
223 // will be on the original context openCursor was called on. Is this right?
224 m_request->setPendingCursor(this);
225 m_gotValue = false;
226 m_backend->continueFunction(key, primaryKey, WebIDBCallbacksImpl::create(m_request).leakPtr());
227 }
228
deleteFunction(ScriptState * scriptState,ExceptionState & exceptionState)229 IDBRequest* IDBCursor::deleteFunction(ScriptState* scriptState, ExceptionState& exceptionState)
230 {
231 IDB_TRACE("IDBCursor::delete");
232 if (m_transaction->isFinished() || m_transaction->isFinishing()) {
233 exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionFinishedErrorMessage);
234 return 0;
235 }
236 if (!m_transaction->isActive()) {
237 exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionInactiveErrorMessage);
238 return 0;
239 }
240 if (m_transaction->isReadOnly()) {
241 exceptionState.throwDOMException(ReadOnlyError, "The record may not be deleted inside a read-only transaction.");
242 return 0;
243 }
244
245 if (!m_gotValue) {
246 exceptionState.throwDOMException(InvalidStateError, IDBDatabase::noValueErrorMessage);
247 return 0;
248 }
249 if (isKeyCursor()) {
250 exceptionState.throwDOMException(InvalidStateError, IDBDatabase::isKeyCursorErrorMessage);
251 return 0;
252 }
253 if (isDeleted()) {
254 exceptionState.throwDOMException(InvalidStateError, IDBDatabase::sourceDeletedErrorMessage);
255 return 0;
256 }
257 if (!m_transaction->backendDB()) {
258 exceptionState.throwDOMException(InvalidStateError, IDBDatabase::databaseClosedErrorMessage);
259 return 0;
260 }
261
262 IDBKeyRange* keyRange = IDBKeyRange::only(m_primaryKey, exceptionState);
263 ASSERT(!exceptionState.hadException());
264
265 IDBRequest* request = IDBRequest::create(scriptState, IDBAny::create(this), m_transaction.get());
266 m_transaction->backendDB()->deleteRange(m_transaction->id(), effectiveObjectStore()->id(), keyRange, WebIDBCallbacksImpl::create(request).leakPtr());
267 return request;
268 }
269
postSuccessHandlerCallback()270 void IDBCursor::postSuccessHandlerCallback()
271 {
272 if (m_backend)
273 m_backend->postSuccessHandlerCallback();
274 }
275
close()276 void IDBCursor::close()
277 {
278 handleBlobAcks();
279 m_request.clear();
280 m_backend.clear();
281 }
282
key(ScriptState * scriptState)283 ScriptValue IDBCursor::key(ScriptState* scriptState)
284 {
285 m_keyDirty = false;
286 return idbKeyToScriptValue(scriptState, m_key);
287 }
288
primaryKey(ScriptState * scriptState)289 ScriptValue IDBCursor::primaryKey(ScriptState* scriptState)
290 {
291 m_primaryKeyDirty = false;
292 return idbKeyToScriptValue(scriptState, m_primaryKey);
293 }
294
value(ScriptState * scriptState)295 ScriptValue IDBCursor::value(ScriptState* scriptState)
296 {
297 ASSERT(isCursorWithValue());
298
299 IDBObjectStore* objectStore = effectiveObjectStore();
300 const IDBObjectStoreMetadata& metadata = objectStore->metadata();
301 IDBAny* value;
302 if (metadata.autoIncrement && !metadata.keyPath.isNull()) {
303 value = IDBAny::create(m_value, m_blobInfo.get(), m_primaryKey, metadata.keyPath);
304 #if ENABLE(ASSERT)
305 assertPrimaryKeyValidOrInjectable(scriptState, m_value, m_blobInfo.get(), m_primaryKey, metadata.keyPath);
306 #endif
307 } else {
308 value = IDBAny::create(m_value, m_blobInfo.get());
309 }
310
311 m_valueDirty = false;
312 ScriptValue scriptValue = idbAnyToScriptValue(scriptState, value);
313 handleBlobAcks();
314 return scriptValue;
315 }
316
source(ScriptState * scriptState) const317 ScriptValue IDBCursor::source(ScriptState* scriptState) const
318 {
319 return idbAnyToScriptValue(scriptState, m_source);
320 }
321
setValueReady(IDBKey * key,IDBKey * primaryKey,PassRefPtr<SharedBuffer> value,PassOwnPtr<Vector<WebBlobInfo>> blobInfo)322 void IDBCursor::setValueReady(IDBKey* key, IDBKey* primaryKey, PassRefPtr<SharedBuffer> value, PassOwnPtr<Vector<WebBlobInfo> > blobInfo)
323 {
324 m_key = key;
325 m_keyDirty = true;
326
327 m_primaryKey = primaryKey;
328 m_primaryKeyDirty = true;
329
330 if (isCursorWithValue()) {
331 m_value = value;
332 handleBlobAcks();
333 m_blobInfo = blobInfo;
334 m_valueDirty = true;
335 if (m_blobInfo && m_blobInfo->size() > 0)
336 V8PerIsolateData::from(m_request->scriptState()->isolate())->ensureIDBPendingTransactionMonitor()->registerCursor(*this);
337 }
338
339 m_gotValue = true;
340 }
341
effectiveObjectStore() const342 IDBObjectStore* IDBCursor::effectiveObjectStore() const
343 {
344 if (m_source->type() == IDBAny::IDBObjectStoreType)
345 return m_source->idbObjectStore();
346 return m_source->idbIndex()->objectStore();
347 }
348
isDeleted() const349 bool IDBCursor::isDeleted() const
350 {
351 if (m_source->type() == IDBAny::IDBObjectStoreType)
352 return m_source->idbObjectStore()->isDeleted();
353 return m_source->idbIndex()->isDeleted();
354 }
355
handleBlobAcks()356 void IDBCursor::handleBlobAcks()
357 {
358 ASSERT(m_request || !m_blobInfo || !m_blobInfo->size());
359 if (m_blobInfo.get() && m_blobInfo->size()) {
360 ASSERT(m_request);
361 m_transaction->db()->ackReceivedBlobs(m_blobInfo.get());
362 m_blobInfo.clear();
363 V8PerIsolateData::from(m_request->scriptState()->isolate())->ensureIDBPendingTransactionMonitor()->unregisterCursor(*this);
364 }
365 }
366
stringToDirection(const String & directionString,ExceptionState & exceptionState)367 WebIDBCursorDirection IDBCursor::stringToDirection(const String& directionString, ExceptionState& exceptionState)
368 {
369 if (directionString == IndexedDBNames::next)
370 return WebIDBCursorDirectionNext;
371 if (directionString == IndexedDBNames::nextunique)
372 return WebIDBCursorDirectionNextNoDuplicate;
373 if (directionString == IndexedDBNames::prev)
374 return WebIDBCursorDirectionPrev;
375 if (directionString == IndexedDBNames::prevunique)
376 return WebIDBCursorDirectionPrevNoDuplicate;
377
378 exceptionState.throwTypeError("The direction provided ('" + directionString + "') is not one of 'next', 'nextunique', 'prev', or 'prevunique'.");
379 return WebIDBCursorDirectionNext;
380 }
381
direction() const382 const String& IDBCursor::direction() const
383 {
384 switch (m_direction) {
385 case WebIDBCursorDirectionNext:
386 return IndexedDBNames::next;
387
388 case WebIDBCursorDirectionNextNoDuplicate:
389 return IndexedDBNames::nextunique;
390
391 case WebIDBCursorDirectionPrev:
392 return IndexedDBNames::prev;
393
394 case WebIDBCursorDirectionPrevNoDuplicate:
395 return IndexedDBNames::prevunique;
396
397 default:
398 ASSERT_NOT_REACHED();
399 return IndexedDBNames::next;
400 }
401 }
402
403 } // namespace blink
404