[IndexedDB] Integrating failures and corruption with transaction

content/browser/indexed_db/indexed_db_backing_store.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_backing_store.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/files/file_path.h"
@@ skipping 1321 matching lines @@
       DatabaseMetaDataKey::Encode(
           *row_id, DatabaseMetaDataKey::BLOB_KEY_GENERATOR_CURRENT_NUMBER),
       DatabaseMetaDataKey::kBlobKeyGeneratorInitialNumber);
 
   s = transaction->Commit();
   if (!s.ok())
     INTERNAL_WRITE_ERROR_UNTESTED(CREATE_IDBDATABASE_METADATA);
   return s;
 }
 
-bool IndexedDBBackingStore::UpdateIDBDatabaseIntVersion(
+void IndexedDBBackingStore::UpdateIDBDatabaseIntVersion(
     IndexedDBBackingStore::Transaction* transaction,
     int64_t row_id,
     int64_t version) {
   if (version == IndexedDBDatabaseMetadata::NO_VERSION)
     version = IndexedDBDatabaseMetadata::DEFAULT_VERSION;
   DCHECK_GE(version, 0) << "version was " << version;
   PutVarInt(
       transaction->transaction(),
       DatabaseMetaDataKey::Encode(row_id, DatabaseMetaDataKey::USER_VERSION),
       version);
-  return true;
 }
 
 // If you're deleting a range that contains user keys that have blob info, this
 // won't clean up the blobs.
 static leveldb::Status DeleteRangeBasic(LevelDBTransaction* transaction,
                                         const std::string& begin,
                                         const std::string& end,
                                         bool upper_open,
                                         size_t* delete_count) {
   DCHECK(delete_count);
@@ skipping 2432 matching lines @@
     transaction_->transaction()->Remove(iterator_->Key());
     return false;
   }
 
   current_value_.bits = slice.as_string();
   *s = transaction_->GetBlobInfoForRecord(database_id_, primary_leveldb_key_,
                                           &current_value_);
   return s->ok();
 }
 
