[IndexedDB] Integrating failures and corruption with transaction

content/browser/indexed_db/indexed_db_database.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_database.h"
 
 #include <math.h>
 
 #include <limits>
 #include <set>
@@ skipping 26 matching lines @@
 #include "storage/browser/blob/blob_data_handle.h"
 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBDatabaseException.h"
 #include "third_party/leveldatabase/env_chromium.h"
 #include "url/origin.h"
 
 using base::ASCIIToUTF16;
 using base::Int64ToString16;
 using blink::WebIDBKeyTypeNumber;
 
 namespace content {
-
 namespace {
 
 // Used for WebCore.IndexedDB.Schema.ObjectStore.KeyPathType and
 // WebCore.IndexedDB.Schema.Index.KeyPathType histograms. Do not
 // modify (delete, re-order, renumber) these values other than
 // the _MAX value.
 enum HistogramIDBKeyPathType {
   KEY_PATH_TYPE_NONE = 0,
   KEY_PATH_TYPE_STRING = 1,
   KEY_PATH_TYPE_ARRAY = 2,
@@ skipping 644 matching lines @@
   }
 
   AddIndex(object_store_id, index_metadata, index_id);
   transaction->ScheduleAbortTask(
       base::Bind(&IndexedDBDatabase::CreateIndexAbortOperation,
                  this,
                  object_store_id,
                  index_id));
 }
 
-void IndexedDBDatabase::CreateIndexAbortOperation(
-    int64_t object_store_id,
-    int64_t index_id,
-    IndexedDBTransaction* transaction) {
-  DCHECK(!transaction);
+void IndexedDBDatabase::CreateIndexAbortOperation(int64_t object_store_id,
+                                                  int64_t index_id) {
   IDB_TRACE("IndexedDBDatabase::CreateIndexAbortOperation");
   RemoveIndex(object_store_id, index_id);
 }
 
 void IndexedDBDatabase::DeleteIndex(int64_t transaction_id,
                                     int64_t object_store_id,
                                     int64_t index_id) {
   IDB_TRACE1("IndexedDBDatabase::DeleteIndex", "txn.id", transaction_id);
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
   DCHECK_EQ(transaction->mode(), blink::WebIDBTransactionModeVersionChange);
 
   if (!ValidateObjectStoreIdAndIndexId(object_store_id, index_id))
     return;
 
   transaction->ScheduleTask(
       base::Bind(&IndexedDBDatabase::DeleteIndexOperation,
                  this,
                  object_store_id,
                  index_id));
 }
 
-void IndexedDBDatabase::DeleteIndexOperation(
+leveldb::Status IndexedDBDatabase::DeleteIndexOperation(
     int64_t object_store_id,
     int64_t index_id,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1(
       "IndexedDBDatabase::DeleteIndexOperation", "txn.id", transaction->id());
 
   const IndexedDBIndexMetadata index_metadata =
       metadata_.object_stores[object_store_id].indexes[index_id];
 
   leveldb::Status s =
       backing_store_->DeleteIndex(transaction->BackingStoreTransaction(),
                                   transaction->database()->id(),
                                   object_store_id,
                                   index_id);
   if (!s.ok()) {
     base::string16 error_string =
         ASCIIToUTF16("Internal error deleting index '") +
         index_metadata.name + ASCIIToUTF16("'.");
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  error_string);
     transaction->Abort(error);
-    if (s.IsCorruption())
-      factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
-    return;
+    return s;
   }
 
   RemoveIndex(object_store_id, index_id);
   transaction->ScheduleAbortTask(
       base::Bind(&IndexedDBDatabase::DeleteIndexAbortOperation,
                  this,
                  object_store_id,
                  index_metadata));
+  return s;
 }
 
 void IndexedDBDatabase::DeleteIndexAbortOperation(
     int64_t object_store_id,
-    const IndexedDBIndexMetadata& index_metadata,
-    IndexedDBTransaction* transaction) {
-  DCHECK(!transaction);
+    const IndexedDBIndexMetadata& index_metadata) {
   IDB_TRACE("IndexedDBDatabase::DeleteIndexAbortOperation");
   AddIndex(object_store_id, index_metadata, IndexedDBIndexMetadata::kInvalidId);
 }
 
 void IndexedDBDatabase::RenameIndex(int64_t transaction_id,
                                     int64_t object_store_id,
                                     int64_t index_id,
                                     const base::string16& new_name) {
   IDB_TRACE1("IndexedDBDatabase::RenameIndex", "txn.id", transaction_id);
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
@@ skipping 14 matching lines @@
       backing_store_->RenameIndex(transaction->BackingStoreTransaction(),
                                   transaction->database()->id(),
                                   object_store_id,
                                   index_id,
                                   new_name);
   if (!s.ok()) {
     base::string16 error_string =
         ASCIIToUTF16("Internal error renaming index '") +
         index_metadata.name + ASCIIToUTF16("' to '") + new_name +
         ASCIIToUTF16("'.");
-    transaction->Abort(IndexedDBDatabaseError(
-        blink::WebIDBDatabaseExceptionUnknownError, error_string));
+    IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
+                                 error_string);
+    transaction->Abort(error);
+    if (s.IsCorruption())
+      factory_->HandleBackingStoreCorruption(origin(), error);
+    else
+      factory_->HandleBackingStoreFailure(origin());
     return;
   }
 
   transaction->ScheduleAbortTask(
       base::Bind(&IndexedDBDatabase::RenameIndexAbortOperation,
                  this,
                  object_store_id,
                  index_id,
                  index_metadata.name));
   SetIndexName(object_store_id, index_id, new_name);
 }
 
 void IndexedDBDatabase::RenameIndexAbortOperation(
     int64_t object_store_id,
     int64_t index_id,
-    const base::string16& old_name,
-    IndexedDBTransaction* transaction) {
-  DCHECK(!transaction);
+    const base::string16& old_name) {
   IDB_TRACE("IndexedDBDatabase::RenameIndexAbortOperation");
   SetIndexName(object_store_id, index_id, old_name);
 }
 
 void IndexedDBDatabase::Commit(int64_t transaction_id) {
   // The frontend suggests that we commit, but we may have previously initiated
   // an abort, and so have disposed of the transaction. on_abort has already
   // been dispatched to the frontend, so it will find out about that
   // asynchronously.
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (transaction) {
     scoped_refptr<IndexedDBFactory> factory = factory_;
-    leveldb::Status s = transaction->Commit();
-    if (s.IsCorruption()) {
-      IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
-                                   "Internal error committing transaction.");
-      factory->HandleBackingStoreCorruption(identifier_.first, error);
+    leveldb::Status result = transaction->Commit();
+    if (!result.ok()) {
+      if (result.IsCorruption()) {
+        IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
+                                     base::ASCIIToUTF16(result.ToString()));
+        factory->HandleBackingStoreCorruption(origin(), error);
+      } else {
+        factory->HandleBackingStoreFailure(origin());
+      }
     }
   }
 }
 
 void IndexedDBDatabase::Abort(int64_t transaction_id) {
   // If the transaction is unknown, then it has already been aborted by the
   // backend before this call so it is safe to ignore it.
   IDB_TRACE1("IndexedDBDatabase::Abort", "txn.id", transaction_id);
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (transaction)
@@ skipping 103 matching lines @@
   if (!ValidateObjectStoreIdAndOptionalIndexId(object_store_id, index_id))
     return;
 
   transaction->ScheduleTask(base::Bind(
       &IndexedDBDatabase::GetOperation, this, object_store_id, index_id,
       base::Passed(&key_range),
       key_only ? indexed_db::CURSOR_KEY_ONLY : indexed_db::CURSOR_KEY_AND_VALUE,
       callbacks));
 }
 
