Blob support for IDB [Chromium]

content/browser/indexed_db/indexed_db_transaction.cc

 // 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.
 
 #include "content/browser/indexed_db/indexed_db_transaction.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 69 matching lines @@
   // It shouldn't be possible for this object to get deleted until it's either
   // complete or aborted.
   DCHECK_EQ(state_, FINISHED);
   DCHECK(preemptive_task_queue_.empty());
   DCHECK_EQ(pending_preemptive_events_, 0);
   DCHECK(task_queue_.empty());
   DCHECK(abort_task_stack_.empty());
 }
 
 void IndexedDBTransaction::ScheduleTask(Operation task, Operation abort_task) {
-  if (state_ == FINISHED)
+  if (IsStatePastStarted())
     return;
 
   timeout_timer_.Stop();
   used_ = true;
   task_queue_.push(task);
   ++diagnostics_.tasks_scheduled;
   abort_task_stack_.push(abort_task);
   RunTasksIfStarted();
 }
 
 void IndexedDBTransaction::ScheduleTask(IndexedDBDatabase::TaskType type,
                                         Operation task) {
-  if (state_ == FINISHED)
+  if (IsStatePastStarted())
     return;
 
   timeout_timer_.Stop();
   used_ = true;
   if (type == IndexedDBDatabase::NORMAL_TASK) {
     task_queue_.push(task);
     ++diagnostics_.tasks_scheduled;
   } else {
     preemptive_task_queue_.push(task);
   }
@@ skipping 91 matching lines @@
   DCHECK_EQ(CREATED, state_);
   state_ = STARTED;
   diagnostics_.start_time = base::Time::Now();
 
   if (!used_)
     return;
 
   RunTasksIfStarted();
 }
 
+class BlobWriteCallbackImpl : public IndexedDBBackingStore::BlobWriteCallback {
+ public:
+  BlobWriteCallbackImpl(scoped_refptr<IndexedDBTransaction> transaction)
+      : transaction_(transaction) {}
+  virtual ~BlobWriteCallbackImpl() {}
+  virtual void Run(bool succeeded) {
+    transaction_->BlobWriteComplete(succeeded);
+  }
+
+ private:
+  scoped_refptr<IndexedDBTransaction> transaction_;
+};
+
+void IndexedDBTransaction::BlobWriteComplete(bool success) {
+  IDB_TRACE("IndexedDBTransaction::BlobWriteComplete");
+  if (state_ == FINISHED)  // aborted
+    return;
+  DCHECK_EQ(state_, COMMITTING);
+  if (success)
+    CommitPhaseTwo();
+  else
+    Abort(IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionDataError,
+                                 "Failed to write blobs."));
+}
+
 void IndexedDBTransaction::Commit() {
   IDB_TRACE("IndexedDBTransaction::Commit");
 
   // In multiprocess ports, front-end may have requested a commit but
   // an abort has already been initiated asynchronously by the
   // back-end.
-  if (state_ == FINISHED)
+  if (IsStatePastStarted()) {
+    DCHECK(state_ == FINISHED);
     return;
+  }
 
   DCHECK(!used_ || state_ == STARTED);
   commit_pending_ = true;
 
   // Front-end has requested a commit, but there may be tasks like
   // create_index which are considered synchronous by the front-end
   // but are processed asynchronously.
   if (HasPendingTasks())
     return;
 
+  state_ = COMMITTING;
+
+  if (!used_)
+    CommitPhaseTwo();
+  else {
+    scoped_refptr<IndexedDBBackingStore::BlobWriteCallback> callback(
+        new BlobWriteCallbackImpl(this));
+    // CommitPhaseOne will call the callback synchronously if there are no blobs
+    // to write.
+    if (!transaction_->CommitPhaseOne(callback).ok())
+      Abort(IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionDataError,
+                                   "Error processing blob journal."));
+  }
+}
+
+void IndexedDBTransaction::CommitPhaseTwo() {

[jsbell, 2014/05/20 22:02:19]

Is it possible for an Abort() to slip in between Commit() and CommitPhaseTwo() ?

It doesn't look like the front end currently puts itself into 'Finishing' state
after calling m_backend->commit(), so script could call abort() at an expected
time.

[ericu, 2014/05/21 18:14:47]

Ah, yes it is.  For CommitPhaseTwo to be called after Abort, it would have to
hit just after the blob write completed and posted its callback to the message
loop, but before it got run.  Fixed.
Should we also block this at the frontend, or is it desirable/legal to call
abort during a commit and have it work?

+  DCHECK_EQ(state_, COMMITTING);
+
   // The last reference to this object may be released while performing the
   // commit steps below. We therefore take a self reference to keep ourselves
   // alive while executing this method.
   scoped_refptr<IndexedDBTransaction> protect(this);
 
   timeout_timer_.Stop();
 
   state_ = FINISHED;
 
-  bool committed = !used_ || transaction_->Commit().ok();
+  bool committed = !used_ || transaction_->CommitPhaseTwo().ok();
 
   // Backing store resources (held via cursors) must be released
   // before script callbacks are fired, as the script callbacks may
   // release references and allow the backing store itself to be
   // released, and order is critical.
   CloseOpenCursors();
   transaction_->Reset();
 
   // Transactions must also be marked as completed before the
   // front-end is notified, as the transaction completion unblocks
@@ skipping 34 matching lines @@
     backing_store_transaction_begun_ = true;
   }
 
   // The last reference to this object may be released while performing the
   // tasks. Take take a self reference to keep this object alive so that
   // the loop termination conditions can be checked.
   scoped_refptr<IndexedDBTransaction> protect(this);
 
   TaskQueue* task_queue =
       pending_preemptive_events_ ? &preemptive_task_queue_ : &task_queue_;
-  while (!task_queue->empty() && state_ != FINISHED) {
-    DCHECK_EQ(STARTED, state_);
+  while (!task_queue->empty() && !IsStatePastStarted()) {
+    DCHECK_EQ(state_, STARTED);
     Operation task(task_queue->pop());
     task.Run(this);
     if (!pending_preemptive_events_) {
       DCHECK(diagnostics_.tasks_completed < diagnostics_.tasks_scheduled);
       ++diagnostics_.tasks_completed;
     }
 
     // Event itself may change which queue should be processed next.
     task_queue =
         pending_preemptive_events_ ? &preemptive_task_queue_ : &task_queue_;
   }
 
   // If there are no pending tasks, we haven't already committed/aborted,
   // and the front-end requested a commit, it is now safe to do so.
-  if (!HasPendingTasks() && state_ != FINISHED && commit_pending_) {
+  if (!HasPendingTasks() && !IsStatePastStarted() && commit_pending_) {
     Commit();
     return;
   }
 
   // The transaction may have been aborted while processing tasks.
   if (state_ == FINISHED)
     return;
 
   // Otherwise, start a timer in case the front-end gets wedged and
   // never requests further activity. Read-only transactions don't
@@ skipping 14 matching lines @@
 
 void IndexedDBTransaction::CloseOpenCursors() {
   for (std::set<IndexedDBCursor*>::iterator i = open_cursors_.begin();
        i != open_cursors_.end();
        ++i)
     (*i)->Close();
   open_cursors_.clear();
 }
 
 }  // namespace content