[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 1830 matching lines @@
   return true;
 }
 
 bool IndexedDBBackingStore::Cursor::Continue(const IndexedDBKey* key,
                                              const IndexedDBKey* primary_key,
                                              IteratorState next_state,
                                              leveldb::Status* s) {
   DCHECK(!key || next_state == SEEK);
 
   if (cursor_options_.forward)
-    return ContinueNext(key, primary_key, next_state, s);
+    return ContinueNext(key, primary_key, next_state, s) ==
+           ContinueResult::DONE;
   else
-    return ContinuePrevious(key, primary_key, next_state, s);
+    return ContinuePrevious(key, primary_key, next_state, s) ==
+           ContinueResult::DONE;
 }
 
-bool IndexedDBBackingStore::Cursor::ContinueNext(
-    const IndexedDBKey* key,
-    const IndexedDBKey* primary_key,
-    IteratorState next_state,
-    leveldb::Status* s) {
+IndexedDBBackingStore::Cursor::ContinueResult
+IndexedDBBackingStore::Cursor::ContinueNext(const IndexedDBKey* key,
+                                            const IndexedDBKey* primary_key,
+                                            IteratorState next_state,
+                                            leveldb::Status* s) {
   DCHECK(cursor_options_.forward);
   DCHECK(!key || key->IsValid());
   DCHECK(!primary_key || primary_key->IsValid());
   *s = leveldb::Status::OK();
 
   // TODO(alecflett): avoid a copy here?
   IndexedDBKey previous_key = current_key_ ? *current_key_ : IndexedDBKey();
 
   // If seeking to a particular key (or key and primary key), skip the cursor
   // forward rather than iterating it.
   if (next_state == SEEK && key) {
     std::string leveldb_key =
         primary_key ? EncodeKey(*key, *primary_key) : EncodeKey(*key);
     *s = iterator_->Seek(leveldb_key);
     if (!s->ok())
-      return false;
+      return ContinueResult::LEVELDB_ERROR;
     // Cursor is at the next value already; don't advance it again below.
     next_state = READY;
   }
 
   for (;;) {
     // Only advance the cursor if it was not set to position already, either
     // because it is newly opened (and positioned at start of range) or
     // skipped forward by continue with a specific key.
     if (next_state == SEEK) {
       *s = iterator_->Next();
       if (!s->ok())
-        return false;
+        return ContinueResult::LEVELDB_ERROR;
     } else {
       next_state = SEEK;
     }
 
     // Fail if we've run out of data or gone past the cursor's bounds.
     if (!iterator_->IsValid() || IsPastBounds())
-      return false;
+      return ContinueResult::OUT_OF_BOUNDS;
 
     // TODO(jsbell): Document why this might be false. When do we ever not
     // seek into the range before starting cursor iteration?
     if (!HaveEnteredRange())
       continue;
 
     // The row may not load because there's a stale entry in the index. If no
     // error then not fatal.
     if (!LoadCurrentRow(s)) {
       if (!s->ok())
-        return false;
+        return ContinueResult::LEVELDB_ERROR;
       continue;
     }
 
     // Cursor is now positioned at a non-stale record in range.
 
     // "Unique" cursors should continue seeking until a new key value is seen.
     if (cursor_options_.unique && previous_key.IsValid() &&
         current_key_->Equals(previous_key)) {
       continue;
     }
 
     break;
   }
 
-  return true;
+  return ContinueResult::DONE;
 }
 
-bool IndexedDBBackingStore::Cursor::ContinuePrevious(
-    const IndexedDBKey* key,
-    const IndexedDBKey* primary_key,
-    IteratorState next_state,
-    leveldb::Status* s) {
+IndexedDBBackingStore::Cursor::ContinueResult
+IndexedDBBackingStore::Cursor::ContinuePrevious(const IndexedDBKey* key,
+                                                const IndexedDBKey* primary_key,
+                                                IteratorState next_state,
+                                                leveldb::Status* s) {
   DCHECK(!cursor_options_.forward);
   DCHECK(!key || key->IsValid());
   DCHECK(!primary_key || primary_key->IsValid());
   *s = leveldb::Status::OK();
 
   // TODO(alecflett): avoid a copy here?
   IndexedDBKey previous_key = current_key_ ? *current_key_ : IndexedDBKey();
 
   // When iterating with PrevNoDuplicate, spec requires that the value we
   // yield for each key is the *first* duplicate in forwards order. We do this
   // by remembering the duplicate key (implicitly, the first record seen with
   // a new key), keeping track of the earliest duplicate seen, and continuing
   // until yet another new key is seen, at which point the earliest duplicate
   // is the correct cursor position.
   IndexedDBKey duplicate_key;
   std::string earliest_duplicate;
 
   // TODO(jsbell): Optimize continuing to a specific key (or key and primary
   // key) for reverse cursors as well. See Seek() optimization at the start of
   // ContinueNext() for an example.
 
   for (;;) {
     if (next_state == SEEK) {
       *s = iterator_->Prev();
       if (!s->ok())
-        return false;
+        return ContinueResult::LEVELDB_ERROR;
     } else {
       next_state = SEEK;  // for subsequent iterations
     }
 
     // If we've run out of data or gone past the cursor's bounds.
     if (!iterator_->IsValid() || IsPastBounds()) {
       if (duplicate_key.IsValid())
         break;
-      return false;
+      return ContinueResult::OUT_OF_BOUNDS;
     }
 
     // TODO(jsbell): Document why this might be false. When do we ever not
     // seek into the range before starting cursor iteration?
     if (!HaveEnteredRange())
       continue;
 
     // The row may not load because there's a stale entry in the index. If no
     // error then not fatal.
     if (!LoadCurrentRow(s)) {
       if (!s->ok())
-        return false;
+        return ContinueResult::LEVELDB_ERROR;
       continue;
     }
 
     // If seeking to a key (or key and primary key), continue until found.
     // TODO(jsbell): If Seek() optimization is added above, remove this.
     if (key) {
       if (primary_key && key->Equals(*current_key_) &&
           primary_key->IsLessThan(this->primary_key()))
         continue;
       if (key->IsLessThan(*current_key_))
@@ skipping 26 matching lines @@
 
     break;
   }
 
   if (cursor_options_.unique) {
     DCHECK(duplicate_key.IsValid());
     DCHECK(!earliest_duplicate.empty());
 
     *s = iterator_->Seek(earliest_duplicate);
     if (!s->ok())
-      return false;
+      return ContinueResult::LEVELDB_ERROR;
     if (!LoadCurrentRow(s)) {
       DCHECK(!s->ok());
-      return false;
+      return ContinueResult::LEVELDB_ERROR;
     }
   }
 
-  return true;
+  return ContinueResult::DONE;
 }
 
 bool IndexedDBBackingStore::Cursor::HaveEnteredRange() const {
   if (cursor_options_.forward) {
     int compare = CompareIndexKeys(iterator_->Key(), cursor_options_.low_key);
     if (cursor_options_.low_open) {
       return compare > 0;
     }
     return compare >= 0;
   }
@@ skipping 409 matching lines @@
                                           &current_value_);
   return s->ok();
 }
 
 bool ObjectStoreCursorOptions(
     LevelDBTransaction* transaction,
     int64_t database_id,
     int64_t object_store_id,
     const IndexedDBKeyRange& range,
     blink::WebIDBCursorDirection direction,
-    IndexedDBBackingStore::Cursor::CursorOptions* cursor_options) {
+    IndexedDBBackingStore::Cursor::CursorOptions* cursor_options,
+    leveldb::Status* status) {
   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;
-
   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))
+      if (!FindGreatestKeyLessThanOrEqual(transaction, cursor_options->high_key,
+                                          &cursor_options->high_key, status))
         return false;
       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))
