[IndexedDB] Integrating failures and corruption with transaction

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/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/browser/indexed_db/indexed_db_backing_store.h"
 #include "content/browser/indexed_db/indexed_db_cursor.h"
 #include "content/browser/indexed_db/indexed_db_database.h"
 #include "content/browser/indexed_db/indexed_db_database_callbacks.h"
+#include "content/browser/indexed_db/indexed_db_factory.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/modules/indexeddb/WebIDBDatabaseException.h"
 #include "third_party/leveldatabase/env_chromium.h"
 
 namespace content {
 
 namespace {
 
 const int64_t kInactivityTimeoutPeriodSeconds = 60;
 
 // Helper for posting a task to call IndexedDBTransaction::Commit when we know
 // the transaction had no requests and therefore the commit must succeed.
 void CommitUnused(scoped_refptr<IndexedDBTransaction> transaction) {
   leveldb::Status status = transaction->Commit();
   DCHECK(status.ok());
 }
 
+// The database will be closed during this call.
+void ReportError(leveldb::Status status,
+                 const scoped_refptr<IndexedDBDatabase> database,
+                 IndexedDBFactory* factory) {
+  DCHECK(!status.ok());
+  if (status.IsCorruption()) {
+    IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
+                                 base::ASCIIToUTF16(status.ToString()));
+    factory->HandleBackingStoreCorruption(database->origin(), error);
+  } else {
+    factory->HandleBackingStoreFailure(database->origin());
+  }
+}
+
+
+
 }  // namespace
 
 IndexedDBTransaction::TaskQueue::TaskQueue() {}
 IndexedDBTransaction::TaskQueue::~TaskQueue() { clear(); }
 
 void IndexedDBTransaction::TaskQueue::clear() {
   while (!queue_.empty())
     queue_.pop();
 }
 
 IndexedDBTransaction::Operation IndexedDBTransaction::TaskQueue::pop() {
   DCHECK(!queue_.empty());
-  Operation task(queue_.front());
+  Operation task = std::move(queue_.front());
   queue_.pop();
   return task;
 }
 
 IndexedDBTransaction::TaskStack::TaskStack() {}
 IndexedDBTransaction::TaskStack::~TaskStack() { clear(); }
 
 void IndexedDBTransaction::TaskStack::clear() {
   while (!stack_.empty())
     stack_.pop();
 }
 
-IndexedDBTransaction::Operation IndexedDBTransaction::TaskStack::pop() {
+IndexedDBTransaction::AbortOperation IndexedDBTransaction::TaskStack::pop() {
   DCHECK(!stack_.empty());
-  Operation task(stack_.top());
+  AbortOperation task = std::move(stack_.top());
   stack_.pop();
   return task;
 }
 
 IndexedDBTransaction::IndexedDBTransaction(
     int64_t id,
     base::WeakPtr<IndexedDBConnection> connection,
     const std::set<int64_t>& object_store_ids,
     blink::WebIDBTransactionMode mode,
     IndexedDBBackingStore::Transaction* backing_store_transaction)
     : id_(id),
       object_store_ids_(object_store_ids),
       mode_(mode),
-      used_(false),
-      state_(CREATED),
-      commit_pending_(false),
       connection_(std::move(connection)),
-      transaction_(backing_store_transaction),
-      backing_store_transaction_begun_(false),
-      should_process_queue_(false),
-      pending_preemptive_events_(0) {
+      transaction_(backing_store_transaction) {
   callbacks_ = connection_->callbacks();
   database_ = connection_->database();
 
   database_->transaction_coordinator().DidCreateTransaction(this);
 
   diagnostics_.tasks_scheduled = 0;
   diagnostics_.tasks_completed = 0;
   diagnostics_.creation_time = base::Time::Now();
 }
 
 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_EQ(pending_preemptive_events_, 0);
   DCHECK(task_queue_.empty());
   DCHECK(abort_task_stack_.empty());
   DCHECK(pending_observers_.empty());
+  DCHECK(!processing_event_queue_);
 }
 
 void IndexedDBTransaction::ScheduleTask(blink::WebIDBTaskType type,
                                         Operation task) {
   DCHECK_NE(state_, COMMITTING);
   if (state_ == FINISHED)
     return;
 
   timeout_timer_.Stop();
   used_ = true;
   if (type == blink::WebIDBTaskTypeNormal) {
     task_queue_.push(task);
     ++diagnostics_.tasks_scheduled;
   } else {
     preemptive_task_queue_.push(task);
   }
   RunTasksIfStarted();
 }
 
-void IndexedDBTransaction::ScheduleAbortTask(Operation abort_task) {
+void IndexedDBTransaction::ScheduleAbortTask(AbortOperation abort_task) {
   DCHECK_NE(FINISHED, state_);
   DCHECK(used_);
-  abort_task_stack_.push(abort_task);
+  abort_task_stack_.push(std::move(abort_task));
 }
 
 void IndexedDBTransaction::RunTasksIfStarted() {
   DCHECK(used_);
 
   // Not started by the coordinator yet.
   if (state_ != STARTED)
     return;
 
   // A task is already posted.
@@ skipping 23 matching lines @@
   timeout_timer_.Stop();
 
   state_ = FINISHED;
   should_process_queue_ = false;
 
   if (backing_store_transaction_begun_)
     transaction_->Rollback();
 
   // Run the abort tasks, if any.
   while (!abort_task_stack_.empty())
-    abort_task_stack_.pop().Run(NULL);
+    abort_task_stack_.pop().Run();
 
   preemptive_task_queue_.clear();
   pending_preemptive_events_ = 0;
   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();
@@ skipping 67 matching lines @@
 
  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
+
+  if (!success) {
     Abort(IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionDataError,
                                  "Failed to write blobs."));
+    return;
+  }
+  // Save the database as |this| can be destroyed in the next line.
+  scoped_refptr<IndexedDBDatabase> database = database_;
+  leveldb::Status s = CommitPhaseTwo();
+  if (!s.ok())
+    ReportError(s, database, database->factory());
 }
 
 leveldb::Status IndexedDBTransaction::Commit() {
   IDB_TRACE1("IndexedDBTransaction::Commit", "txn.id", id());
 
   timeout_timer_.Stop();
 
   // In multiprocess ports, front-end may have requested a commit but
   // an abort has already been initiated asynchronously by the
   // back-end.
@@ skipping 86 matching lines @@
       callbacks_->OnComplete(id_);
     }
     if (!pending_observers_.empty() && connection_) {
       connection_->ActivatePendingObservers(std::move(pending_observers_));
       pending_observers_.clear();
     }
 
     database_->TransactionFinished(this, true);
   } else {
     while (!abort_task_stack_.empty())
-      abort_task_stack_.pop().Run(NULL);
+      abort_task_stack_.pop().Run();
 
     IndexedDBDatabaseError error;
     if (leveldb_env::IndicatesDiskFull(s)) {
       error = IndexedDBDatabaseError(
           blink::WebIDBDatabaseExceptionQuotaError,
           "Encountered disk full while committing transaction.");
     } else {
       error = IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionUnknownError,
                                      "Internal error committing transaction.");
     }
     callbacks_->OnAbort(id_, error);
 
     database_->TransactionFinished(this, false);
