Add most of the metadata-handling code for blobs. It's not quite all there, but

content/browser/indexed_db/indexed_db_backing_store.h

 // Copyright (c) 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_BACKING_STORE_H_
 #define CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_BACKING_STORE_H_
 
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 246 matching lines @@
       int64 index_id,
       const IndexedDBKey& key,
       scoped_ptr<IndexedDBKey>* found_primary_key,
       bool* exists) WARN_UNUSED_RESULT;
 
   // Public for IndexedDBActiveBlobRegistry::ReleaseBlobRef.
   virtual void ReportBlobUnused(int64 database_id, int64 blob_key);
 
   base::FilePath GetBlobFileName(int64 database_id, int64 key);
 
+  class Transaction;
+
   class Cursor {
    public:
     virtual ~Cursor();
 
     enum IteratorState {
       READY = 0,
       SEEK
     };
 
     struct CursorOptions {
@@ skipping 24 matching lines @@
     bool Advance(uint32 count, leveldb::Status*);
     bool FirstSeek(leveldb::Status*);
 
     virtual Cursor* Clone() = 0;
     virtual const IndexedDBKey& primary_key() const;
     virtual IndexedDBValue* value() = 0;
     virtual const RecordIdentifier& record_identifier() const;
     virtual bool LoadCurrentRow() = 0;
 
    protected:
-    Cursor(LevelDBTransaction* transaction,
+    Cursor(scoped_refptr<IndexedDBBackingStore> backing_store,
+           Transaction* transaction,
+           int64 database_id,
            const CursorOptions& cursor_options);
     explicit Cursor(const IndexedDBBackingStore::Cursor* other);
 
     virtual std::string EncodeKey(const IndexedDBKey& key) = 0;
     virtual std::string EncodeKey(const IndexedDBKey& key,
                                   const IndexedDBKey& primary_key) = 0;
 
     bool IsPastBounds() const;
     bool HaveEnteredRange() const;
 
-    LevelDBTransaction* transaction_;
+    IndexedDBBackingStore* backing_store_;

[jsbell, 2014/05/06 00:24:16]

We should probably update the ownership graph soon:

https://docs.google.com/a/chromium.org/drawings/d/1JBGlUYkJMJKT5KyIz0h34RxRIl...

[ericu, 2014/05/06 17:26:20]

Updated.  There's nothing in the key about what colors mean, though, so they may
need correction.

+    Transaction* transaction_;
+    int64 database_id_;
     const CursorOptions cursor_options_;
     scoped_ptr<LevelDBIterator> iterator_;
     scoped_ptr<IndexedDBKey> current_key_;
     IndexedDBBackingStore::RecordIdentifier record_identifier_;
   };
 
   virtual scoped_ptr<Cursor> OpenObjectStoreKeyCursor(
       IndexedDBBackingStore::Transaction* transaction,
       int64 database_id,
       int64 object_store_id,
@@ skipping 59 matching lines @@
       transaction_ = NULL;
     }
     void PutBlobInfo(int64 database_id,
                      int64 object_store_id,
                      const std::string& object_store_data_key,
                      std::vector<IndexedDBBlobInfo>*,
                      ScopedVector<webkit_blob::BlobDataHandle>* handles);
 
     LevelDBTransaction* transaction() { return transaction_; }
 
+    leveldb::Status GetBlobInfoForRecord(
+        int64 database_id,
+        const std::string& object_store_data_key,
+        IndexedDBValue* value);
+
     // This holds a BlobEntryKey and the encoded IndexedDBBlobInfo vector stored
     // under that key.
     typedef std::vector<std::pair<BlobEntryKey, std::string> >
         BlobEntryKeyValuePairVec;
 
     class WriteDescriptor {
      public:
       WriteDescriptor(const GURL& url, int64_t key);
       WriteDescriptor(const base::FilePath& path, int64_t key);
 
@@ skipping 56 matching lines @@
                         const base::FilePath& blob_path,
                         net::URLRequestContext* request_context,
                         scoped_ptr<LevelDBDatabase> db,
                         scoped_ptr<LevelDBComparator> comparator,
                         base::TaskRunner* task_runner);
   virtual ~IndexedDBBackingStore();
   friend class base::RefCounted<IndexedDBBackingStore>;
 
   bool is_incognito() const { return !indexed_db_factory_; }
 
+  bool SetUpMetadata();
+
   virtual bool WriteBlobFile(
       int64 database_id,
       const Transaction::WriteDescriptor& descriptor,
       Transaction::ChainedBlobWriter* chained_blob_writer);
   virtual bool RemoveBlobFile(int64 database_id, int64 key);
   virtual void StartJournalCleaningTimer();
   void CleanPrimaryJournalIgnoreReturn();
 
  private:
   static scoped_refptr<IndexedDBBackingStore> Create(
@@ skipping 46 matching lines @@
   scoped_ptr<LevelDBComparator> comparator_;
   // Whenever blobs are registered in active_blob_registry_, indexed_db_factory_
   // will hold a reference to this backing store.
   IndexedDBActiveBlobRegistry active_blob_registry_;
   base::OneShotTimer<IndexedDBBackingStore> close_timer_;
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_BACKING_STORE_H_