TaskScheduler: migrate appcache database over to use it.

content/browser/appcache/chrome_appcache_service_unittest.cc

 // Copyright (c) 2012 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 <utility>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
+#include "base/test/scoped_task_environment.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/browser/appcache/appcache_database.h"
 #include "content/browser/appcache/appcache_storage_impl.h"
 #include "content/browser/appcache/chrome_appcache_service.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/test/test_browser_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/test/appcache_test_helper.h"
 #include "net/url_request/url_request_context_getter.h"
@@ skipping 33 matching lines @@
  private:
   net::URLRequestContext* context_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 };
 
 }  // namespace
 
 class ChromeAppCacheServiceTest : public testing::Test {
  public:
   ChromeAppCacheServiceTest()
-      : kProtectedManifestURL(kProtectedManifest),
+      : scoped_task_environment_(
+            base::test::ScopedTaskEnvironment::MainThreadType::IO),
+        kProtectedManifestURL(kProtectedManifest),
         kNormalManifestURL(kNormalManifest),
         kSessionOnlyManifestURL(kSessionOnlyManifest),
         thread_bundle_(TestBrowserThreadBundle::Options::IO_MAINLOOP) {}
 
  protected:
   scoped_refptr<ChromeAppCacheService> CreateAppCacheServiceImpl(
       const base::FilePath& appcache_path,
       bool init_storage);
   void InsertDataIntoAppCache(ChromeAppCacheService* appcache_service);
 
+  base::test::ScopedTaskEnvironment scoped_task_environment_;
   base::ScopedTempDir temp_dir_;
   const GURL kProtectedManifestURL;
   const GURL kNormalManifestURL;
   const GURL kSessionOnlyManifestURL;
 
  private:
   TestBrowserThreadBundle thread_bundle_;
   TestBrowserContext browser_context_;
 };
 
@@ skipping 11 matching lines @@
       new MockURLRequestContextGetter(
           browser_context_.GetResourceContext()->GetRequestContext(),
           base::ThreadTaskRunnerHandle::Get());
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&ChromeAppCacheService::InitializeOnIOThread,
                  appcache_service, appcache_path,
                  browser_context_.GetResourceContext(),
                  base::RetainedRef(mock_request_context_getter), mock_policy));
   // Steps needed to initialize the storage of AppCache data.
-  base::RunLoop().RunUntilIdle();
+  scoped_task_environment_.RunUntilIdle();
   if (init_storage) {
     AppCacheStorageImpl* storage =
         static_cast<AppCacheStorageImpl*>(
             appcache_service->storage());
     storage->database_->db_connection();
     storage->disk_cache();
-    base::RunLoop().RunUntilIdle();
+    scoped_task_environment_.RunUntilIdle();
   }
   return appcache_service;
 }
 
 void ChromeAppCacheServiceTest::InsertDataIntoAppCache(
     ChromeAppCacheService* appcache_service) {
   AppCacheTestHelper appcache_helper;
   appcache_helper.AddGroupAndCache(appcache_service, kNormalManifestURL);
   appcache_helper.AddGroupAndCache(appcache_service, kProtectedManifestURL);
   appcache_helper.AddGroupAndCache(appcache_service, kSessionOnlyManifestURL);
@@ skipping 15 matching lines @@
 
   // Create a ChromeAppCacheService and insert data into it
   scoped_refptr<ChromeAppCacheService> appcache_service =
       CreateAppCacheServiceImpl(appcache_path, true);
   ASSERT_TRUE(base::PathExists(appcache_path));
   ASSERT_TRUE(base::PathExists(appcache_path.AppendASCII("Index")));
   InsertDataIntoAppCache(appcache_service.get());
 
   // Test: delete the ChromeAppCacheService
   appcache_service = NULL;
-  base::RunLoop().RunUntilIdle();
+  scoped_task_environment_.RunUntilIdle();
 
   // Recreate the appcache (for reading the data back)
   appcache_service = CreateAppCacheServiceImpl(appcache_path, false);
 
   // The directory is still there
   ASSERT_TRUE(base::PathExists(appcache_path));
 
   // The appcache data is also there, except the session-only origin.
   AppCacheTestHelper appcache_helper;
   std::set<GURL> origins;
   appcache_helper.GetOriginsWithCaches(appcache_service.get(), &origins);
   EXPECT_EQ(2UL, origins.size());
   EXPECT_TRUE(origins.find(kProtectedManifestURL.GetOrigin()) != origins.end());
   EXPECT_TRUE(origins.find(kNormalManifestURL.GetOrigin()) != origins.end());
   EXPECT_TRUE(origins.find(kSessionOnlyManifestURL.GetOrigin()) ==
               origins.end());
 
   // Delete and let cleanup tasks run prior to returning.
   appcache_service = NULL;
-  base::RunLoop().RunUntilIdle();
+  scoped_task_environment_.RunUntilIdle();
 }
 
 TEST_F(ChromeAppCacheServiceTest, SaveSessionState) {
   ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   base::FilePath appcache_path =
       temp_dir_.GetPath().Append(kTestingAppCacheDirname);
 
   // Create a ChromeAppCacheService and insert data into it
   scoped_refptr<ChromeAppCacheService> appcache_service =
       CreateAppCacheServiceImpl(appcache_path, true);
   ASSERT_TRUE(base::PathExists(appcache_path));
   ASSERT_TRUE(base::PathExists(appcache_path.AppendASCII("Index")));
   InsertDataIntoAppCache(appcache_service.get());
 
   // Save session state. This should bypass the destruction-time deletion.
   appcache_service->set_force_keep_session_state();
 
   // Test: delete the ChromeAppCacheService
   appcache_service = NULL;
-  base::RunLoop().RunUntilIdle();
+  scoped_task_environment_.RunUntilIdle();
 
   // Recreate the appcache (for reading the data back)
   appcache_service = CreateAppCacheServiceImpl(appcache_path, false);
 
   // The directory is still there
   ASSERT_TRUE(base::PathExists(appcache_path));
 
   // No appcache data was deleted.
   AppCacheTestHelper appcache_helper;
   std::set<GURL> origins;
   appcache_helper.GetOriginsWithCaches(appcache_service.get(), &origins);
   EXPECT_EQ(3UL, origins.size());
   EXPECT_TRUE(origins.find(kProtectedManifestURL.GetOrigin()) != origins.end());
   EXPECT_TRUE(origins.find(kNormalManifestURL.GetOrigin()) != origins.end());
   EXPECT_TRUE(origins.find(kSessionOnlyManifestURL.GetOrigin()) !=
               origins.end());
 
   // Delete and let cleanup tasks run prior to returning.
   appcache_service = NULL;
-  base::RunLoop().RunUntilIdle();
+  scoped_task_environment_.RunUntilIdle();
 }
 
 }  // namespace content