-void IndexedDBDatabase::GetOperation(
+leveldb::Status IndexedDBDatabase::GetOperation(
     int64_t object_store_id,
     int64_t index_id,
     std::unique_ptr<IndexedDBKeyRange> key_range,
     indexed_db::CursorType cursor_type,
     scoped_refptr<IndexedDBCallbacks> callbacks,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1("IndexedDBDatabase::GetOperation", "txn.id", transaction->id());
 
   DCHECK(metadata_.object_stores.find(object_store_id) !=
          metadata_.object_stores.end());
   const IndexedDBObjectStoreMetadata& object_store_metadata =
       metadata_.object_stores[object_store_id];
 
   const IndexedDBKey* key;
 
-  leveldb::Status s;
+  leveldb::Status s = leveldb::Status::OK();
   std::unique_ptr<IndexedDBBackingStore::Cursor> backing_store_cursor;
   if (key_range->IsOnlyKey()) {
     key = &key_range->lower();
   } else {
     if (index_id == IndexedDBIndexMetadata::kInvalidId) {
       // ObjectStore Retrieval Operation
       if (cursor_type == indexed_db::CURSOR_KEY_ONLY) {
         backing_store_cursor = backing_store_->OpenObjectStoreKeyCursor(
             transaction->BackingStoreTransaction(), id(), object_store_id,
             *key_range, blink::WebIDBCursorDirectionNext, &s);
@@ skipping 21 matching lines @@
           index_id,
           *key_range,
           blink::WebIDBCursorDirectionNext,
           &s);
     }
 
     if (!s.ok()) {
       DLOG(ERROR) << "Unable to open cursor operation: " << s.ToString();
       IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                    "Internal error deleting data in range");
-      if (s.IsCorruption()) {
-        factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
-      }
+      callbacks->OnError(error);
+      return s;
     }
 
     if (!backing_store_cursor) {
+      // This means we've run out of data.
       callbacks->OnSuccess();
-      return;
+      return s;
     }
 
     key = &backing_store_cursor->key();
   }
 
   std::unique_ptr<IndexedDBKey> primary_key;
   if (index_id == IndexedDBIndexMetadata::kInvalidId) {
     // Object Store Retrieval Operation
     IndexedDBReturnValue value;
     s = backing_store_->GetRecord(transaction->BackingStoreTransaction(),
                                   id(),
                                   object_store_id,
                                   *key,
                                   &value);
     if (!s.ok()) {
       IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                    "Internal error in GetRecord.");
       callbacks->OnError(error);
-
-      if (s.IsCorruption())
-        factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
-      return;
+      return s;
     }
 
     if (value.empty()) {
       callbacks->OnSuccess();
-      return;
+      return s;
     }
 
     if (cursor_type == indexed_db::CURSOR_KEY_ONLY) {
       callbacks->OnSuccess(*key);
-      return;
+      return s;
     }
 
     if (object_store_metadata.auto_increment &&
         !object_store_metadata.key_path.IsNull()) {
       value.primary_key = *key;
       value.key_path = object_store_metadata.key_path;
     }
 
     callbacks->OnSuccess(&value);
-    return;
+    return s;
   }
 
   // From here we are dealing only with indexes.
   s = backing_store_->GetPrimaryKeyViaIndex(
       transaction->BackingStoreTransaction(),
       id(),
       object_store_id,
       index_id,
       *key,
       &primary_key);
   if (!s.ok()) {
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  "Internal error in GetPrimaryKeyViaIndex.");
     callbacks->OnError(error);
