Let IndexedDBContextImpl create its own task runner

content/browser/indexed_db/indexed_db_backing_store_unittest.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 <stddef.h>
 #include <stdint.h>
 #include <utility>
 
 #include "base/callback.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/sequenced_task_runner.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/test/test_simple_task_runner.h"
+#include "base/test/scoped_task_environment.h"
+#include "base/threading/sequenced_task_runner_handle.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "content/browser/indexed_db/indexed_db_context_impl.h"
 #include "content/browser/indexed_db/indexed_db_factory_impl.h"
 #include "content/browser/indexed_db/indexed_db_leveldb_coding.h"
 #include "content/browser/indexed_db/indexed_db_value.h"
 #include "content/browser/indexed_db/leveldb/leveldb_factory.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "net/url_request/url_request_test_util.h"
 #include "storage/browser/blob/blob_data_handle.h"
 #include "storage/browser/quota/special_storage_policy.h"
 #include "storage/browser/test/mock_quota_manager_proxy.h"
@@ skipping 196 matching lines @@
         this, origin, data_directory, request_context_getter, &leveldb_factory,
         context()->TaskRunner(), status);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestIDBFactory);
 };
 
 class IndexedDBBackingStoreTest : public testing::Test {
  public:
-  IndexedDBBackingStoreTest() {}
+  IndexedDBBackingStoreTest()
+      : scoped_task_environment_(
+            base::test::ScopedTaskEnvironment::MainThreadType::UI),
+        url_request_context_getter_(new net::TestURLRequestContextGetter(
+            base::ThreadTaskRunnerHandle::Get())),
+        special_storage_policy_(new MockSpecialStoragePolicy()),
+        quota_manager_proxy_(new MockQuotaManagerProxy(nullptr, nullptr)) {}
+
   void SetUp() override {
     const Origin origin(GURL("http://localhost:81"));
-    task_runner_ = new base::TestSimpleTaskRunner();
-    url_request_context_getter_ =
-        new net::TestURLRequestContextGetter(task_runner_);
-    special_storage_policy_ = new MockSpecialStoragePolicy();
-    quota_manager_proxy_ = new MockQuotaManagerProxy(nullptr, nullptr);
     special_storage_policy_->SetAllUnlimited(true);
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
-    idb_context_ = new IndexedDBContextImpl(
-        temp_dir_.GetPath(), special_storage_policy_.get(),
-        quota_manager_proxy_.get(), task_runner_.get());
+    idb_context_ = new IndexedDBContextImpl(temp_dir_.GetPath(),
+                                            special_storage_policy_.get(),
+                                            quota_manager_proxy_.get());
+    // Assign current task runner so that methods on backing store can be
+    // invoked directly from test bodies.
+    idb_context_->SetTaskRunnerForTesting(
+        base::SequencedTaskRunnerHandle::Get());
     idb_factory_ = new TestIDBFactory(idb_context_.get());
     backing_store_ = idb_factory_->OpenBackingStoreForTest(
         origin, url_request_context_getter_);
 
     // useful keys and values during tests
     m_value1 = IndexedDBValue("value1", std::vector<IndexedDBBlobInfo>());
     m_value2 = IndexedDBValue("value2", std::vector<IndexedDBBlobInfo>());
 
     m_blob_info.push_back(
         IndexedDBBlobInfo("uuid 3", base::UTF8ToUTF16("blob type"), 1));
@@ skipping 82 matching lines @@
     if (backing_store_->removals().size() != backing_store_->writes().size())
       return false;
     for (size_t i = 0; i < backing_store_->writes().size(); ++i) {
       if (backing_store_->writes()[i].key() != backing_store_->removals()[i])
         return false;
     }
     return true;
   }
 
  protected:
+  base::test::ScopedTaskEnvironment scoped_task_environment_;
+
   // Must be initialized before url_request_context_getter_
   TestBrowserThreadBundle thread_bundle_;
 
   base::ScopedTempDir temp_dir_;
-  scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
+  scoped_refptr<net::URLRequestContextGetter> url_request_context_getter_;
   scoped_refptr<MockSpecialStoragePolicy> special_storage_policy_;
   scoped_refptr<MockQuotaManagerProxy> quota_manager_proxy_;
   scoped_refptr<IndexedDBContextImpl> idb_context_;
   scoped_refptr<TestIDBFactory> idb_factory_;
-  scoped_refptr<net::URLRequestContextGetter> url_request_context_getter_;
 
   scoped_refptr<TestableIndexedDBBackingStore> backing_store_;
 
   // Sample keys and values that are consistent.
   IndexedDBKey m_key1;
   IndexedDBKey m_key2;
   IndexedDBKey m_key3;
   IndexedDBValue m_value1;
   IndexedDBValue m_value2;
   IndexedDBValue m_value3;
@@ skipping 69 matching lines @@
     IndexedDBBackingStore::RecordIdentifier record;
     EXPECT_TRUE(backing_store_->PutRecord(&transaction1,
                                           1,
                                           1,
                                           m_key3,
                                           &m_value3,
                                           &handles,
                                           &record).ok());
     scoped_refptr<TestCallback> callback(new TestCallback());
     EXPECT_TRUE(transaction1.CommitPhaseOne(callback).ok());
-    task_runner_->RunUntilIdle();
+    scoped_task_environment_.RunUntilIdle();
     EXPECT_TRUE(CheckBlobWrites());
     EXPECT_TRUE(callback->called);
     EXPECT_TRUE(callback->succeeded);
     EXPECT_TRUE(transaction1.CommitPhaseTwo().ok());
   }
 
   {
     IndexedDBBackingStore::Transaction transaction2(backing_store_.get());
     transaction2.Begin();
     IndexedDBValue result_value;
@@ skipping 13 matching lines @@
   {
     IndexedDBBackingStore::Transaction transaction3(backing_store_.get());
     transaction3.Begin();
     IndexedDBValue result_value;
     EXPECT_TRUE(
         backing_store_
             ->DeleteRange(&transaction3, 1, 1, IndexedDBKeyRange(m_key3))
             .ok());
     scoped_refptr<TestCallback> callback(new TestCallback());
     EXPECT_TRUE(transaction3.CommitPhaseOne(callback).ok());
-    task_runner_->RunUntilIdle();
+    scoped_task_environment_.RunUntilIdle();
     EXPECT_TRUE(callback->called);
     EXPECT_TRUE(callback->succeeded);
     EXPECT_TRUE(transaction3.CommitPhaseTwo().ok());
     EXPECT_TRUE(CheckBlobRemovals());
   }
 }
 
 TEST_F(IndexedDBBackingStoreTest, DeleteRange) {
   IndexedDBKey key0 = IndexedDBKey(ASCIIToUTF16("key0"));
   IndexedDBKey key1 = IndexedDBKey(ASCIIToUTF16("key1"));
@@ skipping 51 matching lines @@
                                             &record).ok());
       EXPECT_TRUE(backing_store_->PutRecord(&transaction1,
                                             1,
                                             i + 1,
                                             key3,
                                             &value3,
                                             &handles,
                                             &record).ok());
       scoped_refptr<TestCallback> callback(new TestCallback());
       EXPECT_TRUE(transaction1.CommitPhaseOne(callback).ok());