-bool ObjectStoreCursorOptions(
+leveldb::Status ObjectStoreCursorOptions(
     LevelDBTransaction* transaction,
     int64_t database_id,
     int64_t object_store_id,
     const IndexedDBKeyRange& range,
     blink::WebIDBCursorDirection direction,
     IndexedDBBackingStore::Cursor::CursorOptions* cursor_options) {
   cursor_options->database_id = database_id;
   cursor_options->object_store_id = object_store_id;
 
   bool lower_bound = range.lower().IsValid();
   bool upper_bound = range.upper().IsValid();
   cursor_options->forward =
       (direction == blink::WebIDBCursorDirectionNextNoDuplicate ||
        direction == blink::WebIDBCursorDirectionNext);
   cursor_options->unique =
       (direction == blink::WebIDBCursorDirectionNextNoDuplicate ||
        direction == blink::WebIDBCursorDirectionPrevNoDuplicate);
 
   if (!lower_bound) {
     cursor_options->low_key =
         ObjectStoreDataKey::Encode(database_id, object_store_id, MinIDBKey());
     cursor_options->low_open = true;  // Not included.
   } else {
     cursor_options->low_key =
         ObjectStoreDataKey::Encode(database_id, object_store_id, range.lower());
     cursor_options->low_open = range.lower_open();
   }
 
-  leveldb::Status s;
+  leveldb::Status s = leveldb::Status::OK();
 
   if (!upper_bound) {
     cursor_options->high_key =
         ObjectStoreDataKey::Encode(database_id, object_store_id, MaxIDBKey());
 
     if (cursor_options->forward) {
       cursor_options->high_open = true;  // Not included.
     } else {
       // We need a key that exists.
-      // TODO(cmumford): Handle this error (crbug.com/363397)
       if (!FindGreatestKeyLessThanOrEqual(transaction,
                                           cursor_options->high_key,
                                           &cursor_options->high_key,
                                           &s))
-        return false;
+        return s;
       cursor_options->high_open = false;
     }
   } else {
     cursor_options->high_key =
         ObjectStoreDataKey::Encode(database_id, object_store_id, range.upper());
     cursor_options->high_open = range.upper_open();
 
     if (!cursor_options->forward) {
       // For reverse cursors, we need a key that exists.
       std::string found_high_key;
-      // TODO(cmumford): Handle this error (crbug.com/363397)
       if (!FindGreatestKeyLessThanOrEqual(
               transaction, cursor_options->high_key, &found_high_key, &s))
-        return false;
+        return s;
 
       // If the target key should not be included, but we end up with a smaller
       // key, we should include that.
       if (cursor_options->high_open &&
           CompareIndexKeys(found_high_key, cursor_options->high_key) < 0)
         cursor_options->high_open = false;
 
       cursor_options->high_key = found_high_key;
     }
   }
 
-  return true;
+  return s;
 }
 
 bool IndexCursorOptions(
     LevelDBTransaction* transaction,
     int64_t database_id,
     int64_t object_store_id,
     int64_t index_id,
     const IndexedDBKeyRange& range,
     blink::WebIDBCursorDirection direction,
     IndexedDBBackingStore::Cursor::CursorOptions* cursor_options) {
@@ skipping 65 matching lines @@
 
 std::unique_ptr<IndexedDBBackingStore::Cursor>
 IndexedDBBackingStore::OpenObjectStoreCursor(
     IndexedDBBackingStore::Transaction* transaction,
     int64_t database_id,
     int64_t object_store_id,
     const IndexedDBKeyRange& range,
     blink::WebIDBCursorDirection direction,
     leveldb::Status* s) {
   IDB_TRACE("IndexedDBBackingStore::OpenObjectStoreCursor");
-  *s = leveldb::Status::OK();
   LevelDBTransaction* leveldb_transaction = transaction->transaction();
   IndexedDBBackingStore::Cursor::CursorOptions cursor_options;
-  if (!ObjectStoreCursorOptions(leveldb_transaction,
-                                database_id,
-                                object_store_id,
-                                range,
-                                direction,
-                                &cursor_options))
+  *s = ObjectStoreCursorOptions(leveldb_transaction, database_id,
+                                object_store_id, range, direction,
+                                &cursor_options);
+  if (!s->ok())
     return std::unique_ptr<IndexedDBBackingStore::Cursor>();
   std::unique_ptr<ObjectStoreCursorImpl> cursor(
       base::MakeUnique<ObjectStoreCursorImpl>(this, transaction, database_id,
                                               cursor_options));
   if (!cursor->FirstSeek(s))
     return std::unique_ptr<IndexedDBBackingStore::Cursor>();
 
   return std::move(cursor);
 }
 
 std::unique_ptr<IndexedDBBackingStore::Cursor>
 IndexedDBBackingStore::OpenObjectStoreKeyCursor(
     IndexedDBBackingStore::Transaction* transaction,
     int64_t database_id,
     int64_t object_store_id,
     const IndexedDBKeyRange& range,
     blink::WebIDBCursorDirection direction,
     leveldb::Status* s) {
   IDB_TRACE("IndexedDBBackingStore::OpenObjectStoreKeyCursor");
-  *s = leveldb::Status::OK();
   LevelDBTransaction* leveldb_transaction = transaction->transaction();
   IndexedDBBackingStore::Cursor::CursorOptions cursor_options;
-  if (!ObjectStoreCursorOptions(leveldb_transaction,
-                                database_id,
-                                object_store_id,
-                                range,
-                                direction,
-                                &cursor_options))
+  *s = ObjectStoreCursorOptions(leveldb_transaction, database_id,
+                                object_store_id, range, direction,
+                                &cursor_options);
+  if (!s->ok())
     return std::unique_ptr<IndexedDBBackingStore::Cursor>();
   std::unique_ptr<ObjectStoreKeyCursorImpl> cursor(
       base::MakeUnique<ObjectStoreKeyCursorImpl>(this, transaction, database_id,
                                                  cursor_options));
   if (!cursor->FirstSeek(s))
     return std::unique_ptr<IndexedDBBackingStore::Cursor>();
 
   return std::move(cursor);
 }
 
@@ skipping 520 matching lines @@
 
 IndexedDBBackingStore::Transaction::WriteDescriptor::WriteDescriptor(
     const WriteDescriptor& other) = default;
 IndexedDBBackingStore::Transaction::WriteDescriptor::~WriteDescriptor() =
     default;
 IndexedDBBackingStore::Transaction::WriteDescriptor&
     IndexedDBBackingStore::Transaction::WriteDescriptor::
     operator=(const WriteDescriptor& other) = default;
 
 }  // namespace content