-    if (s.IsCorruption())
-      factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
-    return;
+    return s;
   }
   if (!primary_key) {
     callbacks->OnSuccess();
-    return;
+    return s;
   }
   if (cursor_type == indexed_db::CURSOR_KEY_ONLY) {
     // Index Value Retrieval Operation
     callbacks->OnSuccess(*primary_key);
-    return;
+    return s;
   }
 
   // Index Referenced Value Retrieval Operation
   IndexedDBReturnValue value;
   s = backing_store_->GetRecord(transaction->BackingStoreTransaction(),
                                 id(),
                                 object_store_id,
                                 *primary_key,
                                 &value);
   if (!s.ok()) {
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  "Internal error in GetRecord.");
     callbacks->OnError(error);
-    if (s.IsCorruption())
-      factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
-    return;
+    return s;
   }
 
   if (value.empty()) {
     callbacks->OnSuccess();
-    return;
+    return s;
   }
   if (object_store_metadata.auto_increment &&
       !object_store_metadata.key_path.IsNull()) {
     value.primary_key = *primary_key;
     value.key_path = object_store_metadata.key_path;
   }
   callbacks->OnSuccess(&value);
+  return s;
 }
 
-void IndexedDBDatabase::GetAllOperation(
+leveldb::Status IndexedDBDatabase::GetAllOperation(
     int64_t object_store_id,
     int64_t index_id,
     std::unique_ptr<IndexedDBKeyRange> key_range,
     indexed_db::CursorType cursor_type,
     int64_t max_count,
     scoped_refptr<IndexedDBCallbacks> callbacks,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1("IndexedDBDatabase::GetAllOperation", "txn.id", transaction->id());
 
   DCHECK_GT(max_count, 0);
 
   DCHECK(metadata_.object_stores.find(object_store_id) !=
          metadata_.object_stores.end());
   const IndexedDBObjectStoreMetadata& object_store_metadata =
       metadata_.object_stores[object_store_id];
 
-  leveldb::Status s;
+  leveldb::Status s = leveldb::Status::OK();
 
   std::unique_ptr<IndexedDBBackingStore::Cursor> cursor;
 
   if (cursor_type == indexed_db::CURSOR_KEY_ONLY) {
     // Retrieving keys
     if (index_id == IndexedDBIndexMetadata::kInvalidId) {
       // Object Store: Key Retrieval Operation
       cursor = backing_store_->OpenObjectStoreKeyCursor(
           transaction->BackingStoreTransaction(), id(), object_store_id,
           *key_range, blink::WebIDBCursorDirectionNext, &s);
@@ skipping 16 matching lines @@
           transaction->BackingStoreTransaction(), id(), object_store_id,
           index_id, *key_range, blink::WebIDBCursorDirectionNext, &s);
     }
   }
 
   if (!s.ok()) {
     DLOG(ERROR) << "Unable to open cursor operation: " << s.ToString();
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  "Internal error in GetAllOperation");
     callbacks->OnError(error);
-    if (s.IsCorruption()) {
-      factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
-    }
-    return;
+    return s;
   }
 
   std::vector<IndexedDBKey> found_keys;
   std::vector<IndexedDBReturnValue> found_values;
   if (!cursor) {
     // Doesn't matter if key or value array here - will be empty array when it
     // hits JavaScript.
     callbacks->OnSuccessArray(&found_values);
-    return;
+    return s;
   }
 
   bool did_first_seek = false;
   bool generated_key = object_store_metadata.auto_increment &&
                        !object_store_metadata.key_path.IsNull();
 
   size_t response_size = kMaxIDBMessageOverhead;
   int64_t num_found_items = 0;
   while (num_found_items++ < max_count) {
     bool cursor_valid;
     if (did_first_seek) {
       cursor_valid = cursor->Continue(&s);
     } else {
       cursor_valid = cursor->FirstSeek(&s);
       did_first_seek = true;
     }
     if (!s.ok()) {
       IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                    "Internal error in GetAllOperation.");
       callbacks->OnError(error);
-      if (s.IsCorruption())
-        factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
-      return;
+      return s;
     }
 
     if (!cursor_valid)
       break;
 
     IndexedDBReturnValue return_value;
     IndexedDBKey return_key;
 
     if (cursor_type == indexed_db::CURSOR_KEY_ONLY) {
       return_key = cursor->primary_key();
     } else {
       // Retrieving values
       return_value.swap(*cursor->value());
       if (!return_value.empty() && generated_key) {
         return_value.primary_key = cursor->primary_key();
         return_value.key_path = object_store_metadata.key_path;
       }
     }
 
     if (cursor_type == indexed_db::CURSOR_KEY_ONLY)
       response_size += return_key.size_estimate();
     else
       response_size += return_value.SizeEstimate();
     if (response_size > GetMaxMessageSizeInBytes()) {
       callbacks->OnError(
           IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionUnknownError,
                                  "Maximum IPC message size exceeded."));
