Add the IndexedDBActiveBlobRegistry, currently unused, to enable future blob

content/browser/indexed_db/indexed_db_backing_store.cc

 // 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.
 
 #include "content/browser/indexed_db/indexed_db_backing_store.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_piece.h"
@@ skipping 378 matching lines @@
                                       bool* is_disk_full) OVERRIDE {
     return LevelDBDatabase::Open(file_name, comparator, db, is_disk_full);
   }
   virtual leveldb::Status DestroyLevelDB(const base::FilePath& file_name)
       OVERRIDE {
     return LevelDBDatabase::Destroy(file_name);
   }
 };
 
 IndexedDBBackingStore::IndexedDBBackingStore(
+    IndexedDBFactory* indexed_db_factory,
     const GURL& origin_url,
     scoped_ptr<LevelDBDatabase> db,
-    scoped_ptr<LevelDBComparator> comparator)
-    : origin_url_(origin_url),
+    scoped_ptr<LevelDBComparator> comparator,
+    base::TaskRunner* task_runner)
+    : indexed_db_factory_(indexed_db_factory),
+      origin_url_(origin_url),
       origin_identifier_(ComputeOriginIdentifier(origin_url)),
+      task_runner_(task_runner),
       db_(db.Pass()),
-      comparator_(comparator.Pass()) {}
+      comparator_(comparator.Pass()),
+      active_blob_registry_(this) {}
 
 IndexedDBBackingStore::~IndexedDBBackingStore() {
   // db_'s destructor uses comparator_. The order of destruction is important.
   db_.reset();
   comparator_.reset();
 }
 
 IndexedDBBackingStore::RecordIdentifier::RecordIdentifier(
     const std::string& primary_key,
     int64 version)
