Add the IndexedDBActiveBlobRegistry, currently unused, to enable future blob

content/browser/indexed_db/indexed_db_factory_unittest.cc

 // 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.
 
 #include "content/browser/indexed_db/indexed_db_factory.h"
 
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 31 matching lines @@
       const base::FilePath& data_directory) {
     blink::WebIDBDataLoss data_loss =
         blink::WebIDBDataLossNone;
     std::string data_loss_message;
     bool disk_full;
     scoped_refptr<IndexedDBBackingStore> backing_store =
         OpenBackingStore(origin,
                          data_directory,
                          &data_loss,
                          &data_loss_message,
-                         &disk_full);
+                         &disk_full,
+                         NULL /* task_runner */);
     EXPECT_EQ(blink::WebIDBDataLossNone, data_loss);
     return backing_store;
   }
 
   void TestCloseBackingStore(IndexedDBBackingStore* backing_store) {
     CloseBackingStore(backing_store->origin_url());
   }
 
   void TestReleaseBackingStore(IndexedDBBackingStore* backing_store,
                                bool immediate) {
@@ skipping 119 matching lines @@
  public:
   DiskFullFactory() : IndexedDBFactory(NULL) {}
 
  private:
   virtual ~DiskFullFactory() {}
   virtual scoped_refptr<IndexedDBBackingStore> OpenBackingStore(
       const GURL& origin_url,
       const base::FilePath& data_directory,
       blink::WebIDBDataLoss* data_loss,
       std::string* data_loss_message,
-      bool* disk_full) OVERRIDE {
+      bool* disk_full,
+      base::TaskRunner* task_runner) OVERRIDE {
     *disk_full = true;
     return scoped_refptr<IndexedDBBackingStore>();
   }
 };
 
 class LookingForQuotaErrorMockCallbacks : public IndexedDBCallbacks {
  public:
   LookingForQuotaErrorMockCallbacks()
       : IndexedDBCallbacks(NULL, 0, 0), error_called_(false) {}
   virtual void OnError(const IndexedDBDatabaseError& error) OVERRIDE {
     error_called_ = true;
     EXPECT_EQ(blink::WebIDBDatabaseExceptionQuotaError, error.code());
   }
 
  private:
   virtual ~LookingForQuotaErrorMockCallbacks() { EXPECT_TRUE(error_called_); }
   bool error_called_;
 };
 
 TEST_F(IndexedDBFactoryTest, QuotaErrorOnDiskFull) {
   const GURL origin("http://localhost:81");
+  base::ScopedTempDir temp_directory;
+  ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
 
   scoped_refptr<DiskFullFactory> factory = new DiskFullFactory;
   scoped_refptr<LookingForQuotaErrorMockCallbacks> callbacks =
       new LookingForQuotaErrorMockCallbacks;
   scoped_refptr<IndexedDBDatabaseCallbacks> dummy_database_callbacks =
       new IndexedDBDatabaseCallbacks(NULL, 0, 0);
   const base::string16 name(ASCIIToUTF16("name"));
   IndexedDBPendingConnection connection(callbacks,
                                         dummy_database_callbacks,
                                         0, /* child_process_id */
                                         2, /* transaction_id */
                                         1 /* version */);
   factory->Open(
-      name, connection, origin, base::FilePath(FILE_PATH_LITERAL("/dummy")));
+      name, connection, origin, temp_directory.path(), NULL /* task_runner */);
 }
 
 TEST_F(IndexedDBFactoryTest, BackingStoreReleasedOnForcedClose) {
   GURL origin("http://localhost:81");
 
   base::ScopedTempDir temp_directory;
   ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
 
   scoped_refptr<IndexedDBFactory> factory = new IndexedDBFactory(NULL);
 
   scoped_refptr<MockIndexedDBCallbacks> callbacks(new MockIndexedDBCallbacks());
   scoped_refptr<MockIndexedDBDatabaseCallbacks> db_callbacks(
       new MockIndexedDBDatabaseCallbacks());
   const int64 transaction_id = 1;
   IndexedDBPendingConnection connection(
       callbacks,
       db_callbacks,
       0, /* child_process_id */
       transaction_id,
       IndexedDBDatabaseMetadata::DEFAULT_INT_VERSION);
-  factory->Open(ASCIIToUTF16("db"), connection, origin, temp_directory.path());
+  factory->Open(ASCIIToUTF16("db"),
+                connection,
+                origin,
+                temp_directory.path(),
+                NULL /* task_runner */);
 
   EXPECT_TRUE(callbacks->connection());
 
   EXPECT_TRUE(factory->IsBackingStoreOpen(origin));
   EXPECT_FALSE(factory->IsBackingStorePendingClose(origin));
 
   callbacks->connection()->ForceClose();
 
   EXPECT_FALSE(factory->IsBackingStoreOpen(origin));
   EXPECT_FALSE(factory->IsBackingStorePendingClose(origin));
@@ skipping 10 matching lines @@
   scoped_refptr<MockIndexedDBCallbacks> callbacks(new MockIndexedDBCallbacks());
   scoped_refptr<MockIndexedDBDatabaseCallbacks> db_callbacks(
       new MockIndexedDBDatabaseCallbacks());
   const int64 transaction_id = 1;
   IndexedDBPendingConnection connection(
       callbacks,
       db_callbacks,
       0, /* child_process_id */
       transaction_id,
       IndexedDBDatabaseMetadata::DEFAULT_INT_VERSION);
-  factory->Open(ASCIIToUTF16("db"), connection, origin, temp_directory.path());
+  factory->Open(ASCIIToUTF16("db"),
+                connection,
+                origin,
+                temp_directory.path(),
+                NULL /* task_runner */);
 
   EXPECT_TRUE(callbacks->connection());
   IndexedDBBackingStore* store =
       callbacks->connection()->database()->backing_store();
   EXPECT_FALSE(store->HasOneRef());  // Factory and database.
 
   EXPECT_TRUE(factory->IsBackingStoreOpen(origin));
   callbacks->connection()->Close();
   EXPECT_TRUE(store->HasOneRef());  // Factory.
   EXPECT_TRUE(factory->IsBackingStoreOpen(origin));
@@ skipping 18 matching lines @@
 
   scoped_refptr<IndexedDBFactory> factory = new IndexedDBFactory(NULL);
   EXPECT_FALSE(factory->IsBackingStoreOpen(origin));
 
   const bool expect_connection = false;
   scoped_refptr<MockIndexedDBCallbacks> callbacks(
       new MockIndexedDBCallbacks(expect_connection));
   factory->DeleteDatabase(ASCIIToUTF16("db"),
                           callbacks,
                           origin,
-                          temp_directory.path());
+                          temp_directory.path(),
+                          NULL /* task_runner */);
 
   EXPECT_TRUE(factory->IsBackingStoreOpen(origin));
   EXPECT_TRUE(factory->IsBackingStorePendingClose(origin));
 
   // Now simulate shutdown, which should stop the timer.
   factory->ContextDestroyed();
 
   EXPECT_FALSE(factory->IsBackingStoreOpen(origin));
   EXPECT_FALSE(factory->IsBackingStorePendingClose(origin));
 }
 
 TEST_F(IndexedDBFactoryTest, GetDatabaseNamesClosesBackingStore) {
   GURL origin("http://localhost:81");
 
   base::ScopedTempDir temp_directory;
   ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
 
   scoped_refptr<IndexedDBFactory> factory = new IndexedDBFactory(NULL);
   EXPECT_FALSE(factory->IsBackingStoreOpen(origin));
 
   const bool expect_connection = false;
   scoped_refptr<MockIndexedDBCallbacks> callbacks(
       new MockIndexedDBCallbacks(expect_connection));
-  factory->GetDatabaseNames(callbacks,
-                            origin,
-                            temp_directory.path());
+  factory->GetDatabaseNames(
+      callbacks, origin, temp_directory.path(), NULL /* task_runner */);
 
   EXPECT_TRUE(factory->IsBackingStoreOpen(origin));
   EXPECT_TRUE(factory->IsBackingStorePendingClose(origin));
 
   // Now simulate shutdown, which should stop the timer.
   factory->ContextDestroyed();
 
   EXPECT_FALSE(factory->IsBackingStoreOpen(origin));
   EXPECT_FALSE(factory->IsBackingStorePendingClose(origin));
 }
 
 TEST_F(IndexedDBFactoryTest, ForceCloseReleasesBackingStore) {
   GURL origin("http://localhost:81");
 
   base::ScopedTempDir temp_directory;
   ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
 
   scoped_refptr<IndexedDBFactory> factory = new IndexedDBFactory(NULL);
 
   scoped_refptr<MockIndexedDBCallbacks> callbacks(new MockIndexedDBCallbacks());
   scoped_refptr<MockIndexedDBDatabaseCallbacks> db_callbacks(
       new MockIndexedDBDatabaseCallbacks());
   const int64 transaction_id = 1;
   IndexedDBPendingConnection connection(
       callbacks,
       db_callbacks,
       0, /* child_process_id */
       transaction_id,
       IndexedDBDatabaseMetadata::DEFAULT_INT_VERSION);
-  factory->Open(ASCIIToUTF16("db"), connection, origin, temp_directory.path());
+  factory->Open(ASCIIToUTF16("db"),
+                connection,
+                origin,
+                temp_directory.path(),
+                NULL /* task_runner */);
 
   EXPECT_TRUE(callbacks->connection());
   EXPECT_TRUE(factory->IsBackingStoreOpen(origin));
   EXPECT_FALSE(factory->IsBackingStorePendingClose(origin));
 
   callbacks->connection()->Close();
 
   EXPECT_TRUE(factory->IsBackingStoreOpen(origin));
   EXPECT_TRUE(factory->IsBackingStorePendingClose(origin));
 
@@ skipping 55 matching lines @@
 
   // Open at version 2, then close.
   {
     scoped_refptr<MockIndexedDBCallbacks> callbacks(
         new UpgradeNeededCallbacks());
     IndexedDBPendingConnection connection(callbacks,
                                           db_callbacks,
                                           0, /* child_process_id */
                                           transaction_id,
                                           db_version);
-    factory->Open(db_name, connection, origin, temp_directory.path());
+    factory->Open(db_name,
+                  connection,
+                  origin,
+                  temp_directory.path(),
+                  NULL /* task_runner */);
     EXPECT_TRUE(factory->IsDatabaseOpen(origin, db_name));
 
     // Pump the message loop so the upgrade transaction can run.
     base::MessageLoop::current()->RunUntilIdle();
     EXPECT_TRUE(callbacks->connection());
     callbacks->connection()->database()->Commit(transaction_id);
 
     callbacks->connection()->Close();
     EXPECT_FALSE(factory->IsDatabaseOpen(origin, db_name));
   }
 
   // Open at version < 2, which will fail; ensure factory doesn't retain
   // the database object.
   {
     scoped_refptr<IndexedDBCallbacks> callbacks(new ErrorCallbacks());
     IndexedDBPendingConnection connection(callbacks,
                                           db_callbacks,
                                           0, /* child_process_id */
                                           transaction_id,
                                           db_version - 1);
-    factory->Open(db_name, connection, origin, temp_directory.path());
+    factory->Open(db_name,
+                  connection,
+                  origin,
+                  temp_directory.path(),
+                  NULL /* task_runner */);
     EXPECT_FALSE(factory->IsDatabaseOpen(origin, db_name));
   }
 
   // Terminate all pending-close timers.
   factory->ForceClose(origin);
 }
 
 }  // namespace content