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 42 matching lines @@
     scoped_refptr<IndexedDBDatabaseCallbacks> callbacks,
     const std::set<int64>& object_store_ids,
     indexed_db::TransactionMode mode,
     IndexedDBDatabase* database)
     : id_(id),
       object_store_ids_(object_store_ids),
       mode_(mode),
       used_(false),
       state_(CREATED),
       commit_pending_(false),
+      blob_write_success_(false),
       callbacks_(callbacks),
       database_(database),
       transaction_(database->backing_store()),
       backing_store_transaction_begun_(false),
       should_process_queue_(false),
       pending_preemptive_events_(0) {
   database_->transaction_coordinator().DidCreateTransaction(this);
 
   diagnostics_.tasks_scheduled = 0;
   diagnostics_.tasks_completed = 0;
@@ skipping 15 matching lines @@
 
   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 (IsStatePastRunning())
     return;
 
   used_ = true;
   if (type == IndexedDBDatabase::NORMAL_TASK) {
     task_queue_.push(task);
     ++diagnostics_.tasks_scheduled;
   } else {
     preemptive_task_queue_.push(task);
   }
   RunTasksIfStarted();
@@ skipping 90 matching lines @@
   state_ = STARTED;
   database_->TransactionStarted(this);
   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 didSucceed() { transaction_->BlobWriteComplete(true); }

[jsbell, 2013/12/20 00:44:20]

Nit: Chromium naming style

[ericu, 2014/02/20 00:50:29]

Done.

+  virtual void didFail() { transaction_->BlobWriteComplete(false); }
+
+ 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 (IsStatePastRunning())

[jsbell, 2013/12/20 00:44:20]

Can state_ ever be COMMITTING here? The DCHECK(!used_ || state_ == STARTED)
(below) implies it can't. Commit() should get called:

(1) when the front end signals (exactly once) to commit this transaction - state
should be STARTED or FINISHED (if aborted)

(2) there were pending tasks (i.e. index population), which caused a commit
request from the front end to bail (see HasPendingTasks() call)

[ericu, 2014/02/20 00:50:29]

You're right that it shouldn't ever happen.  However, we could get here if a
malicious or malfunctioning renderer sent an extra commit during blob write. 
Returning seems like the safe thing to do; I'll add an extra DCHECK to make it
clear that state_ should be 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))
+      Abort(IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionDataError,
+                                   "Error processing blob journal."));
+  }
+}
+
+void IndexedDBTransaction::CommitPhaseTwo() {
+  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);
 
   // TODO(jsbell): Run abort tasks if commit fails? http://crbug.com/241843

[jsbell, 2013/12/20 00:44:20]

This should be resolved; needs a rebase?

[ericu, 2014/02/20 00:50:29]

Done.

   abort_task_stack_.clear();
 
   state_ = FINISHED;
 
-  bool committed = !used_ || transaction_.Commit();
+  bool committed = !used_ || transaction_.CommitPhaseTwo();
 
   // 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 31 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() && !IsStatePastRunning()) {
+    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() && !IsStatePastRunning() && commit_pending_)

[jsbell, 2013/12/20 00:44:20]

FYI, if you rebase, a test will appear below this line: if (state_ == FINISHED)
return; that should probably change to IsStatePastRunning() too.

[ericu, 2014/02/20 00:50:29]

Hmm...I'm not sure about that one.  It looks like a check for "did we abort",
which would only be FINISHED.  Is there a way to start committing while
processing the task queue?

[jsbell, 2014/02/20 22:55:50]

There shouldn't be; commit_pending_ should only be settable via IPC from the
renderer to the IDB thread, which must wait 'til this returns to the message
loop.

     Commit();
 }
 
 void IndexedDBTransaction::CloseOpenCursors() {
   for (std::set<IndexedDBCursor*>::iterator i = open_cursors_.begin();
        i != open_cursors_.end();
        ++i)
     (*i)->Close();
   open_cursors_.clear();
 }
 
 }  // namespace content