IndexedDB: Added IDBObjectStore.getAll() corruption test.

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 "base/files/file_path.h"
 #include "base/files/file_util.h"
@@ skipping 3223 matching lines @@
         continue;
       }
 
       return false;
     }
 
     if (!HaveEnteredRange())
       continue;
 
     // The row may not load because there's a stale entry in the
-    // index. This is not fatal.
-    if (!LoadCurrentRow())
+    // index. If no error then not fatal.
+    if (!LoadCurrentRow(s)) {
+      if (!s->ok())
+        return false;
       continue;
+    }
 
     if (key) {
       if (forward) {
         if (primary_key && current_key_->Equals(*key) &&
             this->primary_key().IsLessThan(*primary_key))
           continue;
         if (!flipped && current_key_->IsLessThan(*key))
           continue;
       } else {
         if (primary_key && key->Equals(*current_key_) &&
@@ skipping 88 matching lines @@
                                       database_id,
                                       cursor_options) {}
 
   Cursor* Clone() override { return new ObjectStoreKeyCursorImpl(this); }
 
   // IndexedDBBackingStore::Cursor
   IndexedDBValue* value() override {
     NOTREACHED();
     return NULL;
   }
-  bool LoadCurrentRow() override;
+  bool LoadCurrentRow(leveldb::Status* s) override;
 
  protected:
   std::string EncodeKey(const IndexedDBKey& key) override {
     return ObjectStoreDataKey::Encode(
         cursor_options_.database_id, cursor_options_.object_store_id, key);
   }
   std::string EncodeKey(const IndexedDBKey& key,
                         const IndexedDBKey& primary_key) override {
     NOTREACHED();
     return std::string();
   }
 
  private:
   explicit ObjectStoreKeyCursorImpl(const ObjectStoreKeyCursorImpl* other)
       : IndexedDBBackingStore::Cursor(other) {}
 
   DISALLOW_COPY_AND_ASSIGN(ObjectStoreKeyCursorImpl);
 };
 
-bool ObjectStoreKeyCursorImpl::LoadCurrentRow() {
+bool ObjectStoreKeyCursorImpl::LoadCurrentRow(leveldb::Status* s) {
   StringPiece slice(iterator_->Key());
   ObjectStoreDataKey object_store_data_key;
   if (!ObjectStoreDataKey::Decode(&slice, &object_store_data_key)) {
     INTERNAL_READ_ERROR_UNTESTED(LOAD_CURRENT_ROW);
+    *s = InvalidDBKeyStatus();
     return false;
   }
 
   current_key_ = object_store_data_key.user_key();
 
   int64 version;
   slice = StringPiece(iterator_->Value());
   if (!DecodeVarInt(&slice, &version)) {
     INTERNAL_READ_ERROR_UNTESTED(LOAD_CURRENT_ROW);
+    *s = InternalInconsistencyStatus();
     return false;
   }
 
   // TODO(jsbell): This re-encodes what was just decoded; try and optimize.
   std::string encoded_key;
   EncodeIDBKey(*current_key_, &encoded_key);
   record_identifier_.Reset(encoded_key, version);
 
   return true;
 }
 
 class ObjectStoreCursorImpl : public IndexedDBBackingStore::Cursor {
  public:
   ObjectStoreCursorImpl(
       scoped_refptr<IndexedDBBackingStore> backing_store,
       IndexedDBBackingStore::Transaction* transaction,
       int64 database_id,
       const IndexedDBBackingStore::Cursor::CursorOptions& cursor_options)
       : IndexedDBBackingStore::Cursor(backing_store,
                                       transaction,
                                       database_id,
                                       cursor_options) {}
 
   Cursor* Clone() override { return new ObjectStoreCursorImpl(this); }
 
   // IndexedDBBackingStore::Cursor
   IndexedDBValue* value() override { return &current_value_; }
-  bool LoadCurrentRow() override;
+  bool LoadCurrentRow(leveldb::Status* s) override;
 
  protected:
   std::string EncodeKey(const IndexedDBKey& key) override {
     return ObjectStoreDataKey::Encode(
         cursor_options_.database_id, cursor_options_.object_store_id, key);
   }
   std::string EncodeKey(const IndexedDBKey& key,
                         const IndexedDBKey& primary_key) override {
     NOTREACHED();
     return std::string();
   }
 
  private:
   explicit ObjectStoreCursorImpl(const ObjectStoreCursorImpl* other)
       : IndexedDBBackingStore::Cursor(other),
         current_value_(other->current_value_) {}
 
   IndexedDBValue current_value_;
 
   DISALLOW_COPY_AND_ASSIGN(ObjectStoreCursorImpl);
 };
 
-bool ObjectStoreCursorImpl::LoadCurrentRow() {
+bool ObjectStoreCursorImpl::LoadCurrentRow(leveldb::Status* s) {
   StringPiece key_slice(iterator_->Key());
   ObjectStoreDataKey object_store_data_key;
   if (!ObjectStoreDataKey::Decode(&key_slice, &object_store_data_key)) {
     INTERNAL_READ_ERROR_UNTESTED(LOAD_CURRENT_ROW);
+    *s = InvalidDBKeyStatus();
     return false;
   }
 
   current_key_ = object_store_data_key.user_key();
 
   int64 version;
   StringPiece value_slice = StringPiece(iterator_->Value());
   if (!DecodeVarInt(&value_slice, &version)) {
     INTERNAL_READ_ERROR_UNTESTED(LOAD_CURRENT_ROW);
+    *s = InternalInconsistencyStatus();
     return false;
   }
 
   // TODO(jsbell): This re-encodes what was just decoded; try and optimize.
   std::string encoded_key;
   EncodeIDBKey(*current_key_, &encoded_key);
   record_identifier_.Reset(encoded_key, version);
 
-  if (!transaction_->GetBlobInfoForRecord(database_id_,
-                                          iterator_->Key().as_string(),
-                                          &current_value_).ok()) {
+  *s = transaction_->GetBlobInfoForRecord(
+      database_id_, iterator_->Key().as_string(), &current_value_);
+  if (!s->ok())
     return false;
-  }
+
   current_value_.bits = value_slice.as_string();
   return true;
 }
 
 class IndexKeyCursorImpl : public IndexedDBBackingStore::Cursor {
  public:
   IndexKeyCursorImpl(
       scoped_refptr<IndexedDBBackingStore> backing_store,
       IndexedDBBackingStore::Transaction* transaction,
       int64 database_id,
       const IndexedDBBackingStore::Cursor::CursorOptions& cursor_options)
       : IndexedDBBackingStore::Cursor(backing_store,
                                       transaction,
                                       database_id,
                                       cursor_options) {}
 
   Cursor* Clone() override { return new IndexKeyCursorImpl(this); }
 
   // IndexedDBBackingStore::Cursor
   IndexedDBValue* value() override {
     NOTREACHED();
     return NULL;
   }
   const IndexedDBKey& primary_key() const override { return *primary_key_; }
   const IndexedDBBackingStore::RecordIdentifier& record_identifier()
       const override {
     NOTREACHED();
     return record_identifier_;
   }
-  bool LoadCurrentRow() override;
+  bool LoadCurrentRow(leveldb::Status* s) override;
 
  protected:
   std::string EncodeKey(const IndexedDBKey& key) override {
     return IndexDataKey::Encode(cursor_options_.database_id,
                                 cursor_options_.object_store_id,
                                 cursor_options_.index_id,
                                 key);
   }
   std::string EncodeKey(const IndexedDBKey& key,
                         const IndexedDBKey& primary_key) override {
     return IndexDataKey::Encode(cursor_options_.database_id,
                                 cursor_options_.object_store_id,
                                 cursor_options_.index_id,
                                 key,
                                 primary_key);
   }
 
  private:
   explicit IndexKeyCursorImpl(const IndexKeyCursorImpl* other)
       : IndexedDBBackingStore::Cursor(other),
         primary_key_(new IndexedDBKey(*other->primary_key_)) {}
 
   scoped_ptr<IndexedDBKey> primary_key_;
 
   DISALLOW_COPY_AND_ASSIGN(IndexKeyCursorImpl);
 };
 
-bool IndexKeyCursorImpl::LoadCurrentRow() {
+bool IndexKeyCursorImpl::LoadCurrentRow(leveldb::Status* s) {
   StringPiece slice(iterator_->Key());
   IndexDataKey index_data_key;
   if (!IndexDataKey::Decode(&slice, &index_data_key)) {
     INTERNAL_READ_ERROR_UNTESTED(LOAD_CURRENT_ROW);
+    *s = InvalidDBKeyStatus();
     return false;
   }
 
   current_key_ = index_data_key.user_key();
   DCHECK(current_key_);
 
   slice = StringPiece(iterator_->Value());
   int64 index_data_version;
   if (!DecodeVarInt(&slice, &index_data_version)) {
     INTERNAL_READ_ERROR_UNTESTED(LOAD_CURRENT_ROW);
+    *s = InternalInconsistencyStatus();
     return false;
   }
 
   if (!DecodeIDBKey(&slice, &primary_key_) || !slice.empty()) {
     INTERNAL_READ_ERROR_UNTESTED(LOAD_CURRENT_ROW);
+    *s = InternalInconsistencyStatus();
     return false;
   }
 
   std::string primary_leveldb_key =
       ObjectStoreDataKey::Encode(index_data_key.DatabaseId(),
                                  index_data_key.ObjectStoreId(),
                                  *primary_key_);
 
   std::string result;
   bool found = false;
-  leveldb::Status s =
-      transaction_->transaction()->Get(primary_leveldb_key, &result, &found);
-  if (!s.ok()) {
+  *s = transaction_->transaction()->Get(primary_leveldb_key, &result, &found);
+  if (!s->ok()) {
     INTERNAL_READ_ERROR_UNTESTED(LOAD_CURRENT_ROW);
     return false;
   }
   if (!found) {
     transaction_->transaction()->Remove(iterator_->Key());
     return false;
   }
   if (!result.size()) {
     INTERNAL_READ_ERROR_UNTESTED(LOAD_CURRENT_ROW);
     return false;
   }
 
   int64 object_store_data_version;
   slice = StringPiece(result);
   if (!DecodeVarInt(&slice, &object_store_data_version)) {
     INTERNAL_READ_ERROR_UNTESTED(LOAD_CURRENT_ROW);
+    *s = InternalInconsistencyStatus();
     return false;
   }
 
   if (object_store_data_version != index_data_version) {
     transaction_->transaction()->Remove(iterator_->Key());
     return false;
   }
 
   return true;
 }
@@ skipping 13 matching lines @@
   Cursor* Clone() override { return new IndexCursorImpl(this); }
 
   // IndexedDBBackingStore::Cursor
   IndexedDBValue* value() override { return &current_value_; }
   const IndexedDBKey& primary_key() const override { return *primary_key_; }
   const IndexedDBBackingStore::RecordIdentifier& record_identifier()
       const override {
     NOTREACHED();
     return record_identifier_;
   }
-  bool LoadCurrentRow() override;
+  bool LoadCurrentRow(leveldb::Status* s) override;
 
  protected:
   std::string EncodeKey(const IndexedDBKey& key) override {
     return IndexDataKey::Encode(cursor_options_.database_id,
                                 cursor_options_.object_store_id,
                                 cursor_options_.index_id,
                                 key);
   }
   std::string EncodeKey(const IndexedDBKey& key,
                         const IndexedDBKey& primary_key) override {
@@ skipping 11 matching lines @@
         current_value_(other->current_value_),
         primary_leveldb_key_(other->primary_leveldb_key_) {}
 
   scoped_ptr<IndexedDBKey> primary_key_;
   IndexedDBValue current_value_;
   std::string primary_leveldb_key_;
 
   DISALLOW_COPY_AND_ASSIGN(IndexCursorImpl);
 };
 
-bool IndexCursorImpl::LoadCurrentRow() {
+bool IndexCursorImpl::LoadCurrentRow(leveldb::Status* s) {
   StringPiece slice(iterator_->Key());
   IndexDataKey index_data_key;
   if (!IndexDataKey::Decode(&slice, &index_data_key)) {
     INTERNAL_READ_ERROR_UNTESTED(LOAD_CURRENT_ROW);
+    *s = InvalidDBKeyStatus();
     return false;
   }
 
   current_key_ = index_data_key.user_key();
   DCHECK(current_key_);
 
   slice = StringPiece(iterator_->Value());
   int64 index_data_version;
   if (!DecodeVarInt(&slice, &index_data_version)) {
     INTERNAL_READ_ERROR_UNTESTED(LOAD_CURRENT_ROW);
+    *s = InternalInconsistencyStatus();
     return false;
   }
   if (!DecodeIDBKey(&slice, &primary_key_)) {
     INTERNAL_READ_ERROR_UNTESTED(LOAD_CURRENT_ROW);
+    *s = InvalidDBKeyStatus();
     return false;
   }
 
   DCHECK_EQ(index_data_key.DatabaseId(), database_id_);
   primary_leveldb_key_ =
       ObjectStoreDataKey::Encode(index_data_key.DatabaseId(),
                                  index_data_key.ObjectStoreId(),
                                  *primary_key_);
 
   std::string result;
   bool found = false;
-  leveldb::Status s =
-      transaction_->transaction()->Get(primary_leveldb_key_, &result, &found);
-  if (!s.ok()) {
+  *s = transaction_->transaction()->Get(primary_leveldb_key_, &result, &found);
+  if (!s->ok()) {
     INTERNAL_READ_ERROR_UNTESTED(LOAD_CURRENT_ROW);
     return false;
   }
   if (!found) {
     transaction_->transaction()->Remove(iterator_->Key());
     return false;
   }
   if (!result.size()) {
     INTERNAL_READ_ERROR_UNTESTED(LOAD_CURRENT_ROW);
     return false;
   }
 
   int64 object_store_data_version;
   slice = StringPiece(result);
   if (!DecodeVarInt(&slice, &object_store_data_version)) {
     INTERNAL_READ_ERROR_UNTESTED(LOAD_CURRENT_ROW);
+    *s = InternalInconsistencyStatus();
     return false;
   }
 
   if (object_store_data_version != index_data_version) {
     transaction_->transaction()->Remove(iterator_->Key());
     return false;
   }
 
   current_value_.bits = slice.as_string();
-  return transaction_->GetBlobInfoForRecord(database_id_,
-                                            primary_leveldb_key_,
-                                            &current_value_).ok();
+  *s = transaction_->GetBlobInfoForRecord(database_id_, primary_leveldb_key_,
+                                          &current_value_);
+  return s->ok();
 }
 
 bool ObjectStoreCursorOptions(
     LevelDBTransaction* transaction,
     int64 database_id,
     int64 object_store_id,
     const IndexedDBKeyRange& range,
     blink::WebIDBCursorDirection direction,
     IndexedDBBackingStore::Cursor::CursorOptions* cursor_options) {
   cursor_options->database_id = database_id;
@@ skipping 711 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