-      return;
+      return s;
     }
 
     if (cursor_type == indexed_db::CURSOR_KEY_ONLY)
       found_keys.push_back(return_key);
     else
       found_values.push_back(return_value);
   }
 
   if (cursor_type == indexed_db::CURSOR_KEY_ONLY) {
     // IndexedDBKey already supports an array of values so we can leverage  this
     // to return an array of keys - no need to create our own array of keys.
     callbacks->OnSuccess(IndexedDBKey(found_keys));
   } else {
     callbacks->OnSuccessArray(&found_values);
   }
+  return s;
 }
 
 static std::unique_ptr<IndexedDBKey> GenerateKey(
     IndexedDBBackingStore* backing_store,
     IndexedDBTransaction* transaction,
     int64_t database_id,
     int64_t object_store_id) {
   const int64_t max_generator_value =
       9007199254740992LL;  // Maximum integer storable as ECMAScript number.
   int64_t current_number;
@@ skipping 64 matching lines @@
   params->value.swap(*value);
   params->handles.swap(*handles);
   params->key = std::move(key);
   params->put_mode = put_mode;
   params->callbacks = callbacks;
   params->index_keys = index_keys;
   transaction->ScheduleTask(base::Bind(
       &IndexedDBDatabase::PutOperation, this, base::Passed(&params)));
 }
 
-void IndexedDBDatabase::PutOperation(std::unique_ptr<PutOperationParams> params,
-                                     IndexedDBTransaction* transaction) {
+leveldb::Status IndexedDBDatabase::PutOperation(
+    std::unique_ptr<PutOperationParams> params,
+    IndexedDBTransaction* transaction) {
   IDB_TRACE1("IndexedDBDatabase::PutOperation", "txn.id", transaction->id());
   DCHECK_NE(transaction->mode(), blink::WebIDBTransactionModeReadOnly);
   bool key_was_generated = false;
+  leveldb::Status s = leveldb::Status::OK();
 
   DCHECK(metadata_.object_stores.find(params->object_store_id) !=
          metadata_.object_stores.end());
   const IndexedDBObjectStoreMetadata& object_store =
       metadata_.object_stores[params->object_store_id];
   DCHECK(object_store.auto_increment || params->key->IsValid());
 
   std::unique_ptr<IndexedDBKey> key;
   if (params->put_mode != blink::WebIDBPutModeCursorUpdate &&
       object_store.auto_increment && !params->key->IsValid()) {
     std::unique_ptr<IndexedDBKey> auto_inc_key = GenerateKey(
         backing_store_.get(), transaction, id(), params->object_store_id);
     key_was_generated = true;
     if (!auto_inc_key->IsValid()) {
       params->callbacks->OnError(
           IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionConstraintError,
                                  "Maximum key generator value reached."));
-      return;
+      return s;
     }
     key = std::move(auto_inc_key);
   } else {
     key = std::move(params->key);
   }
 
   DCHECK(key->IsValid());
 
   IndexedDBBackingStore::RecordIdentifier record_identifier;
   if (params->put_mode == blink::WebIDBPutModeAddOnly) {
     bool found = false;
     leveldb::Status s = backing_store_->KeyExistsInObjectStore(
         transaction->BackingStoreTransaction(),
         id(),
         params->object_store_id,
         *key,
         &record_identifier,
         &found);
     if (!s.ok()) {
       IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                    "Internal error checking key existence.");
       params->callbacks->OnError(error);
-      if (s.IsCorruption())
-        factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
-      return;
+      return s;
     }
     if (found) {
       params->callbacks->OnError(
           IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionConstraintError,
                                  "Key already exists in the object store."));
-      return;
+      return s;
     }
   }
 
   std::vector<std::unique_ptr<IndexWriter>> index_writers;
   base::string16 error_message;
   bool obeys_constraints = false;
   bool backing_store_success = MakeIndexWriters(transaction,
                                                 backing_store_.get(),
                                                 id(),
                                                 object_store,
                                                 *key,
                                                 key_was_generated,
                                                 params->index_keys,
                                                 &index_writers,
                                                 &error_message,
                                                 &obeys_constraints);
   if (!backing_store_success) {
     params->callbacks->OnError(IndexedDBDatabaseError(
         blink::WebIDBDatabaseExceptionUnknownError,
         "Internal error: backing store error updating index keys."));
-    return;
+    return s;
   }
   if (!obeys_constraints) {
     params->callbacks->OnError(IndexedDBDatabaseError(
         blink::WebIDBDatabaseExceptionConstraintError, error_message));
-    return;
+    return s;
   }
 
   // Before this point, don't do any mutation. After this point, rollback the
   // transaction in case of error.
