[IndexedDB] Integrating failures and corruption with transaction

content/browser/indexed_db/indexed_db_transaction.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_TRANSACTION_H_
 #define CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_TRANSACTION_H_
 
 #include <stdint.h>
 
 #include <memory>
@@ skipping 17 matching lines @@
 
 class BlobWriteCallbackImpl;
 class IndexedDBCursor;
 class IndexedDBDatabaseCallbacks;
 class IndexedDBObservation;
 class IndexedDBObserverChanges;
 
 class CONTENT_EXPORT IndexedDBTransaction
     : public NON_EXPORTED_BASE(base::RefCounted<IndexedDBTransaction>) {
  public:
-  typedef base::Callback<void(IndexedDBTransaction*)> Operation;
+  using OperationResult = leveldb::Status;

[cmumford, 2016/11/21 18:29:22]

I'm not a fan of introducing OperationResult. It obfuscates the type, and isn't
even shorter than leveldb::Status.

[dmurph, 2016/11/22 23:33:11]

Done.

+  using Operation = base::Callback<OperationResult(IndexedDBTransaction*)>;
+  using AbortOperation = base::Closure;
 
   enum State {
     CREATED,     // Created, but not yet started by coordinator.
     STARTED,     // Started by the coordinator.
     COMMITTING,  // In the process of committing, possibly waiting for blobs
                  // to be written.
     FINISHED,    // Either aborted or committed.
   };
 
   virtual void Abort();
   leveldb::Status Commit();
   void Abort(const IndexedDBDatabaseError& error);
 
   // Called by the transaction coordinator when this transaction is unblocked.
   void Start();
 
   blink::WebIDBTransactionMode mode() const { return mode_; }
   const std::set<int64_t>& scope() const { return object_store_ids_; }
 
   void ScheduleTask(Operation task) {
     ScheduleTask(blink::WebIDBTaskTypeNormal, task);
   }
   void ScheduleTask(blink::WebIDBTaskType, Operation task);
-  void ScheduleAbortTask(Operation abort_task);
+  void ScheduleAbortTask(AbortOperation abort_task);
   void RegisterOpenCursor(IndexedDBCursor* cursor);
   void UnregisterOpenCursor(IndexedDBCursor* cursor);
   void AddPreemptiveEvent() { pending_preemptive_events_++; }
   void DidCompletePreemptiveEvent() {
     pending_preemptive_events_--;
     DCHECK_GE(pending_preemptive_events_, 0);
   }
   void AddPendingObserver(int32_t observer_id,
                           const IndexedDBObserver::Options& options);
   // Delete pending observers with ID's listed in |pending_observer_ids|.
@@ skipping 47 matching lines @@
   friend class IndexedDBClassFactory;
   friend class base::RefCounted<IndexedDBTransaction>;
 
   FRIEND_TEST_ALL_PREFIXES(IndexedDBTransactionTestMode, AbortPreemptive);
   FRIEND_TEST_ALL_PREFIXES(IndexedDBTransactionTestMode, AbortTasks);
   FRIEND_TEST_ALL_PREFIXES(IndexedDBTransactionTest, NoTimeoutReadOnly);
   FRIEND_TEST_ALL_PREFIXES(IndexedDBTransactionTest,
                            SchedulePreemptiveTask);
   FRIEND_TEST_ALL_PREFIXES(IndexedDBTransactionTestMode,
                            ScheduleNormalTask);
+  FRIEND_TEST_ALL_PREFIXES(IndexedDBTransactionTestMode, TaskFails);
   FRIEND_TEST_ALL_PREFIXES(IndexedDBTransactionTest, Timeout);
   FRIEND_TEST_ALL_PREFIXES(IndexedDBTransactionTest, IndexedDBObserver);
 
   void RunTasksIfStarted();
 
   bool IsTaskQueueEmpty() const;
   bool HasPendingTasks() const;
 
   void BlobWriteComplete(bool success);
   void ProcessTaskQueue();
   void CloseOpenCursors();
   leveldb::Status CommitPhaseTwo();
   void Timeout();
 
   const int64_t id_;
   const std::set<int64_t> object_store_ids_;
   const blink::WebIDBTransactionMode mode_;
 
-  bool used_;
-  State state_;
-  bool commit_pending_;
+  bool used_ = false;
+  State state_ = CREATED;
+  bool commit_pending_ = false;
   base::WeakPtr<IndexedDBConnection> connection_;
   scoped_refptr<IndexedDBDatabaseCallbacks> callbacks_;
   scoped_refptr<IndexedDBDatabase> database_;
 
   // Observers in pending queue do not listen to changes until activated.
   std::vector<std::unique_ptr<IndexedDBObserver>> pending_observers_;
   std::map<int32_t, std::unique_ptr<IndexedDBObserverChanges>>
       connection_changes_map_;
 
   class TaskQueue {
    public:
     TaskQueue();
     ~TaskQueue();
     bool empty() const { return queue_.empty(); }
-    void push(Operation task) { queue_.push(task); }
+    void push(Operation task) { queue_.push(std::move(task)); }
     Operation pop();
     void clear();
 
    private:
     std::queue<Operation> queue_;
 
     DISALLOW_COPY_AND_ASSIGN(TaskQueue);
   };
 
   class TaskStack {
    public:
     TaskStack();
     ~TaskStack();
     bool empty() const { return stack_.empty(); }
-    void push(Operation task) { stack_.push(task); }
-    Operation pop();
+    void push(AbortOperation task) { stack_.push(std::move(task)); }
+    AbortOperation pop();
     void clear();
 
    private:
-    std::stack<Operation> stack_;
+    std::stack<AbortOperation> stack_;
 
     DISALLOW_COPY_AND_ASSIGN(TaskStack);
   };
 
   TaskQueue task_queue_;
   TaskQueue preemptive_task_queue_;
   TaskStack abort_task_stack_;
 
   std::unique_ptr<IndexedDBBackingStore::Transaction> transaction_;
-  bool backing_store_transaction_begun_;
+  bool backing_store_transaction_begun_ = false;
 
-  bool should_process_queue_;
-  int pending_preemptive_events_;
+  bool should_process_queue_ = false;
+  int pending_preemptive_events_ = 0;
+  bool processing_event_queue_ = false;
 
   std::set<IndexedDBCursor*> open_cursors_;
 
   // This timer is started after requests have been processed. If no subsequent
   // requests are processed before the timer fires, assume the script is
   // unresponsive and abort to unblock the transaction queue.
   base::OneShotTimer timeout_timer_;
 
   Diagnostics diagnostics_;
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_TRANSACTION_H_