+      if (!FindGreatestKeyLessThanOrEqual(transaction, cursor_options->high_key,
+                                          &found_high_key, status))
         return false;
 
       // 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;
 }
 
 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) {
+    IndexedDBBackingStore::Cursor::CursorOptions* cursor_options,
+    leveldb::Status* status) {
   DCHECK(transaction);
   if (!KeyPrefix::ValidIds(database_id, object_store_id, index_id))
     return false;
 
   cursor_options->database_id = database_id;
   cursor_options->object_store_id = object_store_id;
   cursor_options->index_id = index_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 =
         IndexDataKey::EncodeMinKey(database_id, object_store_id, index_id);
     cursor_options->low_open = false;  // Included.
   } else {
     cursor_options->low_key = IndexDataKey::Encode(
         database_id, object_store_id, index_id, range.lower());
     cursor_options->low_open = range.lower_open();
   }
 
-  leveldb::Status s;
-
   if (!upper_bound) {
     cursor_options->high_key =
         IndexDataKey::EncodeMaxKey(database_id, object_store_id, index_id);
     cursor_options->high_open = false;  // Included.
 
-    if (!cursor_options->forward) {  // We need a key that exists.
-      if (!FindGreatestKeyLessThanOrEqual(transaction,
-                                          cursor_options->high_key,
-                                          &cursor_options->high_key,
-                                          &s))
+    if (!cursor_options->forward) {
+      // We need a key that exists.
+      if (!FindGreatestKeyLessThanOrEqual(transaction, cursor_options->high_key,
+                                          &cursor_options->high_key, status))
         return false;
       cursor_options->high_open = false;
     }
   } else {
     cursor_options->high_key = IndexDataKey::Encode(
         database_id, object_store_id, index_id, range.upper());
     cursor_options->high_open = range.upper_open();
 
     std::string found_high_key;
     // Seek to the *last* key in the set of non-unique keys
-    // TODO(cmumford): Handle this error (crbug.com/363397)
-    if (!FindGreatestKeyLessThanOrEqual(
-            transaction, cursor_options->high_key, &found_high_key, &s))
+    if (!FindGreatestKeyLessThanOrEqual(transaction, cursor_options->high_key,
+                                        &found_high_key, status))
       return false;
 
     // 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;
 }
 
 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))
