| OLD | NEW |
|---|
| (Empty) | |
| 1 // Copyright (c) 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 #ifndef CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_BACKING_STORE_H_ |
| 6 #define CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_BACKING_STORE_H_ |
| 7 |
| 8 #include <vector> |
| 9 |
| 10 #include "base/basictypes.h" |
| 11 #include "base/files/file_path.h" |
| 12 #include "base/memory/ref_counted.h" |
| 13 #include "base/memory/scoped_ptr.h" |
| 14 #include "base/memory/weak_ptr.h" |
| 15 #include "content/browser/indexed_db/indexed_db.h" |
| 16 #include "content/browser/indexed_db/indexed_db_metadata.h" |
| 17 #include "content/browser/indexed_db/leveldb/leveldb_iterator.h" |
| 18 #include "content/browser/indexed_db/leveldb/leveldb_transaction.h" |
| 19 #include "content/common/content_export.h" |
| 20 #include "content/common/indexed_db/indexed_db_key.h" |
| 21 #include "content/common/indexed_db/indexed_db_key_path.h" |
| 22 #include "content/common/indexed_db/indexed_db_key_range.h" |
| 23 |
| 24 namespace content { |
| 25 |
| 26 class LevelDBComparator; |
| 27 class LevelDBDatabase; |
| 28 |
| 29 class LevelDBFactory { |
| 30 public: |
| 31 virtual scoped_ptr<LevelDBDatabase> OpenLevelDB( |
| 32 const base::FilePath& file_name, |
| 33 const LevelDBComparator* comparator) = 0; |
| 34 virtual bool DestroyLevelDB(const base::FilePath& file_name) = 0; |
| 35 }; |
| 36 |
| 37 class CONTENT_EXPORT IndexedDBBackingStore |
| 38 : public base::RefCounted<IndexedDBBackingStore> { |
| 39 public: |
| 40 class CONTENT_EXPORT Transaction; |
| 41 |
| 42 static scoped_refptr<IndexedDBBackingStore> Open( |
| 43 const string16& database_identifier, |
| 44 const string16& path_base, |
| 45 const string16& file_identifier); |
| 46 static scoped_refptr<IndexedDBBackingStore> Open( |
| 47 const string16& database_identifier, |
| 48 const string16& path_base, |
| 49 const string16& file_identifier, |
| 50 LevelDBFactory* factory); |
| 51 static scoped_refptr<IndexedDBBackingStore> OpenInMemory( |
| 52 const string16& identifier); |
| 53 static scoped_refptr<IndexedDBBackingStore> OpenInMemory( |
| 54 const string16& identifier, |
| 55 LevelDBFactory* factory); |
| 56 base::WeakPtr<IndexedDBBackingStore> GetWeakPtr() { |
| 57 return weak_factory_.GetWeakPtr(); |
| 58 } |
| 59 |
| 60 virtual std::vector<string16> GetDatabaseNames(); |
| 61 virtual bool GetIDBDatabaseMetaData(const string16& name, |
| 62 IndexedDBDatabaseMetadata* metadata, |
| 63 bool& success) WARN_UNUSED_RESULT; |
| 64 virtual bool CreateIDBDatabaseMetaData(const string16& name, |
| 65 const string16& version, |
| 66 int64 int_version, |
| 67 int64& row_id); |
| 68 virtual bool UpdateIDBDatabaseMetaData( |
| 69 IndexedDBBackingStore::Transaction* transaction, |
| 70 int64 row_id, |
| 71 const string16& version); |
| 72 virtual bool UpdateIDBDatabaseIntVersion( |
| 73 IndexedDBBackingStore::Transaction* transaction, |
| 74 int64 row_id, |
| 75 int64 int_version); |
| 76 virtual bool DeleteDatabase(const string16& name); |
| 77 |
| 78 bool GetObjectStores(int64 database_id, |
| 79 IndexedDBDatabaseMetadata::ObjectStoreMap* map) |
| 80 WARN_UNUSED_RESULT; |
| 81 virtual bool CreateObjectStore( |
| 82 IndexedDBBackingStore::Transaction* transaction, |
| 83 int64 database_id, |
| 84 int64 object_store_id, |
| 85 const string16& name, |
| 86 const IndexedDBKeyPath& key_path, |
| 87 bool auto_increment); |
| 88 virtual bool DeleteObjectStore( |
| 89 IndexedDBBackingStore::Transaction* transaction, |
| 90 int64 database_id, |
| 91 int64 object_store_id) WARN_UNUSED_RESULT; |
| 92 |
| 93 class CONTENT_EXPORT RecordIdentifier { |
| 94 public: |
| 95 RecordIdentifier(const std::vector<char>& primary_key, int64 version); |
| 96 RecordIdentifier(); |
| 97 ~RecordIdentifier(); |
| 98 |
| 99 const std::vector<char>& primary_key() const { return primary_key_; } |
| 100 int64 version() const { return version_; } |
| 101 void Reset(const std::vector<char>& primary_key, int64 version) { |
| 102 primary_key_ = primary_key; |
| 103 version_ = version; |
| 104 } |
| 105 |
| 106 private: |
| 107 std::vector<char> |
| 108 primary_key_; // TODO(jsbell): Make it more clear that this is |
| 109 // the *encoded* version of the key. |
| 110 int64 version_; |
| 111 DISALLOW_COPY_AND_ASSIGN(RecordIdentifier); |
| 112 }; |
| 113 |
| 114 virtual bool GetRecord(IndexedDBBackingStore::Transaction* transaction, |
| 115 int64 database_id, |
| 116 int64 object_store_id, |
| 117 const IndexedDBKey& key, |
| 118 std::vector<char>& record) WARN_UNUSED_RESULT; |
| 119 virtual bool PutRecord(IndexedDBBackingStore::Transaction* transaction, |
| 120 int64 database_id, |
| 121 int64 object_store_id, |
| 122 const IndexedDBKey& key, |
| 123 const std::vector<char>& value, |
| 124 RecordIdentifier* record) WARN_UNUSED_RESULT; |
| 125 virtual bool ClearObjectStore(IndexedDBBackingStore::Transaction* transaction, |
| 126 int64 database_id, |
| 127 int64 object_store_id) WARN_UNUSED_RESULT; |
| 128 virtual bool DeleteRecord(IndexedDBBackingStore::Transaction* transaction, |
| 129 int64 database_id, |
| 130 int64 object_store_id, |
| 131 const RecordIdentifier& record) WARN_UNUSED_RESULT; |
| 132 virtual bool GetKeyGeneratorCurrentNumber( |
| 133 IndexedDBBackingStore::Transaction* transaction, |
| 134 int64 database_id, |
| 135 int64 object_store_id, |
| 136 int64& current_number) WARN_UNUSED_RESULT; |
| 137 virtual bool MaybeUpdateKeyGeneratorCurrentNumber( |
| 138 IndexedDBBackingStore::Transaction* transaction, |
| 139 int64 database_id, |
| 140 int64 object_store_id, |
| 141 int64 new_state, |
| 142 bool check_current) WARN_UNUSED_RESULT; |
| 143 virtual bool KeyExistsInObjectStore( |
| 144 IndexedDBBackingStore::Transaction* transaction, |
| 145 int64 database_id, |
| 146 int64 object_store_id, |
| 147 const IndexedDBKey& key, |
| 148 RecordIdentifier* found_record_identifier, |
| 149 bool& found) WARN_UNUSED_RESULT; |
| 150 |
| 151 virtual bool CreateIndex(IndexedDBBackingStore::Transaction* transaction, |
| 152 int64 database_id, |
| 153 int64 object_store_id, |
| 154 int64 index_id, |
| 155 const string16& name, |
| 156 const IndexedDBKeyPath& key_path, |
| 157 bool is_unique, |
| 158 bool is_multi_entry) WARN_UNUSED_RESULT; |
| 159 virtual bool DeleteIndex(IndexedDBBackingStore::Transaction* transaction, |
| 160 int64 database_id, |
| 161 int64 object_store_id, |
| 162 int64 index_id) WARN_UNUSED_RESULT; |
| 163 virtual bool PutIndexDataForRecord( |
| 164 IndexedDBBackingStore::Transaction* transaction, |
| 165 int64 database_id, |
| 166 int64 object_store_id, |
| 167 int64 index_id, |
| 168 const IndexedDBKey& key, |
| 169 const RecordIdentifier& record) WARN_UNUSED_RESULT; |
| 170 virtual bool GetPrimaryKeyViaIndex( |
| 171 IndexedDBBackingStore::Transaction* transaction, |
| 172 int64 database_id, |
| 173 int64 object_store_id, |
| 174 int64 index_id, |
| 175 const IndexedDBKey& key, |
| 176 scoped_ptr<IndexedDBKey>* primary_key) WARN_UNUSED_RESULT; |
| 177 virtual bool KeyExistsInIndex(IndexedDBBackingStore::Transaction* transaction, |
| 178 int64 database_id, |
| 179 int64 object_store_id, |
| 180 int64 index_id, |
| 181 const IndexedDBKey& key, |
| 182 scoped_ptr<IndexedDBKey>* found_primary_key, |
| 183 bool& exists) WARN_UNUSED_RESULT; |
| 184 |
| 185 class Cursor { |
| 186 public: |
| 187 virtual ~Cursor(); |
| 188 |
| 189 enum IteratorState { |
| 190 READY = 0, |
| 191 SEEK |
| 192 }; |
| 193 |
| 194 struct CursorOptions { |
| 195 CursorOptions(); |
| 196 ~CursorOptions(); |
| 197 int64 database_id; |
| 198 int64 object_store_id; |
| 199 int64 index_id; |
| 200 std::vector<char> low_key; |
| 201 bool low_open; |
| 202 std::vector<char> high_key; |
| 203 bool high_open; |
| 204 bool forward; |
| 205 bool unique; |
| 206 }; |
| 207 |
| 208 const IndexedDBKey& key() const { return *current_key_; } |
| 209 bool ContinueFunction(const IndexedDBKey* = 0, IteratorState = SEEK); |
| 210 bool Advance(unsigned long); |
| 211 bool FirstSeek(); |
| 212 |
| 213 virtual Cursor* Clone() = 0; |
| 214 virtual const IndexedDBKey& primary_key() const; |
| 215 virtual std::vector<char>* Value() = 0; |
| 216 virtual const RecordIdentifier& record_identifier() const; |
| 217 virtual bool LoadCurrentRow() = 0; |
| 218 |
| 219 protected: |
| 220 Cursor(LevelDBTransaction* transaction, |
| 221 const CursorOptions& cursor_options); |
| 222 explicit Cursor(const IndexedDBBackingStore::Cursor* other); |
| 223 |
| 224 virtual std::vector<char> EncodeKey(const IndexedDBKey& key) = 0; |
| 225 |
| 226 bool IsPastBounds() const; |
| 227 bool HaveEnteredRange() const; |
| 228 |
| 229 LevelDBTransaction* transaction_; |
| 230 const CursorOptions cursor_options_; |
| 231 scoped_ptr<LevelDBIterator> iterator_; |
| 232 scoped_ptr<IndexedDBKey> current_key_; |
| 233 IndexedDBBackingStore::RecordIdentifier record_identifier_; |
| 234 }; |
| 235 |
| 236 virtual scoped_ptr<Cursor> OpenObjectStoreKeyCursor( |
| 237 IndexedDBBackingStore::Transaction* transaction, |
| 238 int64 database_id, |
| 239 int64 object_store_id, |
| 240 const IndexedDBKeyRange& key_range, |
| 241 indexed_db::CursorDirection); |
| 242 virtual scoped_ptr<Cursor> OpenObjectStoreCursor( |
| 243 IndexedDBBackingStore::Transaction* transaction, |
| 244 int64 database_id, |
| 245 int64 object_store_id, |
| 246 const IndexedDBKeyRange& key_range, |
| 247 indexed_db::CursorDirection); |
| 248 virtual scoped_ptr<Cursor> OpenIndexKeyCursor( |
| 249 IndexedDBBackingStore::Transaction* transaction, |
| 250 int64 database_id, |
| 251 int64 object_store_id, |
| 252 int64 index_id, |
| 253 const IndexedDBKeyRange& key_range, |
| 254 indexed_db::CursorDirection); |
| 255 virtual scoped_ptr<Cursor> OpenIndexCursor( |
| 256 IndexedDBBackingStore::Transaction* transaction, |
| 257 int64 database_id, |
| 258 int64 object_store_id, |
| 259 int64 index_id, |
| 260 const IndexedDBKeyRange& key_range, |
| 261 indexed_db::CursorDirection); |
| 262 |
| 263 class Transaction { |
| 264 public: |
| 265 explicit Transaction(IndexedDBBackingStore* backing_store); |
| 266 ~Transaction(); |
| 267 void begin(); |
| 268 bool Commit(); |
| 269 void Rollback(); |
| 270 void Reset() { |
| 271 backing_store_ = NULL; |
| 272 transaction_ = NULL; |
| 273 } |
| 274 |
| 275 static LevelDBTransaction* LevelDBTransactionFrom( |
| 276 Transaction* transaction) { |
| 277 return transaction->transaction_.get(); |
| 278 } |
| 279 |
| 280 private: |
| 281 IndexedDBBackingStore* backing_store_; |
| 282 scoped_refptr<LevelDBTransaction> transaction_; |
| 283 }; |
| 284 |
| 285 protected: |
| 286 IndexedDBBackingStore(const string16& identifier, |
| 287 scoped_ptr<LevelDBDatabase> db, |
| 288 scoped_ptr<LevelDBComparator> comparator); |
| 289 virtual ~IndexedDBBackingStore(); |
| 290 friend class base::RefCounted<IndexedDBBackingStore>; |
| 291 |
| 292 private: |
| 293 static scoped_refptr<IndexedDBBackingStore> Create( |
| 294 const string16& identifier, |
| 295 scoped_ptr<LevelDBDatabase> db, |
| 296 scoped_ptr<LevelDBComparator> comparator); |
| 297 |
| 298 bool FindKeyInIndex(IndexedDBBackingStore::Transaction* transaction, |
| 299 int64 database_id, |
| 300 int64 object_store_id, |
| 301 int64 index_id, |
| 302 const IndexedDBKey& key, |
| 303 std::vector<char>& found_encoded_primary_key, |
| 304 bool& found); |
| 305 bool GetIndexes(int64 database_id, |
| 306 int64 object_store_id, |
| 307 IndexedDBObjectStoreMetadata::IndexMap* map) |
| 308 WARN_UNUSED_RESULT; |
| 309 |
| 310 string16 identifier_; |
| 311 |
| 312 scoped_ptr<LevelDBDatabase> db_; |
| 313 scoped_ptr<LevelDBComparator> comparator_; |
| 314 base::WeakPtrFactory<IndexedDBBackingStore> weak_factory_; |
| 315 }; |
| 316 |
| 317 } // namespace content |
| 318 |
| 319 #endif // CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_BACKING_STORE_H_ |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 15564008:
Migrate the IndexedDB backend from Blink to Chromium (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src