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_MAP(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, PassRefPtr<IDBCallb acks> callbacks, 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, PassRefPtr<IDBCallbacks> callbacks, IDBDatabaseCallbacks* d atabaseCallbacks) |
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 RefPtr<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, PassRefPtr<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 } |
(...skipping 172 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
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 RefPtr<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(PassRefPtr<IDBCallbacks> callbacks , IDBDatabaseCallbacks* databaseCallbacks, int64_t transactionId, int64_t versio n) |
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 PassRefPtr<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(PassRefPtr<IDBCallbacks> callbacks, IDBDatabaseCallbacks* da tabaseCallbacks, 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 RefPtr<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(PassRefPtr<IDBCallbacks> callbac ks) |
454 { | 456 { |
455 return adoptPtr(new PendingDeleteCall(callbacks)); | 457 return adoptPtr(new PendingDeleteCall(callbacks)); |
456 } | 458 } |
457 PassRefPtr<IDBCallbacks> callbacks() { return m_callbacks; } | 459 PassRefPtr<IDBCallbacks> callbacks() { return m_callbacks; } |
458 | 460 |
459 private: | 461 private: |
460 PendingDeleteCall(PassRefPtr<IDBCallbacks> callbacks) | 462 PendingDeleteCall(PassRefPtr<IDBCallbacks> callbacks) |
461 : m_callbacks(callbacks) | 463 : m_callbacks(callbacks) |
462 { | 464 { |
463 } | 465 } |
464 RefPtr<IDBCallbacks> m_callbacks; | 466 RefPtr<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 682 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(PassRefPtr<IDBCallbacks> prpCallback s, IDBDatabaseCallbacks* databaseCallbacks, int64_t transactionId, int64_t versi on) |
1183 { | 1185 { |
1184 ASSERT(m_backingStore.get()); | 1186 ASSERT(m_backingStore.get()); |
1185 RefPtr<IDBCallbacks> callbacks = prpCallbacks; | 1187 RefPtr<IDBCallbacks> callbacks = prpCallbacks; |
1186 RefPtr<IDBDatabaseCallbacks> databaseCallbacks = prpDatabaseCallbacks; | |
1187 | 1188 |
1188 if (!m_pendingDeleteCalls.isEmpty() || m_runningVersionChangeTransaction) { | 1189 if (!m_pendingDeleteCalls.isEmpty() || m_runningVersionChangeTransaction) { |
1189 m_pendingOpenCalls.append(PendingOpenCall::create(callbacks, databaseCal lbacks, transactionId, version)); | 1190 m_pendingOpenCalls.append(PendingOpenCall::create(callbacks, databaseCal lbacks, transactionId, version)); |
1190 return; | 1191 return; |
1191 } | 1192 } |
1192 | 1193 |
1193 if (m_metadata.id == InvalidId) { | 1194 if (m_metadata.id == InvalidId) { |
1194 // The database was deleted then immediately re-opened; openInternal() r ecreates it in the backing store. | 1195 // The database was deleted then immediately re-opened; openInternal() r ecreates it in the backing store. |
1195 if (openInternal()) | 1196 if (openInternal()) |
1196 ASSERT(m_metadata.intVersion == IDBDatabaseMetadata::NoIntVersion); | 1197 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. | 1214 // For unit tests only - skip upgrade steps. Calling from script with De faultIntVersion throws exception. |
1214 ASSERT(WebKit::Platform::current()->unitTestSupport()); | 1215 ASSERT(WebKit::Platform::current()->unitTestSupport()); |
1215 ASSERT(isNewDatabase); | 1216 ASSERT(isNewDatabase); |
1216 m_databaseCallbacksSet.add(databaseCallbacks); | 1217 m_databaseCallbacksSet.add(databaseCallbacks); |
1217 callbacks->onSuccess(this, this->metadata()); | 1218 callbacks->onSuccess(this, this->metadata()); |
1218 return; | 1219 return; |
1219 } | 1220 } |
1220 | 1221 |
1221 if (version == IDBDatabaseMetadata::NoIntVersion) { | 1222 if (version == IDBDatabaseMetadata::NoIntVersion) { |
1222 if (!isNewDatabase) { | 1223 if (!isNewDatabase) { |
1223 m_databaseCallbacksSet.add(RefPtr<IDBDatabaseCallbacks>(databaseCall backs)); | 1224 m_databaseCallbacksSet.add(databaseCallbacks); |
1224 callbacks->onSuccess(this, this->metadata()); | 1225 callbacks->onSuccess(this, this->metadata()); |
1225 return; | 1226 return; |
1226 } | 1227 } |
1227 // Spec says: If no version is specified and no database exists, set dat abase version to 1. | 1228 // Spec says: If no version is specified and no database exists, set dat abase version to 1. |
1228 version = 1; | 1229 version = 1; |
1229 } | 1230 } |
1230 | 1231 |
1231 if (version > m_metadata.intVersion) { | 1232 if (version > m_metadata.intVersion) { |
1232 runIntVersionChangeTransaction(callbacks, databaseCallbacks, transaction Id, version); | 1233 runIntVersionChangeTransaction(callbacks, databaseCallbacks, transaction Id, version); |
1233 return; | 1234 return; |
1234 } | 1235 } |
1235 if (version < m_metadata.intVersion) { | 1236 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)))); | 1237 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; | 1238 return; |
1238 } | 1239 } |
1239 ASSERT(version == m_metadata.intVersion); | 1240 ASSERT(version == m_metadata.intVersion); |
1240 m_databaseCallbacksSet.add(databaseCallbacks); | 1241 m_databaseCallbacksSet.add(databaseCallbacks); |
1241 callbacks->onSuccess(this, this->metadata()); | 1242 callbacks->onSuccess(this, this->metadata()); |
1242 } | 1243 } |
1243 | 1244 |
1244 void IDBDatabaseBackendImpl::runIntVersionChangeTransaction(PassRefPtr<IDBCallba cks> prpCallbacks, PassRefPtr<IDBDatabaseCallbacks> prpDatabaseCallbacks, int64_ t transactionId, int64_t requestedVersion) | 1245 void IDBDatabaseBackendImpl::runIntVersionChangeTransaction(PassRefPtr<IDBCallba cks> prpCallbacks, IDBDatabaseCallbacks* databaseCallbacks, int64_t transactionI d, int64_t requestedVersion) |
1245 { | 1246 { |
1246 RefPtr<IDBCallbacks> callbacks = prpCallbacks; | 1247 RefPtr<IDBCallbacks> callbacks = prpCallbacks; |
1247 RefPtr<IDBDatabaseCallbacks> databaseCallbacks = prpDatabaseCallbacks; | |
1248 ASSERT(callbacks); | 1248 ASSERT(callbacks); |
1249 for (DatabaseCallbacksSet::const_iterator it = m_databaseCallbacksSet.begin( ); it != m_databaseCallbacksSet.end(); ++it) { | 1249 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. | 1250 // Front end ensures the event is not fired at connections that have clo sePending set. |
1251 if (*it != databaseCallbacks) | 1251 if (*it != databaseCallbacks) |
1252 (*it)->onVersionChange(m_metadata.intVersion, requestedVersion); | 1252 (*it)->onVersionChange(m_metadata.intVersion, requestedVersion); |
1253 } | 1253 } |
1254 // The spec dictates we wait until all the version change events are | 1254 // The spec dictates we wait until all the version change events are |
1255 // delivered and then check m_databaseCallbacks.empty() before proceeding | 1255 // delivered and then check m_databaseCallbacks.empty() before proceeding |
1256 // or firing a blocked event, but instead we should be consistent with how | 1256 // or firing a blocked event, but instead we should be consistent with how |
1257 // the old setVersion (incorrectly) did it. | 1257 // the old setVersion (incorrectly) did it. |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1307 callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::Unknow nError, "Internal error deleting database.")); | 1307 callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::Unknow nError, "Internal error deleting database.")); |
1308 return; | 1308 return; |
1309 } | 1309 } |
1310 m_metadata.version = NoStringVersion; | 1310 m_metadata.version = NoStringVersion; |
1311 m_metadata.id = InvalidId; | 1311 m_metadata.id = InvalidId; |
1312 m_metadata.intVersion = IDBDatabaseMetadata::NoIntVersion; | 1312 m_metadata.intVersion = IDBDatabaseMetadata::NoIntVersion; |
1313 m_metadata.objectStores.clear(); | 1313 m_metadata.objectStores.clear(); |
1314 callbacks->onSuccess(); | 1314 callbacks->onSuccess(); |
1315 } | 1315 } |
1316 | 1316 |
1317 void IDBDatabaseBackendImpl::close(PassRefPtr<IDBDatabaseCallbacks> prpCallbacks ) | 1317 void IDBDatabaseBackendImpl::close(IDBDatabaseCallbacks* callbacks) |
1318 { | 1318 { |
1319 RefPtr<IDBDatabaseCallbacks> callbacks = prpCallbacks; | |
1320 ASSERT(m_databaseCallbacksSet.contains(callbacks)); | 1319 ASSERT(m_databaseCallbacksSet.contains(callbacks)); |
1321 | 1320 |
1322 // Close outstanding transactions from the closing connection. This can not happen | 1321 // 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 | 1322 // 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 | 1323 // the close until all transactions are complete, so something unusual has h appened |
1325 // e.g. unexpected process termination. | 1324 // e.g. unexpected process termination. |
1326 { | 1325 { |
1327 TransactionMap transactions(m_transactions); | 1326 TransactionMap transactions(m_transactions); |
1328 for (TransactionMap::const_iterator::Values it = transactions.values().b egin(), end = transactions.values().end(); it != end; ++it) { | 1327 for (TransactionMap::const_iterator::Values it = transactions.values().b egin(), end = transactions.values().end(); it != end; ++it) { |
1329 if ((*it)->connection() == callbacks) | 1328 if ((*it)->connection() == callbacks) |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1378 } | 1377 } |
1379 | 1378 |
1380 void IDBDatabaseBackendImpl::VersionChangeAbortOperation::perform(IDBTransaction BackendImpl* transaction) | 1379 void IDBDatabaseBackendImpl::VersionChangeAbortOperation::perform(IDBTransaction BackendImpl* transaction) |
1381 { | 1380 { |
1382 IDB_TRACE("VersionChangeAbortOperation"); | 1381 IDB_TRACE("VersionChangeAbortOperation"); |
1383 ASSERT(!transaction); | 1382 ASSERT(!transaction); |
1384 m_database->m_metadata.version = m_previousVersion; | 1383 m_database->m_metadata.version = m_previousVersion; |
1385 m_database->m_metadata.intVersion = m_previousIntVersion; | 1384 m_database->m_metadata.intVersion = m_previousIntVersion; |
1386 } | 1385 } |
1387 | 1386 |
1387 void IDBDatabaseBackendImpl::trace(Visitor* visitor) const | |
1388 { | |
1389 visitor->visit(m_factory); | |
Mads Ager (chromium)
2013/11/28 10:24:46
These are now called |trace|.
haraken
2013/12/02 09:13:27
Done.
| |
1390 for (DatabaseCallbacksSet::const_iterator it = m_databaseCallbacksSet.begin( ); it != m_databaseCallbacksSet.end(); ++it) { | |
Mads Ager (chromium)
2013/11/28 10:24:46
We should extend the visitor to understand ListHas
haraken
2013/12/02 09:13:27
Done. Please double-check a change to Visitor.h :)
| |
1391 visitor->visit(*it); | |
1392 } | |
1393 } | |
1394 | |
1388 } // namespace WebCore | 1395 } // namespace WebCore |
OLD | NEW |