@@ skipping 20 matching lines @@
   INDEXED_DB_BACKING_STORE_OPEN_MEMORY_FAILED,
   INDEXED_DB_BACKING_STORE_OPEN_ATTEMPT_NON_ASCII,
   INDEXED_DB_BACKING_STORE_OPEN_DISK_FULL_DEPRECATED,
   INDEXED_DB_BACKING_STORE_OPEN_ORIGIN_TOO_LONG,
   INDEXED_DB_BACKING_STORE_OPEN_NO_RECOVERY,
   INDEXED_DB_BACKING_STORE_OPEN_MAX,
 };
 
 // static
 scoped_refptr<IndexedDBBackingStore> IndexedDBBackingStore::Open(
+    IndexedDBFactory* indexed_db_factory,
     const GURL& origin_url,
     const base::FilePath& path_base,
     blink::WebIDBDataLoss* data_loss,
     std::string* data_loss_message,
-    bool* disk_full) {
+    bool* disk_full,
+    base::TaskRunner* task_runner) {
   *data_loss = blink::WebIDBDataLossNone;
   DefaultLevelDBFactory leveldb_factory;
-  return IndexedDBBackingStore::Open(origin_url,
+  return IndexedDBBackingStore::Open(indexed_db_factory,
+                                     origin_url,
                                      path_base,
                                      data_loss,
                                      data_loss_message,
                                      disk_full,
-                                     &leveldb_factory);
+                                     &leveldb_factory,
+                                     task_runner);
 }
 
 static std::string OriginToCustomHistogramSuffix(const GURL& origin_url) {
   if (origin_url.host() == "docs.google.com")
     return ".Docs";
   return std::string();
 }
 
 static void HistogramOpenStatus(IndexedDBBackingStoreOpenResult result,
                                 const GURL& origin_url) {
@@ skipping 40 matching lines @@
         min,
         max,
         num_buckets);
     return true;
   }
   return false;
 }
 
 // static
 scoped_refptr<IndexedDBBackingStore> IndexedDBBackingStore::Open(
+    IndexedDBFactory* indexed_db_factory,
     const GURL& origin_url,
     const base::FilePath& path_base,
     blink::WebIDBDataLoss* data_loss,
     std::string* data_loss_message,
     bool* is_disk_full,
-    LevelDBFactory* leveldb_factory) {
+    LevelDBFactory* leveldb_factory,
+    base::TaskRunner* task_runner) {
   IDB_TRACE("IndexedDBBackingStore::Open");
   DCHECK(!path_base.empty());
   *data_loss = blink::WebIDBDataLossNone;
   *data_loss_message = "";
   *is_disk_full = false;
 
   scoped_ptr<LevelDBComparator> comparator(new Comparator());
 
   if (!IsStringASCII(path_base.AsUTF8Unsafe())) {
     HistogramOpenStatus(INDEXED_DB_BACKING_STORE_OPEN_ATTEMPT_NON_ASCII,
@@ skipping 86 matching lines @@
                         origin_url);
   }
 
   if (!db) {
     NOTREACHED();
     HistogramOpenStatus(INDEXED_DB_BACKING_STORE_OPEN_FAILED_UNKNOWN_ERR,
                         origin_url);
     return scoped_refptr<IndexedDBBackingStore>();
   }
 
-  return Create(origin_url, db.Pass(), comparator.Pass());
-}
-
-// static
-scoped_refptr<IndexedDBBackingStore> IndexedDBBackingStore::OpenInMemory(
-    const GURL& origin_url) {
-  DefaultLevelDBFactory leveldb_factory;
-  return IndexedDBBackingStore::OpenInMemory(origin_url, &leveldb_factory);
+  return Create(indexed_db_factory,
+                origin_url,
+                db.Pass(),
+                comparator.Pass(),
+                task_runner);
 }
 
 // static
 scoped_refptr<IndexedDBBackingStore> IndexedDBBackingStore::OpenInMemory(
     const GURL& origin_url,
-    LevelDBFactory* leveldb_factory) {
+    base::TaskRunner* task_runner) {
+  DefaultLevelDBFactory leveldb_factory;
+  return IndexedDBBackingStore::OpenInMemory(
+      origin_url, &leveldb_factory, task_runner);
+}
+
+// static
+scoped_refptr<IndexedDBBackingStore> IndexedDBBackingStore::OpenInMemory(
+    const GURL& origin_url,
+    LevelDBFactory* leveldb_factory,
+    base::TaskRunner* task_runner) {
   IDB_TRACE("IndexedDBBackingStore::OpenInMemory");
 
   scoped_ptr<LevelDBComparator> comparator(new Comparator());
   scoped_ptr<LevelDBDatabase> db =
       LevelDBDatabase::OpenInMemory(comparator.get());
   if (!db) {
     LOG(ERROR) << "LevelDBDatabase::OpenInMemory failed.";
     HistogramOpenStatus(INDEXED_DB_BACKING_STORE_OPEN_MEMORY_FAILED,
                         origin_url);
     return scoped_refptr<IndexedDBBackingStore>();
   }
   HistogramOpenStatus(INDEXED_DB_BACKING_STORE_OPEN_MEMORY_SUCCESS, origin_url);
 
-  return Create(origin_url, db.Pass(), comparator.Pass());
+  return Create(NULL /* indexed_db_factory */,
+                origin_url,
+                db.Pass(),
+                comparator.Pass(),
+                task_runner);
 }
 
 // static
 scoped_refptr<IndexedDBBackingStore> IndexedDBBackingStore::Create(
+    IndexedDBFactory* indexed_db_factory,
     const GURL& origin_url,
     scoped_ptr<LevelDBDatabase> db,
-    scoped_ptr<LevelDBComparator> comparator) {
+    scoped_ptr<LevelDBComparator> comparator,
+    base::TaskRunner* task_runner) {
   // TODO(jsbell): Handle comparator name changes.
 
   scoped_refptr<IndexedDBBackingStore> backing_store(
-      new IndexedDBBackingStore(origin_url, db.Pass(), comparator.Pass()));
+      new IndexedDBBackingStore(indexed_db_factory,
+                                origin_url,
+                                db.Pass(),
+                                comparator.Pass(),
+                                task_runner));
   if (!SetUpMetadata(backing_store->db_.get(),
                      backing_store->origin_identifier_))
     return scoped_refptr<IndexedDBBackingStore>();
 
   return backing_store;
 }
 
 std::vector<base::string16> IndexedDBBackingStore::GetDatabaseNames() {
   std::vector<base::string16> found_names;
   const std::string start_key =
@@ skipping 1169 matching lines @@
     return InvalidDBKeyStatus();
   }
 
   StringPiece slice(found_encoded_primary_key);
   if (DecodeIDBKey(&slice, found_primary_key) && slice.empty())
     return s;
   else
     return InvalidDBKeyStatus();
 }
 
+void IndexedDBBackingStore::ReportBlobUnused(int64 database_id,
+                                             int64 blob_key) {
+  // TODO(ericu)
+}
+
 IndexedDBBackingStore::Cursor::Cursor(
     const IndexedDBBackingStore::Cursor* other)
     : transaction_(other->transaction_),
       cursor_options_(other->cursor_options_),
       current_key_(new IndexedDBKey(*other->current_key_)) {
   if (other->iterator_) {
     iterator_ = transaction_->CreateIterator();
 
     if (other->iterator_->IsValid()) {
       iterator_->Seek(other->iterator_->Key());
@@ skipping 776 matching lines @@
 }
 
 void IndexedDBBackingStore::Transaction::Rollback() {
   IDB_TRACE("IndexedDBBackingStore::Transaction::Rollback");
   DCHECK(transaction_.get());
   transaction_->Rollback();
   transaction_ = NULL;
 }
 
 }  // namespace content