Home | History | Annotate | Download | only in indexed_db
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "content/browser/indexed_db/indexed_db_fake_backing_store.h"
      6 
      7 #include "base/files/file_path.h"
      8 #include "base/memory/scoped_ptr.h"
      9 
     10 namespace content {
     11 
     12 IndexedDBFakeBackingStore::IndexedDBFakeBackingStore()
     13     : IndexedDBBackingStore(NULL /* indexed_db_factory */,
     14                             GURL("http://localhost:81"),
     15                             base::FilePath(),
     16                             NULL /* request_context */,
     17                             scoped_ptr<LevelDBDatabase>(),
     18                             scoped_ptr<LevelDBComparator>(),
     19                             NULL /* task_runner */) {
     20 }
     21 IndexedDBFakeBackingStore::IndexedDBFakeBackingStore(
     22     IndexedDBFactory* factory,
     23     base::SequencedTaskRunner* task_runner)
     24     : IndexedDBBackingStore(factory,
     25                             GURL("http://localhost:81"),
     26                             base::FilePath(),
     27                             NULL /* request_context */,
     28                             scoped_ptr<LevelDBDatabase>(),
     29                             scoped_ptr<LevelDBComparator>(),
     30                             task_runner) {
     31 }
     32 IndexedDBFakeBackingStore::~IndexedDBFakeBackingStore() {}
     33 
     34 std::vector<base::string16> IndexedDBFakeBackingStore::GetDatabaseNames(
     35     leveldb::Status* s) {
     36   *s = leveldb::Status::OK();
     37   return std::vector<base::string16>();
     38 }
     39 leveldb::Status IndexedDBFakeBackingStore::GetIDBDatabaseMetaData(
     40     const base::string16& name,
     41     IndexedDBDatabaseMetadata*,
     42     bool* found) {
     43   return leveldb::Status::OK();
     44 }
     45 
     46 leveldb::Status IndexedDBFakeBackingStore::CreateIDBDatabaseMetaData(
     47     const base::string16& name,
     48     const base::string16& version,
     49     int64 int_version,
     50     int64* row_id) {
     51   return leveldb::Status::OK();
     52 }
     53 bool IndexedDBFakeBackingStore::UpdateIDBDatabaseIntVersion(Transaction*,
     54                                                             int64 row_id,
     55                                                             int64 version) {
     56   return false;
     57 }
     58 leveldb::Status IndexedDBFakeBackingStore::DeleteDatabase(
     59     const base::string16& name) {
     60   return leveldb::Status::OK();
     61 }
     62 
     63 leveldb::Status IndexedDBFakeBackingStore::CreateObjectStore(
     64     Transaction*,
     65     int64 database_id,
     66     int64 object_store_id,
     67     const base::string16& name,
     68     const IndexedDBKeyPath&,
     69     bool auto_increment) {
     70   return leveldb::Status::OK();
     71 }
     72 
     73 leveldb::Status IndexedDBFakeBackingStore::DeleteObjectStore(
     74     Transaction* transaction,
     75     int64 database_id,
     76     int64 object_store_id) {
     77   return leveldb::Status::OK();
     78 }
     79 
     80 leveldb::Status IndexedDBFakeBackingStore::PutRecord(
     81     IndexedDBBackingStore::Transaction* transaction,
     82     int64 database_id,
     83     int64 object_store_id,
     84     const IndexedDBKey& key,
     85     IndexedDBValue* value,
     86     ScopedVector<storage::BlobDataHandle>* handles,
     87     RecordIdentifier* record) {
     88   return leveldb::Status::OK();
     89 }
     90 
     91 leveldb::Status IndexedDBFakeBackingStore::ClearObjectStore(
     92     Transaction*,
     93     int64 database_id,
     94     int64 object_store_id) {
     95   return leveldb::Status::OK();
     96 }
     97 leveldb::Status IndexedDBFakeBackingStore::DeleteRecord(
     98     Transaction*,
     99     int64 database_id,
    100     int64 object_store_id,
    101     const RecordIdentifier&) {
    102   return leveldb::Status::OK();
    103 }
    104 leveldb::Status IndexedDBFakeBackingStore::GetKeyGeneratorCurrentNumber(
    105     Transaction*,
    106     int64 database_id,
    107     int64 object_store_id,
    108     int64* current_number) {
    109   return leveldb::Status::OK();
    110 }
    111 leveldb::Status IndexedDBFakeBackingStore::MaybeUpdateKeyGeneratorCurrentNumber(
    112     Transaction*,
    113     int64 database_id,
    114     int64 object_store_id,
    115     int64 new_number,
    116     bool check_current) {
    117   return leveldb::Status::OK();
    118 }
    119 leveldb::Status IndexedDBFakeBackingStore::KeyExistsInObjectStore(
    120     Transaction*,
    121     int64 database_id,
    122     int64 object_store_id,
    123     const IndexedDBKey&,
    124     RecordIdentifier* found_record_identifier,
    125     bool* found) {
    126   return leveldb::Status::OK();
    127 }
    128 
    129 leveldb::Status IndexedDBFakeBackingStore::CreateIndex(
    130     Transaction*,
    131     int64 database_id,
    132     int64 object_store_id,
    133     int64 index_id,
    134     const base::string16& name,
    135     const IndexedDBKeyPath&,
    136     bool is_unique,
    137     bool is_multi_entry) {
    138   return leveldb::Status::OK();
    139 }
    140 
    141 leveldb::Status IndexedDBFakeBackingStore::DeleteIndex(Transaction*,
    142                                                        int64 database_id,
    143                                                        int64 object_store_id,
    144                                                        int64 index_id) {
    145   return leveldb::Status::OK();
    146 }
    147 leveldb::Status IndexedDBFakeBackingStore::PutIndexDataForRecord(
    148     Transaction*,
    149     int64 database_id,
    150     int64 object_store_id,
    151     int64 index_id,
    152     const IndexedDBKey&,
    153     const RecordIdentifier&) {
    154   return leveldb::Status::OK();
    155 }
    156 
    157 void IndexedDBFakeBackingStore::ReportBlobUnused(int64 database_id,
    158                                                  int64 blob_key) {}
    159 
    160 scoped_ptr<IndexedDBBackingStore::Cursor>
    161 IndexedDBFakeBackingStore::OpenObjectStoreKeyCursor(
    162     IndexedDBBackingStore::Transaction* transaction,
    163     int64 database_id,
    164     int64 object_store_id,
    165     const IndexedDBKeyRange& key_range,
    166     blink::WebIDBCursorDirection,
    167     leveldb::Status* s) {
    168   return scoped_ptr<IndexedDBBackingStore::Cursor>();
    169 }
    170 scoped_ptr<IndexedDBBackingStore::Cursor>
    171 IndexedDBFakeBackingStore::OpenObjectStoreCursor(
    172     IndexedDBBackingStore::Transaction* transaction,
    173     int64 database_id,
    174     int64 object_store_id,
    175     const IndexedDBKeyRange& key_range,
    176     blink::WebIDBCursorDirection,
    177     leveldb::Status* s) {
    178   return scoped_ptr<IndexedDBBackingStore::Cursor>();
    179 }
    180 scoped_ptr<IndexedDBBackingStore::Cursor>
    181 IndexedDBFakeBackingStore::OpenIndexKeyCursor(
    182     IndexedDBBackingStore::Transaction* transaction,
    183     int64 database_id,
    184     int64 object_store_id,
    185     int64 index_id,
    186     const IndexedDBKeyRange& key_range,
    187     blink::WebIDBCursorDirection,
    188     leveldb::Status* s) {
    189   return scoped_ptr<IndexedDBBackingStore::Cursor>();
    190 }
    191 scoped_ptr<IndexedDBBackingStore::Cursor>
    192 IndexedDBFakeBackingStore::OpenIndexCursor(
    193     IndexedDBBackingStore::Transaction* transaction,
    194     int64 database_id,
    195     int64 object_store_id,
    196     int64 index_id,
    197     const IndexedDBKeyRange& key_range,
    198     blink::WebIDBCursorDirection,
    199     leveldb::Status* s) {
    200   return scoped_ptr<IndexedDBBackingStore::Cursor>();
    201 }
    202 
    203 IndexedDBFakeBackingStore::FakeTransaction::FakeTransaction(
    204     leveldb::Status result)
    205     : IndexedDBBackingStore::Transaction(NULL), result_(result) {
    206 }
    207 void IndexedDBFakeBackingStore::FakeTransaction::Begin() {}
    208 leveldb::Status IndexedDBFakeBackingStore::FakeTransaction::CommitPhaseOne(
    209     scoped_refptr<BlobWriteCallback> callback) {
    210   callback->Run(true);
    211   return leveldb::Status::OK();
    212 }
    213 leveldb::Status IndexedDBFakeBackingStore::FakeTransaction::CommitPhaseTwo() {
    214   return result_;
    215 }
    216 void IndexedDBFakeBackingStore::FakeTransaction::Rollback() {}
    217 
    218 }  // namespace content
    219