OLD | NEW |
1 /* | 1 /* |
2 * Copyright (C) 2011 Google Inc. All rights reserved. | 2 * Copyright (C) 2011 Google Inc. All rights reserved. |
3 * | 3 * |
4 * Redistribution and use in source and binary forms, with or without | 4 * Redistribution and use in source and binary forms, with or without |
5 * modification, are permitted provided that the following conditions | 5 * modification, are permitted provided that the following conditions |
6 * are met: | 6 * are met: |
7 * | 7 * |
8 * 1. Redistributions of source code must retain the above copyright | 8 * 1. Redistributions of source code must retain the above copyright |
9 * notice, this list of conditions and the following disclaimer. | 9 * notice, this list of conditions and the following disclaimer. |
10 * 2. Redistributions in binary form must reproduce the above copyright | 10 * 2. Redistributions in binary form must reproduce the above copyright |
(...skipping 23 matching lines...) Expand all Loading... |
34 #include "modules/indexeddb/IDBKeyRange.h" | 34 #include "modules/indexeddb/IDBKeyRange.h" |
35 #include "modules/indexeddb/IDBObjectStoreBackendImpl.h" | 35 #include "modules/indexeddb/IDBObjectStoreBackendImpl.h" |
36 #include "modules/indexeddb/IDBTracing.h" | 36 #include "modules/indexeddb/IDBTracing.h" |
37 #include "modules/indexeddb/IDBTransactionBackendImpl.h" | 37 #include "modules/indexeddb/IDBTransactionBackendImpl.h" |
38 #include "modules/indexeddb/IDBTransactionCoordinator.h" | 38 #include "modules/indexeddb/IDBTransactionCoordinator.h" |
39 #include <public/Platform.h> | 39 #include <public/Platform.h> |
40 #include "wtf/TemporaryChange.h" | 40 #include "wtf/TemporaryChange.h" |
41 | 41 |
42 namespace WebCore { | 42 namespace WebCore { |
43 | 43 |
| 44 DEFINE_GC_INFO(IDBDatabaseBackendInterface); |
| 45 |
44 class CreateObjectStoreOperation : public IDBTransactionBackendImpl::Operation { | 46 class CreateObjectStoreOperation : public IDBTransactionBackendImpl::Operation { |
45 public: | 47 public: |
46 static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<ID
BBackingStore> backingStore, const IDBObjectStoreMetadata& objectStoreMetadata) | 48 static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<ID
BBackingStore> backingStore, const IDBObjectStoreMetadata& objectStoreMetadata) |
47 { | 49 { |
48 return adoptPtr(new CreateObjectStoreOperation(backingStore, objectStore
Metadata)); | 50 return adoptPtr(new CreateObjectStoreOperation(backingStore, objectStore
Metadata)); |
49 } | 51 } |
50 virtual void perform(IDBTransactionBackendImpl*); | 52 virtual void perform(IDBTransactionBackendImpl*); |
51 private: | 53 private: |
52 CreateObjectStoreOperation(PassRefPtr<IDBBackingStore> backingStore, const I
DBObjectStoreMetadata& objectStoreMetadata) | 54 CreateObjectStoreOperation(PassRefPtr<IDBBackingStore> backingStore, const I
DBObjectStoreMetadata& objectStoreMetadata) |
53 : m_backingStore(backingStore) | 55 : m_backingStore(backingStore) |
(...skipping 18 matching lines...) Expand all Loading... |
72 , m_objectStoreMetadata(objectStoreMetadata) | 74 , m_objectStoreMetadata(objectStoreMetadata) |
73 { | 75 { |
74 } | 76 } |
75 | 77 |
76 const RefPtr<IDBBackingStore> m_backingStore; | 78 const RefPtr<IDBBackingStore> m_backingStore; |
77 const IDBObjectStoreMetadata m_objectStoreMetadata; | 79 const IDBObjectStoreMetadata m_objectStoreMetadata; |
78 }; | 80 }; |
79 | 81 |
80 class IDBDatabaseBackendImpl::VersionChangeOperation : public IDBTransactionBack
endImpl::Operation { | 82 class IDBDatabaseBackendImpl::VersionChangeOperation : public IDBTransactionBack
endImpl::Operation { |
81 public: | 83 public: |
82 static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<ID
BDatabaseBackendImpl> database, int64_t transactionId, int64_t version, PassRefP
tr<IDBCallbacks> callbacks, PassRefPtr<IDBDatabaseCallbacks> databaseCallbacks) | 84 static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(IDBDatabaseBa
ckendImpl* database, int64_t transactionId, int64_t version, IDBCallbacks* callb
acks, IDBDatabaseCallbacks* databaseCallbacks) |
83 { | 85 { |
84 return adoptPtr(new VersionChangeOperation(database, transactionId, vers
ion, callbacks, databaseCallbacks)); | 86 return adoptPtr(new VersionChangeOperation(database, transactionId, vers
ion, callbacks, databaseCallbacks)); |
85 } | 87 } |
86 virtual void perform(IDBTransactionBackendImpl*); | 88 virtual void perform(IDBTransactionBackendImpl*); |
87 private: | 89 private: |
88 VersionChangeOperation(PassRefPtr<IDBDatabaseBackendImpl> database, int64_t
transactionId, int64_t version, PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<I
DBDatabaseCallbacks> databaseCallbacks) | 90 VersionChangeOperation(IDBDatabaseBackendImpl* database, int64_t transaction
Id, int64_t version, IDBCallbacks* callbacks, IDBDatabaseCallbacks* databaseCall
backs) |
89 : m_database(database) | 91 : m_database(database) |
90 , m_transactionId(transactionId) | 92 , m_transactionId(transactionId) |
91 , m_version(version) | 93 , m_version(version) |
92 , m_callbacks(callbacks) | 94 , m_callbacks(callbacks) |
93 , m_databaseCallbacks(databaseCallbacks) | 95 , m_databaseCallbacks(databaseCallbacks) |
94 { | 96 { |
95 } | 97 } |
96 | 98 |
97 RefPtr<IDBDatabaseBackendImpl> m_database; | 99 Persistent<IDBDatabaseBackendImpl> m_database; |
98 int64_t m_transactionId; | 100 int64_t m_transactionId; |
99 int64_t m_version; | 101 int64_t m_version; |
100 RefPtr<IDBCallbacks> m_callbacks; | 102 Persistent<IDBCallbacks> m_callbacks; |
101 RefPtr<IDBDatabaseCallbacks> m_databaseCallbacks; | 103 Persistent<IDBDatabaseCallbacks> m_databaseCallbacks; |
102 }; | 104 }; |
103 | 105 |
104 class CreateObjectStoreAbortOperation : public IDBTransactionBackendImpl::Operat
ion { | 106 class CreateObjectStoreAbortOperation : public IDBTransactionBackendImpl::Operat
ion { |
105 public: | 107 public: |
106 static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<ID
BDatabaseBackendImpl> database, int64_t objectStoreId) | 108 static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(IDBDatabaseBa
ckendImpl* database, int64_t objectStoreId) |
107 { | 109 { |
108 return adoptPtr(new CreateObjectStoreAbortOperation(database, objectStor
eId)); | 110 return adoptPtr(new CreateObjectStoreAbortOperation(database, objectStor
eId)); |
109 } | 111 } |
110 virtual void perform(IDBTransactionBackendImpl*); | 112 virtual void perform(IDBTransactionBackendImpl*); |
111 private: | 113 private: |
112 CreateObjectStoreAbortOperation(PassRefPtr<IDBDatabaseBackendImpl> database,
int64_t objectStoreId) | 114 CreateObjectStoreAbortOperation(IDBDatabaseBackendImpl* database, int64_t ob
jectStoreId) |
113 : m_database(database) | 115 : m_database(database) |
114 , m_objectStoreId(objectStoreId) | 116 , m_objectStoreId(objectStoreId) |
115 { | 117 { |
116 } | 118 } |
117 | 119 |
118 const RefPtr<IDBDatabaseBackendImpl> m_database; | 120 const Persistent<IDBDatabaseBackendImpl> m_database; |
119 const int64_t m_objectStoreId; | 121 const int64_t m_objectStoreId; |
120 }; | 122 }; |
121 | 123 |
122 class DeleteObjectStoreAbortOperation : public IDBTransactionBackendImpl::Operat
ion { | 124 class DeleteObjectStoreAbortOperation : public IDBTransactionBackendImpl::Operat
ion { |
123 public: | 125 public: |
124 static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<ID
BDatabaseBackendImpl> database, const IDBObjectStoreMetadata& objectStore) | 126 static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(IDBDatabaseBa
ckendImpl* database, const IDBObjectStoreMetadata& objectStore) |
125 { | 127 { |
126 return adoptPtr(new DeleteObjectStoreAbortOperation(database, objectStor
e)); | 128 return adoptPtr(new DeleteObjectStoreAbortOperation(database, objectStor
e)); |
127 } | 129 } |
128 virtual void perform(IDBTransactionBackendImpl*); | 130 virtual void perform(IDBTransactionBackendImpl*); |
129 private: | 131 private: |
130 DeleteObjectStoreAbortOperation(PassRefPtr<IDBDatabaseBackendImpl> database,
const IDBObjectStoreMetadata& objectStoreMetadata) | 132 DeleteObjectStoreAbortOperation(IDBDatabaseBackendImpl* database, const IDBO
bjectStoreMetadata& objectStoreMetadata) |
131 : m_database(database) | 133 : m_database(database) |
132 , m_objectStoreMetadata(objectStoreMetadata) | 134 , m_objectStoreMetadata(objectStoreMetadata) |
133 { | 135 { |
134 } | 136 } |
135 | 137 |
136 RefPtr<IDBDatabaseBackendImpl> m_database; | 138 Persistent<IDBDatabaseBackendImpl> m_database; |
137 IDBObjectStoreMetadata m_objectStoreMetadata; | 139 IDBObjectStoreMetadata m_objectStoreMetadata; |
138 }; | 140 }; |
139 | 141 |
140 class IDBDatabaseBackendImpl::VersionChangeAbortOperation : public IDBTransactio
nBackendImpl::Operation { | 142 class IDBDatabaseBackendImpl::VersionChangeAbortOperation : public IDBTransactio
nBackendImpl::Operation { |
141 public: | 143 public: |
142 static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<ID
BDatabaseBackendImpl> database, const String& previousVersion, int64_t previousI
ntVersion) | 144 static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(IDBDatabaseBa
ckendImpl* database, const String& previousVersion, int64_t previousIntVersion) |
143 { | 145 { |
144 return adoptPtr(new VersionChangeAbortOperation(database, previousVersio
n, previousIntVersion)); | 146 return adoptPtr(new VersionChangeAbortOperation(database, previousVersio
n, previousIntVersion)); |
145 } | 147 } |
146 virtual void perform(IDBTransactionBackendImpl*); | 148 virtual void perform(IDBTransactionBackendImpl*); |
147 private: | 149 private: |
148 VersionChangeAbortOperation(PassRefPtr<IDBDatabaseBackendImpl> database, con
st String& previousVersion, int64_t previousIntVersion) | 150 VersionChangeAbortOperation(IDBDatabaseBackendImpl* database, const String&
previousVersion, int64_t previousIntVersion) |
149 : m_database(database) | 151 : m_database(database) |
150 , m_previousVersion(previousVersion) | 152 , m_previousVersion(previousVersion) |
151 , m_previousIntVersion(previousIntVersion) | 153 , m_previousIntVersion(previousIntVersion) |
152 { | 154 { |
153 } | 155 } |
154 | 156 |
155 RefPtr<IDBDatabaseBackendImpl> m_database; | 157 Persistent<IDBDatabaseBackendImpl> m_database; |
156 String m_previousVersion; | 158 String m_previousVersion; |
157 int64_t m_previousIntVersion; | 159 int64_t m_previousIntVersion; |
158 }; | 160 }; |
159 | 161 |
160 class CreateIndexOperation : public IDBTransactionBackendImpl::Operation { | 162 class CreateIndexOperation : public IDBTransactionBackendImpl::Operation { |
161 public: | 163 public: |
162 static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<ID
BBackingStore> backingStore, int64_t objectStoreId, const IDBIndexMetadata& inde
xMetadata) | 164 static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<ID
BBackingStore> backingStore, int64_t objectStoreId, const IDBIndexMetadata& inde
xMetadata) |
163 { | 165 { |
164 return adoptPtr(new CreateIndexOperation(backingStore, objectStoreId, in
dexMetadata)); | 166 return adoptPtr(new CreateIndexOperation(backingStore, objectStoreId, in
dexMetadata)); |
165 } | 167 } |
(...skipping 26 matching lines...) Expand all Loading... |
192 { | 194 { |
193 } | 195 } |
194 | 196 |
195 const RefPtr<IDBBackingStore> m_backingStore; | 197 const RefPtr<IDBBackingStore> m_backingStore; |
196 const int64_t m_objectStoreId; | 198 const int64_t m_objectStoreId; |
197 const IDBIndexMetadata m_indexMetadata; | 199 const IDBIndexMetadata m_indexMetadata; |
198 }; | 200 }; |
199 | 201 |
200 class CreateIndexAbortOperation : public IDBTransactionBackendImpl::Operation { | 202 class CreateIndexAbortOperation : public IDBTransactionBackendImpl::Operation { |
201 public: | 203 public: |
202 static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<ID
BDatabaseBackendImpl> database, int64_t objectStoreId, int64_t indexId) | 204 static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(IDBDatabaseBa
ckendImpl* database, int64_t objectStoreId, int64_t indexId) |
203 { | 205 { |
204 return adoptPtr(new CreateIndexAbortOperation(database, objectStoreId, i
ndexId)); | 206 return adoptPtr(new CreateIndexAbortOperation(database, objectStoreId, i
ndexId)); |
205 } | 207 } |
206 virtual void perform(IDBTransactionBackendImpl*); | 208 virtual void perform(IDBTransactionBackendImpl*); |
207 private: | 209 private: |
208 CreateIndexAbortOperation(PassRefPtr<IDBDatabaseBackendImpl> database, int64
_t objectStoreId, int64_t indexId) | 210 CreateIndexAbortOperation(IDBDatabaseBackendImpl* database, int64_t objectSt
oreId, int64_t indexId) |
209 : m_database(database) | 211 : m_database(database) |
210 , m_objectStoreId(objectStoreId) | 212 , m_objectStoreId(objectStoreId) |
211 , m_indexId(indexId) | 213 , m_indexId(indexId) |
212 { | 214 { |
213 } | 215 } |
214 | 216 |
215 const RefPtr<IDBDatabaseBackendImpl> m_database; | 217 const Persistent<IDBDatabaseBackendImpl> m_database; |
216 const int64_t m_objectStoreId; | 218 const int64_t m_objectStoreId; |
217 const int64_t m_indexId; | 219 const int64_t m_indexId; |
218 }; | 220 }; |
219 | 221 |
220 class DeleteIndexAbortOperation : public IDBTransactionBackendImpl::Operation { | 222 class DeleteIndexAbortOperation : public IDBTransactionBackendImpl::Operation { |
221 public: | 223 public: |
222 static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<ID
BDatabaseBackendImpl> database, int64_t objectStoreId, const IDBIndexMetadata& i
ndexMetadata) | 224 static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(IDBDatabaseBa
ckendImpl* database, int64_t objectStoreId, const IDBIndexMetadata& indexMetadat
a) |
223 { | 225 { |
224 return adoptPtr(new DeleteIndexAbortOperation(database, objectStoreId, i
ndexMetadata)); | 226 return adoptPtr(new DeleteIndexAbortOperation(database, objectStoreId, i
ndexMetadata)); |
225 } | 227 } |
226 virtual void perform(IDBTransactionBackendImpl*); | 228 virtual void perform(IDBTransactionBackendImpl*); |
227 private: | 229 private: |
228 DeleteIndexAbortOperation(PassRefPtr<IDBDatabaseBackendImpl> database, int64
_t objectStoreId, const IDBIndexMetadata& indexMetadata) | 230 DeleteIndexAbortOperation(IDBDatabaseBackendImpl* database, int64_t objectSt
oreId, const IDBIndexMetadata& indexMetadata) |
229 : m_database(database) | 231 : m_database(database) |
230 , m_objectStoreId(objectStoreId) | 232 , m_objectStoreId(objectStoreId) |
231 , m_indexMetadata(indexMetadata) | 233 , m_indexMetadata(indexMetadata) |
232 { | 234 { |
233 } | 235 } |
234 | 236 |
235 const RefPtr<IDBDatabaseBackendImpl> m_database; | 237 const Persistent<IDBDatabaseBackendImpl> m_database; |
236 const int64_t m_objectStoreId; | 238 const int64_t m_objectStoreId; |
237 const IDBIndexMetadata m_indexMetadata; | 239 const IDBIndexMetadata m_indexMetadata; |
238 }; | 240 }; |
239 | 241 |
240 class GetOperation : public IDBTransactionBackendImpl::Operation { | 242 class GetOperation : public IDBTransactionBackendImpl::Operation { |
241 public: | 243 public: |
242 static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<ID
BBackingStore> backingStore, const IDBDatabaseMetadata& metadata, int64_t object
StoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, IndexedDB::CursorTyp
e cursorType, PassRefPtr<IDBCallbacks> callbacks) | 244 static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<ID
BBackingStore> backingStore, const IDBDatabaseMetadata& metadata, int64_t object
StoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, IndexedDB::CursorTyp
e cursorType, IDBCallbacks* callbacks) |
243 { | 245 { |
244 return adoptPtr(new GetOperation(backingStore, metadata, objectStoreId,
indexId, keyRange, cursorType, callbacks)); | 246 return adoptPtr(new GetOperation(backingStore, metadata, objectStoreId,
indexId, keyRange, cursorType, callbacks)); |
245 } | 247 } |
246 virtual void perform(IDBTransactionBackendImpl*); | 248 virtual void perform(IDBTransactionBackendImpl*); |
247 private: | 249 private: |
248 GetOperation(PassRefPtr<IDBBackingStore> backingStore, const IDBDatabaseMeta
data& metadata, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange>
keyRange, IndexedDB::CursorType cursorType, PassRefPtr<IDBCallbacks> callbacks) | 250 GetOperation(PassRefPtr<IDBBackingStore> backingStore, const IDBDatabaseMeta
data& metadata, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange>
keyRange, IndexedDB::CursorType cursorType, IDBCallbacks* callbacks) |
249 : m_backingStore(backingStore) | 251 : m_backingStore(backingStore) |
250 , m_databaseId(metadata.id) | 252 , m_databaseId(metadata.id) |
251 , m_objectStoreId(objectStoreId) | 253 , m_objectStoreId(objectStoreId) |
252 , m_indexId(indexId) | 254 , m_indexId(indexId) |
253 , m_keyPath(metadata.objectStores.get(objectStoreId).keyPath) | 255 , m_keyPath(metadata.objectStores.get(objectStoreId).keyPath) |
254 , m_autoIncrement(metadata.objectStores.get(objectStoreId).autoIncrement
) | 256 , m_autoIncrement(metadata.objectStores.get(objectStoreId).autoIncrement
) |
255 , m_keyRange(keyRange) | 257 , m_keyRange(keyRange) |
256 , m_cursorType(cursorType) | 258 , m_cursorType(cursorType) |
257 , m_callbacks(callbacks) | 259 , m_callbacks(callbacks) |
258 { | 260 { |
259 ASSERT(metadata.objectStores.contains(objectStoreId)); | 261 ASSERT(metadata.objectStores.contains(objectStoreId)); |
260 ASSERT(metadata.objectStores.get(objectStoreId).id == objectStoreId); | 262 ASSERT(metadata.objectStores.get(objectStoreId).id == objectStoreId); |
261 } | 263 } |
262 | 264 |
263 const RefPtr<IDBBackingStore> m_backingStore; | 265 const RefPtr<IDBBackingStore> m_backingStore; |
264 const int64_t m_databaseId; | 266 const int64_t m_databaseId; |
265 const int64_t m_objectStoreId; | 267 const int64_t m_objectStoreId; |
266 const int64_t m_indexId; | 268 const int64_t m_indexId; |
267 const IDBKeyPath m_keyPath; | 269 const IDBKeyPath m_keyPath; |
268 const bool m_autoIncrement; | 270 const bool m_autoIncrement; |
269 const RefPtr<IDBKeyRange> m_keyRange; | 271 const RefPtr<IDBKeyRange> m_keyRange; |
270 const IndexedDB::CursorType m_cursorType; | 272 const IndexedDB::CursorType m_cursorType; |
271 const RefPtr<IDBCallbacks> m_callbacks; | 273 const Persistent<IDBCallbacks> m_callbacks; |
272 }; | 274 }; |
273 | 275 |
274 class PutOperation : public IDBTransactionBackendImpl::Operation { | 276 class PutOperation : public IDBTransactionBackendImpl::Operation { |
275 public: | 277 public: |
276 static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<ID
BBackingStore> backingStore, int64_t databaseId, const IDBObjectStoreMetadata& o
bjectStore, PassRefPtr<SharedBuffer> value, PassRefPtr<IDBKey> key, IDBDatabaseB
ackendInterface::PutMode putMode, PassRefPtr<IDBCallbacks> callbacks, const Vect
or<int64_t>& indexIds, const Vector<IDBDatabaseBackendInterface::IndexKeys>& ind
exKeys) | 278 static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<ID
BBackingStore> backingStore, int64_t databaseId, const IDBObjectStoreMetadata& o
bjectStore, PassRefPtr<SharedBuffer> value, PassRefPtr<IDBKey> key, IDBDatabaseB
ackendInterface::PutMode putMode, IDBCallbacks* callbacks, const Vector<int64_t>
& indexIds, const Vector<IDBDatabaseBackendInterface::IndexKeys>& indexKeys) |
277 { | 279 { |
278 return adoptPtr(new PutOperation(backingStore, databaseId, objectStore,
value, key, putMode, callbacks, indexIds, indexKeys)); | 280 return adoptPtr(new PutOperation(backingStore, databaseId, objectStore,
value, key, putMode, callbacks, indexIds, indexKeys)); |
279 } | 281 } |
280 virtual void perform(IDBTransactionBackendImpl*); | 282 virtual void perform(IDBTransactionBackendImpl*); |
281 private: | 283 private: |
282 PutOperation(PassRefPtr<IDBBackingStore> backingStore, int64_t databaseId, c
onst IDBObjectStoreMetadata& objectStore, PassRefPtr<SharedBuffer>& value, PassR
efPtr<IDBKey> key, IDBDatabaseBackendInterface::PutMode putMode, PassRefPtr<IDBC
allbacks> callbacks, const Vector<int64_t>& indexIds, const Vector<IDBDatabaseBa
ckendInterface::IndexKeys>& indexKeys) | 284 PutOperation(PassRefPtr<IDBBackingStore> backingStore, int64_t databaseId, c
onst IDBObjectStoreMetadata& objectStore, PassRefPtr<SharedBuffer>& value, PassR
efPtr<IDBKey> key, IDBDatabaseBackendInterface::PutMode putMode, IDBCallbacks* c
allbacks, const Vector<int64_t>& indexIds, const Vector<IDBDatabaseBackendInterf
ace::IndexKeys>& indexKeys) |
283 : m_backingStore(backingStore) | 285 : m_backingStore(backingStore) |
284 , m_databaseId(databaseId) | 286 , m_databaseId(databaseId) |
285 , m_objectStore(objectStore) | 287 , m_objectStore(objectStore) |
286 , m_value(value) | 288 , m_value(value) |
287 , m_key(key) | 289 , m_key(key) |
288 , m_putMode(putMode) | 290 , m_putMode(putMode) |
289 , m_callbacks(callbacks) | 291 , m_callbacks(callbacks) |
290 , m_indexIds(indexIds) | 292 , m_indexIds(indexIds) |
291 , m_indexKeys(indexKeys) | 293 , m_indexKeys(indexKeys) |
292 { | 294 { |
293 } | 295 } |
294 | 296 |
295 const RefPtr<IDBBackingStore> m_backingStore; | 297 const RefPtr<IDBBackingStore> m_backingStore; |
296 const int64_t m_databaseId; | 298 const int64_t m_databaseId; |
297 const IDBObjectStoreMetadata m_objectStore; | 299 const IDBObjectStoreMetadata m_objectStore; |
298 const RefPtr<SharedBuffer> m_value; | 300 const RefPtr<SharedBuffer> m_value; |
299 const RefPtr<IDBKey> m_key; | 301 const RefPtr<IDBKey> m_key; |
300 const IDBDatabaseBackendInterface::PutMode m_putMode; | 302 const IDBDatabaseBackendInterface::PutMode m_putMode; |
301 const RefPtr<IDBCallbacks> m_callbacks; | 303 const Persistent<IDBCallbacks> m_callbacks; |
302 const Vector<int64_t> m_indexIds; | 304 const Vector<int64_t> m_indexIds; |
303 const Vector<IDBDatabaseBackendInterface::IndexKeys> m_indexKeys; | 305 const Vector<IDBDatabaseBackendInterface::IndexKeys> m_indexKeys; |
304 }; | 306 }; |
305 | 307 |
306 class SetIndexesReadyOperation : public IDBTransactionBackendImpl::Operation { | 308 class SetIndexesReadyOperation : public IDBTransactionBackendImpl::Operation { |
307 public: | 309 public: |
308 static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(size_t indexC
ount) | 310 static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(size_t indexC
ount) |
309 { | 311 { |
310 return adoptPtr(new SetIndexesReadyOperation(indexCount)); | 312 return adoptPtr(new SetIndexesReadyOperation(indexCount)); |
311 } | 313 } |
312 virtual void perform(IDBTransactionBackendImpl*); | 314 virtual void perform(IDBTransactionBackendImpl*); |
313 private: | 315 private: |
314 SetIndexesReadyOperation(size_t indexCount) | 316 SetIndexesReadyOperation(size_t indexCount) |
315 : m_indexCount(indexCount) | 317 : m_indexCount(indexCount) |
316 { | 318 { |
317 } | 319 } |
318 | 320 |
319 const size_t m_indexCount; | 321 const size_t m_indexCount; |
320 }; | 322 }; |
321 | 323 |
322 class OpenCursorOperation : public IDBTransactionBackendImpl::Operation { | 324 class OpenCursorOperation : public IDBTransactionBackendImpl::Operation { |
323 public: | 325 public: |
324 static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<ID
BBackingStore> backingStore, int64_t databaseId, int64_t objectStoreId, int64_t
indexId, PassRefPtr<IDBKeyRange> keyRange, IndexedDB::CursorDirection direction,
IndexedDB::CursorType cursorType, IDBDatabaseBackendInterface::TaskType taskTyp
e, PassRefPtr<IDBCallbacks> callbacks) | 326 static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<ID
BBackingStore> backingStore, int64_t databaseId, int64_t objectStoreId, int64_t
indexId, PassRefPtr<IDBKeyRange> keyRange, IndexedDB::CursorDirection direction,
IndexedDB::CursorType cursorType, IDBDatabaseBackendInterface::TaskType taskTyp
e, IDBCallbacks* callbacks) |
325 { | 327 { |
326 return adoptPtr(new OpenCursorOperation(backingStore, databaseId, object
StoreId, indexId, keyRange, direction, cursorType, taskType, callbacks)); | 328 return adoptPtr(new OpenCursorOperation(backingStore, databaseId, object
StoreId, indexId, keyRange, direction, cursorType, taskType, callbacks)); |
327 } | 329 } |
328 virtual void perform(IDBTransactionBackendImpl*); | 330 virtual void perform(IDBTransactionBackendImpl*); |
329 private: | 331 private: |
330 OpenCursorOperation(PassRefPtr<IDBBackingStore> backingStore, int64_t databa
seId, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange,
IndexedDB::CursorDirection direction, IndexedDB::CursorType cursorType, IDBDatab
aseBackendInterface::TaskType taskType, PassRefPtr<IDBCallbacks> callbacks) | 332 OpenCursorOperation(PassRefPtr<IDBBackingStore> backingStore, int64_t databa
seId, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange,
IndexedDB::CursorDirection direction, IndexedDB::CursorType cursorType, IDBDatab
aseBackendInterface::TaskType taskType, IDBCallbacks* callbacks) |
331 : m_backingStore(backingStore) | 333 : m_backingStore(backingStore) |
332 , m_databaseId(databaseId) | 334 , m_databaseId(databaseId) |
333 , m_objectStoreId(objectStoreId) | 335 , m_objectStoreId(objectStoreId) |
334 , m_indexId(indexId) | 336 , m_indexId(indexId) |
335 , m_keyRange(keyRange) | 337 , m_keyRange(keyRange) |
336 , m_direction(direction) | 338 , m_direction(direction) |
337 , m_cursorType(cursorType) | 339 , m_cursorType(cursorType) |
338 , m_taskType(taskType) | 340 , m_taskType(taskType) |
339 , m_callbacks(callbacks) | 341 , m_callbacks(callbacks) |
340 { | 342 { |
341 } | 343 } |
342 | 344 |
343 const RefPtr<IDBBackingStore> m_backingStore; | 345 const RefPtr<IDBBackingStore> m_backingStore; |
344 const int64_t m_databaseId; | 346 const int64_t m_databaseId; |
345 const int64_t m_objectStoreId; | 347 const int64_t m_objectStoreId; |
346 const int64_t m_indexId; | 348 const int64_t m_indexId; |
347 const PassRefPtr<IDBKeyRange> m_keyRange; | 349 const PassRefPtr<IDBKeyRange> m_keyRange; |
348 const IndexedDB::CursorDirection m_direction; | 350 const IndexedDB::CursorDirection m_direction; |
349 const IndexedDB::CursorType m_cursorType; | 351 const IndexedDB::CursorType m_cursorType; |
350 const IDBDatabaseBackendInterface::TaskType m_taskType; | 352 const IDBDatabaseBackendInterface::TaskType m_taskType; |
351 const RefPtr<IDBCallbacks> m_callbacks; | 353 const Persistent<IDBCallbacks> m_callbacks; |
352 }; | 354 }; |
353 | 355 |
354 class CountOperation : public IDBTransactionBackendImpl::Operation { | 356 class CountOperation : public IDBTransactionBackendImpl::Operation { |
355 public: | 357 public: |
356 static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<ID
BBackingStore> backingStore, int64_t databaseId, int64_t objectStoreId, int64_t
indexId, PassRefPtr<IDBKeyRange> keyRange, PassRefPtr<IDBCallbacks> callbacks) | 358 static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<ID
BBackingStore> backingStore, int64_t databaseId, int64_t objectStoreId, int64_t
indexId, PassRefPtr<IDBKeyRange> keyRange, IDBCallbacks* callbacks) |
357 { | 359 { |
358 return adoptPtr(new CountOperation(backingStore, databaseId, objectStore
Id, indexId, keyRange, callbacks)); | 360 return adoptPtr(new CountOperation(backingStore, databaseId, objectStore
Id, indexId, keyRange, callbacks)); |
359 } | 361 } |
360 virtual void perform(IDBTransactionBackendImpl*); | 362 virtual void perform(IDBTransactionBackendImpl*); |
361 private: | 363 private: |
362 CountOperation(PassRefPtr<IDBBackingStore> backingStore, int64_t databaseId,
int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, PassR
efPtr<IDBCallbacks> callbacks) | 364 CountOperation(PassRefPtr<IDBBackingStore> backingStore, int64_t databaseId,
int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, IDBCa
llbacks* callbacks) |
363 : m_backingStore(backingStore) | 365 : m_backingStore(backingStore) |
364 , m_databaseId(databaseId) | 366 , m_databaseId(databaseId) |
365 , m_objectStoreId(objectStoreId) | 367 , m_objectStoreId(objectStoreId) |
366 , m_indexId(indexId) | 368 , m_indexId(indexId) |
367 , m_keyRange(keyRange) | 369 , m_keyRange(keyRange) |
368 , m_callbacks(callbacks) | 370 , m_callbacks(callbacks) |
369 { | 371 { |
370 } | 372 } |
371 | 373 |
372 const RefPtr<IDBBackingStore> m_backingStore; | 374 const RefPtr<IDBBackingStore> m_backingStore; |
373 const int64_t m_databaseId; | 375 const int64_t m_databaseId; |
374 const int64_t m_objectStoreId; | 376 const int64_t m_objectStoreId; |
375 const int64_t m_indexId; | 377 const int64_t m_indexId; |
376 const RefPtr<IDBKeyRange> m_keyRange; | 378 const RefPtr<IDBKeyRange> m_keyRange; |
377 const RefPtr<IDBCallbacks> m_callbacks; | 379 const Persistent<IDBCallbacks> m_callbacks; |
378 }; | 380 }; |
379 | 381 |
380 class DeleteRangeOperation : public IDBTransactionBackendImpl::Operation { | 382 class DeleteRangeOperation : public IDBTransactionBackendImpl::Operation { |
381 public: | 383 public: |
382 static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<ID
BBackingStore> backingStore, int64_t databaseId, int64_t objectStoreId, PassRefP
tr<IDBKeyRange> keyRange, PassRefPtr<IDBCallbacks> callbacks) | 384 static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<ID
BBackingStore> backingStore, int64_t databaseId, int64_t objectStoreId, PassRefP
tr<IDBKeyRange> keyRange, IDBCallbacks* callbacks) |
383 { | 385 { |
384 return adoptPtr(new DeleteRangeOperation(backingStore, databaseId, objec
tStoreId, keyRange, callbacks)); | 386 return adoptPtr(new DeleteRangeOperation(backingStore, databaseId, objec
tStoreId, keyRange, callbacks)); |
385 } | 387 } |
386 virtual void perform(IDBTransactionBackendImpl*); | 388 virtual void perform(IDBTransactionBackendImpl*); |
387 private: | 389 private: |
388 DeleteRangeOperation(PassRefPtr<IDBBackingStore> backingStore, int64_t datab
aseId, int64_t objectStoreId, PassRefPtr<IDBKeyRange> keyRange, PassRefPtr<IDBCa
llbacks> callbacks) | 390 DeleteRangeOperation(PassRefPtr<IDBBackingStore> backingStore, int64_t datab
aseId, int64_t objectStoreId, PassRefPtr<IDBKeyRange> keyRange, IDBCallbacks* ca
llbacks) |
389 : m_backingStore(backingStore) | 391 : m_backingStore(backingStore) |
390 , m_databaseId(databaseId) | 392 , m_databaseId(databaseId) |
391 , m_objectStoreId(objectStoreId) | 393 , m_objectStoreId(objectStoreId) |
392 , m_keyRange(keyRange) | 394 , m_keyRange(keyRange) |
393 , m_callbacks(callbacks) | 395 , m_callbacks(callbacks) |
394 { | 396 { |
395 } | 397 } |
396 | 398 |
397 const RefPtr<IDBBackingStore> m_backingStore; | 399 const RefPtr<IDBBackingStore> m_backingStore; |
398 const int64_t m_databaseId; | 400 const int64_t m_databaseId; |
399 const int64_t m_objectStoreId; | 401 const int64_t m_objectStoreId; |
400 const RefPtr<IDBKeyRange> m_keyRange; | 402 const RefPtr<IDBKeyRange> m_keyRange; |
401 const RefPtr<IDBCallbacks> m_callbacks; | 403 const Persistent<IDBCallbacks> m_callbacks; |
402 }; | 404 }; |
403 | 405 |
404 class ClearOperation : public IDBTransactionBackendImpl::Operation { | 406 class ClearOperation : public IDBTransactionBackendImpl::Operation { |
405 public: | 407 public: |
406 static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<ID
BBackingStore> backingStore, int64_t databaseId, int64_t objectStoreId, PassRefP
tr<IDBCallbacks> callbacks) | 408 static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<ID
BBackingStore> backingStore, int64_t databaseId, int64_t objectStoreId, IDBCallb
acks* callbacks) |
407 { | 409 { |
408 return adoptPtr(new ClearOperation(backingStore, databaseId, objectStore
Id, callbacks)); | 410 return adoptPtr(new ClearOperation(backingStore, databaseId, objectStore
Id, callbacks)); |
409 } | 411 } |
410 virtual void perform(IDBTransactionBackendImpl*); | 412 virtual void perform(IDBTransactionBackendImpl*); |
411 private: | 413 private: |
412 ClearOperation(PassRefPtr<IDBBackingStore> backingStore, int64_t databaseId,
int64_t objectStoreId, PassRefPtr<IDBCallbacks> callbacks) | 414 ClearOperation(PassRefPtr<IDBBackingStore> backingStore, int64_t databaseId,
int64_t objectStoreId, IDBCallbacks* callbacks) |
413 : m_backingStore(backingStore) | 415 : m_backingStore(backingStore) |
414 , m_databaseId(databaseId) | 416 , m_databaseId(databaseId) |
415 , m_objectStoreId(objectStoreId) | 417 , m_objectStoreId(objectStoreId) |
416 , m_callbacks(callbacks) | 418 , m_callbacks(callbacks) |
417 { | 419 { |
418 } | 420 } |
419 | 421 |
420 const RefPtr<IDBBackingStore> m_backingStore; | 422 const RefPtr<IDBBackingStore> m_backingStore; |
421 const int64_t m_databaseId; | 423 const int64_t m_databaseId; |
422 const int64_t m_objectStoreId; | 424 const int64_t m_objectStoreId; |
423 const RefPtr<IDBCallbacks> m_callbacks; | 425 const Persistent<IDBCallbacks> m_callbacks; |
424 }; | 426 }; |
425 | 427 |
426 class IDBDatabaseBackendImpl::PendingOpenCall { | 428 class IDBDatabaseBackendImpl::PendingOpenCall { |
427 public: | 429 public: |
428 static PassOwnPtr<PendingOpenCall> create(PassRefPtr<IDBCallbacks> callbacks
, PassRefPtr<IDBDatabaseCallbacks> databaseCallbacks, int64_t transactionId, int
64_t version) | 430 static PassOwnPtr<PendingOpenCall> create(IDBCallbacks* callbacks, IDBDataba
seCallbacks* databaseCallbacks, int64_t transactionId, int64_t version) |
429 { | 431 { |
430 return adoptPtr(new PendingOpenCall(callbacks, databaseCallbacks, transa
ctionId, version)); | 432 return adoptPtr(new PendingOpenCall(callbacks, databaseCallbacks, transa
ctionId, version)); |
431 } | 433 } |
432 PassRefPtr<IDBCallbacks> callbacks() { return m_callbacks; } | 434 IDBCallbacks* callbacks() { return m_callbacks; } |
433 PassRefPtr<IDBDatabaseCallbacks> databaseCallbacks() { return m_databaseCall
backs; } | 435 IDBDatabaseCallbacks* databaseCallbacks() { return m_databaseCallbacks; } |
434 int64_t version() { return m_version; } | 436 int64_t version() { return m_version; } |
435 int64_t transactionId() const { return m_transactionId; } | 437 int64_t transactionId() const { return m_transactionId; } |
436 | 438 |
437 private: | 439 private: |
438 PendingOpenCall(PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<IDBDatabaseCa
llbacks> databaseCallbacks, int64_t transactionId, int64_t version) | 440 PendingOpenCall(IDBCallbacks* callbacks, IDBDatabaseCallbacks* databaseCallb
acks, int64_t transactionId, int64_t version) |
439 : m_callbacks(callbacks) | 441 : m_callbacks(callbacks) |
440 , m_databaseCallbacks(databaseCallbacks) | 442 , m_databaseCallbacks(databaseCallbacks) |
441 , m_version(version) | 443 , m_version(version) |
442 , m_transactionId(transactionId) | 444 , m_transactionId(transactionId) |
443 { | 445 { |
444 } | 446 } |
445 RefPtr<IDBCallbacks> m_callbacks; | 447 Persistent<IDBCallbacks> m_callbacks; |
446 RefPtr<IDBDatabaseCallbacks> m_databaseCallbacks; | 448 Persistent<IDBDatabaseCallbacks> m_databaseCallbacks; |
447 int64_t m_version; | 449 int64_t m_version; |
448 const int64_t m_transactionId; | 450 const int64_t m_transactionId; |
449 }; | 451 }; |
450 | 452 |
451 class IDBDatabaseBackendImpl::PendingDeleteCall { | 453 class IDBDatabaseBackendImpl::PendingDeleteCall { |
452 public: | 454 public: |
453 static PassOwnPtr<PendingDeleteCall> create(PassRefPtr<IDBCallbacks> callbac
ks) | 455 static PassOwnPtr<PendingDeleteCall> create(IDBCallbacks* callbacks) |
454 { | 456 { |
455 return adoptPtr(new PendingDeleteCall(callbacks)); | 457 return adoptPtr(new PendingDeleteCall(callbacks)); |
456 } | 458 } |
457 PassRefPtr<IDBCallbacks> callbacks() { return m_callbacks; } | 459 IDBCallbacks* callbacks() { return m_callbacks; } |
458 | 460 |
459 private: | 461 private: |
460 PendingDeleteCall(PassRefPtr<IDBCallbacks> callbacks) | 462 PendingDeleteCall(IDBCallbacks* callbacks) |
461 : m_callbacks(callbacks) | 463 : m_callbacks(callbacks) |
462 { | 464 { |
463 } | 465 } |
464 RefPtr<IDBCallbacks> m_callbacks; | 466 Persistent<IDBCallbacks> m_callbacks; |
465 }; | 467 }; |
466 | 468 |
467 PassRefPtr<IDBDatabaseBackendImpl> IDBDatabaseBackendImpl::create(const String&
name, IDBBackingStore* database, IDBFactoryBackendImpl* factory, const String& u
niqueIdentifier) | 469 IDBDatabaseBackendImpl* IDBDatabaseBackendImpl::create(const String& name, IDBBa
ckingStore* database, IDBFactoryBackendImpl* factory, const String& uniqueIdenti
fier) |
468 { | 470 { |
469 RefPtr<IDBDatabaseBackendImpl> backend = adoptRef(new IDBDatabaseBackendImpl
(name, database, factory, uniqueIdentifier)); | 471 IDBDatabaseBackendImpl* backend = new IDBDatabaseBackendImpl(name, database,
factory, uniqueIdentifier); |
470 if (!backend->openInternal()) | 472 if (!backend->openInternal()) |
471 return 0; | 473 return 0; |
472 return backend.release(); | 474 return backend; |
473 } | 475 } |
474 | 476 |
475 namespace { | 477 namespace { |
476 const char* NoStringVersion = ""; | 478 const char* NoStringVersion = ""; |
477 } | 479 } |
478 | 480 |
479 IDBDatabaseBackendImpl::IDBDatabaseBackendImpl(const String& name, IDBBackingSto
re* backingStore, IDBFactoryBackendImpl* factory, const String& uniqueIdentifier
) | 481 IDBDatabaseBackendImpl::IDBDatabaseBackendImpl(const String& name, IDBBackingSto
re* backingStore, IDBFactoryBackendImpl* factory, const String& uniqueIdentifier
) |
480 : m_backingStore(backingStore) | 482 : m_backingStore(backingStore) |
481 , m_metadata(name, InvalidId, NoStringVersion, IDBDatabaseMetadata::NoIntVer
sion, InvalidId) | 483 , m_metadata(name, InvalidId, NoStringVersion, IDBDatabaseMetadata::NoIntVer
sion, InvalidId) |
482 , m_identifier(uniqueIdentifier) | 484 , m_identifier(uniqueIdentifier) |
(...skipping 192 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
675 m_transactions.get(transactionId)->abort(); | 677 m_transactions.get(transactionId)->abort(); |
676 } | 678 } |
677 | 679 |
678 void IDBDatabaseBackendImpl::abort(int64_t transactionId, PassRefPtr<IDBDatabase
Error> error) | 680 void IDBDatabaseBackendImpl::abort(int64_t transactionId, PassRefPtr<IDBDatabase
Error> error) |
679 { | 681 { |
680 // If the transaction is unknown, then it has already been aborted by the ba
ckend before this call so it is safe to ignore it. | 682 // If the transaction is unknown, then it has already been aborted by the ba
ckend before this call so it is safe to ignore it. |
681 if (m_transactions.contains(transactionId)) | 683 if (m_transactions.contains(transactionId)) |
682 m_transactions.get(transactionId)->abort(error); | 684 m_transactions.get(transactionId)->abort(error); |
683 } | 685 } |
684 | 686 |
685 void IDBDatabaseBackendImpl::get(int64_t transactionId, int64_t objectStoreId, i
nt64_t indexId, PassRefPtr<IDBKeyRange> keyRange, bool keyOnly, PassRefPtr<IDBCa
llbacks> callbacks) | 687 void IDBDatabaseBackendImpl::get(int64_t transactionId, int64_t objectStoreId, i
nt64_t indexId, PassRefPtr<IDBKeyRange> keyRange, bool keyOnly, IDBCallbacks* ca
llbacks) |
686 { | 688 { |
687 IDB_TRACE("IDBDatabaseBackendImpl::get"); | 689 IDB_TRACE("IDBDatabaseBackendImpl::get"); |
688 IDBTransactionBackendImpl* transaction = m_transactions.get(transactionId); | 690 IDBTransactionBackendImpl* transaction = m_transactions.get(transactionId); |
689 if (!transaction) | 691 if (!transaction) |
690 return; | 692 return; |
691 | 693 |
692 transaction->scheduleTask(GetOperation::create(m_backingStore, m_metadata, o
bjectStoreId, indexId, keyRange, keyOnly ? IndexedDB::CursorKeyOnly : IndexedDB:
:CursorKeyAndValue, callbacks)); | 694 transaction->scheduleTask(GetOperation::create(m_backingStore, m_metadata, o
bjectStoreId, indexId, keyRange, keyOnly ? IndexedDB::CursorKeyOnly : IndexedDB:
:CursorKeyAndValue, callbacks)); |
693 } | 695 } |
694 | 696 |
695 void GetOperation::perform(IDBTransactionBackendImpl* transaction) | 697 void GetOperation::perform(IDBTransactionBackendImpl* transaction) |
(...skipping 81 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
777 m_callbacks->onSuccess(); | 779 m_callbacks->onSuccess(); |
778 return; | 780 return; |
779 } | 781 } |
780 if (m_autoIncrement && !m_keyPath.isNull()) { | 782 if (m_autoIncrement && !m_keyPath.isNull()) { |
781 m_callbacks->onSuccess(SharedBuffer::adoptVector(value), primaryKey, m_k
eyPath); | 783 m_callbacks->onSuccess(SharedBuffer::adoptVector(value), primaryKey, m_k
eyPath); |
782 return; | 784 return; |
783 } | 785 } |
784 m_callbacks->onSuccess(SharedBuffer::adoptVector(value)); | 786 m_callbacks->onSuccess(SharedBuffer::adoptVector(value)); |
785 } | 787 } |
786 | 788 |
787 void IDBDatabaseBackendImpl::put(int64_t transactionId, int64_t objectStoreId, P
assRefPtr<SharedBuffer> value, PassRefPtr<IDBKey> key, PutMode putMode, PassRefP
tr<IDBCallbacks> callbacks, const Vector<int64_t>& indexIds, const Vector<IndexK
eys>& indexKeys) | 789 void IDBDatabaseBackendImpl::put(int64_t transactionId, int64_t objectStoreId, P
assRefPtr<SharedBuffer> value, PassRefPtr<IDBKey> key, PutMode putMode, IDBCallb
acks* callbacks, const Vector<int64_t>& indexIds, const Vector<IndexKeys>& index
Keys) |
788 { | 790 { |
789 IDB_TRACE("IDBDatabaseBackendImpl::put"); | 791 IDB_TRACE("IDBDatabaseBackendImpl::put"); |
790 IDBTransactionBackendImpl* transaction = m_transactions.get(transactionId); | 792 IDBTransactionBackendImpl* transaction = m_transactions.get(transactionId); |
791 if (!transaction) | 793 if (!transaction) |
792 return; | 794 return; |
793 ASSERT(transaction->mode() != IndexedDB::TransactionReadOnly); | 795 ASSERT(transaction->mode() != IndexedDB::TransactionReadOnly); |
794 | 796 |
795 const IDBObjectStoreMetadata objectStoreMetadata = m_metadata.objectStores.g
et(objectStoreId); | 797 const IDBObjectStoreMetadata objectStoreMetadata = m_metadata.objectStores.g
et(objectStoreId); |
796 | 798 |
797 ASSERT(objectStoreMetadata.autoIncrement || key.get()); | 799 ASSERT(objectStoreMetadata.autoIncrement || key.get()); |
(...skipping 128 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
926 transaction->scheduleTask(IDBDatabaseBackendInterface::PreemptiveTask, SetIn
dexesReadyOperation::create(indexIds.size())); | 928 transaction->scheduleTask(IDBDatabaseBackendInterface::PreemptiveTask, SetIn
dexesReadyOperation::create(indexIds.size())); |
927 } | 929 } |
928 | 930 |
929 void SetIndexesReadyOperation::perform(IDBTransactionBackendImpl* transaction) | 931 void SetIndexesReadyOperation::perform(IDBTransactionBackendImpl* transaction) |
930 { | 932 { |
931 IDB_TRACE("SetIndexesReadyOperation"); | 933 IDB_TRACE("SetIndexesReadyOperation"); |
932 for (size_t i = 0; i < m_indexCount; ++i) | 934 for (size_t i = 0; i < m_indexCount; ++i) |
933 transaction->didCompletePreemptiveEvent(); | 935 transaction->didCompletePreemptiveEvent(); |
934 } | 936 } |
935 | 937 |
936 void IDBDatabaseBackendImpl::openCursor(int64_t transactionId, int64_t objectSto
reId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, IndexedDB::CursorDirect
ion direction, bool keyOnly, TaskType taskType, PassRefPtr<IDBCallbacks> callbac
ks) | 938 void IDBDatabaseBackendImpl::openCursor(int64_t transactionId, int64_t objectSto
reId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, IndexedDB::CursorDirect
ion direction, bool keyOnly, TaskType taskType, IDBCallbacks* callbacks) |
937 { | 939 { |
938 IDB_TRACE("IDBDatabaseBackendImpl::openCursor"); | 940 IDB_TRACE("IDBDatabaseBackendImpl::openCursor"); |
939 IDBTransactionBackendImpl* transaction = m_transactions.get(transactionId); | 941 IDBTransactionBackendImpl* transaction = m_transactions.get(transactionId); |
940 if (!transaction) | 942 if (!transaction) |
941 return; | 943 return; |
942 | 944 |
943 transaction->scheduleTask(OpenCursorOperation::create(m_backingStore, id(),
objectStoreId, indexId, keyRange, direction, keyOnly ? IndexedDB::CursorKeyOnly
: IndexedDB::CursorKeyAndValue, taskType, callbacks)); | 945 transaction->scheduleTask(OpenCursorOperation::create(m_backingStore, id(),
objectStoreId, indexId, keyRange, direction, keyOnly ? IndexedDB::CursorKeyOnly
: IndexedDB::CursorKeyAndValue, taskType, callbacks)); |
944 } | 946 } |
945 | 947 |
946 void OpenCursorOperation::perform(IDBTransactionBackendImpl* transaction) | 948 void OpenCursorOperation::perform(IDBTransactionBackendImpl* transaction) |
(...skipping 22 matching lines...) Expand all Loading... |
969 if (!backingStoreCursor) { | 971 if (!backingStoreCursor) { |
970 m_callbacks->onSuccess(static_cast<SharedBuffer*>(0)); | 972 m_callbacks->onSuccess(static_cast<SharedBuffer*>(0)); |
971 return; | 973 return; |
972 } | 974 } |
973 | 975 |
974 IDBDatabaseBackendInterface::TaskType taskType(static_cast<IDBDatabaseBacken
dInterface::TaskType>(m_taskType)); | 976 IDBDatabaseBackendInterface::TaskType taskType(static_cast<IDBDatabaseBacken
dInterface::TaskType>(m_taskType)); |
975 RefPtr<IDBCursorBackendImpl> cursor = IDBCursorBackendImpl::create(backingSt
oreCursor.get(), m_cursorType, taskType, transaction, m_objectStoreId); | 977 RefPtr<IDBCursorBackendImpl> cursor = IDBCursorBackendImpl::create(backingSt
oreCursor.get(), m_cursorType, taskType, transaction, m_objectStoreId); |
976 m_callbacks->onSuccess(cursor, cursor->key(), cursor->primaryKey(), cursor->
value()); | 978 m_callbacks->onSuccess(cursor, cursor->key(), cursor->primaryKey(), cursor->
value()); |
977 } | 979 } |
978 | 980 |
979 void IDBDatabaseBackendImpl::count(int64_t transactionId, int64_t objectStoreId,
int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, PassRefPtr<IDBCallbacks> cal
lbacks) | 981 void IDBDatabaseBackendImpl::count(int64_t transactionId, int64_t objectStoreId,
int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, IDBCallbacks* callbacks) |
980 { | 982 { |
981 IDB_TRACE("IDBDatabaseBackendImpl::count"); | 983 IDB_TRACE("IDBDatabaseBackendImpl::count"); |
982 IDBTransactionBackendImpl* transaction = m_transactions.get(transactionId); | 984 IDBTransactionBackendImpl* transaction = m_transactions.get(transactionId); |
983 if (!transaction) | 985 if (!transaction) |
984 return; | 986 return; |
985 | 987 |
986 ASSERT(m_metadata.objectStores.contains(objectStoreId)); | 988 ASSERT(m_metadata.objectStores.contains(objectStoreId)); |
987 transaction->scheduleTask(CountOperation::create(m_backingStore, id(), objec
tStoreId, indexId, keyRange, callbacks)); | 989 transaction->scheduleTask(CountOperation::create(m_backingStore, id(), objec
tStoreId, indexId, keyRange, callbacks)); |
988 } | 990 } |
989 | 991 |
(...skipping 12 matching lines...) Expand all Loading... |
1002 return; | 1004 return; |
1003 } | 1005 } |
1004 | 1006 |
1005 do { | 1007 do { |
1006 ++count; | 1008 ++count; |
1007 } while (backingStoreCursor->continueFunction(0)); | 1009 } while (backingStoreCursor->continueFunction(0)); |
1008 | 1010 |
1009 m_callbacks->onSuccess(count); | 1011 m_callbacks->onSuccess(count); |
1010 } | 1012 } |
1011 | 1013 |
1012 void IDBDatabaseBackendImpl::deleteRange(int64_t transactionId, int64_t objectSt
oreId, PassRefPtr<IDBKeyRange> keyRange, PassRefPtr<IDBCallbacks> callbacks) | 1014 void IDBDatabaseBackendImpl::deleteRange(int64_t transactionId, int64_t objectSt
oreId, PassRefPtr<IDBKeyRange> keyRange, IDBCallbacks* callbacks) |
1013 { | 1015 { |
1014 IDB_TRACE("IDBDatabaseBackendImpl::deleteRange"); | 1016 IDB_TRACE("IDBDatabaseBackendImpl::deleteRange"); |
1015 IDBTransactionBackendImpl* transaction = m_transactions.get(transactionId); | 1017 IDBTransactionBackendImpl* transaction = m_transactions.get(transactionId); |
1016 if (!transaction) | 1018 if (!transaction) |
1017 return; | 1019 return; |
1018 ASSERT(transaction->mode() != IndexedDB::TransactionReadOnly); | 1020 ASSERT(transaction->mode() != IndexedDB::TransactionReadOnly); |
1019 | 1021 |
1020 transaction->scheduleTask(DeleteRangeOperation::create(m_backingStore, id(),
objectStoreId, keyRange, callbacks)); | 1022 transaction->scheduleTask(DeleteRangeOperation::create(m_backingStore, id(),
objectStoreId, keyRange, callbacks)); |
1021 } | 1023 } |
1022 | 1024 |
1023 void DeleteRangeOperation::perform(IDBTransactionBackendImpl* transaction) | 1025 void DeleteRangeOperation::perform(IDBTransactionBackendImpl* transaction) |
1024 { | 1026 { |
1025 IDB_TRACE("DeleteRangeOperation"); | 1027 IDB_TRACE("DeleteRangeOperation"); |
1026 RefPtr<IDBBackingStore::Cursor> backingStoreCursor = m_backingStore->openObj
ectStoreCursor(transaction->backingStoreTransaction(), m_databaseId, m_objectSto
reId, m_keyRange.get(), IndexedDB::CursorNext); | 1028 RefPtr<IDBBackingStore::Cursor> backingStoreCursor = m_backingStore->openObj
ectStoreCursor(transaction->backingStoreTransaction(), m_databaseId, m_objectSto
reId, m_keyRange.get(), IndexedDB::CursorNext); |
1027 if (backingStoreCursor) { | 1029 if (backingStoreCursor) { |
1028 do { | 1030 do { |
1029 if (!m_backingStore->deleteRecord(transaction->backingStoreTransacti
on(), m_databaseId, m_objectStoreId, backingStoreCursor->recordIdentifier())) { | 1031 if (!m_backingStore->deleteRecord(transaction->backingStoreTransacti
on(), m_databaseId, m_objectStoreId, backingStoreCursor->recordIdentifier())) { |
1030 m_callbacks->onError(IDBDatabaseError::create(IDBDatabaseExcepti
on::UnknownError, "Error deleting data in range")); | 1032 m_callbacks->onError(IDBDatabaseError::create(IDBDatabaseExcepti
on::UnknownError, "Error deleting data in range")); |
1031 return; | 1033 return; |
1032 } | 1034 } |
1033 } while (backingStoreCursor->continueFunction(0)); | 1035 } while (backingStoreCursor->continueFunction(0)); |
1034 } | 1036 } |
1035 | 1037 |
1036 m_callbacks->onSuccess(); | 1038 m_callbacks->onSuccess(); |
1037 } | 1039 } |
1038 | 1040 |
1039 void IDBDatabaseBackendImpl::clear(int64_t transactionId, int64_t objectStoreId,
PassRefPtr<IDBCallbacks> callbacks) | 1041 void IDBDatabaseBackendImpl::clear(int64_t transactionId, int64_t objectStoreId,
IDBCallbacks* callbacks) |
1040 { | 1042 { |
1041 IDB_TRACE("IDBDatabaseBackendImpl::clear"); | 1043 IDB_TRACE("IDBDatabaseBackendImpl::clear"); |
1042 IDBTransactionBackendImpl* transaction = m_transactions.get(transactionId); | 1044 IDBTransactionBackendImpl* transaction = m_transactions.get(transactionId); |
1043 if (!transaction) | 1045 if (!transaction) |
1044 return; | 1046 return; |
1045 ASSERT(transaction->mode() != IndexedDB::TransactionReadOnly); | 1047 ASSERT(transaction->mode() != IndexedDB::TransactionReadOnly); |
1046 | 1048 |
1047 transaction->scheduleTask(ClearOperation::create(m_backingStore, id(), objec
tStoreId, callbacks)); | 1049 transaction->scheduleTask(ClearOperation::create(m_backingStore, id(), objec
tStoreId, callbacks)); |
1048 } | 1050 } |
1049 | 1051 |
(...skipping 115 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1165 | 1167 |
1166 // Open calls can be requeued if an open call started a version change trans
action. | 1168 // Open calls can be requeued if an open call started a version change trans
action. |
1167 Deque<OwnPtr<PendingOpenCall> > pendingOpenCalls; | 1169 Deque<OwnPtr<PendingOpenCall> > pendingOpenCalls; |
1168 m_pendingOpenCalls.swap(pendingOpenCalls); | 1170 m_pendingOpenCalls.swap(pendingOpenCalls); |
1169 while (!pendingOpenCalls.isEmpty()) { | 1171 while (!pendingOpenCalls.isEmpty()) { |
1170 OwnPtr<PendingOpenCall> pendingOpenCall = pendingOpenCalls.takeFirst(); | 1172 OwnPtr<PendingOpenCall> pendingOpenCall = pendingOpenCalls.takeFirst(); |
1171 openConnection(pendingOpenCall->callbacks(), pendingOpenCall->databaseCa
llbacks(), pendingOpenCall->transactionId(), pendingOpenCall->version()); | 1173 openConnection(pendingOpenCall->callbacks(), pendingOpenCall->databaseCa
llbacks(), pendingOpenCall->transactionId(), pendingOpenCall->version()); |
1172 } | 1174 } |
1173 } | 1175 } |
1174 | 1176 |
1175 void IDBDatabaseBackendImpl::createTransaction(int64_t transactionId, PassRefPtr
<IDBDatabaseCallbacks> callbacks, const Vector<int64_t>& objectStoreIds, unsigne
d short mode) | 1177 void IDBDatabaseBackendImpl::createTransaction(int64_t transactionId, IDBDatabas
eCallbacks* callbacks, const Vector<int64_t>& objectStoreIds, unsigned short mod
e) |
1176 { | 1178 { |
1177 RefPtr<IDBTransactionBackendImpl> transaction = IDBTransactionBackendImpl::c
reate(transactionId, callbacks, objectStoreIds, static_cast<IndexedDB::Transacti
onMode>(mode), this); | 1179 RefPtr<IDBTransactionBackendImpl> transaction = IDBTransactionBackendImpl::c
reate(transactionId, callbacks, objectStoreIds, static_cast<IndexedDB::Transacti
onMode>(mode), this); |
1178 ASSERT(!m_transactions.contains(transactionId)); | 1180 ASSERT(!m_transactions.contains(transactionId)); |
1179 m_transactions.add(transactionId, transaction.get()); | 1181 m_transactions.add(transactionId, transaction.get()); |
1180 } | 1182 } |
1181 | 1183 |
1182 void IDBDatabaseBackendImpl::openConnection(PassRefPtr<IDBCallbacks> prpCallback
s, PassRefPtr<IDBDatabaseCallbacks> prpDatabaseCallbacks, int64_t transactionId,
int64_t version) | 1184 void IDBDatabaseBackendImpl::openConnection(IDBCallbacks* callbacks, IDBDatabase
Callbacks* databaseCallbacks, int64_t transactionId, int64_t version) |
1183 { | 1185 { |
1184 ASSERT(m_backingStore.get()); | 1186 ASSERT(m_backingStore.get()); |
1185 RefPtr<IDBCallbacks> callbacks = prpCallbacks; | |
1186 RefPtr<IDBDatabaseCallbacks> databaseCallbacks = prpDatabaseCallbacks; | |
1187 | 1187 |
1188 if (!m_pendingDeleteCalls.isEmpty() || m_runningVersionChangeTransaction) { | 1188 if (!m_pendingDeleteCalls.isEmpty() || m_runningVersionChangeTransaction) { |
1189 m_pendingOpenCalls.append(PendingOpenCall::create(callbacks, databaseCal
lbacks, transactionId, version)); | 1189 m_pendingOpenCalls.append(PendingOpenCall::create(callbacks, databaseCal
lbacks, transactionId, version)); |
1190 return; | 1190 return; |
1191 } | 1191 } |
1192 | 1192 |
1193 if (m_metadata.id == InvalidId) { | 1193 if (m_metadata.id == InvalidId) { |
1194 // The database was deleted then immediately re-opened; openInternal() r
ecreates it in the backing store. | 1194 // The database was deleted then immediately re-opened; openInternal() r
ecreates it in the backing store. |
1195 if (openInternal()) | 1195 if (openInternal()) |
1196 ASSERT(m_metadata.intVersion == IDBDatabaseMetadata::NoIntVersion); | 1196 ASSERT(m_metadata.intVersion == IDBDatabaseMetadata::NoIntVersion); |
(...skipping 16 matching lines...) Expand all Loading... |
1213 // For unit tests only - skip upgrade steps. Calling from script with De
faultIntVersion throws exception. | 1213 // For unit tests only - skip upgrade steps. Calling from script with De
faultIntVersion throws exception. |
1214 ASSERT(WebKit::Platform::current()->unitTestSupport()); | 1214 ASSERT(WebKit::Platform::current()->unitTestSupport()); |
1215 ASSERT(isNewDatabase); | 1215 ASSERT(isNewDatabase); |
1216 m_databaseCallbacksSet.add(databaseCallbacks); | 1216 m_databaseCallbacksSet.add(databaseCallbacks); |
1217 callbacks->onSuccess(this, this->metadata()); | 1217 callbacks->onSuccess(this, this->metadata()); |
1218 return; | 1218 return; |
1219 } | 1219 } |
1220 | 1220 |
1221 if (version == IDBDatabaseMetadata::NoIntVersion) { | 1221 if (version == IDBDatabaseMetadata::NoIntVersion) { |
1222 if (!isNewDatabase) { | 1222 if (!isNewDatabase) { |
1223 m_databaseCallbacksSet.add(RefPtr<IDBDatabaseCallbacks>(databaseCall
backs)); | 1223 m_databaseCallbacksSet.add(databaseCallbacks); |
1224 callbacks->onSuccess(this, this->metadata()); | 1224 callbacks->onSuccess(this, this->metadata()); |
1225 return; | 1225 return; |
1226 } | 1226 } |
1227 // Spec says: If no version is specified and no database exists, set dat
abase version to 1. | 1227 // Spec says: If no version is specified and no database exists, set dat
abase version to 1. |
1228 version = 1; | 1228 version = 1; |
1229 } | 1229 } |
1230 | 1230 |
1231 if (version > m_metadata.intVersion) { | 1231 if (version > m_metadata.intVersion) { |
1232 runIntVersionChangeTransaction(callbacks, databaseCallbacks, transaction
Id, version); | 1232 runIntVersionChangeTransaction(callbacks, databaseCallbacks, transaction
Id, version); |
1233 return; | 1233 return; |
1234 } | 1234 } |
1235 if (version < m_metadata.intVersion) { | 1235 if (version < m_metadata.intVersion) { |
1236 callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::Versio
nError, String::format("The requested version (%lld) is less than the existing v
ersion (%lld).", static_cast<long long>(version), static_cast<long long>(m_metad
ata.intVersion)))); | 1236 callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::Versio
nError, String::format("The requested version (%lld) is less than the existing v
ersion (%lld).", static_cast<long long>(version), static_cast<long long>(m_metad
ata.intVersion)))); |
1237 return; | 1237 return; |
1238 } | 1238 } |
1239 ASSERT(version == m_metadata.intVersion); | 1239 ASSERT(version == m_metadata.intVersion); |
1240 m_databaseCallbacksSet.add(databaseCallbacks); | 1240 m_databaseCallbacksSet.add(databaseCallbacks); |
1241 callbacks->onSuccess(this, this->metadata()); | 1241 callbacks->onSuccess(this, this->metadata()); |
1242 } | 1242 } |
1243 | 1243 |
1244 void IDBDatabaseBackendImpl::runIntVersionChangeTransaction(PassRefPtr<IDBCallba
cks> prpCallbacks, PassRefPtr<IDBDatabaseCallbacks> prpDatabaseCallbacks, int64_
t transactionId, int64_t requestedVersion) | 1244 void IDBDatabaseBackendImpl::runIntVersionChangeTransaction(IDBCallbacks* callba
cks, IDBDatabaseCallbacks* databaseCallbacks, int64_t transactionId, int64_t req
uestedVersion) |
1245 { | 1245 { |
1246 RefPtr<IDBCallbacks> callbacks = prpCallbacks; | |
1247 RefPtr<IDBDatabaseCallbacks> databaseCallbacks = prpDatabaseCallbacks; | |
1248 ASSERT(callbacks); | 1246 ASSERT(callbacks); |
1249 for (DatabaseCallbacksSet::const_iterator it = m_databaseCallbacksSet.begin(
); it != m_databaseCallbacksSet.end(); ++it) { | 1247 for (DatabaseCallbacksSet::const_iterator it = m_databaseCallbacksSet.begin(
); it != m_databaseCallbacksSet.end(); ++it) { |
1250 // Front end ensures the event is not fired at connections that have clo
sePending set. | 1248 // Front end ensures the event is not fired at connections that have clo
sePending set. |
1251 if (*it != databaseCallbacks) | 1249 if (*it != databaseCallbacks) |
1252 (*it)->onVersionChange(m_metadata.intVersion, requestedVersion); | 1250 (*it)->onVersionChange(m_metadata.intVersion, requestedVersion); |
1253 } | 1251 } |
1254 // The spec dictates we wait until all the version change events are | 1252 // The spec dictates we wait until all the version change events are |
1255 // delivered and then check m_databaseCallbacks.empty() before proceeding | 1253 // delivered and then check m_databaseCallbacks.empty() before proceeding |
1256 // or firing a blocked event, but instead we should be consistent with how | 1254 // or firing a blocked event, but instead we should be consistent with how |
1257 // the old setVersion (incorrectly) did it. | 1255 // the old setVersion (incorrectly) did it. |
(...skipping 11 matching lines...) Expand all Loading... |
1269 Vector<int64_t> objectStoreIds; | 1267 Vector<int64_t> objectStoreIds; |
1270 createTransaction(transactionId, databaseCallbacks, objectStoreIds, IndexedD
B::TransactionVersionChange); | 1268 createTransaction(transactionId, databaseCallbacks, objectStoreIds, IndexedD
B::TransactionVersionChange); |
1271 RefPtr<IDBTransactionBackendImpl> transaction = m_transactions.get(transacti
onId); | 1269 RefPtr<IDBTransactionBackendImpl> transaction = m_transactions.get(transacti
onId); |
1272 | 1270 |
1273 transaction->scheduleTask(VersionChangeOperation::create(this, transactionId
, requestedVersion, callbacks, databaseCallbacks), VersionChangeAbortOperation::
create(this, m_metadata.version, m_metadata.intVersion)); | 1271 transaction->scheduleTask(VersionChangeOperation::create(this, transactionId
, requestedVersion, callbacks, databaseCallbacks), VersionChangeAbortOperation::
create(this, m_metadata.version, m_metadata.intVersion)); |
1274 | 1272 |
1275 ASSERT(!m_pendingSecondHalfOpen); | 1273 ASSERT(!m_pendingSecondHalfOpen); |
1276 m_databaseCallbacksSet.add(databaseCallbacks); | 1274 m_databaseCallbacksSet.add(databaseCallbacks); |
1277 } | 1275 } |
1278 | 1276 |
1279 void IDBDatabaseBackendImpl::deleteDatabase(PassRefPtr<IDBCallbacks> prpCallback
s) | 1277 void IDBDatabaseBackendImpl::deleteDatabase(IDBCallbacks* callbacks) |
1280 { | 1278 { |
1281 RefPtr<IDBCallbacks> callbacks = prpCallbacks; | |
1282 if (isDeleteDatabaseBlocked()) { | 1279 if (isDeleteDatabaseBlocked()) { |
1283 for (DatabaseCallbacksSet::const_iterator it = m_databaseCallbacksSet.be
gin(); it != m_databaseCallbacksSet.end(); ++it) { | 1280 for (DatabaseCallbacksSet::const_iterator it = m_databaseCallbacksSet.be
gin(); it != m_databaseCallbacksSet.end(); ++it) { |
1284 // Front end ensures the event is not fired at connections that have
closePending set. | 1281 // Front end ensures the event is not fired at connections that have
closePending set. |
1285 (*it)->onVersionChange(m_metadata.intVersion, IDBDatabaseMetadata::N
oIntVersion); | 1282 (*it)->onVersionChange(m_metadata.intVersion, IDBDatabaseMetadata::N
oIntVersion); |
1286 } | 1283 } |
1287 // FIXME: Only fire onBlocked if there are open connections after the | 1284 // FIXME: Only fire onBlocked if there are open connections after the |
1288 // VersionChangeEvents are received, not just set up to fire. | 1285 // VersionChangeEvents are received, not just set up to fire. |
1289 // https://bugs.webkit.org/show_bug.cgi?id=71130 | 1286 // https://bugs.webkit.org/show_bug.cgi?id=71130 |
1290 callbacks->onBlocked(m_metadata.intVersion); | 1287 callbacks->onBlocked(m_metadata.intVersion); |
1291 m_pendingDeleteCalls.append(PendingDeleteCall::create(callbacks.release(
))); | 1288 m_pendingDeleteCalls.append(PendingDeleteCall::create(callbacks)); |
1292 return; | 1289 return; |
1293 } | 1290 } |
1294 deleteDatabaseFinal(callbacks.release()); | 1291 deleteDatabaseFinal(callbacks); |
1295 } | 1292 } |
1296 | 1293 |
1297 bool IDBDatabaseBackendImpl::isDeleteDatabaseBlocked() | 1294 bool IDBDatabaseBackendImpl::isDeleteDatabaseBlocked() |
1298 { | 1295 { |
1299 return connectionCount(); | 1296 return connectionCount(); |
1300 } | 1297 } |
1301 | 1298 |
1302 void IDBDatabaseBackendImpl::deleteDatabaseFinal(PassRefPtr<IDBCallbacks> callba
cks) | 1299 void IDBDatabaseBackendImpl::deleteDatabaseFinal(IDBCallbacks* callbacks) |
1303 { | 1300 { |
1304 ASSERT(!isDeleteDatabaseBlocked()); | 1301 ASSERT(!isDeleteDatabaseBlocked()); |
1305 ASSERT(m_backingStore); | 1302 ASSERT(m_backingStore); |
1306 if (!m_backingStore->deleteDatabase(m_metadata.name)) { | 1303 if (!m_backingStore->deleteDatabase(m_metadata.name)) { |
1307 callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::Unknow
nError, "Internal error deleting database.")); | 1304 callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::Unknow
nError, "Internal error deleting database.")); |
1308 return; | 1305 return; |
1309 } | 1306 } |
1310 m_metadata.version = NoStringVersion; | 1307 m_metadata.version = NoStringVersion; |
1311 m_metadata.id = InvalidId; | 1308 m_metadata.id = InvalidId; |
1312 m_metadata.intVersion = IDBDatabaseMetadata::NoIntVersion; | 1309 m_metadata.intVersion = IDBDatabaseMetadata::NoIntVersion; |
1313 m_metadata.objectStores.clear(); | 1310 m_metadata.objectStores.clear(); |
1314 callbacks->onSuccess(); | 1311 callbacks->onSuccess(); |
1315 } | 1312 } |
1316 | 1313 |
1317 void IDBDatabaseBackendImpl::close(PassRefPtr<IDBDatabaseCallbacks> prpCallbacks
) | 1314 void IDBDatabaseBackendImpl::close(IDBDatabaseCallbacks* callbacks) |
1318 { | 1315 { |
1319 RefPtr<IDBDatabaseCallbacks> callbacks = prpCallbacks; | |
1320 ASSERT(m_databaseCallbacksSet.contains(callbacks)); | 1316 ASSERT(m_databaseCallbacksSet.contains(callbacks)); |
1321 | 1317 |
1322 // Close outstanding transactions from the closing connection. This can not
happen | 1318 // Close outstanding transactions from the closing connection. This can not
happen |
1323 // if the close is requested by the connection itself as the front-end defer
s | 1319 // if the close is requested by the connection itself as the front-end defer
s |
1324 // the close until all transactions are complete, so something unusual has h
appened | 1320 // the close until all transactions are complete, so something unusual has h
appened |
1325 // e.g. unexpected process termination. | 1321 // e.g. unexpected process termination. |
1326 { | 1322 { |
1327 TransactionMap transactions(m_transactions); | 1323 TransactionMap transactions(m_transactions); |
1328 for (TransactionMap::const_iterator::Values it = transactions.values().b
egin(), end = transactions.values().end(); it != end; ++it) { | 1324 for (TransactionMap::const_iterator::Values it = transactions.values().b
egin(), end = transactions.values().end(); it != end; ++it) { |
1329 if ((*it)->connection() == callbacks) | 1325 if ((*it)->connection() == callbacks) |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1378 } | 1374 } |
1379 | 1375 |
1380 void IDBDatabaseBackendImpl::VersionChangeAbortOperation::perform(IDBTransaction
BackendImpl* transaction) | 1376 void IDBDatabaseBackendImpl::VersionChangeAbortOperation::perform(IDBTransaction
BackendImpl* transaction) |
1381 { | 1377 { |
1382 IDB_TRACE("VersionChangeAbortOperation"); | 1378 IDB_TRACE("VersionChangeAbortOperation"); |
1383 ASSERT(!transaction); | 1379 ASSERT(!transaction); |
1384 m_database->m_metadata.version = m_previousVersion; | 1380 m_database->m_metadata.version = m_previousVersion; |
1385 m_database->m_metadata.intVersion = m_previousIntVersion; | 1381 m_database->m_metadata.intVersion = m_previousIntVersion; |
1386 } | 1382 } |
1387 | 1383 |
| 1384 void IDBDatabaseBackendImpl::trace(Visitor* visitor) |
| 1385 { |
| 1386 visitor->trace(m_factory); |
| 1387 visitor->trace(m_databaseCallbacksSet); |
| 1388 } |
| 1389 |
1388 } // namespace WebCore | 1390 } // namespace WebCore |
OLD | NEW |