content/browser/indexed_db/indexed_db_backing_store.h

   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 <map>
   9 #include <set>
  10 #include <string>
  11 #include <utility>
  12 #include <vector>
  13
  14 #include "base/basictypes.h"
  15 #include "base/files/file_path.h"
  16 #include "base/memory/ref_counted.h"
  17 #include "base/memory/scoped_ptr.h"
  18 #include "base/strings/string_piece.h"
  19 #include "base/time/time.h"
  20 #include "base/timer/timer.h"
  21 #include "content/browser/indexed_db/indexed_db.h"
  22 #include "content/browser/indexed_db/indexed_db_active_blob_registry.h"
  23 #include "content/browser/indexed_db/indexed_db_blob_info.h"
  24 #include "content/browser/indexed_db/indexed_db_leveldb_coding.h"
  25 #include "content/browser/indexed_db/indexed_db_metadata.h"
  26 #include "content/browser/indexed_db/leveldb/leveldb_iterator.h"
  27 #include "content/browser/indexed_db/leveldb/leveldb_transaction.h"
  28 #include "content/common/content_export.h"
  29 #include "content/common/indexed_db/indexed_db_key.h"
  30 #include "content/common/indexed_db/indexed_db_key_path.h"
  31 #include "content/common/indexed_db/indexed_db_key_range.h"
  32 #include "storage/browser/blob/blob_data_handle.h"
  33 #include "third_party/leveldatabase/src/include/leveldb/status.h"
  34 #include "url/gurl.h"
  35
  36 namespace base {
  37 class SequencedTaskRunner;
  38 }
  39
  40 namespace storage {
  41 class FileWriterDelegate;
  42 }
  43
  44 namespace net {
  45 class URLRequestContext;
  46 }
  47
  48 namespace content {
  49
  50 class IndexedDBFactory;
  51 class LevelDBComparator;
  52 class LevelDBDatabase;
  53 class LevelDBFactory;
  54 struct IndexedDBValue;
  55
  56 class CONTENT_EXPORT IndexedDBBackingStore
  57     : public base::RefCounted<IndexedDBBackingStore> {
  58  public:
  59   class CONTENT_EXPORT Comparator : public LevelDBComparator {
  60    public:
  61     int Compare(const base::StringPiece& a,
  62                 const base::StringPiece& b) const override;
  63     const char* Name() const override;
  64   };
  65
  66   class CONTENT_EXPORT RecordIdentifier {
  67    public:
  68     RecordIdentifier(const std::string& primary_key, int64 version);
  69     RecordIdentifier();
  70     ~RecordIdentifier();
  71
  72     const std::string& primary_key() const { return primary_key_; }
  73     int64 version() const { return version_; }
  74     void Reset(const std::string& primary_key, int64 version) {
  75       primary_key_ = primary_key;
  76       version_ = version;
  77     }
  78
  79    private:
  80     // TODO(jsbell): Make it more clear that this is the *encoded* version of
  81     // the key.
  82     std::string primary_key_;
  83     int64 version_;
  84     DISALLOW_COPY_AND_ASSIGN(RecordIdentifier);
  85   };
  86
  87   class BlobWriteCallback : public base::RefCounted<BlobWriteCallback> {
  88    public:
  89     virtual void Run(bool succeeded) = 0;
  90
  91    protected:
  92     friend class base::RefCounted<BlobWriteCallback>;
  93     virtual ~BlobWriteCallback() {}
  94   };
  95
  96   class BlobChangeRecord {
  97    public:
  98     BlobChangeRecord(const std::string& key, int64 object_store_id);
  99     ~BlobChangeRecord();
 100
 101     const std::string& key() const { return key_; }
 102     int64 object_store_id() const { return object_store_id_; }
 103     void SetBlobInfo(std::vector<IndexedDBBlobInfo>* blob_info);
 104     std::vector<IndexedDBBlobInfo>& mutable_blob_info() { return blob_info_; }
 105     const std::vector<IndexedDBBlobInfo>& blob_info() const {
 106       return blob_info_;
 107     }
 108     void SetHandles(ScopedVector<storage::BlobDataHandle>* handles);
 109     scoped_ptr<BlobChangeRecord> Clone() const;
 110
 111    private:
 112     std::string key_;
 113     int64 object_store_id_;
 114     std::vector<IndexedDBBlobInfo> blob_info_;
 115     ScopedVector<storage::BlobDataHandle> handles_;
 116     DISALLOW_COPY_AND_ASSIGN(BlobChangeRecord);
 117   };
 118   typedef std::map<std::string, BlobChangeRecord*> BlobChangeMap;
 119
 120   class CONTENT_EXPORT Transaction {
 121    public:
 122     explicit Transaction(IndexedDBBackingStore* backing_store);
 123     virtual ~Transaction();
 124
 125     virtual void Begin();
 126
 127     // CommitPhaseOne determines what blobs (if any) need to be written to disk
 128     // and updates the primary blob journal, and kicks off the async writing
 129     // of the blob files. In case of crash/rollback, the journal indicates what
 130     // files should be cleaned up.
 131     // The callback will be called eventually on success or failure, or
 132     // immediately if phase one is complete due to lack of any blobs to write.
 133     virtual leveldb::Status CommitPhaseOne(scoped_refptr<BlobWriteCallback>);
 134
 135     // CommitPhaseTwo is called once the blob files (if any) have been written
 136     // to disk, and commits the actual transaction to the backing store,
 137     // including blob journal updates, then deletes any blob files deleted
 138     // by the transaction and not referenced by running scripts.
 139     virtual leveldb::Status CommitPhaseTwo();
 140
 141     virtual void Rollback();
 142     void Reset() {
 143       backing_store_ = NULL;
 144       transaction_ = NULL;
 145     }
 146     leveldb::Status PutBlobInfoIfNeeded(
 147         int64 database_id,
 148         int64 object_store_id,
 149         const std::string& object_store_data_key,
 150         std::vector<IndexedDBBlobInfo>*,
 151         ScopedVector<storage::BlobDataHandle>* handles);
 152     void PutBlobInfo(int64 database_id,
 153                      int64 object_store_id,
 154                      const std::string& object_store_data_key,
 155                      std::vector<IndexedDBBlobInfo>*,
 156                      ScopedVector<storage::BlobDataHandle>* handles);
 157
 158     LevelDBTransaction* transaction() { return transaction_.get(); }
 159
 160     leveldb::Status GetBlobInfoForRecord(
 161         int64 database_id,
 162         const std::string& object_store_data_key,
 163         IndexedDBValue* value);
 164
 165     // This holds a BlobEntryKey and the encoded IndexedDBBlobInfo vector stored
 166     // under that key.
 167     typedef std::vector<std::pair<BlobEntryKey, std::string> >
 168         BlobEntryKeyValuePairVec;
 169
 170     class CONTENT_EXPORT WriteDescriptor {
 171      public:
 172       WriteDescriptor(const GURL& url,
 173                       int64_t key,
 174                       int64_t size,
 175                       base::Time last_modified);
 176       WriteDescriptor(const base::FilePath& path,
 177                       int64_t key,
 178                       int64_t size,
 179                       base::Time last_modified);
 180       WriteDescriptor(const WriteDescriptor& other);
 181       ~WriteDescriptor();
 182       WriteDescriptor& operator=(const WriteDescriptor& other);
 183
 184       bool is_file() const { return is_file_; }
 185       const GURL& url() const {
 186         DCHECK(!is_file_);
 187         return url_;
 188       }
 189       const base::FilePath& file_path() const {
 190         DCHECK(is_file_);
 191         return file_path_;
 192       }
 193       int64_t key() const { return key_; }
 194       int64_t size() const { return size_; }
 195       base::Time last_modified() const { return last_modified_; }
 196
 197      private:
 198       bool is_file_;
 199       GURL url_;
 200       base::FilePath file_path_;
 201       int64_t key_;
 202       int64_t size_;
 203       base::Time last_modified_;
 204     };
 205
 206     class ChainedBlobWriter
 207         : public base::RefCountedThreadSafe<ChainedBlobWriter> {
 208      public:
 209       virtual void set_delegate(
 210           scoped_ptr<storage::FileWriterDelegate> delegate) = 0;
 211
 212       // TODO(ericu): Add a reason in the event of failure.
 213       virtual void ReportWriteCompletion(bool succeeded,
 214                                          int64 bytes_written) = 0;
 215
 216       virtual void Abort() = 0;
 217
 218      protected:
 219       friend class base::RefCountedThreadSafe<ChainedBlobWriter>;
 220       virtual ~ChainedBlobWriter() {}
 221     };
 222
 223     class ChainedBlobWriterImpl;
 224
 225     typedef std::vector<WriteDescriptor> WriteDescriptorVec;
 226
 227    private:
 228     class BlobWriteCallbackWrapper;
 229
 230     // Called by CommitPhaseOne: Identifies the blob entries to write and adds
 231     // them to the primary blob journal directly (i.e. not as part of the
 232     // transaction). Populates blobs_to_write_.
 233     leveldb::Status HandleBlobPreTransaction(
 234         BlobEntryKeyValuePairVec* new_blob_entries,
 235         WriteDescriptorVec* new_files_to_write);
 236
 237     // Called by CommitPhaseOne: Populates blob_files_to_remove_ by
 238     // determining which blobs are deleted as part of the transaction, and
 239     // adds blob entry cleanup operations to the transaction. Returns true on
 240     // success, false on failure.
 241     bool CollectBlobFilesToRemove();
 242
 243     // Called by CommitPhaseOne: Kicks off the asynchronous writes of blobs
 244     // identified in HandleBlobPreTransaction. The callback will be called
 245     // eventually on success or failure.
 246     void WriteNewBlobs(BlobEntryKeyValuePairVec* new_blob_entries,
 247                        WriteDescriptorVec* new_files_to_write,
 248                        scoped_refptr<BlobWriteCallback> callback);
 249
 250     // Called by CommitPhaseTwo: Partition blob references in blobs_to_remove_
 251     // into live (active references) and dead (no references).
 252     void PartitionBlobsToRemove(BlobJournalType* dead_blobs,
 253                                 BlobJournalType* live_blobs) const;
 254
 255     IndexedDBBackingStore* backing_store_;
 256     scoped_refptr<LevelDBTransaction> transaction_;
 257     BlobChangeMap blob_change_map_;
 258     BlobChangeMap incognito_blob_map_;
 259     int64 database_id_;
 260
 261     // List of blob files being newly written as part of this transaction.
 262     // These will be added to the primary blob journal prior to commit, then
 263     // removed after a sucessful commit.
 264     BlobJournalType blobs_to_write_;
 265
 266     // List of blob files being deleted as part of this transaction. These will
 267     // be added to either the primary or live blob journal as appropriate
 268     // following a successful commit.
 269     BlobJournalType blobs_to_remove_;
 270     scoped_refptr<ChainedBlobWriter> chained_blob_writer_;
 271
 272     // Set to true between CommitPhaseOne and CommitPhaseTwo/Rollback, to
 273     // indicate that the committing_transaction_count_ on the backing store
 274     // has been bumped, and journal cleaning should be deferred.
 275     bool committing_;
 276   };
 277
 278   class Cursor {
 279    public:
 280     enum IteratorState { READY = 0, SEEK };
 281
 282     virtual ~Cursor();
 283
 284     struct CursorOptions {
 285       CursorOptions();
 286       ~CursorOptions();
 287       int64 database_id;
 288       int64 object_store_id;
 289       int64 index_id;
 290       std::string low_key;
 291       bool low_open;
 292       std::string high_key;
 293       bool high_open;
 294       bool forward;
 295       bool unique;
 296     };
 297
 298     const IndexedDBKey& key() const { return *current_key_; }
 299     bool Continue(leveldb::Status* s) { return Continue(NULL, NULL, SEEK, s); }
 300     bool Continue(const IndexedDBKey* key,
 301                   IteratorState state,
 302                   leveldb::Status* s) {
 303       return Continue(key, NULL, state, s);
 304     }
 305     bool Continue(const IndexedDBKey* key,
 306                   const IndexedDBKey* primary_key,
 307                   IteratorState state,
 308                   leveldb::Status*);
 309     bool Advance(uint32 count, leveldb::Status*);
 310     bool FirstSeek(leveldb::Status*);
 311
 312     virtual Cursor* Clone() = 0;
 313     virtual const IndexedDBKey& primary_key() const;
 314     virtual IndexedDBValue* value() = 0;
 315     virtual const RecordIdentifier& record_identifier() const;
 316     virtual bool LoadCurrentRow(leveldb::Status* s) = 0;
 317
 318    protected:
 319     Cursor(scoped_refptr<IndexedDBBackingStore> backing_store,
 320            Transaction* transaction,
 321            int64 database_id,
 322            const CursorOptions& cursor_options);
 323     explicit Cursor(const IndexedDBBackingStore::Cursor* other);
 324
 325     virtual std::string EncodeKey(const IndexedDBKey& key) = 0;
 326     virtual std::string EncodeKey(const IndexedDBKey& key,
 327                                   const IndexedDBKey& primary_key) = 0;
 328
 329     bool IsPastBounds() const;
 330     bool HaveEnteredRange() const;
 331
 332     IndexedDBBackingStore* backing_store_;
 333     Transaction* transaction_;
 334     int64 database_id_;
 335     const CursorOptions cursor_options_;
 336     scoped_ptr<LevelDBIterator> iterator_;
 337     scoped_ptr<IndexedDBKey> current_key_;
 338     IndexedDBBackingStore::RecordIdentifier record_identifier_;
 339
 340    private:
 341     // For cursors with direction Next or NextNoDuplicate.
 342     bool ContinueNext(const IndexedDBKey* key,
 343                       const IndexedDBKey* primary_key,
 344                       IteratorState state,
 345                       leveldb::Status*);
 346     // For cursors with direction Prev or PrevNoDuplicate. The PrevNoDuplicate
 347     // case has additional complexity of not being symmetric with
 348     // NextNoDuplicate.
 349     bool ContinuePrevious(const IndexedDBKey* key,
 350                           const IndexedDBKey* primary_key,
 351                           IteratorState state,
 352                           leveldb::Status*);
 353
 354     DISALLOW_COPY_AND_ASSIGN(Cursor);
 355   };
 356
 357   const GURL& origin_url() const { return origin_url_; }
 358   IndexedDBFactory* factory() const { return indexed_db_factory_; }
 359   base::SequencedTaskRunner* task_runner() const { return task_runner_.get(); }
 360   base::OneShotTimer<IndexedDBBackingStore>* close_timer() {
 361     return &close_timer_;
 362   }
 363   IndexedDBActiveBlobRegistry* active_blob_registry() {
 364     return &active_blob_registry_;
 365   }
 366
 367   static scoped_refptr<IndexedDBBackingStore> Open(
 368       IndexedDBFactory* indexed_db_factory,
 369       const GURL& origin_url,
 370       const base::FilePath& path_base,
 371       net::URLRequestContext* request_context,
 372       blink::WebIDBDataLoss* data_loss,
 373       std::string* data_loss_message,
 374       bool* disk_full,
 375       base::SequencedTaskRunner* task_runner,
 376       bool clean_journal,
 377       leveldb::Status* status);
 378   static scoped_refptr<IndexedDBBackingStore> Open(
 379       IndexedDBFactory* indexed_db_factory,
 380       const GURL& origin_url,
 381       const base::FilePath& path_base,
 382       net::URLRequestContext* request_context,
 383       blink::WebIDBDataLoss* data_loss,
 384       std::string* data_loss_message,
 385       bool* disk_full,
 386       LevelDBFactory* leveldb_factory,
 387       base::SequencedTaskRunner* task_runner,
 388       bool clean_journal,
 389       leveldb::Status* status);
 390   static scoped_refptr<IndexedDBBackingStore> OpenInMemory(
 391       const GURL& origin_url,
 392       base::SequencedTaskRunner* task_runner,
 393       leveldb::Status* status);
 394   static scoped_refptr<IndexedDBBackingStore> OpenInMemory(
 395       const GURL& origin_url,
 396       LevelDBFactory* leveldb_factory,
 397       base::SequencedTaskRunner* task_runner,
 398       leveldb::Status* status);
 399
 400   void GrantChildProcessPermissions(int child_process_id);
 401
 402   // Compact is public for testing.
 403   virtual void Compact();
 404   virtual std::vector<base::string16> GetDatabaseNames(leveldb::Status*);
 405   virtual leveldb::Status GetIDBDatabaseMetaData(
 406       const base::string16& name,
 407       IndexedDBDatabaseMetadata* metadata,
 408       bool* success) WARN_UNUSED_RESULT;
 409   virtual leveldb::Status CreateIDBDatabaseMetaData(
 410       const base::string16& name,
 411       const base::string16& version,
 412       int64 int_version,
 413       int64* row_id);
 414   virtual bool UpdateIDBDatabaseIntVersion(
 415       IndexedDBBackingStore::Transaction* transaction,
 416       int64 row_id,
 417       int64 int_version);
 418   virtual leveldb::Status DeleteDatabase(const base::string16& name);
 419
 420   // Assumes caller has already closed the backing store.
 421   static leveldb::Status DestroyBackingStore(const base::FilePath& path_base,
 422                                              const GURL& origin_url);
 423   static bool RecordCorruptionInfo(const base::FilePath& path_base,
 424                                    const GURL& origin_url,
 425                                    const std::string& message);
 426   leveldb::Status GetObjectStores(
 427       int64 database_id,
 428       IndexedDBDatabaseMetadata::ObjectStoreMap* map) WARN_UNUSED_RESULT;
 429   virtual leveldb::Status CreateObjectStore(
 430       IndexedDBBackingStore::Transaction* transaction,
 431       int64 database_id,
 432       int64 object_store_id,
 433       const base::string16& name,
 434       const IndexedDBKeyPath& key_path,
 435       bool auto_increment);
 436   virtual leveldb::Status DeleteObjectStore(
 437       IndexedDBBackingStore::Transaction* transaction,
 438       int64 database_id,
 439       int64 object_store_id) WARN_UNUSED_RESULT;
 440
 441   virtual leveldb::Status GetRecord(
 442       IndexedDBBackingStore::Transaction* transaction,
 443       int64 database_id,
 444       int64 object_store_id,
 445       const IndexedDBKey& key,
 446       IndexedDBValue* record) WARN_UNUSED_RESULT;
 447   virtual leveldb::Status PutRecord(
 448       IndexedDBBackingStore::Transaction* transaction,
 449       int64 database_id,
 450       int64 object_store_id,
 451       const IndexedDBKey& key,
 452       IndexedDBValue* value,
 453       ScopedVector<storage::BlobDataHandle>* handles,
 454       RecordIdentifier* record) WARN_UNUSED_RESULT;
 455   virtual leveldb::Status ClearObjectStore(
 456       IndexedDBBackingStore::Transaction* transaction,
 457       int64 database_id,
 458       int64 object_store_id) WARN_UNUSED_RESULT;
 459   virtual leveldb::Status DeleteRecord(
 460       IndexedDBBackingStore::Transaction* transaction,
 461       int64 database_id,
 462       int64 object_store_id,
 463       const RecordIdentifier& record) WARN_UNUSED_RESULT;
 464   virtual leveldb::Status DeleteRange(
 465       IndexedDBBackingStore::Transaction* transaction,
 466       int64 database_id,
 467       int64 object_store_id,
 468       const IndexedDBKeyRange&) WARN_UNUSED_RESULT;
 469   virtual leveldb::Status GetKeyGeneratorCurrentNumber(
 470       IndexedDBBackingStore::Transaction* transaction,
 471       int64 database_id,
 472       int64 object_store_id,
 473       int64* current_number) WARN_UNUSED_RESULT;
 474   virtual leveldb::Status MaybeUpdateKeyGeneratorCurrentNumber(
 475       IndexedDBBackingStore::Transaction* transaction,
 476       int64 database_id,
 477       int64 object_store_id,
 478       int64 new_state,
 479       bool check_current) WARN_UNUSED_RESULT;
 480   virtual leveldb::Status KeyExistsInObjectStore(
 481       IndexedDBBackingStore::Transaction* transaction,
 482       int64 database_id,
 483       int64 object_store_id,
 484       const IndexedDBKey& key,
 485       RecordIdentifier* found_record_identifier,
 486       bool* found) WARN_UNUSED_RESULT;
 487
 488   virtual leveldb::Status CreateIndex(
 489       IndexedDBBackingStore::Transaction* transaction,
 490       int64 database_id,
 491       int64 object_store_id,
 492       int64 index_id,
 493       const base::string16& name,
 494       const IndexedDBKeyPath& key_path,
 495       bool is_unique,
 496       bool is_multi_entry) WARN_UNUSED_RESULT;
 497   virtual leveldb::Status DeleteIndex(
 498       IndexedDBBackingStore::Transaction* transaction,
 499       int64 database_id,
 500       int64 object_store_id,
 501       int64 index_id) WARN_UNUSED_RESULT;
 502   virtual leveldb::Status PutIndexDataForRecord(
 503       IndexedDBBackingStore::Transaction* transaction,
 504       int64 database_id,
 505       int64 object_store_id,
 506       int64 index_id,
 507       const IndexedDBKey& key,
 508       const RecordIdentifier& record) WARN_UNUSED_RESULT;
 509   virtual leveldb::Status GetPrimaryKeyViaIndex(
 510       IndexedDBBackingStore::Transaction* transaction,
 511       int64 database_id,
 512       int64 object_store_id,
 513       int64 index_id,
 514       const IndexedDBKey& key,
 515       scoped_ptr<IndexedDBKey>* primary_key) WARN_UNUSED_RESULT;
 516   virtual leveldb::Status KeyExistsInIndex(
 517       IndexedDBBackingStore::Transaction* transaction,
 518       int64 database_id,
 519       int64 object_store_id,
 520       int64 index_id,
 521       const IndexedDBKey& key,
 522       scoped_ptr<IndexedDBKey>* found_primary_key,
 523       bool* exists) WARN_UNUSED_RESULT;
 524
 525   // Public for IndexedDBActiveBlobRegistry::ReleaseBlobRef.
 526   virtual void ReportBlobUnused(int64 database_id, int64 blob_key);
 527
 528   base::FilePath GetBlobFileName(int64 database_id, int64 key) const;
 529
 530   virtual scoped_ptr<Cursor> OpenObjectStoreKeyCursor(
 531       IndexedDBBackingStore::Transaction* transaction,
 532       int64 database_id,
 533       int64 object_store_id,
 534       const IndexedDBKeyRange& key_range,
 535       blink::WebIDBCursorDirection,
 536       leveldb::Status*);
 537   virtual scoped_ptr<Cursor> OpenObjectStoreCursor(
 538       IndexedDBBackingStore::Transaction* transaction,
 539       int64 database_id,
 540       int64 object_store_id,
 541       const IndexedDBKeyRange& key_range,
 542       blink::WebIDBCursorDirection,
 543       leveldb::Status*);
 544   virtual scoped_ptr<Cursor> OpenIndexKeyCursor(
 545       IndexedDBBackingStore::Transaction* transaction,
 546       int64 database_id,
 547       int64 object_store_id,
 548       int64 index_id,
 549       const IndexedDBKeyRange& key_range,
 550       blink::WebIDBCursorDirection,
 551       leveldb::Status*);
 552   virtual scoped_ptr<Cursor> OpenIndexCursor(
 553       IndexedDBBackingStore::Transaction* transaction,
 554       int64 database_id,
 555       int64 object_store_id,
 556       int64 index_id,
 557       const IndexedDBKeyRange& key_range,
 558       blink::WebIDBCursorDirection,
 559       leveldb::Status*);
 560
 561  protected:
 562   friend class base::RefCounted<IndexedDBBackingStore>;
 563
 564   IndexedDBBackingStore(IndexedDBFactory* indexed_db_factory,
 565                         const GURL& origin_url,
 566                         const base::FilePath& blob_path,
 567                         net::URLRequestContext* request_context,
 568                         scoped_ptr<LevelDBDatabase> db,
 569                         scoped_ptr<LevelDBComparator> comparator,
 570                         base::SequencedTaskRunner* task_runner);
 571   virtual ~IndexedDBBackingStore();
 572
 573   bool is_incognito() const { return !indexed_db_factory_; }
 574
 575   leveldb::Status SetUpMetadata();
 576
 577   virtual bool WriteBlobFile(
 578       int64 database_id,
 579       const Transaction::WriteDescriptor& descriptor,
 580       Transaction::ChainedBlobWriter* chained_blob_writer);
 581
 582   // Remove the referenced file on disk.
 583   virtual bool RemoveBlobFile(int64 database_id, int64 key) const;
 584
 585   // Schedule a call to CleanPrimaryJournalIgnoreReturn() via
 586   // an owned timer. If this object is destroyed, the timer
 587   // will automatically be cancelled.
 588   virtual void StartJournalCleaningTimer();
 589
 590   // Attempt to clean the primary journal. This will remove
 591   // any referenced files and delete the journal entry. If any
 592   // transaction is currently committing this will be deferred
 593   // via StartJournalCleaningTimer().
 594   void CleanPrimaryJournalIgnoreReturn();
 595
 596  private:
 597   static scoped_refptr<IndexedDBBackingStore> Create(
 598       IndexedDBFactory* indexed_db_factory,
 599       const GURL& origin_url,
 600       const base::FilePath& blob_path,
 601       net::URLRequestContext* request_context,
 602       scoped_ptr<LevelDBDatabase> db,
 603       scoped_ptr<LevelDBComparator> comparator,
 604       base::SequencedTaskRunner* task_runner,
 605       leveldb::Status* status);
 606
 607   static bool ReadCorruptionInfo(const base::FilePath& path_base,
 608                                  const GURL& origin_url,
 609                                  std::string* message);
 610
 611   leveldb::Status FindKeyInIndex(
 612       IndexedDBBackingStore::Transaction* transaction,
 613       int64 database_id,
 614       int64 object_store_id,
 615       int64 index_id,
 616       const IndexedDBKey& key,
 617       std::string* found_encoded_primary_key,
 618       bool* found);
 619   leveldb::Status GetIndexes(int64 database_id,
 620                              int64 object_store_id,
 621                              IndexedDBObjectStoreMetadata::IndexMap* map)
 622       WARN_UNUSED_RESULT;
 623
 624   // Remove the blob directory for the specified database and all contained
 625   // blob files.
 626   bool RemoveBlobDirectory(int64 database_id) const;
 627
 628   // Synchronously read the key-specified blob journal entry from the backing
 629   // store, delete all referenced blob files, and erase the journal entry.
 630   // This must not be used while temporary entries are present e.g. during
 631   // a two-stage transaction commit with blobs.
 632   leveldb::Status CleanUpBlobJournal(const std::string& level_db_key) const;
 633
 634   // Synchronously delete the files and/or directories on disk referenced by
 635   // the blob journal.
 636   leveldb::Status CleanUpBlobJournalEntries(
 637       const BlobJournalType& journal) const;
 638
 639   IndexedDBFactory* indexed_db_factory_;
 640   const GURL origin_url_;
 641   base::FilePath blob_path_;
 642
 643   // The origin identifier is a key prefix unique to the origin used in the
 644   // leveldb backing store to partition data by origin. It is a normalized
 645   // version of the origin URL with a versioning suffix appended, e.g.
 646   // "http_localhost_81@1" Since only one origin is stored per backing store
 647   // this is redundant but necessary for backwards compatibility; the suffix
 648   // provides for future flexibility.
 649   const std::string origin_identifier_;
 650
 651   net::URLRequestContext* request_context_;
 652   scoped_refptr<base::SequencedTaskRunner> task_runner_;
 653   std::set<int> child_process_ids_granted_;
 654   BlobChangeMap incognito_blob_map_;
 655   base::OneShotTimer<IndexedDBBackingStore> journal_cleaning_timer_;
 656
 657   scoped_ptr<LevelDBDatabase> db_;
 658   scoped_ptr<LevelDBComparator> comparator_;
 659   // Whenever blobs are registered in active_blob_registry_, indexed_db_factory_
 660   // will hold a reference to this backing store.
 661   IndexedDBActiveBlobRegistry active_blob_registry_;
 662   base::OneShotTimer<IndexedDBBackingStore> close_timer_;
 663
 664   // Incremented whenever a transaction starts committing, decremented when
 665   // complete. While > 0, temporary journal entries may exist so out-of-band
 666   // journal cleaning must be deferred.
 667   size_t committing_transaction_count_;
 668
 669   DISALLOW_COPY_AND_ASSIGN(IndexedDBBackingStore);
 670 };
 671
 672 }  // namespace content
 673
 674 #endif  // CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_BACKING_STORE_H_