Migrate the IndexedDB backend from Blink to Chromium

To get the IDB backend off the (deprecated) WebKit thread, remove
intermediate proxying, and let us take advantage of base utilities,
we're moving the code from Blink to Chromium.

This patch is basically a glorified copy/paste of the Blink IDB
backend code, with Chromium coding style applied, WTF dependencies
replaced with STL and base/, redundant classes removed, etc. It
introduces some new temporary proxy classes
(content/browser/webidb*_impl.*) to allow us build both the old and
new backends.

The new backend is currently disabled by default. It can be enabled
using a new (and temporary) command line switch: --new-indexeddb Once
we've done some further cleanup and are confident that the new backend
is stable, and the bots have moved from DumpRenderTree to
content_shell, we'll switch to the new backend by default. Once that
has survived through a dev channel release, we'll delete the Blink
code and eliminate unnecessary proxy classes.

BUG=234278
R=alecflett@chromium.org, dgrogan@chromium.org, piman@chromium.org

Committed: https://src.chromium.org/viewvc/chrome?view=rev&revision=202215

Committed: https://src.chromium.org/viewvc/chrome?view=rev&revision=202604

Committed: https://src.chromium.org/viewvc/chrome?view=rev&revision=203164

Committed: https://src.chromium.org/viewvc/chrome?view=rev&revision=203257

Review URL: https://codereview.chromium.org/15564008

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@203443 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 308 insertions, 0 deletions

