IndexedDB: Defer delete calls when there is a running upgrade

content/browser/indexed_db/indexed_db_database.h

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_DATABASE_H_
 #define CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_DATABASE_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 246 matching lines @@
 
   class PendingDeleteCall;
   class PendingSuccessCall;
   class PendingUpgradeCall;
 
   typedef std::map<int64_t, IndexedDBTransaction*> TransactionMap;
   typedef std::list<IndexedDBPendingConnection> PendingOpenCallList;
   typedef std::list<PendingDeleteCall*> PendingDeleteCallList;
   typedef list_set<IndexedDBConnection*> ConnectionSet;
 
+  bool IsUpgradeRunning() const;
+  bool IsUpgradePendingOrRunning() const;
+
   bool IsOpenConnectionBlocked() const;
   leveldb::Status OpenInternal();
   void RunVersionChangeTransaction(
       scoped_refptr<IndexedDBCallbacks> callbacks,
       std::unique_ptr<IndexedDBConnection> connection,
       int64_t transaction_id,
       int64_t requested_version);
   void RunVersionChangeTransactionFinal(
       scoped_refptr<IndexedDBCallbacks> callbacks,
       std::unique_ptr<IndexedDBConnection> connection,
@@ skipping 20 matching lines @@
 
   scoped_refptr<IndexedDBBackingStore> backing_store_;
   IndexedDBDatabaseMetadata metadata_;
 
   const Identifier identifier_;
   scoped_refptr<IndexedDBFactory> factory_;
 
   IndexedDBTransactionCoordinator transaction_coordinator_;
 
   TransactionMap transactions_;
+
+  // An open request ends up here if:
+  //  * There is a running or pending upgrade.
+  //  * There are pending deletes.
+  // Requests here have *not* broadcast OnVersionChange if necessary.
+  // When no longer blocked, the OpenConnection() calls are remade.
   PendingOpenCallList pending_open_calls_;
+
+  // This owns the connection for the first upgrade request (open with higher
+  // version) that could not be immediately processed. The request has already
+  // broadcast OnVersionChange if necessary.
   std::unique_ptr<PendingUpgradeCall>
       pending_run_version_change_transaction_call_;
+
+  // This references a connection for an upgrade request while the upgrade
+  // transaction is running, so that the success/error result can be sent. It
+  // is not set until the upgrade transaction actually starts executing
+  // operations, so do not rely on it to determine if an upgrade is in
+  // progress.
   std::unique_ptr<PendingSuccessCall> pending_second_half_open_;
+
+  // A delete request ends up here if:
+  //  * There is a running upgrade.
+  // Requests here have *not* broadcast OnVersionChange if necessary.
+  // When no longer blocked, DeleteDatabase() calls are remade.
   PendingDeleteCallList pending_delete_calls_;
 
+  // A delete request ends up here if:
+  //  * There are open connections.
+  // Requests here have already broadcast OnVersionChange if necessary.
+  // When no longer blocked, DeleteDatabaseFinal() calls are made.
+  PendingDeleteCallList blocked_delete_calls_;

[cmumford, 2016/06/23 21:44:20]

Why do we use a std::list instead of std::queue?

[jsbell, 2016/06/23 22:26:50]

No good reason; probably ported mechanically from WebKit. I'll convert these to
queues.

[jsbell, 2016/06/23 23:00:27]

Ah, I remember. you can't iterate over a std::queue, and we iterate over these
when sending out OnBlocked().

That isn't done for pending_delete_calls_ so we could switch that to be a queue.

[palakj1, 2016/06/24 03:41:40]

nit: the names pending_delete_calls_ and blocked_delete_calls_ are a bit
confusing regarding their purpose, although the comments clarify things.

+
   ConnectionSet connections_;
   bool experimental_web_platform_features_enabled_;
 
   DISALLOW_COPY_AND_ASSIGN(IndexedDBDatabase);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_DATABASE_H_