-      task_runner_->RunUntilIdle();
+      scoped_task_environment_.RunUntilIdle();
       EXPECT_TRUE(callback->called);
       EXPECT_TRUE(callback->succeeded);
       EXPECT_TRUE(transaction1.CommitPhaseTwo().ok());
     }
 
     {
       IndexedDBBackingStore::Transaction transaction2(backing_store_.get());
       transaction2.Begin();
       IndexedDBValue result_value;
       EXPECT_TRUE(
           backing_store_->DeleteRange(&transaction2, 1, i + 1, ranges[i]).ok());
       scoped_refptr<TestCallback> callback(new TestCallback());
       EXPECT_TRUE(transaction2.CommitPhaseOne(callback).ok());
-      task_runner_->RunUntilIdle();
+      scoped_task_environment_.RunUntilIdle();
       EXPECT_TRUE(callback->called);
       EXPECT_TRUE(callback->succeeded);
       EXPECT_TRUE(transaction2.CommitPhaseTwo().ok());
       ASSERT_EQ(2UL, backing_store_->removals().size());
       EXPECT_EQ(backing_store_->writes()[1].key(),
                 backing_store_->removals()[0]);
       EXPECT_EQ(backing_store_->writes()[2].key(),
                 backing_store_->removals()[1]);
     }
   }