-  leveldb::Status s =
-      backing_store_->PutRecord(transaction->BackingStoreTransaction(),
-                                id(),
-                                params->object_store_id,
-                                *key,
-                                &params->value,
-                                &params->handles,
-                                &record_identifier);
+  s = backing_store_->PutRecord(transaction->BackingStoreTransaction(), id(),
+                                params->object_store_id, *key, &params->value,
+                                &params->handles, &record_identifier);
   if (!s.ok()) {
     IndexedDBDatabaseError error(
         blink::WebIDBDatabaseExceptionUnknownError,
         "Internal error: backing store error performing put/add.");
     params->callbacks->OnError(error);
-    if (s.IsCorruption())
-      factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
-    return;
+    return s;
   }
   {
     IDB_TRACE1("IndexedDBDatabase::PutOperation.UpdateIndexes", "txn.id",
                transaction->id());
     for (const auto& writer : index_writers) {
       writer->WriteIndexKeys(record_identifier, backing_store_.get(),
                              transaction->BackingStoreTransaction(), id(),
                              params->object_store_id);
     }
   }
 
   if (object_store.auto_increment &&
       params->put_mode != blink::WebIDBPutModeCursorUpdate &&
       key->type() == WebIDBKeyTypeNumber) {
     IDB_TRACE1("IndexedDBDatabase::PutOperation.AutoIncrement", "txn.id",
                transaction->id());
-    leveldb::Status s = UpdateKeyGenerator(backing_store_.get(),
-                                           transaction,
-                                           id(),
-                                           params->object_store_id,
-                                           *key,
-                                           !key_was_generated);
+    s = UpdateKeyGenerator(backing_store_.get(), transaction, id(),
+                           params->object_store_id, *key, !key_was_generated);
     if (!s.ok()) {
       IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                    "Internal error updating key generator.");
       params->callbacks->OnError(error);
-      if (s.IsCorruption())
-        factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
-      return;
+      return s;
     }
   }
   {
     IDB_TRACE1("IndexedDBDatabase::PutOperation.Callbacks", "txn.id",
                transaction->id());
     params->callbacks->OnSuccess(*key);
   }
   FilterObservation(transaction, params->object_store_id,
                     params->put_mode == blink::WebIDBPutModeAddOnly
                         ? blink::WebIDBAdd
                         : blink::WebIDBPut,
                     IndexedDBKeyRange(*key));