diff --git a/content/browser/indexed_db/indexed_db_transaction.cc b/content/browser/indexed_db/indexed_db_transaction.cc
new file mode 100644
index 0000000..b0a9946
--- /dev/null
+++ b/content/browser/indexed_db/indexed_db_transaction.cc
@@ -0,0 +1,308 @@
+// 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 <vector>
+#include "base/logging.h"
+#include "base/utf_string_conversions.h"
+#include "content/browser/indexed_db/indexed_db_backing_store.h"
+#include "content/browser/indexed_db/indexed_db_cursor_impl.h"
+#include "content/browser/indexed_db/indexed_db_database_callbacks_wrapper.h"
+#include "content/browser/indexed_db/indexed_db_database_impl.h"
+#include "content/browser/indexed_db/indexed_db_tracing.h"
+#include "content/browser/indexed_db/indexed_db_transaction_coordinator.h"
+#include "third_party/WebKit/public/platform/WebIDBDatabaseException.h"
+
+namespace content {
+
+IndexedDBTransaction::TaskQueue::TaskQueue() {}
+IndexedDBTransaction::TaskQueue::~TaskQueue() { clear(); }
+
+void IndexedDBTransaction::TaskQueue::clear() {
+  while (!queue_.empty())
+    scoped_ptr<Operation> task(pop());
+}
+
+scoped_ptr<IndexedDBTransaction::Operation>
+IndexedDBTransaction::TaskQueue::pop() {
+  DCHECK(!queue_.empty());
+  scoped_ptr<Operation> task(queue_.front());
+  queue_.pop();
+  return task.Pass();
+}
+
+IndexedDBTransaction::TaskStack::TaskStack() {}
+IndexedDBTransaction::TaskStack::~TaskStack() { clear(); }
+
+void IndexedDBTransaction::TaskStack::clear() {
+  while (!stack_.empty())
+    scoped_ptr<Operation> task(pop());
+}
+
+scoped_ptr<IndexedDBTransaction::Operation>
+IndexedDBTransaction::TaskStack::pop() {
+  DCHECK(!stack_.empty());
+  scoped_ptr<Operation> task(stack_.top());
+  stack_.pop();
+  return task.Pass();
+}
+
+scoped_refptr<IndexedDBTransaction> IndexedDBTransaction::Create(
+    int64 id,
+    scoped_refptr<IndexedDBDatabaseCallbacksWrapper> callbacks,
+    const std::vector<int64>& object_store_ids,
+    indexed_db::TransactionMode mode,
+    IndexedDBDatabaseImpl* database) {
+  std::set<int64> object_store_hash_set;
+  for (size_t i = 0; i < object_store_ids.size(); ++i)
+    object_store_hash_set.insert(object_store_ids[i]);
+
+  return make_scoped_refptr(new IndexedDBTransaction(
+      id, callbacks, object_store_hash_set, mode, database));
+}
+
+IndexedDBTransaction::IndexedDBTransaction(
+    int64 id,
+    scoped_refptr<IndexedDBDatabaseCallbacksWrapper> callbacks,
+    const std::set<int64>& object_store_ids,
+    indexed_db::TransactionMode mode,
+    IndexedDBDatabaseImpl* database)
+    : id_(id),
+      object_store_ids_(object_store_ids),
+      mode_(mode),
+      state_(UNUSED),
+      commit_pending_(false),
+      callbacks_(callbacks),
+      database_(database),
+      transaction_(database->BackingStore().get()),
+      pending_preemptive_events_(0) {
+  database_->transaction_coordinator().DidCreateTransaction(this);
+}
+
+IndexedDBTransaction::~IndexedDBTransaction() {
+  // 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(task_queue_.empty());
+  DCHECK(abort_task_stack_.empty());
+}
+
+void IndexedDBTransaction::ScheduleTask(IndexedDBDatabase::TaskType type,
+                                        Operation* task,
+                                        Operation* abort_task) {
+  if (state_ == FINISHED)
+    return;
+
+  if (type == IndexedDBDatabase::NORMAL_TASK)
+    task_queue_.push(task);
+  else
+    preemptive_task_queue_.push(task);
+
+  if (abort_task)
+    abort_task_stack_.push(abort_task);
+
+  if (state_ == UNUSED)
+    Start();
+  else if (state_ == RUNNING && !task_timer_.IsRunning())
+    task_timer_.Start(FROM_HERE,
+                      base::TimeDelta::FromSeconds(0),
+                      this,
+                      &IndexedDBTransaction::TaskTimerFired);
+}
+
+void IndexedDBTransaction::Abort() {
+  Abort(IndexedDBDatabaseError::Create(
+      WebKit::WebIDBDatabaseExceptionUnknownError,
+      ASCIIToUTF16("Internal error (unknown cause)")));
+}
+
+void IndexedDBTransaction::Abort(scoped_refptr<IndexedDBDatabaseError> error) {
+  IDB_TRACE("IndexedDBTransaction::abort");
+  if (state_ == FINISHED)
+    return;
+
+  bool was_running = state_ == RUNNING;
+
+  // The last reference to this object may be released while performing the
+  // abort steps below. We therefore take a self reference to keep ourselves
+  // alive while executing this method.
+  scoped_refptr<IndexedDBTransaction> protect(this);
+
+  state_ = FINISHED;
+  task_timer_.Stop();
+
+  if (was_running)
+    transaction_.Rollback();
+
+  // Run the abort tasks, if any.
+  while (!abort_task_stack_.empty()) {
+    scoped_ptr<Operation> task(abort_task_stack_.pop());
+    task->Perform(0);
+  }
+  preemptive_task_queue_.clear();
+  task_queue_.clear();
+
+  // 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
+  // operations like closing connections.
+  database_->transaction_coordinator().DidFinishTransaction(this);
+#ifndef NDEBUG
+  DCHECK(!database_->transaction_coordinator().IsActive(this));
+#endif
+  database_->TransactionFinished(this);
+
+  if (callbacks_)
+    callbacks_->OnAbort(id_, error);
+
+  database_->TransactionFinishedAndAbortFired(this);
+
+  database_ = NULL;
+}
+
+bool IndexedDBTransaction::IsTaskQueueEmpty() const {
+  return preemptive_task_queue_.empty() && task_queue_.empty();
+}
+
+bool IndexedDBTransaction::HasPendingTasks() const {
+  return pending_preemptive_events_ || !IsTaskQueueEmpty();
+}
+
+void IndexedDBTransaction::RegisterOpenCursor(IndexedDBCursorImpl* cursor) {
+  open_cursors_.insert(cursor);
+}
+
+void IndexedDBTransaction::UnregisterOpenCursor(IndexedDBCursorImpl* cursor) {
+  open_cursors_.erase(cursor);
+}
+
+void IndexedDBTransaction::Run() {
+  // TransactionCoordinator has started this transaction. Schedule a timer
+  // to process the first task.
+  DCHECK(state_ == START_PENDING || state_ == RUNNING);
+  DCHECK(!task_timer_.IsRunning());
+
+  task_timer_.Start(FROM_HERE,
+                    base::TimeDelta::FromSeconds(0),
+                    this,
+                    &IndexedDBTransaction::TaskTimerFired);
+}
+
+void IndexedDBTransaction::Start() {
+  DCHECK_EQ(state_, UNUSED);
+
+  state_ = START_PENDING;
+  database_->transaction_coordinator().DidStartTransaction(this);
+  database_->TransactionStarted(this);
+}
+
+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)
+    return;
+
+  DCHECK(state_ == UNUSED || state_ == RUNNING);
+  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;
+
+  // 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
+  abort_task_stack_.clear();
+
+  bool unused = state_ == UNUSED;
+  state_ = FINISHED;
+
+  bool committed = unused || transaction_.Commit();
+
+  // 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
+  // operations like closing connections.
+  if (!unused)
+    database_->transaction_coordinator().DidFinishTransaction(this);
+  database_->TransactionFinished(this);
+
+  if (committed) {
+    callbacks_->OnComplete(id_);
+    database_->TransactionFinishedAndCompleteFired(this);
+  } else {
+    callbacks_->OnAbort(
+        id_,
+        IndexedDBDatabaseError::Create(
+            WebKit::WebIDBDatabaseExceptionUnknownError,
+            ASCIIToUTF16("Internal error committing transaction.")));
+    database_->TransactionFinishedAndAbortFired(this);
+  }
+
+  database_ = NULL;
+}
+
+void IndexedDBTransaction::TaskTimerFired() {
+  IDB_TRACE("IndexedDBTransaction::task_timer_fired");
+  DCHECK(!IsTaskQueueEmpty());
+
+  if (state_ == START_PENDING) {
+    transaction_.begin();
+    state_ = RUNNING;
+  }
+
+  // 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(state_, RUNNING);
+    scoped_ptr<Operation> task(task_queue->pop());
+    task->Perform(this);
+
+    // 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_)
+    Commit();
+}
+
+void IndexedDBTransaction::CloseOpenCursors() {
+  for (std::set<IndexedDBCursorImpl*>::iterator i = open_cursors_.begin();
+       i != open_cursors_.end();
+       ++i)
+    (*i)->Close();
+  open_cursors_.clear();
+}
+
+}  // namespace content