+  // TODO(cmumford): Handle this error (crbug.com/363397)
+  if (!ObjectStoreCursorOptions(leveldb_transaction, database_id,
+                                object_store_id, range, direction,
+                                &cursor_options, s)) {
     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))
+  // TODO(cmumford): Handle this error (crbug.com/363397)
+  if (!ObjectStoreCursorOptions(leveldb_transaction, database_id,
+                                object_store_id, range, direction,
+                                &cursor_options, s)) {
     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);
 }
 
 std::unique_ptr<IndexedDBBackingStore::Cursor>
 IndexedDBBackingStore::OpenIndexKeyCursor(
     IndexedDBBackingStore::Transaction* transaction,
     int64_t database_id,
     int64_t object_store_id,
     int64_t index_id,
     const IndexedDBKeyRange& range,
     blink::WebIDBCursorDirection direction,
     leveldb::Status* s) {
   IDB_TRACE("IndexedDBBackingStore::OpenIndexKeyCursor");
   *s = leveldb::Status::OK();
   LevelDBTransaction* leveldb_transaction = transaction->transaction();
   IndexedDBBackingStore::Cursor::CursorOptions cursor_options;
-  if (!IndexCursorOptions(leveldb_transaction,
-                          database_id,
-                          object_store_id,
-                          index_id,
-                          range,
-                          direction,
-                          &cursor_options))
+  if (!IndexCursorOptions(leveldb_transaction, database_id, object_store_id,
+                          index_id, range, direction, &cursor_options, s))
     return std::unique_ptr<IndexedDBBackingStore::Cursor>();
   std::unique_ptr<IndexKeyCursorImpl> cursor(
       base::MakeUnique<IndexKeyCursorImpl>(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::OpenIndexCursor(
     IndexedDBBackingStore::Transaction* transaction,
     int64_t database_id,
     int64_t object_store_id,
     int64_t index_id,
     const IndexedDBKeyRange& range,
     blink::WebIDBCursorDirection direction,
     leveldb::Status* s) {
   IDB_TRACE("IndexedDBBackingStore::OpenIndexCursor");
   LevelDBTransaction* leveldb_transaction = transaction->transaction();
   IndexedDBBackingStore::Cursor::CursorOptions cursor_options;
-  if (!IndexCursorOptions(leveldb_transaction,
-                          database_id,
-                          object_store_id,
-                          index_id,
-                          range,
-                          direction,
-                          &cursor_options))
+  if (!IndexCursorOptions(leveldb_transaction, database_id, object_store_id,
+                          index_id, range, direction, &cursor_options, s))
     return std::unique_ptr<IndexedDBBackingStore::Cursor>();
   std::unique_ptr<IndexCursorImpl> cursor(
       new IndexCursorImpl(this, transaction, database_id, cursor_options));
   if (!cursor->FirstSeek(s))
     return std::unique_ptr<IndexedDBBackingStore::Cursor>();
 
   return std::move(cursor);
 }
 
 IndexedDBBackingStore::Transaction::Transaction(
@@ skipping 461 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