[IndexedDB] Integrating failures and corruption with transaction

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 31 matching lines @@
 class IndexedDBKeyRange;
 class IndexedDBObserverChanges;
 class IndexedDBTransaction;
 struct IndexedDBValue;
 
 class CONTENT_EXPORT IndexedDBDatabase
     : NON_EXPORTED_BASE(public base::RefCounted<IndexedDBDatabase>) {
  public:
   // Identifier is pair of (origin, database name).
   using Identifier = std::pair<url::Origin, base::string16>;
+  using OperationResult = leveldb::Status;
 
   static const int64_t kInvalidId = 0;
   static const int64_t kMinimumIndexId = 30;
 
   static scoped_refptr<IndexedDBDatabase> Create(
       const base::string16& name,
       IndexedDBBackingStore* backing_store,
       IndexedDBFactory* factory,
       const Identifier& unique_identifier,
       leveldb::Status* s);
 
   const Identifier& identifier() const { return identifier_; }
   IndexedDBBackingStore* backing_store() { return backing_store_.get(); }
 
   int64_t id() const { return metadata_.id; }
   const base::string16& name() const { return metadata_.name; }
+  const url::Origin& origin() const { return identifier_.first; }
 
   void AddObjectStore(const IndexedDBObjectStoreMetadata& metadata,
                       int64_t new_max_object_store_id);
   void RemoveObjectStore(int64_t object_store_id);
   void SetObjectStoreName(int64_t object_store_id, const base::string16& name);
   void AddIndex(int64_t object_store_id,
                 const IndexedDBIndexMetadata& metadata,
                 int64_t new_max_index_id);
   void RemoveIndex(int64_t object_store_id, int64_t index_id);
   void SetIndexName(int64_t object_store_id,
@@ skipping 51 matching lines @@
   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,
                           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);
@@ skipping 53 matching lines @@
   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,
+  void CreateObjectStoreAbortOperation(int64_t object_store_id);
+  OperationResult DeleteObjectStoreOperation(int64_t object_store_id,
+                                             IndexedDBTransaction* transaction);
+  void DeleteObjectStoreAbortOperation(
+      const IndexedDBObjectStoreMetadata& object_store_metadata);
+  void RenameObjectStoreAbortOperation(int64_t object_store_id,
+                                       const base::string16& old_name);
+  OperationResult VersionChangeOperation(
+      int64_t version,
+      scoped_refptr<IndexedDBCallbacks> callbacks,
+      IndexedDBTransaction* transaction);
+  void VersionChangeAbortOperation(int64_t previous_version);
+  OperationResult DeleteIndexOperation(int64_t object_store_id,
+                                       int64_t index_id,
                                        IndexedDBTransaction* transaction);
-  void DeleteObjectStoreOperation(int64_t object_store_id,
-                                  IndexedDBTransaction* transaction);
-  void DeleteObjectStoreAbortOperation(
-      const IndexedDBObjectStoreMetadata& object_store_metadata,
-      IndexedDBTransaction* transaction);
-  void RenameObjectStoreAbortOperation(int64_t object_store_id,
-                                       const base::string16& old_name,
-                                       IndexedDBTransaction* transaction);
-  void VersionChangeOperation(int64_t version,
-                              scoped_refptr<IndexedDBCallbacks> callbacks,
-                              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 CreateIndexAbortOperation(int64_t object_store_id, int64_t index_id);
   void DeleteIndexAbortOperation(int64_t object_store_id,
-                                 const IndexedDBIndexMetadata& index_metadata,
-                                 IndexedDBTransaction* transaction);
+                                 const IndexedDBIndexMetadata& index_metadata);
   void RenameIndexAbortOperation(int64_t object_store_id,
                                  int64_t index_id,
-                                 const base::string16& old_name,
+                                 const base::string16& old_name);
+  OperationResult GetOperation(int64_t object_store_id,
+                               int64_t index_id,
+                               std::unique_ptr<IndexedDBKeyRange> key_range,
+                               indexed_db::CursorType cursor_type,
+                               scoped_refptr<IndexedDBCallbacks> callbacks,
+                               IndexedDBTransaction* transaction);
+  OperationResult GetAllOperation(int64_t object_store_id,
+                                  int64_t index_id,
+                                  std::unique_ptr<IndexedDBKeyRange> key_range,
+                                  indexed_db::CursorType cursor_type,
+                                  int64_t max_count,
+                                  scoped_refptr<IndexedDBCallbacks> callbacks,
+                                  IndexedDBTransaction* transaction);
+  struct PutOperationParams;
+  OperationResult PutOperation(std::unique_ptr<PutOperationParams> params,
+                               IndexedDBTransaction* transaction);
+  OperationResult SetIndexesReadyOperation(size_t index_count,
+                                           IndexedDBTransaction* transaction);
+  struct OpenCursorOperationParams;
+  OperationResult OpenCursorOperation(
+      std::unique_ptr<OpenCursorOperationParams> params,
+      IndexedDBTransaction* transaction);
+  OperationResult CountOperation(int64_t object_store_id,
+                                 int64_t index_id,
+                                 std::unique_ptr<IndexedDBKeyRange> key_range,
+                                 scoped_refptr<IndexedDBCallbacks> callbacks,
                                  IndexedDBTransaction* transaction);
-  void GetOperation(int64_t object_store_id,
-                    int64_t index_id,
-                    std::unique_ptr<IndexedDBKeyRange> key_range,
-                    indexed_db::CursorType cursor_type,
-                    scoped_refptr<IndexedDBCallbacks> callbacks,
-                    IndexedDBTransaction* transaction);
-  void GetAllOperation(int64_t object_store_id,
-                       int64_t index_id,
-                       std::unique_ptr<IndexedDBKeyRange> key_range,
-                       indexed_db::CursorType cursor_type,
-                       int64_t max_count,
-                       scoped_refptr<IndexedDBCallbacks> callbacks,
-                       IndexedDBTransaction* transaction);
-  struct PutOperationParams;
-  void PutOperation(std::unique_ptr<PutOperationParams> params,
-                    IndexedDBTransaction* transaction);
-  void SetIndexesReadyOperation(size_t index_count,
-                                IndexedDBTransaction* transaction);
-  struct OpenCursorOperationParams;
-  void OpenCursorOperation(std::unique_ptr<OpenCursorOperationParams> params,
-                           IndexedDBTransaction* transaction);
-  void CountOperation(int64_t object_store_id,
-                      int64_t index_id,
-                      std::unique_ptr<IndexedDBKeyRange> key_range,
-                      scoped_refptr<IndexedDBCallbacks> callbacks,
-                      IndexedDBTransaction* transaction);
-  void DeleteRangeOperation(int64_t object_store_id,
-                            std::unique_ptr<IndexedDBKeyRange> key_range,
-                            scoped_refptr<IndexedDBCallbacks> callbacks,
-                            IndexedDBTransaction* transaction);
-  void ClearOperation(int64_t object_store_id,
-                      scoped_refptr<IndexedDBCallbacks> callbacks,
-                      IndexedDBTransaction* transaction);
+  OperationResult DeleteRangeOperation(
+      int64_t object_store_id,
+      std::unique_ptr<IndexedDBKeyRange> key_range,
+      scoped_refptr<IndexedDBCallbacks> callbacks,
+      IndexedDBTransaction* transaction);
+  OperationResult ClearOperation(int64_t object_store_id,
+                                 scoped_refptr<IndexedDBCallbacks> callbacks,
+                                 IndexedDBTransaction* transaction);
 
  protected:
+  friend class IndexedDBTransaction;
+
   IndexedDBDatabase(const base::string16& name,
                     IndexedDBBackingStore* backing_store,
                     IndexedDBFactory* factory,
                     const Identifier& unique_identifier);
   virtual ~IndexedDBDatabase();
 
   // May be overridden in tests.
   virtual size_t GetMaxMessageSizeInBytes() const;
 
+  IndexedDBFactory* factory() const { return factory_.get(); }
+
  private:
   friend class base::RefCounted<IndexedDBDatabase>;
   friend class IndexedDBClassFactory;
 
   class ConnectionRequest;
   class OpenRequest;
   class DeleteRequest;
 
   leveldb::Status OpenInternal();
 
@@ skipping 49 matching lines @@
   // 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_