IndexedDB: Implement explicit queue for IDBOpenDBRequests

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>
 
 #include <list>
 #include <map>
+#include <memory>
 #include <queue>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "content/browser/indexed_db/indexed_db.h"
 #include "content/browser/indexed_db/indexed_db_backing_store.h"
 #include "content/browser/indexed_db/indexed_db_callbacks.h"
@@ skipping 55 matching lines @@
   void OpenConnection(const IndexedDBPendingConnection& connection);
   void DeleteDatabase(scoped_refptr<IndexedDBCallbacks> callbacks);
   const IndexedDBDatabaseMetadata& metadata() const { return metadata_; }
 
   void CreateObjectStore(int64_t transaction_id,
                          int64_t object_store_id,
                          const base::string16& name,
                          const IndexedDBKeyPath& key_path,
                          bool auto_increment);
   void DeleteObjectStore(int64_t transaction_id, int64_t object_store_id);
-  void CreateTransaction(int64_t transaction_id,
-                         IndexedDBConnection* connection,
-                         const std::vector<int64_t>& object_store_ids,
-                         blink::WebIDBTransactionMode mode);
+  IndexedDBTransaction* CreateTransaction(
+      int64_t transaction_id,
+      IndexedDBConnection* connection,
+      const std::vector<int64_t>& object_store_ids,
+      blink::WebIDBTransactionMode mode);
   void Close(IndexedDBConnection* connection, bool forced);
   void ForceClose();
 
   // Ack that one of the connections notified with a "versionchange" event did
   // not promptly close. Therefore a "blocked" event should be fired at the
   // pending connection.
   void VersionChangeIgnored();
 
   void Commit(int64_t transaction_id);
   void Abort(int64_t transaction_id);
@@ skipping 70 matching lines @@
              scoped_refptr<IndexedDBCallbacks> callbacks);
   void DeleteRange(int64_t transaction_id,
                    int64_t object_store_id,
                    std::unique_ptr<IndexedDBKeyRange> key_range,
                    scoped_refptr<IndexedDBCallbacks> callbacks);
   void Clear(int64_t transaction_id,
              int64_t object_store_id,
              scoped_refptr<IndexedDBCallbacks> callbacks);
 
   // Number of connections that have progressed passed initial open call.
-  size_t ConnectionCount() const;
-  // Number of open calls that are blocked on other connections.
-  size_t PendingOpenCount() const;
-  // Number of pending upgrades (0 or 1). Also included in ConnectionCount().
-  size_t PendingUpgradeCount() const;
-  // Number of running upgrades (0 or 1). Also included in ConnectionCount().
-  size_t RunningUpgradeCount() const;
-  // Number of pending deletes, blocked on other connections.
-  size_t PendingDeleteCount() const;
+  size_t ConnectionCount() const { return connections_.size(); }
+
+  // Number of active open/delete calls (running or blocked on other
+  // connections).
+  size_t ActiveOpenDeleteCount() const { return active_request_ ? 1 : 0; }
+
+  // Number of open/delete calls that are waiting their turn.
+  size_t PendingOpenDeleteCount() const { return pending_requests_.size(); }
 
   // Asynchronous tasks scheduled within transactions:
   void CreateObjectStoreAbortOperation(int64_t object_store_id,
                                        IndexedDBTransaction* transaction);
   void DeleteObjectStoreOperation(int64_t object_store_id,
                                   IndexedDBTransaction* transaction);
   void DeleteObjectStoreAbortOperation(
       const IndexedDBObjectStoreMetadata& object_store_metadata,
       IndexedDBTransaction* transaction);
   void VersionChangeOperation(int64_t version,
                               scoped_refptr<IndexedDBCallbacks> callbacks,
-                              std::unique_ptr<IndexedDBConnection> connection,
                               IndexedDBTransaction* transaction);
   void VersionChangeAbortOperation(int64_t previous_version,
                                    IndexedDBTransaction* transaction);
   void DeleteIndexOperation(int64_t object_store_id,
                             int64_t index_id,
                             IndexedDBTransaction* transaction);
   void CreateIndexAbortOperation(int64_t object_store_id,
                                  int64_t index_id,
                                  IndexedDBTransaction* transaction);
   void DeleteIndexAbortOperation(int64_t object_store_id,
@@ skipping 40 matching lines @@
                     const Identifier& unique_identifier);
   virtual ~IndexedDBDatabase();
 
   // May be overridden in tests.
   virtual size_t GetMaxMessageSizeInBytes() const;
 
  private:
   friend class base::RefCounted<IndexedDBDatabase>;
   friend class IndexedDBClassFactory;
 
