root/content/browser/indexed_db/indexed_db_fake_backing_store.cc

DEFINITIONS

1. GetDatabaseNames
2. GetIDBDatabaseMetaData
3. CreateIDBDatabaseMetaData
4. UpdateIDBDatabaseIntVersion
5. DeleteDatabase
6. CreateObjectStore
7. ClearObjectStore
8. DeleteRecord
9. GetKeyGeneratorCurrentNumber
10. MaybeUpdateKeyGeneratorCurrentNumber
11. KeyExistsInObjectStore
12. CreateIndex
13. DeleteIndex
14. PutIndexDataForRecord
15. ReportBlobUnused
16. OpenObjectStoreKeyCursor
17. OpenObjectStoreCursor
18. OpenIndexKeyCursor
19. OpenIndexCursor
20. result_
21. Begin
22. Commit
23. Rollback

// Copyright 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_fake_backing_store.h"

#include "base/memory/scoped_ptr.h"

namespace content {

IndexedDBFakeBackingStore::IndexedDBFakeBackingStore()
    : IndexedDBBackingStore(NULL,
                            GURL("http://localhost:81"),
                            scoped_ptr<LevelDBDatabase>(),
                            scoped_ptr<LevelDBComparator>(),
                            NULL) {}

IndexedDBFakeBackingStore::IndexedDBFakeBackingStore(
    IndexedDBFactory* factory,
    base::TaskRunner* task_runner)
    : IndexedDBBackingStore(factory,
                            GURL("http://localhost:81"),
                            scoped_ptr<LevelDBDatabase>(),
                            scoped_ptr<LevelDBComparator>(),
                            task_runner) {}

IndexedDBFakeBackingStore::~IndexedDBFakeBackingStore() {}

std::vector<base::string16> IndexedDBFakeBackingStore::GetDatabaseNames() {
  return std::vector<base::string16>();
}
leveldb::Status IndexedDBFakeBackingStore::GetIDBDatabaseMetaData(
    const base::string16& name,
    IndexedDBDatabaseMetadata*,
    bool* found) {
  return leveldb::Status::OK();
}

leveldb::Status IndexedDBFakeBackingStore::CreateIDBDatabaseMetaData(
    const base::string16& name,
    const base::string16& version,
    int64 int_version,
    int64* row_id) {
  return leveldb::Status::OK();
}
bool IndexedDBFakeBackingStore::UpdateIDBDatabaseIntVersion(Transaction*,
                                                            int64 row_id,
                                                            int64 version) {
  return false;
}
leveldb::Status IndexedDBFakeBackingStore::DeleteDatabase(
    const base::string16& name) {
  return leveldb::Status::OK();
}

leveldb::Status IndexedDBFakeBackingStore::CreateObjectStore(
    Transaction*,
    int64 database_id,
    int64 object_store_id,
    const base::string16& name,
    const IndexedDBKeyPath&,
    bool auto_increment) {
  return leveldb::Status::IOError("test error");
}

leveldb::Status IndexedDBFakeBackingStore::ClearObjectStore(
    Transaction*,
    int64 database_id,
    int64 object_store_id) {
  return leveldb::Status::IOError("test error");
}
leveldb::Status IndexedDBFakeBackingStore::DeleteRecord(
    Transaction*,
    int64 database_id,
    int64 object_store_id,
    const RecordIdentifier&) {
  return leveldb::Status::IOError("test error");
}
leveldb::Status IndexedDBFakeBackingStore::GetKeyGeneratorCurrentNumber(
    Transaction*,
    int64 database_id,
    int64 object_store_id,
    int64* current_number) {
  return leveldb::Status::OK();
}
leveldb::Status IndexedDBFakeBackingStore::MaybeUpdateKeyGeneratorCurrentNumber(
    Transaction*,
    int64 database_id,
    int64 object_store_id,
    int64 new_number,
    bool check_current) {
  return leveldb::Status::OK();
}
leveldb::Status IndexedDBFakeBackingStore::KeyExistsInObjectStore(
    Transaction*,
    int64 database_id,
    int64 object_store_id,
    const IndexedDBKey&,
    RecordIdentifier* found_record_identifier,
    bool* found) {
  return leveldb::Status::OK();
}

leveldb::Status IndexedDBFakeBackingStore::CreateIndex(
    Transaction*,
    int64 database_id,
    int64 object_store_id,
    int64 index_id,
    const base::string16& name,
    const IndexedDBKeyPath&,
    bool is_unique,
    bool is_multi_entry) {
  return leveldb::Status::IOError("test error");
}

leveldb::Status IndexedDBFakeBackingStore::DeleteIndex(Transaction*,
                                                       int64 database_id,
                                                       int64 object_store_id,
                                                       int64 index_id) {
  return leveldb::Status::IOError("test error");
}
leveldb::Status IndexedDBFakeBackingStore::PutIndexDataForRecord(
    Transaction*,
    int64 database_id,
    int64 object_store_id,
    int64 index_id,
    const IndexedDBKey&,
    const RecordIdentifier&) {
  return leveldb::Status::IOError("test error");
}

void IndexedDBFakeBackingStore::ReportBlobUnused(int64 database_id,
                                                 int64 blob_key) {}

scoped_ptr<IndexedDBBackingStore::Cursor>
IndexedDBFakeBackingStore::OpenObjectStoreKeyCursor(
    IndexedDBBackingStore::Transaction* transaction,
    int64 database_id,
    int64 object_store_id,
    const IndexedDBKeyRange& key_range,
    indexed_db::CursorDirection) {
  return scoped_ptr<IndexedDBBackingStore::Cursor>();
}
scoped_ptr<IndexedDBBackingStore::Cursor>
IndexedDBFakeBackingStore::OpenObjectStoreCursor(
    IndexedDBBackingStore::Transaction* transaction,
    int64 database_id,
    int64 object_store_id,
    const IndexedDBKeyRange& key_range,
    indexed_db::CursorDirection) {
  return scoped_ptr<IndexedDBBackingStore::Cursor>();
}
scoped_ptr<IndexedDBBackingStore::Cursor>
IndexedDBFakeBackingStore::OpenIndexKeyCursor(
    IndexedDBBackingStore::Transaction* transaction,
    int64 database_id,
    int64 object_store_id,
    int64 index_id,
    const IndexedDBKeyRange& key_range,
    indexed_db::CursorDirection) {
  return scoped_ptr<IndexedDBBackingStore::Cursor>();
}
scoped_ptr<IndexedDBBackingStore::Cursor>
IndexedDBFakeBackingStore::OpenIndexCursor(
    IndexedDBBackingStore::Transaction* transaction,
    int64 database_id,
    int64 object_store_id,
    int64 index_id,
    const IndexedDBKeyRange& key_range,
    indexed_db::CursorDirection) {
  return scoped_ptr<IndexedDBBackingStore::Cursor>();
}

IndexedDBFakeBackingStore::FakeTransaction::FakeTransaction(bool result)
    : IndexedDBBackingStore::Transaction(NULL), result_(result) {}
void IndexedDBFakeBackingStore::FakeTransaction::Begin() {}
leveldb::Status IndexedDBFakeBackingStore::FakeTransaction::Commit() {
  if (result_)
    return leveldb::Status::OK();
  else
    return leveldb::Status::IOError("test error");
}
void IndexedDBFakeBackingStore::FakeTransaction::Rollback() {}

}  // namespace content