Let IndexedDBContextImpl create its own task runner

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 <stdint.h>
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/test_simple_task_runner.h"
-#include "base/threading/thread_task_runner_handle.h"
+#include "base/threading/sequenced_task_runner_handle.h"
 #include "content/browser/indexed_db/indexed_db_connection.h"
 #include "content/browser/indexed_db/indexed_db_context_impl.h"
 #include "content/browser/indexed_db/indexed_db_data_format_version.h"
 #include "content/browser/indexed_db/indexed_db_factory_impl.h"
 #include "content/browser/indexed_db/mock_indexed_db_callbacks.h"
 #include "content/browser/indexed_db/mock_indexed_db_database_callbacks.h"
 #include "content/public/test/test_browser_thread_bundle.h"
+#include "content/public/test/test_utils.h"
 #include "storage/browser/test/mock_quota_manager_proxy.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBDatabaseException.h"
 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBTypes.h"
 #include "url/gurl.h"
 #include "url/origin.h"
 
 using base::ASCIIToUTF16;
 using url::Origin;
 
@@ skipping 30 matching lines @@
  private:
   ~MockIDBFactory() override {}
 
   DISALLOW_COPY_AND_ASSIGN(MockIDBFactory);
 };
 
 }  // namespace
 
 class IndexedDBFactoryTest : public testing::Test {
  public:
+  IndexedDBFactoryTest()
+      : quota_manager_proxy_(
+            base::MakeRefCounted<MockQuotaManagerProxy>(nullptr, nullptr)) {}
+
   void SetUp() override {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
-    task_runner_ = new base::TestSimpleTaskRunner();
-    quota_manager_proxy_ = new MockQuotaManagerProxy(nullptr, nullptr);
-    context_ = new IndexedDBContextImpl(
+    context_ = base::MakeRefCounted<IndexedDBContextImpl>(
         temp_dir_.GetPath(), nullptr /* special_storage_policy */,
-        quota_manager_proxy_.get(), task_runner_.get());
-    idb_factory_ = new MockIDBFactory(context_.get());
+        quota_manager_proxy_.get());
   }
 
   void TearDown() override {
     quota_manager_proxy_->SimulateQuotaManagerDestroyed();
   }
 
  protected:
-  IndexedDBFactoryTest() {}
-  MockIDBFactory* factory() const { return idb_factory_.get(); }
-  void clear_factory() { idb_factory_ = nullptr; }
   IndexedDBContextImpl* context() const { return context_.get(); }
 
  private:
+  TestBrowserThreadBundle thread_bundle_;
+
   base::ScopedTempDir temp_dir_;
-  scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
+  scoped_refptr<MockQuotaManagerProxy> quota_manager_proxy_;
   scoped_refptr<IndexedDBContextImpl> context_;
-  scoped_refptr<MockIDBFactory> idb_factory_;
-  scoped_refptr<MockQuotaManagerProxy> quota_manager_proxy_;
-  TestBrowserThreadBundle thread_bundle_;
 
   DISALLOW_COPY_AND_ASSIGN(IndexedDBFactoryTest);
 };
 
 TEST_F(IndexedDBFactoryTest, BackingStoreLifetime) {
-  const Origin origin1(GURL("http://localhost:81"));
-  const Origin origin2(GURL("http://localhost:82"));
+  context()->TaskRunner()->PostTask(
+      FROM_HERE,
+      base::BindOnce(
+          [](IndexedDBContextImpl* context) {
+            scoped_refptr<MockIDBFactory> factory =
+                base::MakeRefCounted<MockIDBFactory>(context);
 
-  base::ScopedTempDir temp_directory;
-  ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
-  scoped_refptr<IndexedDBBackingStore> disk_store1 =
-      factory()->TestOpenBackingStore(origin1, temp_directory.GetPath());
+            const Origin origin1(GURL("http://localhost:81"));
+            const Origin origin2(GURL("http://localhost:82"));
 
-  scoped_refptr<IndexedDBBackingStore> disk_store2 =
-      factory()->TestOpenBackingStore(origin1, temp_directory.GetPath());
-  EXPECT_EQ(disk_store1.get(), disk_store2.get());
+            scoped_refptr<IndexedDBBackingStore> disk_store1 =
+                factory->TestOpenBackingStore(origin1, context->data_path());
 
-  scoped_refptr<IndexedDBBackingStore> disk_store3 =
-      factory()->TestOpenBackingStore(origin2, temp_directory.GetPath());
+            scoped_refptr<IndexedDBBackingStore> disk_store2 =
+                factory->TestOpenBackingStore(origin1, context->data_path());
+            EXPECT_EQ(disk_store1.get(), disk_store2.get());
 
-  factory()->TestCloseBackingStore(disk_store1.get());
-  factory()->TestCloseBackingStore(disk_store3.get());
+            scoped_refptr<IndexedDBBackingStore> disk_store3 =
+                factory->TestOpenBackingStore(origin2, context->data_path());
 
-  EXPECT_FALSE(disk_store1->HasOneRef());
-  EXPECT_FALSE(disk_store2->HasOneRef());
-  EXPECT_TRUE(disk_store3->HasOneRef());
+            factory->TestCloseBackingStore(disk_store1.get());
+            factory->TestCloseBackingStore(disk_store3.get());
 
-  disk_store2 = nullptr;
-  EXPECT_TRUE(disk_store1->HasOneRef());
+            EXPECT_FALSE(disk_store1->HasOneRef());
+            EXPECT_FALSE(disk_store2->HasOneRef());
+            EXPECT_TRUE(disk_store3->HasOneRef());
+
+            disk_store2 = nullptr;
+            EXPECT_TRUE(disk_store1->HasOneRef());
+          },
+          base::Unretained(context())));
+
+  RunAllBlockingPoolTasksUntilIdle();
 }
 
 TEST_F(IndexedDBFactoryTest, BackingStoreLazyClose) {
-  const Origin origin(GURL("http://localhost:81"));
+  context()->TaskRunner()->PostTask(
+      FROM_HERE,
+      base::BindOnce(
+          [](IndexedDBContextImpl* context) {
 
-  base::ScopedTempDir temp_directory;
-  ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
-  scoped_refptr<IndexedDBBackingStore> store =
-      factory()->TestOpenBackingStore(origin, temp_directory.GetPath());
+            scoped_refptr<MockIDBFactory> factory =
+                base::MakeRefCounted<MockIDBFactory>(context);
 
-  // Give up the local refptr so that the factory has the only
-  // outstanding reference.
-  IndexedDBBackingStore* store_ptr = store.get();
-  store = nullptr;
-  EXPECT_FALSE(store_ptr->close_timer()->IsRunning());
-  factory()->TestReleaseBackingStore(store_ptr, false);
-  EXPECT_TRUE(store_ptr->close_timer()->IsRunning());
+            const Origin origin(GURL("http://localhost:81"));
 
-  factory()->TestOpenBackingStore(origin, temp_directory.GetPath());
-  EXPECT_FALSE(store_ptr->close_timer()->IsRunning());
-  factory()->TestReleaseBackingStore(store_ptr, false);
-  EXPECT_TRUE(store_ptr->close_timer()->IsRunning());
+            scoped_refptr<IndexedDBBackingStore> store =
+                factory->TestOpenBackingStore(origin, context->data_path());
 
-  // Take back a ref ptr and ensure that the actual close
-  // stops a running timer.
-  store = store_ptr;
-  factory()->TestCloseBackingStore(store_ptr);
-  EXPECT_FALSE(store_ptr->close_timer()->IsRunning());
+            // Give up the local refptr so that the factory has the only
+            // outstanding reference.
+            IndexedDBBackingStore* store_ptr = store.get();
+            store = nullptr;
+            EXPECT_FALSE(store_ptr->close_timer()->IsRunning());
+            factory->TestReleaseBackingStore(store_ptr, false);
+            EXPECT_TRUE(store_ptr->close_timer()->IsRunning());
+
+            factory->TestOpenBackingStore(origin, context->data_path());
+            EXPECT_FALSE(store_ptr->close_timer()->IsRunning());
+            factory->TestReleaseBackingStore(store_ptr, false);
+            EXPECT_TRUE(store_ptr->close_timer()->IsRunning());
+
+            // Take back a ref ptr and ensure that the actual close
+            // stops a running timer.
+            store = store_ptr;
+            factory->TestCloseBackingStore(store_ptr);
+            EXPECT_FALSE(store_ptr->close_timer()->IsRunning());
+          },
+          base::Unretained(context())));
+
+  RunAllBlockingPoolTasksUntilIdle();
 }
 
 TEST_F(IndexedDBFactoryTest, MemoryBackingStoreLifetime) {
-  const Origin origin1(GURL("http://localhost:81"));
-  const Origin origin2(GURL("http://localhost:82"));
+  context()->TaskRunner()->PostTask(
+      FROM_HERE,
+      base::BindOnce(
+          [](IndexedDBContextImpl* context) {
 
-  scoped_refptr<IndexedDBBackingStore> mem_store1 =
-      factory()->TestOpenBackingStore(origin1, base::FilePath());
+            scoped_refptr<MockIDBFactory> factory =
+                base::MakeRefCounted<MockIDBFactory>(context);
 
-  scoped_refptr<IndexedDBBackingStore> mem_store2 =
-      factory()->TestOpenBackingStore(origin1, base::FilePath());
-  EXPECT_EQ(mem_store1.get(), mem_store2.get());
+            const Origin origin1(GURL("http://localhost:81"));
+            const Origin origin2(GURL("http://localhost:82"));
 
-  scoped_refptr<IndexedDBBackingStore> mem_store3 =
-      factory()->TestOpenBackingStore(origin2, base::FilePath());
+            scoped_refptr<IndexedDBBackingStore> mem_store1 =
+                factory->TestOpenBackingStore(origin1, base::FilePath());
 
-  factory()->TestCloseBackingStore(mem_store1.get());
-  factory()->TestCloseBackingStore(mem_store3.get());
+            scoped_refptr<IndexedDBBackingStore> mem_store2 =
+                factory->TestOpenBackingStore(origin1, base::FilePath());
+            EXPECT_EQ(mem_store1.get(), mem_store2.get());
 
-  EXPECT_FALSE(mem_store1->HasOneRef());
-  EXPECT_FALSE(mem_store2->HasOneRef());
-  EXPECT_FALSE(mem_store3->HasOneRef());
+            scoped_refptr<IndexedDBBackingStore> mem_store3 =
+                factory->TestOpenBackingStore(origin2, base::FilePath());
 
-  clear_factory();
-  EXPECT_FALSE(mem_store1->HasOneRef());  // mem_store1 and 2
-  EXPECT_FALSE(mem_store2->HasOneRef());  // mem_store1 and 2
-  EXPECT_TRUE(mem_store3->HasOneRef());
+            factory->TestCloseBackingStore(mem_store1.get());
+            factory->TestCloseBackingStore(mem_store3.get());
 
-  mem_store2 = nullptr;
-  EXPECT_TRUE(mem_store1->HasOneRef());
+            EXPECT_FALSE(mem_store1->HasOneRef());
+            EXPECT_FALSE(mem_store2->HasOneRef());
+            EXPECT_FALSE(mem_store3->HasOneRef());
+
+            factory = nullptr;
+            EXPECT_FALSE(mem_store1->HasOneRef());  // mem_store1 and 2
+            EXPECT_FALSE(mem_store2->HasOneRef());  // mem_store1 and 2
+            EXPECT_TRUE(mem_store3->HasOneRef());
+
+            mem_store2 = nullptr;
+            EXPECT_TRUE(mem_store1->HasOneRef());
+          },
+          base::Unretained(context())));
+
+  RunAllBlockingPoolTasksUntilIdle();
 }
 
 TEST_F(IndexedDBFactoryTest, RejectLongOrigins) {
-  base::ScopedTempDir temp_directory;
-  ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
-  const base::FilePath base_path = temp_directory.GetPath();
+  context()->TaskRunner()->PostTask(
+      FROM_HERE,
+      base::BindOnce(
+          [](IndexedDBContextImpl* context) {
+            base::FilePath temp_dir = context->data_path().DirName();
+            int limit = base::GetMaximumPathComponentLength(temp_dir);
+            EXPECT_GT(limit, 0);
 
-  int limit = base::GetMaximumPathComponentLength(base_path);
-  EXPECT_GT(limit, 0);
+            scoped_refptr<MockIDBFactory> factory =
+                base::MakeRefCounted<MockIDBFactory>(context);
 
-  std::string origin(limit + 1, 'x');
-  Origin too_long_origin(GURL("http://" + origin + ":81/"));
-  scoped_refptr<IndexedDBBackingStore> diskStore1 =
-      factory()->TestOpenBackingStore(too_long_origin, base_path);
-  EXPECT_FALSE(diskStore1.get());
+            std::string origin(limit + 1, 'x');
+            Origin too_long_origin(GURL("http://" + origin + ":81/"));
+            scoped_refptr<IndexedDBBackingStore> diskStore1 =
+                factory->TestOpenBackingStore(too_long_origin,
+                                              context->data_path());
+            EXPECT_FALSE(diskStore1.get());
 
-  Origin ok_origin(GURL("http://someorigin.com:82/"));
-  scoped_refptr<IndexedDBBackingStore> diskStore2 =
-      factory()->TestOpenBackingStore(ok_origin, base_path);
-  EXPECT_TRUE(diskStore2.get());
-  // We need a manual close or Windows can't delete the temp directory.
-  factory()->TestCloseBackingStore(diskStore2.get());
+            Origin ok_origin(GURL("http://someorigin.com:82/"));
+            scoped_refptr<IndexedDBBackingStore> diskStore2 =
+                factory->TestOpenBackingStore(ok_origin, context->data_path());
+            EXPECT_TRUE(diskStore2.get());
+            // We need a manual close or Windows can't delete the temp
+            // directory.
+            factory->TestCloseBackingStore(diskStore2.get());
+          },
+          base::Unretained(context())));
+
+  RunAllBlockingPoolTasksUntilIdle();
 }
 
 class DiskFullFactory : public IndexedDBFactoryImpl {
  public:
   explicit DiskFullFactory(IndexedDBContextImpl* context)
       : IndexedDBFactoryImpl(context) {}
 
  private:
   ~DiskFullFactory() override {}
   scoped_refptr<IndexedDBBackingStore> OpenBackingStore(
@@ skipping 10 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(DiskFullFactory);
 };
 
 class LookingForQuotaErrorMockCallbacks : public IndexedDBCallbacks {
  public:
   LookingForQuotaErrorMockCallbacks()
       : IndexedDBCallbacks(nullptr,
                            url::Origin(),
                            nullptr,
-                           base::ThreadTaskRunnerHandle::Get()),
+                           base::SequencedTaskRunnerHandle::Get()),
         error_called_(false) {}
   void OnError(const IndexedDBDatabaseError& error) override {
     error_called_ = true;
     EXPECT_EQ(blink::kWebIDBDatabaseExceptionQuotaError, error.code());
   }
   bool error_called() const { return error_called_; }
 
  private:
   ~LookingForQuotaErrorMockCallbacks() override {}
   bool error_called_;
 
   DISALLOW_COPY_AND_ASSIGN(LookingForQuotaErrorMockCallbacks);
 };
 
 TEST_F(IndexedDBFactoryTest, QuotaErrorOnDiskFull) {
-  const Origin origin(GURL("http://localhost:81"));
-  base::ScopedTempDir temp_directory;
-  ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
-
-  scoped_refptr<DiskFullFactory> factory = new DiskFullFactory(context());
   scoped_refptr<LookingForQuotaErrorMockCallbacks> callbacks =
-      new LookingForQuotaErrorMockCallbacks;
+      base::MakeRefCounted<LookingForQuotaErrorMockCallbacks>();
   scoped_refptr<IndexedDBDatabaseCallbacks> dummy_database_callbacks =
-      new IndexedDBDatabaseCallbacks(nullptr, nullptr);
-  const base::string16 name(ASCIIToUTF16("name"));
-  std::unique_ptr<IndexedDBPendingConnection> connection(
-      base::MakeUnique<IndexedDBPendingConnection>(
-          callbacks, dummy_database_callbacks, 0 /* child_process_id */,
-          2 /* transaction_id */, 1 /* version */));
-  factory->Open(name, std::move(connection), nullptr /* request_context */,
-                origin, temp_directory.GetPath());
-  EXPECT_TRUE(callbacks->error_called());
+      base::MakeRefCounted<IndexedDBDatabaseCallbacks>(nullptr, nullptr);
+
+  context()->TaskRunner()->PostTask(
+      FROM_HERE,
+      base::BindOnce(
+          [](IndexedDBContextImpl* context,
+             scoped_refptr<LookingForQuotaErrorMockCallbacks> callbacks,
+             scoped_refptr<IndexedDBDatabaseCallbacks>
+                 dummy_database_callbacks) {
+
+            const Origin origin(GURL("http://localhost:81"));
+            scoped_refptr<DiskFullFactory> factory =
+                base::MakeRefCounted<DiskFullFactory>(context);
+            const base::string16 name(ASCIIToUTF16("name"));
+            std::unique_ptr<IndexedDBPendingConnection> connection(
+                base::MakeUnique<IndexedDBPendingConnection>(
+                    callbacks, dummy_database_callbacks,
+                    0 /* child_process_id */, 2 /* transaction_id */,
+                    1 /* version */));
+            factory->Open(name, std::move(connection),
+                          nullptr /* request_context */, origin,
+                          context->data_path());
+            EXPECT_TRUE(callbacks->error_called());
+          },
+          base::Unretained(context()), std::move(callbacks),
+          std::move(dummy_database_callbacks)));
+  RunAllBlockingPoolTasksUntilIdle();
 }
 
 TEST_F(IndexedDBFactoryTest, BackingStoreReleasedOnForcedClose) {
-  const Origin origin(GURL("http://localhost:81"));
-
-  base::ScopedTempDir temp_directory;
-  ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
-
-  scoped_refptr<MockIndexedDBCallbacks> callbacks(new MockIndexedDBCallbacks());
-  scoped_refptr<MockIndexedDBDatabaseCallbacks> db_callbacks(
-      new MockIndexedDBDatabaseCallbacks());
-  const int64_t transaction_id = 1;
-  std::unique_ptr<IndexedDBPendingConnection> connection(
-      base::MakeUnique<IndexedDBPendingConnection>(
-          callbacks, db_callbacks, 0 /* child_process_id */, transaction_id,
-          IndexedDBDatabaseMetadata::DEFAULT_VERSION));
-  factory()->Open(ASCIIToUTF16("db"), std::move(connection),
-                  nullptr /* request_context */, origin,
-                  temp_directory.GetPath());
-
-  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));
+  context()->TaskRunner()->PostTask(
+      FROM_HERE,
+      base::BindOnce(
+          [](IndexedDBContextImpl* context,
+             scoped_refptr<MockIndexedDBCallbacks> callbacks,
+             scoped_refptr<IndexedDBDatabaseCallbacks> db_callbacks) {
+
+            scoped_refptr<MockIDBFactory> factory =
+                base::MakeRefCounted<MockIDBFactory>(context);
+
+            const Origin origin(GURL("http://localhost:81"));
+            const int64_t transaction_id = 1;
+            std::unique_ptr<IndexedDBPendingConnection> connection(
+                base::MakeUnique<IndexedDBPendingConnection>(
+                    callbacks, db_callbacks, 0 /* child_process_id */,
+                    transaction_id,
+                    IndexedDBDatabaseMetadata::DEFAULT_VERSION));
+            factory->Open(ASCIIToUTF16("db"), std::move(connection),
+                          nullptr /* request_context */, origin,
+                          context->data_path());
+
+            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));
+          },
+          base::Unretained(context()),
+          base::MakeRefCounted<MockIndexedDBCallbacks>(),
+          base::MakeRefCounted<MockIndexedDBDatabaseCallbacks>()));
+  RunAllBlockingPoolTasksUntilIdle();
 }
 
 TEST_F(IndexedDBFactoryTest, BackingStoreReleaseDelayedOnClose) {
-  const Origin origin(GURL("http://localhost:81"));
-
-  base::ScopedTempDir temp_directory;
-  ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
-
-  scoped_refptr<MockIndexedDBCallbacks> callbacks(new MockIndexedDBCallbacks());
-  scoped_refptr<MockIndexedDBDatabaseCallbacks> db_callbacks(
-      new MockIndexedDBDatabaseCallbacks());
-  const int64_t transaction_id = 1;
-  std::unique_ptr<IndexedDBPendingConnection> connection(
-      base::MakeUnique<IndexedDBPendingConnection>(
-          callbacks, db_callbacks, 0 /* child_process_id */, transaction_id,
-          IndexedDBDatabaseMetadata::DEFAULT_VERSION));
-  factory()->Open(ASCIIToUTF16("db"), std::move(connection),
-                  nullptr /* request_context */, origin,
-                  temp_directory.GetPath());
-
-  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));
-  EXPECT_TRUE(factory()->IsBackingStorePendingClose(origin));
-  EXPECT_TRUE(store->close_timer()->IsRunning());
-
-  // Take a ref so it won't be destroyed out from under the test.
-  scoped_refptr<IndexedDBBackingStore> store_ref = store;
-  // Now simulate shutdown, which should stop the timer.
-  factory()->ContextDestroyed();
-  EXPECT_TRUE(store->HasOneRef());  // Local.
-  EXPECT_FALSE(store->close_timer()->IsRunning());
-  EXPECT_FALSE(factory()->IsBackingStoreOpen(origin));
-  EXPECT_FALSE(factory()->IsBackingStorePendingClose(origin));
+  context()->TaskRunner()->PostTask(
+      FROM_HERE,
+      base::BindOnce(
+          [](IndexedDBContextImpl* context,
+             scoped_refptr<MockIndexedDBCallbacks> callbacks,
+             scoped_refptr<IndexedDBDatabaseCallbacks> db_callbacks) {
+
+            scoped_refptr<MockIDBFactory> factory =
+                base::MakeRefCounted<MockIDBFactory>(context);
+
+            const Origin origin(GURL("http://localhost:81"));
+            const int64_t transaction_id = 1;
+            std::unique_ptr<IndexedDBPendingConnection> connection(
+                base::MakeUnique<IndexedDBPendingConnection>(
+                    callbacks, db_callbacks, 0 /* child_process_id */,
+                    transaction_id,
+                    IndexedDBDatabaseMetadata::DEFAULT_VERSION));
+            factory->Open(ASCIIToUTF16("db"), std::move(connection),
+                          nullptr /* request_context */, origin,
+                          context->data_path());
+
+            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));
+            EXPECT_TRUE(factory->IsBackingStorePendingClose(origin));
+            EXPECT_TRUE(store->close_timer()->IsRunning());
+
+            // Take a ref so it won't be destroyed out from under the test.
+            scoped_refptr<IndexedDBBackingStore> store_ref = store;
+            // Now simulate shutdown, which should stop the timer.
+            factory->ContextDestroyed();
+            EXPECT_TRUE(store->HasOneRef());  // Local.
+            EXPECT_FALSE(store->close_timer()->IsRunning());
+            EXPECT_FALSE(factory->IsBackingStoreOpen(origin));
+            EXPECT_FALSE(factory->IsBackingStorePendingClose(origin));
+          },
+          base::Unretained(context()),
+          base::MakeRefCounted<MockIndexedDBCallbacks>(),
+          base::MakeRefCounted<MockIndexedDBDatabaseCallbacks>()));
+  RunAllBlockingPoolTasksUntilIdle();
 }
 
 TEST_F(IndexedDBFactoryTest, DeleteDatabaseClosesBackingStore) {
-  const Origin origin(GURL("http://localhost:81"));
-
-  base::ScopedTempDir temp_directory;
-  ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
-
-  EXPECT_FALSE(factory()->IsBackingStoreOpen(origin));
-
-  const bool expect_connection = false;
-  scoped_refptr<MockIndexedDBCallbacks> callbacks(
-      new MockIndexedDBCallbacks(expect_connection));
-  factory()->DeleteDatabase(ASCIIToUTF16("db"), nullptr /* request_context */,
-                            callbacks, origin, temp_directory.GetPath(),
-                            false /* force_close */);
-
-  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));
+  context()->TaskRunner()->PostTask(
+      FROM_HERE,
+      base::BindOnce(
+          [](IndexedDBContextImpl* context,
+             scoped_refptr<MockIndexedDBCallbacks> callbacks) {
+
+            scoped_refptr<MockIDBFactory> factory =
+                base::MakeRefCounted<MockIDBFactory>(context);
+
+            const Origin origin(GURL("http://localhost:81"));
+            EXPECT_FALSE(factory->IsBackingStoreOpen(origin));
+
+            factory->DeleteDatabase(
+                ASCIIToUTF16("db"), nullptr /* request_context */, callbacks,
+                origin, context->data_path(), false /* force_close */);
+
+            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));
+
+          },
+          base::Unretained(context()),
+          base::MakeRefCounted<MockIndexedDBCallbacks>(
+              false /*expect_connection*/)));
+  RunAllBlockingPoolTasksUntilIdle();
 }
 
 TEST_F(IndexedDBFactoryTest, GetDatabaseNamesClosesBackingStore) {
-  const Origin origin(GURL("http://localhost:81"));
-
-  base::ScopedTempDir temp_directory;
-  ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
-
-  EXPECT_FALSE(factory()->IsBackingStoreOpen(origin));
-
-  const bool expect_connection = false;
-  scoped_refptr<MockIndexedDBCallbacks> callbacks(
-      new MockIndexedDBCallbacks(expect_connection));
-  factory()->GetDatabaseNames(callbacks, origin, temp_directory.GetPath(),
-                              nullptr /* request_context */);
-
-  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));
+  context()->TaskRunner()->PostTask(
+      FROM_HERE,
+      base::BindOnce(
+          [](IndexedDBContextImpl* context,
+             scoped_refptr<MockIndexedDBCallbacks> callbacks) {
+            scoped_refptr<MockIDBFactory> factory =
+                base::MakeRefCounted<MockIDBFactory>(context);
+
+            const Origin origin(GURL("http://localhost:81"));
+            EXPECT_FALSE(factory->IsBackingStoreOpen(origin));
+
+            factory->GetDatabaseNames(callbacks, origin, context->data_path(),
+                                      nullptr /* request_context */);
+
+            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));
+
+          },
+          base::Unretained(context()),
+          base::MakeRefCounted<MockIndexedDBCallbacks>(
+              false /*expect_connection*/)));
+  RunAllBlockingPoolTasksUntilIdle();
 }
 
 TEST_F(IndexedDBFactoryTest, ForceCloseReleasesBackingStore) {
-  const Origin origin(GURL("http://localhost:81"));
-
-  base::ScopedTempDir temp_directory;
-  ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
-
-  scoped_refptr<MockIndexedDBCallbacks> callbacks(new MockIndexedDBCallbacks());
-  scoped_refptr<MockIndexedDBDatabaseCallbacks> db_callbacks(
-      new MockIndexedDBDatabaseCallbacks());
-  const int64_t transaction_id = 1;
-  std::unique_ptr<IndexedDBPendingConnection> connection(
-      base::MakeUnique<IndexedDBPendingConnection>(
-          callbacks, db_callbacks, 0 /* child_process_id */, transaction_id,
-          IndexedDBDatabaseMetadata::DEFAULT_VERSION));
-  factory()->Open(ASCIIToUTF16("db"), std::move(connection),
-                  nullptr /* request_context */, origin,
-                  temp_directory.GetPath());
-
-  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));
-
-  factory()->ForceClose(origin);
-
-  EXPECT_FALSE(factory()->IsBackingStoreOpen(origin));
-  EXPECT_FALSE(factory()->IsBackingStorePendingClose(origin));
-
-  // Ensure it is safe if the store is not open.
-  factory()->ForceClose(origin);
+  context()->TaskRunner()->PostTask(
+      FROM_HERE,
+      base::BindOnce(
+          [](IndexedDBContextImpl* context,
+             scoped_refptr<MockIndexedDBCallbacks> callbacks,
+             scoped_refptr<IndexedDBDatabaseCallbacks> db_callbacks) {
+            scoped_refptr<MockIDBFactory> factory =
+                base::MakeRefCounted<MockIDBFactory>(context);
+
+            const Origin origin(GURL("http://localhost:81"));
+            const int64_t transaction_id = 1;
+            std::unique_ptr<IndexedDBPendingConnection> connection(
+                base::MakeUnique<IndexedDBPendingConnection>(
+                    callbacks, db_callbacks, 0 /* child_process_id */,
+                    transaction_id,
+                    IndexedDBDatabaseMetadata::DEFAULT_VERSION));
+            factory->Open(ASCIIToUTF16("db"), std::move(connection),
+                          nullptr /* request_context */, origin,
+                          context->data_path());
+
+            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));
+
+            factory->ForceClose(origin);
+
+            EXPECT_FALSE(factory->IsBackingStoreOpen(origin));
+            EXPECT_FALSE(factory->IsBackingStorePendingClose(origin));
+
+            // Ensure it is safe if the store is not open.
+            factory->ForceClose(origin);
+
+          },
+          base::Unretained(context()),
+          base::MakeRefCounted<MockIndexedDBCallbacks>(),
+          base::MakeRefCounted<MockIndexedDBDatabaseCallbacks>()));
+  RunAllBlockingPoolTasksUntilIdle();
 }
 
 class UpgradeNeededCallbacks : public MockIndexedDBCallbacks {
  public:
   UpgradeNeededCallbacks() {}
 
   void OnSuccess(std::unique_ptr<IndexedDBConnection> connection,
                  const IndexedDBDatabaseMetadata& metadata) override {
     EXPECT_TRUE(connection_.get());
     EXPECT_FALSE(connection.get());
@@ skipping 24 matching lines @@
 
  private:
   ~ErrorCallbacks() override {}
   bool saw_error_;
 
   DISALLOW_COPY_AND_ASSIGN(ErrorCallbacks);
 };
 
 TEST_F(IndexedDBFactoryTest, DatabaseFailedOpen) {
   const Origin origin(GURL("http://localhost:81"));
+  const base::string16 db_name(ASCIIToUTF16("db"));
+  const int64_t transaction_id = 1;
 
-  base::ScopedTempDir temp_directory;
-  ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
+  // These objects are retained across posted tasks, so despite being used
+  // exclusively on the IDB sequence.
 
-  const base::string16 db_name(ASCIIToUTF16("db"));
-  const int64_t db_version = 2;
-  const int64_t transaction_id = 1;
-  scoped_refptr<IndexedDBDatabaseCallbacks> db_callbacks(
-      new MockIndexedDBDatabaseCallbacks());
+  // Created and used on IDB sequence.
+  scoped_refptr<MockIDBFactory> factory;
+  // Created on IO thread, used on IDB sequence.
+  scoped_refptr<UpgradeNeededCallbacks> upgrade_callbacks =
+      base::MakeRefCounted<UpgradeNeededCallbacks>();
 
-  // Open at version 2, then close.
-  {
-    scoped_refptr<UpgradeNeededCallbacks> callbacks(
-        new UpgradeNeededCallbacks());
-    std::unique_ptr<IndexedDBPendingConnection> connection(
-        base::MakeUnique<IndexedDBPendingConnection>(
-            callbacks, db_callbacks, 0 /* child_process_id */, transaction_id,
-            db_version));
-    factory()->Open(db_name, std::move(connection),
-                    nullptr /* request_context */, origin,
-                    temp_directory.GetPath());
-    EXPECT_TRUE(factory()->IsDatabaseOpen(origin, db_name));
+  context()->TaskRunner()->PostTask(
+      FROM_HERE,
+      base::BindOnce(
+          [](IndexedDBContextImpl* context,
+             scoped_refptr<MockIDBFactory>* factory,
+             scoped_refptr<UpgradeNeededCallbacks>* upgrade_callbacks,
+             scoped_refptr<IndexedDBDatabaseCallbacks> db_callbacks,
+             const base::string16& db_name, int64_t transaction_id,
+             const Origin& origin) {
 
-    // Pump the message loop so the upgrade transaction can run.
-    base::RunLoop().RunUntilIdle();
-    EXPECT_TRUE(callbacks->connection());
-    callbacks->connection()->database()->Commit(
-        callbacks->connection()->GetTransaction(transaction_id));
+            *factory = base::MakeRefCounted<MockIDBFactory>(context);
 
-    callbacks->connection()->Close();
-    EXPECT_FALSE(factory()->IsDatabaseOpen(origin, db_name));
-  }
+            // Open at version 2.
+            const int64_t db_version = 2;
+            (*factory)->Open(
+                db_name,
+                base::MakeUnique<IndexedDBPendingConnection>(
+                    *upgrade_callbacks, db_callbacks, 0 /* child_process_id */,
+                    transaction_id, db_version),
+                nullptr /* request_context */, origin, context->data_path());
 
-  // Open at version < 2, which will fail; ensure factory doesn't retain
-  // the database object.
-  {
-    scoped_refptr<ErrorCallbacks> callbacks(new ErrorCallbacks());
-    std::unique_ptr<IndexedDBPendingConnection> connection(
-        base::MakeUnique<IndexedDBPendingConnection>(
-            callbacks, db_callbacks, 0 /* child_process_id */, transaction_id,
-            db_version - 1));
-    factory()->Open(db_name, std::move(connection),
-                    nullptr /* request_context */, origin,
-                    temp_directory.GetPath());
-    EXPECT_TRUE(callbacks->saw_error());
-    EXPECT_FALSE(factory()->IsDatabaseOpen(origin, db_name));
-  }
+            EXPECT_TRUE((*factory)->IsDatabaseOpen(origin, db_name));
+          },
+          base::Unretained(context()), base::Unretained(&factory),
+          base::Unretained(&upgrade_callbacks),
+          base::MakeRefCounted<MockIndexedDBDatabaseCallbacks>(), db_name,
+          transaction_id, origin));
 
-  // Terminate all pending-close timers.
-  factory()->ForceClose(origin);
+  // Pump the message loop so the upgrade transaction can run.
+  RunAllBlockingPoolTasksUntilIdle();
+
+  context()->TaskRunner()->PostTask(
+      FROM_HERE,
+      base::BindOnce(
+          [](IndexedDBContextImpl* context,
+             scoped_refptr<MockIDBFactory> factory,
+             scoped_refptr<UpgradeNeededCallbacks> upgrade_callbacks,
+             scoped_refptr<ErrorCallbacks> failed_open_callbacks,
+             scoped_refptr<IndexedDBDatabaseCallbacks> db_callbacks,
+             const base::string16& db_name, int64_t transaction_id,
+             const Origin& origin) {
+            // Close the connection.
+            {
+              EXPECT_TRUE(upgrade_callbacks->connection());
+              upgrade_callbacks->connection()->database()->Commit(
+                  upgrade_callbacks->connection()->GetTransaction(
+                      transaction_id));
+              upgrade_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.
+            {
+              const int64_t db_version = 1;
+              std::unique_ptr<IndexedDBPendingConnection> connection(
+                  base::MakeUnique<IndexedDBPendingConnection>(
+                      failed_open_callbacks, db_callbacks,
+                      0 /* child_process_id */, transaction_id, db_version));
+              factory->Open(db_name, std::move(connection),
+                            nullptr /* request_context */, origin,
+                            context->data_path());
+              EXPECT_TRUE(failed_open_callbacks->saw_error());
+              EXPECT_FALSE(factory->IsDatabaseOpen(origin, db_name));
+            }
+
+            // Terminate all pending-close timers.
+            factory->ForceClose(origin);
+          },
+          base::Unretained(context()), std::move(factory),
+          std::move(upgrade_callbacks), base::MakeRefCounted<ErrorCallbacks>(),
+          base::MakeRefCounted<MockIndexedDBDatabaseCallbacks>(), db_name,
+          transaction_id, origin));
+
+  RunAllBlockingPoolTasksUntilIdle();

[dmurph, 2017/07/07 18:28:59]

I'd be a little more comfortable if you do something like:

base::RunLoop loop;
context()->TaskRunner()->PostTask(FROM_HERE, loop.QuitClosure());
loop.Run();

This is a little more constrained & direct, where we will run past tasks and
stop when we reach that quit closure. This might be a lot of work to change
though, and if the tests aren't flaky then it's "ok" to do the rununtilidle. But
I'd like to encourage moving towards the above method.  RunUntilIdle is
apparently a recipe for flakiness.

This is up to you.

[jsbell, 2017/07/07 21:35:44]

Per gab@ (email thread to scheduler-dev@) the scheduler doesn't have a message
loop so using WaitableEvents would be necessary... and I think that would make
the tests even more complex. So... would prefer to start this way. I haven't
seen any flakiness in local runs or the bots (just in the DispatcherHostTest
which was because I removed too much cleanup code)

 }
 
 namespace {
 
 class DataLossCallbacks final : public MockIndexedDBCallbacks {
  public:
   blink::WebIDBDataLoss data_loss() const { return data_loss_; }
   void OnSuccess(std::unique_ptr<IndexedDBConnection> connection,
                  const IndexedDBDatabaseMetadata& metadata) override {
     if (!connection_)
@@ skipping 13 matching lines @@
  private:
   ~DataLossCallbacks() final {}
   blink::WebIDBDataLoss data_loss_ = blink::kWebIDBDataLossNone;
 };
 
 TEST_F(IndexedDBFactoryTest, DataFormatVersion) {
   auto try_open = [this](const Origin& origin,
                          const IndexedDBDataFormatVersion& version) {
     base::AutoReset<IndexedDBDataFormatVersion> override_version(
         &IndexedDBDataFormatVersion::GetMutableCurrentForTesting(), version);
-    auto db_callbacks = base::MakeRefCounted<MockIndexedDBDatabaseCallbacks>();
-    auto callbacks = base::MakeRefCounted<DataLossCallbacks>();
+
+    // These objects are retained across posted tasks, so despite being used
+    // exclusively on the IDB sequence.
+
+    // Created and used on IDB sequence.
+    scoped_refptr<MockIDBFactory> factory;
+    // Created on IO thread, used on IDB sequence.
+    scoped_refptr<DataLossCallbacks> callbacks =
+        base::MakeRefCounted<DataLossCallbacks>();
+
     const int64_t transaction_id = 1;
-    factory()->Open(ASCIIToUTF16("test_db"),
-                    base::MakeUnique<IndexedDBPendingConnection>(
-                        callbacks, db_callbacks, 0 /* child_process_id */,
-                        transaction_id, 1 /* version */),
-                    nullptr /* request_context */, origin,
-                    context()->data_path());
-    base::RunLoop().RunUntilIdle();
-    auto* connection = callbacks->connection();
-    EXPECT_TRUE(connection);
-    connection->database()->Commit(connection->GetTransaction(transaction_id));
-    connection->Close();
-    factory()->ForceClose(origin);
-    return callbacks->data_loss();
+    blink::WebIDBDataLoss result;
+
+    context()->TaskRunner()->PostTask(
+        FROM_HERE,
+        base::BindOnce(
+            [](IndexedDBContextImpl* context,
+               scoped_refptr<MockIDBFactory>* factory,
+               scoped_refptr<DataLossCallbacks>* callbacks,
+               scoped_refptr<IndexedDBDatabaseCallbacks> db_callbacks,
+               const Origin& origin, int64_t transaction_id) {
+              *factory = base::MakeRefCounted<MockIDBFactory>(context);
+              (*factory)->Open(
+                  ASCIIToUTF16("test_db"),
+                  base::MakeUnique<IndexedDBPendingConnection>(
+                      *callbacks, db_callbacks, 0 /* child_process_id */,
+                      transaction_id, 1 /* version */),
+                  nullptr /* request_context */, origin, context->data_path());
+            },
+            base::Unretained(context()), base::Unretained(&factory),
+            base::Unretained(&callbacks),
+            base::MakeRefCounted<MockIndexedDBDatabaseCallbacks>(), origin,
+            transaction_id));
+    RunAllBlockingPoolTasksUntilIdle();
+    context()->TaskRunner()->PostTask(
+        FROM_HERE,
+        base::BindOnce(
+            [](scoped_refptr<MockIDBFactory> factory,
+               scoped_refptr<DataLossCallbacks> callbacks, const Origin& origin,
+               int64_t transaction_id, blink::WebIDBDataLoss* result) {
+              auto* connection = callbacks->connection();
+              EXPECT_TRUE(connection);
+              connection->database()->Commit(
+                  connection->GetTransaction(transaction_id));
+              connection->Close();
+              factory->ForceClose(origin);
+              *result = callbacks->data_loss();
+            },
+            std::move(factory), std::move(callbacks), origin, transaction_id,
+            base::Unretained(&result)));
+    RunAllBlockingPoolTasksUntilIdle();
+    return result;
   };
 
   using blink::kWebIDBDataLossNone;
   using blink::kWebIDBDataLossTotal;
   static const struct {
     const char* origin;
     IndexedDBDataFormatVersion open_version_1;
     IndexedDBDataFormatVersion open_version_2;
     blink::WebIDBDataLoss expected_data_loss;
   } kTestCases[] = {
@@ skipping 11 matching lines @@
     SCOPED_TRACE(test.origin);
     const Origin origin(GURL(test.origin));
     ASSERT_EQ(kWebIDBDataLossNone, try_open(origin, test.open_version_1));
     EXPECT_EQ(test.expected_data_loss, try_open(origin, test.open_version_2));
   }
 }
 
 }  // namespace
 
 }  // namespace content