-  class PendingDeleteCall;
-  class PendingSuccessCall;
-  class PendingUpgradeCall;
+  class OpenOrDeleteRequest;
+  class OpenRequest;
+  class DeleteRequest;
 
-  bool IsUpgradeRunning() const;
-  bool IsUpgradePendingOrRunning() const;
+  leveldb::Status OpenInternal();
 
-  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,
-      int64_t transaction_id,
-      int64_t requested_version);
-  void ProcessPendingCalls();
+  // Called internally when an open or delete request comes in. Processes
+  // the queue immediately if there are no other requests.
+  void AppendRequest(std::unique_ptr<OpenOrDeleteRequest> request);
 
-  bool IsDeleteDatabaseBlocked() const;
-  void DeleteDatabaseFinal(scoped_refptr<IndexedDBCallbacks> callbacks);
+  // Called by requests when complete. The request will be freed, so the
+  // request must do no other work after calling this. If there are pending
+  // requests, the queue will be synchronously processed.
+  void RequestComplete(OpenOrDeleteRequest* request);
+
+  // Pop the first request from the queue and start it.
+  void ProcessRequestQueue();
 
   std::unique_ptr<IndexedDBConnection> CreateConnection(
       scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks,
       int child_process_id);
 
   IndexedDBTransaction* GetTransaction(int64_t transaction_id) const;
 
   bool ValidateObjectStoreId(int64_t object_store_id) const;
   bool ValidateObjectStoreIdAndIndexId(int64_t object_store_id,
                                        int64_t index_id) const;
   bool ValidateObjectStoreIdAndOptionalIndexId(int64_t object_store_id,
                                                int64_t index_id) const;
   bool ValidateObjectStoreIdAndNewIndexId(int64_t object_store_id,
                                           int64_t index_id) const;
 
   scoped_refptr<IndexedDBBackingStore> backing_store_;
   IndexedDBDatabaseMetadata metadata_;
 
   const Identifier identifier_;
   scoped_refptr<IndexedDBFactory> factory_;
 
   IndexedDBTransactionCoordinator transaction_coordinator_;
 
   std::map<int64_t, IndexedDBTransaction*> 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.
-  std::queue<IndexedDBPendingConnection> pending_open_calls_;
+  list_set<IndexedDBConnection*> connections_;
 
-  // 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 holds the first open or delete request that could not be immediately
+  // processed. The request has already broadcast OnVersionChange if
+  // necessary.
+  std::unique_ptr<OpenOrDeleteRequest> active_request_;
 
-  // 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_;
+  // This holds open or delete requests that are waiting for the active
+  // request to be completed. The requests have not yet broadcast
+  // OnVersionChange (if necessary).
+  std::queue<std::unique_ptr<OpenOrDeleteRequest>> pending_requests_;
 
-  // 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.
-  std::list<std::unique_ptr<PendingDeleteCall>> pending_delete_calls_;
+  // The |processing_pending_requests_| flag is set while ProcessRequestQueue()
+  // is executing. It prevents rentrant calls if the active request completes
+  // synchronously.
+  bool processing_pending_requests_ = false;
 
-  // 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.
-  std::list<std::unique_ptr<PendingDeleteCall>> blocked_delete_calls_;
-
-  list_set<IndexedDBConnection*> connections_;
   bool experimental_web_platform_features_enabled_;
 
   DISALLOW_COPY_AND_ASSIGN(IndexedDBDatabase);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_DATABASE_H_