+  return s;
 }
 
 void IndexedDBDatabase::SetIndexKeys(
     int64_t transaction_id,
     int64_t object_store_id,
     std::unique_ptr<IndexedDBKey> primary_key,
     const std::vector<IndexedDBIndexKeys>& index_keys) {
   IDB_TRACE1("IndexedDBDatabase::SetIndexKeys", "txn.id", transaction_id);
+
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
   DCHECK_EQ(transaction->mode(), blink::WebIDBTransactionModeVersionChange);
 
   // TODO(alecflett): This method could be asynchronous, but we need to
   // evaluate if it's worth the extra complexity.
   IndexedDBBackingStore::RecordIdentifier record_identifier;
   bool found = false;
   leveldb::Status s = backing_store_->KeyExistsInObjectStore(
@@ skipping 62 matching lines @@
     return;
   DCHECK_EQ(transaction->mode(), blink::WebIDBTransactionModeVersionChange);
 
   transaction->ScheduleTask(
       blink::WebIDBTaskTypePreemptive,
       base::Bind(&IndexedDBDatabase::SetIndexesReadyOperation,
                  this,
                  index_ids.size()));
 }
 
-void IndexedDBDatabase::SetIndexesReadyOperation(
+leveldb::Status IndexedDBDatabase::SetIndexesReadyOperation(
     size_t index_count,
     IndexedDBTransaction* transaction) {
   for (size_t i = 0; i < index_count; ++i)
     transaction->DidCompletePreemptiveEvent();
+  return leveldb::Status::OK();
 }
 
 struct IndexedDBDatabase::OpenCursorOperationParams {
   OpenCursorOperationParams() {}
   int64_t object_store_id;
   int64_t index_id;
   std::unique_ptr<IndexedDBKeyRange> key_range;
   blink::WebIDBCursorDirection direction;
   indexed_db::CursorType cursor_type;
   blink::WebIDBTaskType task_type;
@@ skipping 27 matching lines @@
   params->key_range = std::move(key_range);
   params->direction = direction;
   params->cursor_type =
       key_only ? indexed_db::CURSOR_KEY_ONLY : indexed_db::CURSOR_KEY_AND_VALUE;
   params->task_type = task_type;
   params->callbacks = callbacks;
   transaction->ScheduleTask(base::Bind(
       &IndexedDBDatabase::OpenCursorOperation, this, base::Passed(&params)));
 }
 
-void IndexedDBDatabase::OpenCursorOperation(
+leveldb::Status IndexedDBDatabase::OpenCursorOperation(
     std::unique_ptr<OpenCursorOperationParams> params,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1(
       "IndexedDBDatabase::OpenCursorOperation", "txn.id", transaction->id());
 
   // The frontend has begun indexing, so this pauses the transaction
   // until the indexing is complete. This can't happen any earlier
   // because we don't want to switch to early mode in case multiple
   // indexes are being created in a row, with Put()'s in between.
   if (params->task_type == blink::WebIDBTaskTypePreemptive)
     transaction->AddPreemptiveEvent();
 
-  leveldb::Status s;
+  leveldb::Status s = leveldb::Status::OK();
   std::unique_ptr<IndexedDBBackingStore::Cursor> backing_store_cursor;
   if (params->index_id == IndexedDBIndexMetadata::kInvalidId) {
     if (params->cursor_type == indexed_db::CURSOR_KEY_ONLY) {
       DCHECK_EQ(params->task_type, blink::WebIDBTaskTypeNormal);
       backing_store_cursor = backing_store_->OpenObjectStoreKeyCursor(
           transaction->BackingStoreTransaction(),
           id(),
           params->object_store_id,
           *params->key_range,
           params->direction,
@@ skipping 27 matching lines @@
           *params->key_range,
           params->direction,
           &s);
     }
   }
 
   if (!s.ok()) {
     DLOG(ERROR) << "Unable to open cursor operation: " << s.ToString();
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  "Internal error opening cursor operation");
-    if (s.IsCorruption()) {
-      factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
-    }
+    return s;
   }
 
   if (!backing_store_cursor) {
-    // Why is Success being called?
+    // Occurs when we've reached the end of cursor's data.
     params->callbacks->OnSuccess(nullptr);
-    return;
+    return s;
   }
 
   scoped_refptr<IndexedDBCursor> cursor =
       new IndexedDBCursor(std::move(backing_store_cursor), params->cursor_type,
                           params->task_type, transaction);
   params->callbacks->OnSuccess(
       cursor, cursor->key(), cursor->primary_key(), cursor->Value());
+  return s;
 }
 
 void IndexedDBDatabase::Count(int64_t transaction_id,
                               int64_t object_store_id,
                               int64_t index_id,
                               std::unique_ptr<IndexedDBKeyRange> key_range,
                               scoped_refptr<IndexedDBCallbacks> callbacks) {
   IDB_TRACE1("IndexedDBDatabase::Count", "txn.id", transaction_id);
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
 
   if (!ValidateObjectStoreIdAndOptionalIndexId(object_store_id, index_id))
     return;
 
   transaction->ScheduleTask(base::Bind(&IndexedDBDatabase::CountOperation,
                                        this,
                                        object_store_id,
                                        index_id,
                                        base::Passed(&key_range),
                                        callbacks));
 }
 
-void IndexedDBDatabase::CountOperation(
+leveldb::Status IndexedDBDatabase::CountOperation(
     int64_t object_store_id,
     int64_t index_id,
     std::unique_ptr<IndexedDBKeyRange> key_range,
     scoped_refptr<IndexedDBCallbacks> callbacks,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1("IndexedDBDatabase::CountOperation", "txn.id", transaction->id());
   uint32_t count = 0;
   std::unique_ptr<IndexedDBBackingStore::Cursor> backing_store_cursor;
 
-  leveldb::Status s;
+  leveldb::Status s = leveldb::Status::OK();
   if (index_id == IndexedDBIndexMetadata::kInvalidId) {
     backing_store_cursor = backing_store_->OpenObjectStoreKeyCursor(
         transaction->BackingStoreTransaction(),
         id(),
         object_store_id,
         *key_range,
         blink::WebIDBCursorDirectionNext,
         &s);
   } else {
     backing_store_cursor = backing_store_->OpenIndexKeyCursor(
         transaction->BackingStoreTransaction(),
         id(),
         object_store_id,
         index_id,
         *key_range,
         blink::WebIDBCursorDirectionNext,
         &s);
   }
   if (!s.ok()) {
     DLOG(ERROR) << "Unable perform count operation: " << s.ToString();
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  "Internal error performing count operation");
-    if (s.IsCorruption()) {
-      factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
-    }
+    return s;
   }
   if (!backing_store_cursor) {
     callbacks->OnSuccess(count);
-    return;
+    return s;
   }
 
   do {
+    if (!s.ok())
+      return s;
     ++count;
   } while (backing_store_cursor->Continue(&s));
 
-  // TODO(cmumford): Check for database corruption.
-
   callbacks->OnSuccess(count);
+  return s;
 }
 
 void IndexedDBDatabase::DeleteRange(
     int64_t transaction_id,
     int64_t object_store_id,
     std::unique_ptr<IndexedDBKeyRange> key_range,
     scoped_refptr<IndexedDBCallbacks> callbacks) {
   IDB_TRACE1("IndexedDBDatabase::DeleteRange", "txn.id", transaction_id);
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
   DCHECK_NE(transaction->mode(), blink::WebIDBTransactionModeReadOnly);
 
   if (!ValidateObjectStoreId(object_store_id))
     return;
 
   transaction->ScheduleTask(base::Bind(&IndexedDBDatabase::DeleteRangeOperation,
                                        this,
                                        object_store_id,
                                        base::Passed(&key_range),
                                        callbacks));
 }
 
-void IndexedDBDatabase::DeleteRangeOperation(
+leveldb::Status IndexedDBDatabase::DeleteRangeOperation(
     int64_t object_store_id,
     std::unique_ptr<IndexedDBKeyRange> key_range,
     scoped_refptr<IndexedDBCallbacks> callbacks,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1("IndexedDBDatabase::DeleteRangeOperation", "txn.id",
              transaction->id());
   size_t delete_count = 0;
   leveldb::Status s =
       backing_store_->DeleteRange(transaction->BackingStoreTransaction(), id(),
                                   object_store_id, *key_range, &delete_count);
   if (!s.ok()) {
     base::string16 error_string =
         ASCIIToUTF16("Internal error deleting data in range");
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  error_string);
     transaction->Abort(error);
-    if (s.IsCorruption()) {
-      factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
-    }
-    return;
+    return s;
   }
   callbacks->OnSuccess();
   FilterObservation(transaction, object_store_id, blink::WebIDBDelete,
                     *key_range);
+  return s;
 }
 
 void IndexedDBDatabase::Clear(int64_t transaction_id,
                               int64_t object_store_id,
                               scoped_refptr<IndexedDBCallbacks> callbacks) {
   IDB_TRACE1("IndexedDBDatabase::Clear", "txn.id", transaction_id);
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
   DCHECK_NE(transaction->mode(), blink::WebIDBTransactionModeReadOnly);
 
   if (!ValidateObjectStoreId(object_store_id))
     return;
 
   transaction->ScheduleTask(base::Bind(
       &IndexedDBDatabase::ClearOperation, this, object_store_id, callbacks));
 }
 
-void IndexedDBDatabase::ClearOperation(
+leveldb::Status IndexedDBDatabase::ClearOperation(
     int64_t object_store_id,
     scoped_refptr<IndexedDBCallbacks> callbacks,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1("IndexedDBDatabase::ClearOperation", "txn.id", transaction->id());
   leveldb::Status s = backing_store_->ClearObjectStore(
       transaction->BackingStoreTransaction(), id(), object_store_id);
   if (!s.ok()) {
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  "Internal error clearing object store");
     callbacks->OnError(error);
-    if (s.IsCorruption()) {
-      factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
-    }
-    return;
+    return s;
   }
   callbacks->OnSuccess();
 
   FilterObservation(transaction, object_store_id, blink::WebIDBClear,
                     IndexedDBKeyRange());
+  return s;
 }
 
-void IndexedDBDatabase::DeleteObjectStoreOperation(
+leveldb::Status IndexedDBDatabase::DeleteObjectStoreOperation(
     int64_t object_store_id,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1("IndexedDBDatabase::DeleteObjectStoreOperation",
              "txn.id",
              transaction->id());
 
   const IndexedDBObjectStoreMetadata object_store_metadata =
       metadata_.object_stores[object_store_id];
   leveldb::Status s =
       backing_store_->DeleteObjectStore(transaction->BackingStoreTransaction(),
                                         transaction->database()->id(),
                                         object_store_id);
   if (!s.ok()) {
     base::string16 error_string =
         ASCIIToUTF16("Internal error deleting object store '") +
         object_store_metadata.name + ASCIIToUTF16("'.");
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  error_string);
     transaction->Abort(error);
-    if (s.IsCorruption())
-      factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
-    return;
+    return s;
   }
 
   RemoveObjectStore(object_store_id);
   transaction->ScheduleAbortTask(
       base::Bind(&IndexedDBDatabase::DeleteObjectStoreAbortOperation,
                  this,
                  object_store_metadata));
+  return s;
 }
 
-void IndexedDBDatabase::VersionChangeOperation(
+leveldb::Status IndexedDBDatabase::VersionChangeOperation(
     int64_t version,
     scoped_refptr<IndexedDBCallbacks> callbacks,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1(
       "IndexedDBDatabase::VersionChangeOperation", "txn.id", transaction->id());
   int64_t old_version = metadata_.version;
   DCHECK_GT(version, old_version);
 
-  if (!backing_store_->UpdateIDBDatabaseIntVersion(
-          transaction->BackingStoreTransaction(), id(), version)) {
-    IndexedDBDatabaseError error(
-        blink::WebIDBDatabaseExceptionUnknownError,
-        ASCIIToUTF16(
-            "Internal error writing data to stable storage when "
-            "updating version."));
-    callbacks->OnError(error);
-    transaction->Abort(error);
-    return;
-  }
+  backing_store_->UpdateIDBDatabaseIntVersion(
+      transaction->BackingStoreTransaction(), id(), version);
 
   transaction->ScheduleAbortTask(
       base::Bind(&IndexedDBDatabase::VersionChangeAbortOperation, this,
                  metadata_.version));
   metadata_.version = version;
 
   active_request_->UpgradeTransactionStarted(old_version);
+  return leveldb::Status::OK();
 }
 
 void IndexedDBDatabase::TransactionFinished(IndexedDBTransaction* transaction,
                                             bool committed) {
   IDB_TRACE1("IndexedDBTransaction::TransactionFinished", "txn.id", id());
   DCHECK(transactions_.find(transaction->id()) != transactions_.end());
   DCHECK_EQ(transactions_[transaction->id()], transaction);
   transactions_.erase(transaction->id());
 
   // This may be an unrelated transaction finishing while waiting for
   // connections to close, or the actual upgrade transaction from an active
   // request. Notify the active request if it's the latter.
   if (active_request_ &&
       transaction->mode() == blink::WebIDBTransactionModeVersionChange) {
     active_request_->UpgradeTransactionFinished(committed);
   }
 }
 
-void IndexedDBDatabase::TransactionCommitFailed(const leveldb::Status& status) {
-  if (status.IsCorruption()) {
-    IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
-                                 "Error committing transaction");
-    factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
-  } else {
-    factory_->HandleBackingStoreFailure(backing_store_->origin());
-  }
-}
-
 void IndexedDBDatabase::AppendRequest(
     std::unique_ptr<ConnectionRequest> request) {
   pending_requests_.push(std::move(request));
 
   if (!active_request_)
     ProcessRequestQueue();
 }
 
 void IndexedDBDatabase::RequestComplete(ConnectionRequest* request) {
   DCHECK_EQ(request, active_request_.get());
@@ skipping 114 matching lines @@
   // If there are no more connections (current, active, or pending), tell the
   // factory to clean us up.
   if (connections_.empty() && !active_request_ && pending_requests_.empty()) {
     DCHECK(transactions_.empty());
     backing_store_ = nullptr;
     factory_->ReleaseDatabase(identifier_, forced);
   }
 }
 
 void IndexedDBDatabase::CreateObjectStoreAbortOperation(
-    int64_t object_store_id,
-    IndexedDBTransaction* transaction) {
-  DCHECK(!transaction);
+    int64_t object_store_id) {
   IDB_TRACE("IndexedDBDatabase::CreateObjectStoreAbortOperation");
   RemoveObjectStore(object_store_id);
 }
 
 void IndexedDBDatabase::DeleteObjectStoreAbortOperation(
-    const IndexedDBObjectStoreMetadata& object_store_metadata,
-    IndexedDBTransaction* transaction) {
-  DCHECK(!transaction);
+    const IndexedDBObjectStoreMetadata& object_store_metadata) {
   IDB_TRACE("IndexedDBDatabase::DeleteObjectStoreAbortOperation");
   AddObjectStore(object_store_metadata,
                  IndexedDBObjectStoreMetadata::kInvalidId);
 }
 
 void IndexedDBDatabase::RenameObjectStoreAbortOperation(
     int64_t object_store_id,
-    const base::string16& old_name,
-    IndexedDBTransaction* transaction) {
-  DCHECK(!transaction);
+    const base::string16& old_name) {
   IDB_TRACE("IndexedDBDatabase::RenameObjectStoreAbortOperation");
   SetObjectStoreName(object_store_id, old_name);
 }
 
-void IndexedDBDatabase::VersionChangeAbortOperation(
-    int64_t previous_version,
-    IndexedDBTransaction* transaction) {
-  DCHECK(!transaction);
+void IndexedDBDatabase::VersionChangeAbortOperation(int64_t previous_version) {
   IDB_TRACE("IndexedDBDatabase::VersionChangeAbortOperation");
   metadata_.version = previous_version;
 }
 
 }  // namespace content