@@ skipping 55 matching lines @@
                                             &record).ok());
       EXPECT_TRUE(backing_store_->PutRecord(&transaction1,
                                             1,
                                             i + 1,
                                             key3,
                                             &value3,
                                             &handles,
                                             &record).ok());
       scoped_refptr<TestCallback> callback(new TestCallback());
       EXPECT_TRUE(transaction1.CommitPhaseOne(callback).ok());
-      task_runner_->RunUntilIdle();
+      scoped_task_environment_.RunUntilIdle();
       EXPECT_TRUE(callback->called);
       EXPECT_TRUE(callback->succeeded);
       EXPECT_TRUE(transaction1.CommitPhaseTwo().ok());
     }
 
     {
       IndexedDBBackingStore::Transaction transaction2(backing_store_.get());
       transaction2.Begin();
       IndexedDBValue result_value;
       EXPECT_TRUE(
           backing_store_->DeleteRange(&transaction2, 1, i + 1, ranges[i]).ok());
       scoped_refptr<TestCallback> callback(new TestCallback());
       EXPECT_TRUE(transaction2.CommitPhaseOne(callback).ok());
-      task_runner_->RunUntilIdle();
+      scoped_task_environment_.RunUntilIdle();
       EXPECT_TRUE(callback->called);
       EXPECT_TRUE(callback->succeeded);
       EXPECT_TRUE(transaction2.CommitPhaseTwo().ok());
       EXPECT_EQ(0UL, backing_store_->removals().size());
     }
   }
 }
 
 TEST_F(IndexedDBBackingStoreTest, BlobJournalInterleavedTransactions) {
   IndexedDBBackingStore::Transaction transaction1(backing_store_.get());
   transaction1.Begin();
   std::vector<std::unique_ptr<storage::BlobDataHandle>> handles1;
   IndexedDBBackingStore::RecordIdentifier record1;
   EXPECT_TRUE(backing_store_->PutRecord(&transaction1, 1, 1, m_key3, &m_value3,
                                         &handles1, &record1).ok());
   scoped_refptr<TestCallback> callback1(new TestCallback());
   EXPECT_TRUE(transaction1.CommitPhaseOne(callback1).ok());
-  task_runner_->RunUntilIdle();
+  scoped_task_environment_.RunUntilIdle();
   EXPECT_TRUE(CheckBlobWrites());
   EXPECT_TRUE(callback1->called);
   EXPECT_TRUE(callback1->succeeded);
   EXPECT_EQ(0U, backing_store_->removals().size());
 
   IndexedDBBackingStore::Transaction transaction2(backing_store_.get());
   transaction2.Begin();
   std::vector<std::unique_ptr<storage::BlobDataHandle>> handles2;
   IndexedDBBackingStore::RecordIdentifier record2;
   EXPECT_TRUE(backing_store_->PutRecord(&transaction2, 1, 1, m_key1, &m_value1,
                                         &handles2, &record2).ok());
   scoped_refptr<TestCallback> callback2(new TestCallback());
   EXPECT_TRUE(transaction2.CommitPhaseOne(callback2).ok());
-  task_runner_->RunUntilIdle();
+  scoped_task_environment_.RunUntilIdle();
   EXPECT_TRUE(CheckBlobWrites());
   EXPECT_TRUE(callback2->called);
   EXPECT_TRUE(callback2->succeeded);
   EXPECT_EQ(0U, backing_store_->removals().size());
 
   EXPECT_TRUE(transaction1.CommitPhaseTwo().ok());
   EXPECT_EQ(0U, backing_store_->removals().size());
 
   EXPECT_TRUE(transaction2.CommitPhaseTwo().ok());
   EXPECT_EQ(0U, backing_store_->removals().size());
 }
 
 TEST_F(IndexedDBBackingStoreTest, LiveBlobJournal) {
   {
     IndexedDBBackingStore::Transaction transaction1(backing_store_.get());
     transaction1.Begin();
     std::vector<std::unique_ptr<storage::BlobDataHandle>> handles;
     IndexedDBBackingStore::RecordIdentifier record;
     EXPECT_TRUE(backing_store_->PutRecord(&transaction1,
                                           1,
                                           1,
                                           m_key3,
                                           &m_value3,
                                           &handles,
                                           &record).ok());
     scoped_refptr<TestCallback> callback(new TestCallback());
     EXPECT_TRUE(transaction1.CommitPhaseOne(callback).ok());
-    task_runner_->RunUntilIdle();
+    scoped_task_environment_.RunUntilIdle();
     EXPECT_TRUE(CheckBlobWrites());
     EXPECT_TRUE(callback->called);
     EXPECT_TRUE(callback->succeeded);
     EXPECT_TRUE(transaction1.CommitPhaseTwo().ok());
   }
 
   IndexedDBValue read_result_value;
   {
     IndexedDBBackingStore::Transaction transaction2(backing_store_.get());
     transaction2.Begin();
@@ skipping 16 matching lines @@
 
   {
     IndexedDBBackingStore::Transaction transaction3(backing_store_.get());
     transaction3.Begin();
     EXPECT_TRUE(
         backing_store_
             ->DeleteRange(&transaction3, 1, 1, IndexedDBKeyRange(m_key3))
             .ok());
     scoped_refptr<TestCallback> callback(new TestCallback());
     EXPECT_TRUE(transaction3.CommitPhaseOne(callback).ok());
-    task_runner_->RunUntilIdle();
+    scoped_task_environment_.RunUntilIdle();
     EXPECT_TRUE(callback->called);
     EXPECT_TRUE(callback->succeeded);
     EXPECT_TRUE(transaction3.CommitPhaseTwo().ok());
     EXPECT_EQ(0U, backing_store_->removals().size());
     for (size_t i = 0; i < read_result_value.blob_info.size(); ++i) {
       read_result_value.blob_info[i].release_callback().Run(
           read_result_value.blob_info[i].file_path());
     }
-    task_runner_->RunUntilIdle();
+    scoped_task_environment_.RunUntilIdle();
     EXPECT_NE(0U, backing_store_->removals().size());
     EXPECT_TRUE(CheckBlobRemovals());
   }
 }
 
 // Make sure that using very high ( more than 32 bit ) values for database_id
 // and object_store_id still work.
 TEST_F(IndexedDBBackingStoreTest, HighIds) {
   const int64_t high_database_id = 1ULL << 35;
   const int64_t high_object_store_id = 1ULL << 39;
@@ skipping 371 matching lines @@
 
   // Dictionary, message key and more.
   ASSERT_TRUE(WriteFile(info_path, "{\"message\":\"foo\",\"bar\":5}"));
   EXPECT_TRUE(
       IndexedDBBackingStore::ReadCorruptionInfo(path_base, origin, &message));
   EXPECT_FALSE(PathExists(info_path));
   EXPECT_EQ("foo", message);
 }
 
 }  // namespace content