Blob support for IDB [Chromium]

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 <queue>
 #include <set>
 #include <stack>
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "content/browser/indexed_db/indexed_db_backing_store.h"
 #include "content/browser/indexed_db/indexed_db_database.h"
 #include "content/browser/indexed_db/indexed_db_database_error.h"
 
 namespace content {
 
+class BlobWriteCallbackImpl;
 class IndexedDBCursor;
 class IndexedDBDatabaseCallbacks;
 
 class IndexedDBTransaction : public base::RefCounted<IndexedDBTransaction> {
  public:
   typedef base::Callback<void(IndexedDBTransaction*)> Operation;
 
   IndexedDBTransaction(int64 id,
                        scoped_refptr<IndexedDBDatabaseCallbacks> callbacks,
                        const std::set<int64>& object_store_ids,
@@ skipping 27 matching lines @@
 
   IndexedDBDatabase* database() const { return database_; }
   IndexedDBDatabaseCallbacks* connection() const { return callbacks_; }
   bool IsRunning() const { return state_ == RUNNING; }
 
  protected:
   virtual ~IndexedDBTransaction();
   friend class base::RefCounted<IndexedDBTransaction>;
 
  private:
+  friend class BlobWriteCallbackImpl;
+
   enum State {
     UNUSED,         // Created, but no tasks yet.
     START_PENDING,  // Enqueued tasks, but backing store transaction not yet
                     // started.
     RUNNING,        // Backing store transaction started but not yet finished.
+    COMMITTING,     // In the process of committing, possibly waiting for blobs

[jsbell, 2013/09/13 00:12:21]

Happy fun state transition diagram.

[ericu, 2013/11/20 23:05:39]

Yup.  At least it's still pretty non-branchy.

[jsbell, 2013/11/21 22:54:32]

FYI, I just learned we have a bug here. The UNUSED special case makes sense on
the front end (an unused transaction can be fast-aborted) but it leads to
scheduling bugs here. So we may need to tweak the states a bit. Maybe that helps
with WAS_USED...

crbug.com/322238

+                    // to be written.
     FINISHED,       // Either aborted or committed.
   };
+  enum TransactionUseState { WAS_USED, WAS_NOT_USED };
+  enum ShouldSkipCommit { DO_COMMIT, SKIP_COMMIT };

[jsbell, 2013/09/13 00:12:21]

Seems like we should be able to combine WAS_NOT_USED and SKIP_COMMIT

[ericu, 2013/11/20 23:05:39]

They could be sliced differently, but we do need two bits there AFAICT.  They
control both whether to call transaction_.CommitPhaseTwo() and whether to run
OnComplete() vs. OnAbort().  I just had to write a Karnaugh map to make sure
there wasn't a quick simplification, but I couldn't find one.

+
+  bool IsStatePastRunning() const {

[jsbell, 2013/09/13 00:12:21]

We'll want context to call into this, to report it on the internals page.

[ericu, 2013/11/20 23:05:39]

Added a TODO.

+    return state_ == COMMITTING || state_ == FINISHED;
+  }
 
   void EnsureTasksRunning();
   void Start();
 
   bool IsTaskQueueEmpty() const;
   bool HasPendingTasks() const;
 
+  void BlobWriteComplete(bool success);
   void ProcessTaskQueue();
   void CloseOpenCursors();
+  void CommitPhaseTwo(TransactionUseState use_state,
+      ShouldSkipCommit skip_commit);
 
   const int64 id_;
   const std::set<int64> object_store_ids_;
   const indexed_db::TransactionMode mode_;
 
   State state_;
   bool commit_pending_;
+  bool blob_write_success_;
   scoped_refptr<IndexedDBDatabaseCallbacks> callbacks_;
   scoped_refptr<IndexedDBDatabase> database_;
 
   class TaskQueue {
    public:
     TaskQueue();
     ~TaskQueue();
     bool empty() const { return queue_.empty(); }
     void push(Operation task) { queue_.push(task); }
     Operation pop();
@@ skipping 24 matching lines @@
 
   bool should_process_queue_;
   int pending_preemptive_events_;
 
   std::set<IndexedDBCursor*> open_cursors_;
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_TRANSACTION_H_