Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(134)

Side by Side Diff: content/browser/indexed_db/indexed_db_database.h

Issue 2148253003: IndexedDB: Implement explicit queue for IDBOpenDBRequests (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Use pending member, other review nits Created 4 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. 1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #ifndef CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_DATABASE_H_ 5 #ifndef CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_DATABASE_H_
6 #define CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_DATABASE_H_ 6 #define CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_DATABASE_H_
7 7
8 #include <stddef.h> 8 #include <stddef.h>
9 #include <stdint.h> 9 #include <stdint.h>
10 10
11 #include <list> 11 #include <list>
12 #include <map> 12 #include <map>
13 #include <memory>
13 #include <queue> 14 #include <queue>
14 #include <string> 15 #include <string>
15 #include <utility> 16 #include <utility>
16 #include <vector> 17 #include <vector>
17 18
18 #include "base/macros.h" 19 #include "base/macros.h"
19 #include "base/memory/ref_counted.h" 20 #include "base/memory/ref_counted.h"
20 #include "content/browser/indexed_db/indexed_db.h" 21 #include "content/browser/indexed_db/indexed_db.h"
21 #include "content/browser/indexed_db/indexed_db_backing_store.h" 22 #include "content/browser/indexed_db/indexed_db_backing_store.h"
22 #include "content/browser/indexed_db/indexed_db_callbacks.h" 23 #include "content/browser/indexed_db/indexed_db_callbacks.h"
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after
78 void OpenConnection(const IndexedDBPendingConnection& connection); 79 void OpenConnection(const IndexedDBPendingConnection& connection);
79 void DeleteDatabase(scoped_refptr<IndexedDBCallbacks> callbacks); 80 void DeleteDatabase(scoped_refptr<IndexedDBCallbacks> callbacks);
80 const IndexedDBDatabaseMetadata& metadata() const { return metadata_; } 81 const IndexedDBDatabaseMetadata& metadata() const { return metadata_; }
81 82
82 void CreateObjectStore(int64_t transaction_id, 83 void CreateObjectStore(int64_t transaction_id,
83 int64_t object_store_id, 84 int64_t object_store_id,
84 const base::string16& name, 85 const base::string16& name,
85 const IndexedDBKeyPath& key_path, 86 const IndexedDBKeyPath& key_path,
86 bool auto_increment); 87 bool auto_increment);
87 void DeleteObjectStore(int64_t transaction_id, int64_t object_store_id); 88 void DeleteObjectStore(int64_t transaction_id, int64_t object_store_id);
88 void CreateTransaction(int64_t transaction_id, 89 IndexedDBTransaction* CreateTransaction(
89 IndexedDBConnection* connection, 90 int64_t transaction_id,
90 const std::vector<int64_t>& object_store_ids, 91 IndexedDBConnection* connection,
91 blink::WebIDBTransactionMode mode); 92 const std::vector<int64_t>& object_store_ids,
93 blink::WebIDBTransactionMode mode);
92 void Close(IndexedDBConnection* connection, bool forced); 94 void Close(IndexedDBConnection* connection, bool forced);
93 void ForceClose(); 95 void ForceClose();
94 96
95 // Ack that one of the connections notified with a "versionchange" event did 97 // Ack that one of the connections notified with a "versionchange" event did
96 // not promptly close. Therefore a "blocked" event should be fired at the 98 // not promptly close. Therefore a "blocked" event should be fired at the
97 // pending connection. 99 // pending connection.
98 void VersionChangeIgnored(); 100 void VersionChangeIgnored();
99 101
100 void Commit(int64_t transaction_id); 102 void Commit(int64_t transaction_id);
101 void Abort(int64_t transaction_id); 103 void Abort(int64_t transaction_id);
(...skipping 70 matching lines...) Expand 10 before | Expand all | Expand 10 after
172 scoped_refptr<IndexedDBCallbacks> callbacks); 174 scoped_refptr<IndexedDBCallbacks> callbacks);
173 void DeleteRange(int64_t transaction_id, 175 void DeleteRange(int64_t transaction_id,
174 int64_t object_store_id, 176 int64_t object_store_id,
175 std::unique_ptr<IndexedDBKeyRange> key_range, 177 std::unique_ptr<IndexedDBKeyRange> key_range,
176 scoped_refptr<IndexedDBCallbacks> callbacks); 178 scoped_refptr<IndexedDBCallbacks> callbacks);
177 void Clear(int64_t transaction_id, 179 void Clear(int64_t transaction_id,
178 int64_t object_store_id, 180 int64_t object_store_id,
179 scoped_refptr<IndexedDBCallbacks> callbacks); 181 scoped_refptr<IndexedDBCallbacks> callbacks);
180 182
181 // Number of connections that have progressed passed initial open call. 183 // Number of connections that have progressed passed initial open call.
182 size_t ConnectionCount() const; 184 size_t ConnectionCount() const { return connections_.size(); }
183 // Number of open calls that are blocked on other connections. 185
184 size_t PendingOpenCount() const; 186 // Number of active open/delete calls (running or blocked on other
185 // Number of pending upgrades (0 or 1). Also included in ConnectionCount(). 187 // connections).
186 size_t PendingUpgradeCount() const; 188 size_t ActiveOpenDeleteCount() const { return active_request_ ? 1 : 0; }
187 // Number of running upgrades (0 or 1). Also included in ConnectionCount(). 189
188 size_t RunningUpgradeCount() const; 190 // Number of open/delete calls that are waiting their turn.
189 // Number of pending deletes, blocked on other connections. 191 size_t PendingOpenDeleteCount() const { return pending_requests_.size(); }
190 size_t PendingDeleteCount() const;
191 192
192 // Asynchronous tasks scheduled within transactions: 193 // Asynchronous tasks scheduled within transactions:
193 void CreateObjectStoreAbortOperation(int64_t object_store_id, 194 void CreateObjectStoreAbortOperation(int64_t object_store_id,
194 IndexedDBTransaction* transaction); 195 IndexedDBTransaction* transaction);
195 void DeleteObjectStoreOperation(int64_t object_store_id, 196 void DeleteObjectStoreOperation(int64_t object_store_id,
196 IndexedDBTransaction* transaction); 197 IndexedDBTransaction* transaction);
197 void DeleteObjectStoreAbortOperation( 198 void DeleteObjectStoreAbortOperation(
198 const IndexedDBObjectStoreMetadata& object_store_metadata, 199 const IndexedDBObjectStoreMetadata& object_store_metadata,
199 IndexedDBTransaction* transaction); 200 IndexedDBTransaction* transaction);
200 void VersionChangeOperation(int64_t version, 201 void VersionChangeOperation(int64_t version,
201 scoped_refptr<IndexedDBCallbacks> callbacks, 202 scoped_refptr<IndexedDBCallbacks> callbacks,
202 std::unique_ptr<IndexedDBConnection> connection,
203 IndexedDBTransaction* transaction); 203 IndexedDBTransaction* transaction);
204 void VersionChangeAbortOperation(int64_t previous_version, 204 void VersionChangeAbortOperation(int64_t previous_version,
205 IndexedDBTransaction* transaction); 205 IndexedDBTransaction* transaction);
206 void DeleteIndexOperation(int64_t object_store_id, 206 void DeleteIndexOperation(int64_t object_store_id,
207 int64_t index_id, 207 int64_t index_id,
208 IndexedDBTransaction* transaction); 208 IndexedDBTransaction* transaction);
209 void CreateIndexAbortOperation(int64_t object_store_id, 209 void CreateIndexAbortOperation(int64_t object_store_id,
210 int64_t index_id, 210 int64_t index_id,
211 IndexedDBTransaction* transaction); 211 IndexedDBTransaction* transaction);
212 void DeleteIndexAbortOperation(int64_t object_store_id, 212 void DeleteIndexAbortOperation(int64_t object_store_id,
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after
253 const Identifier& unique_identifier); 253 const Identifier& unique_identifier);
254 virtual ~IndexedDBDatabase(); 254 virtual ~IndexedDBDatabase();
255 255
256 // May be overridden in tests. 256 // May be overridden in tests.
257 virtual size_t GetMaxMessageSizeInBytes() const; 257 virtual size_t GetMaxMessageSizeInBytes() const;
258 258
259 private: 259 private:
260 friend class base::RefCounted<IndexedDBDatabase>; 260 friend class base::RefCounted<IndexedDBDatabase>;
261 friend class IndexedDBClassFactory; 261 friend class IndexedDBClassFactory;
262 262
263 class PendingDeleteCall; 263 class OpenOrDeleteRequest;
264 class PendingSuccessCall; 264 class OpenRequest;
265 class PendingUpgradeCall; 265 class DeleteRequest;
266 266
267 bool IsUpgradeRunning() const; 267 leveldb::Status OpenInternal();
268 bool IsUpgradePendingOrRunning() const;
269 268
270 bool IsOpenConnectionBlocked() const; 269 // Called internally when an open or delete request comes in. Processes
271 leveldb::Status OpenInternal(); 270 // the queue immediately if there are no other requests.
272 void RunVersionChangeTransaction( 271 void AppendRequest(std::unique_ptr<OpenOrDeleteRequest> request);
273 scoped_refptr<IndexedDBCallbacks> callbacks,
274 std::unique_ptr<IndexedDBConnection> connection,
275 int64_t transaction_id,
276 int64_t requested_version);
277 void RunVersionChangeTransactionFinal(
278 scoped_refptr<IndexedDBCallbacks> callbacks,
279 std::unique_ptr<IndexedDBConnection> connection,
280 int64_t transaction_id,
281 int64_t requested_version);
282 void ProcessPendingCalls();
283 272
284 bool IsDeleteDatabaseBlocked() const; 273 // Called by requests when complete. The request will be freed, so the
285 void DeleteDatabaseFinal(scoped_refptr<IndexedDBCallbacks> callbacks); 274 // request must do no other work after calling this. If there are pending
275 // requests, the queue will be synchronously processed.
276 void RequestComplete(OpenOrDeleteRequest* request);
277
278 // Pop the first request from the queue and start it.
279 void ProcessRequestQueue();
286 280
287 std::unique_ptr<IndexedDBConnection> CreateConnection( 281 std::unique_ptr<IndexedDBConnection> CreateConnection(
288 scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks, 282 scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks,
289 int child_process_id); 283 int child_process_id);
290 284
291 IndexedDBTransaction* GetTransaction(int64_t transaction_id) const; 285 IndexedDBTransaction* GetTransaction(int64_t transaction_id) const;
292 286
293 bool ValidateObjectStoreId(int64_t object_store_id) const; 287 bool ValidateObjectStoreId(int64_t object_store_id) const;
294 bool ValidateObjectStoreIdAndIndexId(int64_t object_store_id, 288 bool ValidateObjectStoreIdAndIndexId(int64_t object_store_id,
295 int64_t index_id) const; 289 int64_t index_id) const;
296 bool ValidateObjectStoreIdAndOptionalIndexId(int64_t object_store_id, 290 bool ValidateObjectStoreIdAndOptionalIndexId(int64_t object_store_id,
297 int64_t index_id) const; 291 int64_t index_id) const;
298 bool ValidateObjectStoreIdAndNewIndexId(int64_t object_store_id, 292 bool ValidateObjectStoreIdAndNewIndexId(int64_t object_store_id,
299 int64_t index_id) const; 293 int64_t index_id) const;
300 294
301 scoped_refptr<IndexedDBBackingStore> backing_store_; 295 scoped_refptr<IndexedDBBackingStore> backing_store_;
302 IndexedDBDatabaseMetadata metadata_; 296 IndexedDBDatabaseMetadata metadata_;
303 297
304 const Identifier identifier_; 298 const Identifier identifier_;
305 scoped_refptr<IndexedDBFactory> factory_; 299 scoped_refptr<IndexedDBFactory> factory_;
306 300
307 IndexedDBTransactionCoordinator transaction_coordinator_; 301 IndexedDBTransactionCoordinator transaction_coordinator_;
308 302
309 std::map<int64_t, IndexedDBTransaction*> transactions_; 303 std::map<int64_t, IndexedDBTransaction*> transactions_;
310 304
311 // An open request ends up here if: 305 list_set<IndexedDBConnection*> connections_;
312 // * There is a running or pending upgrade.
313 // * There are pending deletes.
314 // Requests here have *not* broadcast OnVersionChange if necessary.
315 // When no longer blocked, the OpenConnection() calls are remade.
316 std::queue<IndexedDBPendingConnection> pending_open_calls_;
317 306
318 // This owns the connection for the first upgrade request (open with higher 307 // This holds the first open or delete request that could not be immediately
319 // version) that could not be immediately processed. The request has already 308 // processed. The request has already broadcast OnVersionChange if
320 // broadcast OnVersionChange if necessary. 309 // necessary.
321 std::unique_ptr<PendingUpgradeCall> 310 std::unique_ptr<OpenOrDeleteRequest> active_request_;
322 pending_run_version_change_transaction_call_;
323 311
324 // This references a connection for an upgrade request while the upgrade 312 // This holds open or delete requests that are waiting for the active
325 // transaction is running, so that the success/error result can be sent. It 313 // request to be completed. The requests have not yet broadcast
326 // is not set until the upgrade transaction actually starts executing 314 // OnVersionChange (if necessary).
327 // operations, so do not rely on it to determine if an upgrade is in 315 std::queue<std::unique_ptr<OpenOrDeleteRequest>> pending_requests_;
328 // progress.
329 std::unique_ptr<PendingSuccessCall> pending_second_half_open_;
330 316
331 // A delete request ends up here if: 317 // The |processing_pending_requests_| flag is set while ProcessRequestQueue()
332 // * There is a running upgrade. 318 // is executing. It prevents rentrant calls if the active request completes
333 // Requests here have *not* broadcast OnVersionChange if necessary. 319 // synchronously.
334 // When no longer blocked, DeleteDatabase() calls are remade. 320 bool processing_pending_requests_ = false;
335 std::list<std::unique_ptr<PendingDeleteCall>> pending_delete_calls_;
336 321
337 // A delete request ends up here if:
338 // * There are open connections.
339 // Requests here have already broadcast OnVersionChange if necessary.
340 // When no longer blocked, DeleteDatabaseFinal() calls are made.
341 std::list<std::unique_ptr<PendingDeleteCall>> blocked_delete_calls_;
342
343 list_set<IndexedDBConnection*> connections_;
344 bool experimental_web_platform_features_enabled_; 322 bool experimental_web_platform_features_enabled_;
345 323
346 DISALLOW_COPY_AND_ASSIGN(IndexedDBDatabase); 324 DISALLOW_COPY_AND_ASSIGN(IndexedDBDatabase);
347 }; 325 };
348 326
349 } // namespace content 327 } // namespace content
350 328
351 #endif // CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_DATABASE_H_ 329 #endif // CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_DATABASE_H_
OLDNEW
« no previous file with comments | « content/browser/indexed_db/indexed_db_context_impl.cc ('k') | content/browser/indexed_db/indexed_db_database.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698