File: indexed_db_fake_backing_store.h

package info (click to toggle)
chromium-browser 41.0.2272.118-1
  • links: PTS, VCS
  • area: main
  • in suites: jessie-kfreebsd
  • size: 2,189,132 kB
  • sloc: cpp: 9,691,462; ansic: 3,341,451; python: 712,689; asm: 518,779; xml: 208,926; java: 169,820; sh: 119,353; perl: 68,907; makefile: 28,311; yacc: 13,305; objc: 11,385; tcl: 3,186; cs: 2,225; sql: 2,217; lex: 2,215; lisp: 1,349; pascal: 1,256; awk: 407; ruby: 155; sed: 53; php: 14; exp: 11
file content (153 lines) | stat: -rw-r--r-- 6,852 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
// 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.

#ifndef CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_FAKE_BACKING_STORE_H_
#define CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_FAKE_BACKING_STORE_H_

#include <vector>

#include "content/browser/indexed_db/indexed_db_backing_store.h"

namespace base {
class SequencedTaskRunner;
}

namespace content {

class IndexedDBFactory;

class IndexedDBFakeBackingStore : public IndexedDBBackingStore {
 public:
  IndexedDBFakeBackingStore();
  IndexedDBFakeBackingStore(IndexedDBFactory* factory,
                            base::SequencedTaskRunner* task_runner);
  std::vector<base::string16> GetDatabaseNames(leveldb::Status* s) override;
  leveldb::Status GetIDBDatabaseMetaData(const base::string16& name,
                                         IndexedDBDatabaseMetadata*,
                                         bool* found) override;
  leveldb::Status CreateIDBDatabaseMetaData(const base::string16& name,
                                            const base::string16& version,
                                            int64 int_version,
                                            int64* row_id) override;
  bool UpdateIDBDatabaseIntVersion(Transaction*,
                                   int64 row_id,
                                   int64 version) override;
  leveldb::Status DeleteDatabase(const base::string16& name) override;

  leveldb::Status CreateObjectStore(Transaction*,
                                    int64 database_id,
                                    int64 object_store_id,
                                    const base::string16& name,
                                    const IndexedDBKeyPath&,
                                    bool auto_increment) override;

  leveldb::Status DeleteObjectStore(Transaction* transaction,
                                    int64 database_id,
                                    int64 object_store_id) override;

  leveldb::Status PutRecord(IndexedDBBackingStore::Transaction* transaction,
                            int64 database_id,
                            int64 object_store_id,
                            const IndexedDBKey& key,
                            IndexedDBValue* value,
                            ScopedVector<storage::BlobDataHandle>* handles,
                            RecordIdentifier* record) override;

  leveldb::Status ClearObjectStore(Transaction*,
                                   int64 database_id,
                                   int64 object_store_id) override;
  leveldb::Status DeleteRecord(Transaction*,
                               int64 database_id,
                               int64 object_store_id,
                               const RecordIdentifier&) override;
  leveldb::Status GetKeyGeneratorCurrentNumber(Transaction*,
                                               int64 database_id,
                                               int64 object_store_id,
                                               int64* current_number) override;
  leveldb::Status MaybeUpdateKeyGeneratorCurrentNumber(
      Transaction*,
      int64 database_id,
      int64 object_store_id,
      int64 new_number,
      bool check_current) override;
  leveldb::Status KeyExistsInObjectStore(
      Transaction*,
      int64 database_id,
      int64 object_store_id,
      const IndexedDBKey&,
      RecordIdentifier* found_record_identifier,
      bool* found) override;

  leveldb::Status 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) override;
  leveldb::Status DeleteIndex(Transaction*,
                              int64 database_id,
                              int64 object_store_id,
                              int64 index_id) override;
  leveldb::Status PutIndexDataForRecord(Transaction*,
                                        int64 database_id,
                                        int64 object_store_id,
                                        int64 index_id,
                                        const IndexedDBKey&,
                                        const RecordIdentifier&) override;
  void ReportBlobUnused(int64 database_id, int64 blob_key) override;
  scoped_ptr<Cursor> OpenObjectStoreKeyCursor(
      Transaction* transaction,
      int64 database_id,
      int64 object_store_id,
      const IndexedDBKeyRange& key_range,
      blink::WebIDBCursorDirection,
      leveldb::Status*) override;
  scoped_ptr<Cursor> OpenObjectStoreCursor(Transaction* transaction,
                                           int64 database_id,
                                           int64 object_store_id,
                                           const IndexedDBKeyRange& key_range,
                                           blink::WebIDBCursorDirection,
                                           leveldb::Status*) override;
  scoped_ptr<Cursor> OpenIndexKeyCursor(Transaction* transaction,
                                        int64 database_id,
                                        int64 object_store_id,
                                        int64 index_id,
                                        const IndexedDBKeyRange& key_range,
                                        blink::WebIDBCursorDirection,
                                        leveldb::Status*) override;
  scoped_ptr<Cursor> OpenIndexCursor(Transaction* transaction,
                                     int64 database_id,
                                     int64 object_store_id,
                                     int64 index_id,
                                     const IndexedDBKeyRange& key_range,
                                     blink::WebIDBCursorDirection,
                                     leveldb::Status*) override;

  class FakeTransaction : public IndexedDBBackingStore::Transaction {
   public:
    explicit FakeTransaction(leveldb::Status phase_two_result);
    void Begin() override;
    leveldb::Status CommitPhaseOne(scoped_refptr<BlobWriteCallback>) override;
    leveldb::Status CommitPhaseTwo() override;
    void Rollback() override;

   private:
    leveldb::Status result_;

    DISALLOW_COPY_AND_ASSIGN(FakeTransaction);
  };

 protected:
  friend class base::RefCounted<IndexedDBFakeBackingStore>;
  ~IndexedDBFakeBackingStore() override;

 private:
  DISALLOW_COPY_AND_ASSIGN(IndexedDBFakeBackingStore);
};

}  // namespace content

#endif  // CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_FAKE_BACKING_STORE_H_