-    database_->TransactionCommitFailed(s);
   }
 
   database_ = NULL;
   return s;
 }
 
 void IndexedDBTransaction::ProcessTaskQueue() {
   IDB_TRACE1("IndexedDBTransaction::ProcessTaskQueue", "txn.id", id());
 
+  DCHECK(!processing_event_queue_);
+
   // May have been aborted.
   if (!should_process_queue_)
     return;
 
+  processing_event_queue_ = true;
+
   DCHECK(!IsTaskQueueEmpty());
   should_process_queue_ = false;
 
   if (!backing_store_transaction_begun_) {
     transaction_->Begin();
     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(state_, STARTED);
     Operation task(task_queue->pop());
-    task.Run(this);
+    leveldb::Status result = task.Run(this);
     if (!pending_preemptive_events_) {
       DCHECK(diagnostics_.tasks_completed < diagnostics_.tasks_scheduled);
       ++diagnostics_.tasks_completed;
     }
+    if (!result.ok()) {
+      processing_event_queue_ = false;
+      if (!result.ok())
+        ReportError(result, database_, database_->factory());
+      return;
+    }
 
     // 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();
+    leveldb::Status result = Commit();
+    processing_event_queue_ = false;
+    if (!result.ok())
+      ReportError(result, database_, database_->factory());
     return;
   }
 
   // The transaction may have been aborted while processing tasks.
-  if (state_ == FINISHED)
+  if (state_ == FINISHED) {
+    processing_event_queue_ = false;
     return;
+  }
 
   DCHECK(state_ == STARTED);
 
   // Otherwise, start a timer in case the front-end gets wedged and
   // never requests further activity. Read-only transactions don't
   // block other transactions, so don't time those out.
   if (mode_ != blink::WebIDBTransactionModeReadOnly) {
     timeout_timer_.Start(FROM_HERE, GetInactivityTimeout(),
                          base::Bind(&IndexedDBTransaction::Timeout, this));
   }
+  processing_event_queue_ = false;
 }
 
 base::TimeDelta IndexedDBTransaction::GetInactivityTimeout() const {
   return base::TimeDelta::FromSeconds(kInactivityTimeoutPeriodSeconds);
 }
 
 void IndexedDBTransaction::Timeout() {
   Abort(IndexedDBDatabaseError(
       blink::WebIDBDatabaseExceptionTimeoutError,
       base::ASCIIToUTF16("Transaction timed out due to inactivity.")));
@@ skipping 40 matching lines @@
 void IndexedDBTransaction::RecordObserverForLastObservation(
     int32_t connection_id,
     int32_t observer_id) {
   auto it = connection_changes_map_.find(connection_id);
   DCHECK(it != connection_changes_map_.end());
   it->second->observation_index_map[observer_id].push_back(
       it->second->observations.size() - 1);
 }
 
 }  // namespace content