[IndexedDB] Refactoring to remove ref ptrs and host transaction ids.

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 67 matching lines @@
                 int64_t new_max_index_id);
   void RemoveIndex(int64_t object_store_id, int64_t index_id);
   void SetIndexName(int64_t object_store_id,
                     int64_t index_id,
                     const base::string16& name);
 
   void OpenConnection(std::unique_ptr<IndexedDBPendingConnection> connection);
   void DeleteDatabase(scoped_refptr<IndexedDBCallbacks> callbacks);
   const IndexedDBDatabaseMetadata& metadata() const { return metadata_; }
 
-  void CreateObjectStore(int64_t transaction_id,
+  void CreateObjectStore(IndexedDBTransaction* transaction,
                          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 RenameObjectStore(int64_t transaction_id,
+  void DeleteObjectStore(IndexedDBTransaction* transaction,
+                         int64_t object_store_id);
+  void RenameObjectStore(IndexedDBTransaction* transaction,
                          int64_t object_store_id,
                          const base::string16& new_name);
 
   // Returns a pointer to a newly created transaction. The object is owned
   // by |transaction_coordinator_|.
   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);
-  void Abort(int64_t transaction_id, const IndexedDBDatabaseError& error);
+  void Commit(IndexedDBTransaction* transaction);
 
-  void CreateIndex(int64_t transaction_id,
+  void CreateIndex(IndexedDBTransaction* transaction,
                    int64_t object_store_id,
                    int64_t index_id,
                    const base::string16& name,
                    const IndexedDBKeyPath& key_path,
                    bool unique,
                    bool multi_entry);
-  void DeleteIndex(int64_t transaction_id,
+  void DeleteIndex(IndexedDBTransaction* transaction,
                    int64_t object_store_id,
                    int64_t index_id);
-  void RenameIndex(int64_t transaction_id,
+  void RenameIndex(IndexedDBTransaction* transaction,
                    int64_t object_store_id,
                    int64_t index_id,
                    const base::string16& new_name);
 
   IndexedDBTransactionCoordinator& transaction_coordinator() {
     return transaction_coordinator_;
   }
   const IndexedDBTransactionCoordinator& transaction_coordinator() const {
     return transaction_coordinator_;
   }
 
   void TransactionCreated(IndexedDBTransaction* transaction);
   void TransactionFinished(IndexedDBTransaction* transaction, bool committed);
 
   // Called by transactions to report failure committing to the backing store.
   void TransactionCommitFailed(const leveldb::Status& status);
 
-  void AddPendingObserver(int64_t transaction_id,
+  void AddPendingObserver(IndexedDBTransaction* transaction,
                           int32_t observer_id,
                           const IndexedDBObserver::Options& options);
-  void RemovePendingObservers(IndexedDBConnection* connection,
-                              const std::vector<int32_t>& pending_observer_ids);
 
   void FilterObservation(IndexedDBTransaction*,
                          int64_t object_store_id,
                          blink::WebIDBOperationType type,
                          const IndexedDBKeyRange& key_range);
   void SendObservations(
       std::map<int32_t, std::unique_ptr<IndexedDBObserverChanges>> change_map);
 
-  void Get(int64_t transaction_id,
+  void Get(IndexedDBTransaction* transaction,
            int64_t object_store_id,
            int64_t index_id,
            std::unique_ptr<IndexedDBKeyRange> key_range,
            bool key_only,
            scoped_refptr<IndexedDBCallbacks> callbacks);
-  void GetAll(int64_t transaction_id,
+  void GetAll(IndexedDBTransaction* transaction,
               int64_t object_store_id,
               int64_t index_id,
               std::unique_ptr<IndexedDBKeyRange> key_range,
               bool key_only,
               int64_t max_count,
               scoped_refptr<IndexedDBCallbacks> callbacks);
-  void Put(int64_t transaction_id,
+  void Put(IndexedDBTransaction* transaction,
            int64_t object_store_id,
            IndexedDBValue* value,
            std::vector<std::unique_ptr<storage::BlobDataHandle>>* handles,
            std::unique_ptr<IndexedDBKey> key,
            blink::WebIDBPutMode mode,
            scoped_refptr<IndexedDBCallbacks> callbacks,
            const std::vector<IndexKeys>& index_keys);
-  void SetIndexKeys(int64_t transaction_id,
+  void SetIndexKeys(IndexedDBTransaction* transaction,
                     int64_t object_store_id,
                     std::unique_ptr<IndexedDBKey> primary_key,
                     const std::vector<IndexKeys>& index_keys);
-  void SetIndexesReady(int64_t transaction_id,
+  void SetIndexesReady(IndexedDBTransaction* transaction,
                        int64_t object_store_id,
                        const std::vector<int64_t>& index_ids);
-  void OpenCursor(int64_t transaction_id,
+  void OpenCursor(IndexedDBTransaction* transaction,
                   int64_t object_store_id,
                   int64_t index_id,
                   std::unique_ptr<IndexedDBKeyRange> key_range,
                   blink::WebIDBCursorDirection,
                   bool key_only,
                   blink::WebIDBTaskType task_type,
                   scoped_refptr<IndexedDBCallbacks> callbacks);
-  void Count(int64_t transaction_id,
+  void Count(IndexedDBTransaction* transaction,
              int64_t object_store_id,
              int64_t index_id,
              std::unique_ptr<IndexedDBKeyRange> key_range,
              scoped_refptr<IndexedDBCallbacks> callbacks);
-  void DeleteRange(int64_t transaction_id,
+  void DeleteRange(IndexedDBTransaction* transaction,
                    int64_t object_store_id,
                    std::unique_ptr<IndexedDBKeyRange> key_range,
                    scoped_refptr<IndexedDBCallbacks> callbacks);
-  void Clear(int64_t transaction_id,
+  void Clear(IndexedDBTransaction* transaction,
              int64_t object_store_id,
              scoped_refptr<IndexedDBCallbacks> callbacks);
 
   // Number of connections that have progressed passed initial open call.
   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; }
 
@@ skipping 90 matching lines @@
   // 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(ConnectionRequest* 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;
+      int child_process_id,
+      const url::Origin& origin);
 
   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_;
+  int64_t transaction_count_ = 0;
 
   list_set<IndexedDBConnection*> connections_;
 
   // This holds the first open or delete request that is currently being
   // processed. The request has already broadcast OnVersionChange if
   // necessary.
   std::unique_ptr<ConnectionRequest> active_request_;
 
   // 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<ConnectionRequest>> pending_requests_;
 
   // 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;
 
   DISALLOW_COPY_AND_ASSIGN(IndexedDBDatabase);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_DATABASE_H_