Ensure tests have an active task runner

chrome/browser/chromeos/drive/file_system_util_unittest.cc

 // Copyright 2014 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 "chrome/browser/chromeos/drive/file_system_util.h"
 
 #include <vector>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
-#include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chrome/test/base/testing_profile_manager.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_file_system_options.h"
 #include "google_apis/drive/test_util.h"
 #include "storage/browser/fileapi/external_mount_points.h"
 #include "storage/browser/fileapi/file_system_backend.h"
@@ skipping 47 matching lines @@
   EXPECT_EQ(profile1,
             ExtractProfileFromPath(base::FilePath::FromUTF8Unsafe(
                 "/special/drive-" + user1_id_hash)));
   EXPECT_EQ(profile2,
             ExtractProfileFromPath(base::FilePath::FromUTF8Unsafe(
                 "/special/drive-" + user2_id_hash + "/root/xxx")));
   EXPECT_EQ(NULL, ExtractProfileFromPath(
       base::FilePath::FromUTF8Unsafe("/special/non-drive-path")));
 }
 
-TEST(FileSystemUtilTest, IsUnderDriveMountPoint) {
+class FileSystemUtilTest : public testing::Test {
+  content::TestBrowserThreadBundle thread_bundle_;
+};
+
+TEST_F(FileSystemUtilTest, IsUnderDriveMountPoint) {
   EXPECT_FALSE(IsUnderDriveMountPoint(
       base::FilePath::FromUTF8Unsafe("/wherever/foo.txt")));
   EXPECT_FALSE(IsUnderDriveMountPoint(
       base::FilePath::FromUTF8Unsafe("/special/foo.txt")));
   EXPECT_FALSE(IsUnderDriveMountPoint(
       base::FilePath::FromUTF8Unsafe("special/drive/foo.txt")));
 
   EXPECT_TRUE(IsUnderDriveMountPoint(
       base::FilePath::FromUTF8Unsafe("/special/drive")));
   EXPECT_TRUE(IsUnderDriveMountPoint(
       base::FilePath::FromUTF8Unsafe("/special/drive/foo.txt")));
   EXPECT_TRUE(IsUnderDriveMountPoint(
       base::FilePath::FromUTF8Unsafe("/special/drive/subdir/foo.txt")));
   EXPECT_TRUE(IsUnderDriveMountPoint(
       base::FilePath::FromUTF8Unsafe("/special/drive-xxx/foo.txt")));
 }
 
-TEST(FileSystemUtilTest, ExtractDrivePath) {
+TEST_F(FileSystemUtilTest, ExtractDrivePath) {
   EXPECT_EQ(base::FilePath(),
             ExtractDrivePath(
                 base::FilePath::FromUTF8Unsafe("/wherever/foo.txt")));
   EXPECT_EQ(base::FilePath(),
             ExtractDrivePath(
                 base::FilePath::FromUTF8Unsafe("/special/foo.txt")));
 
   EXPECT_EQ(base::FilePath::FromUTF8Unsafe("drive"),
             ExtractDrivePath(
                 base::FilePath::FromUTF8Unsafe("/special/drive")));
   EXPECT_EQ(base::FilePath::FromUTF8Unsafe("drive/foo.txt"),
             ExtractDrivePath(
                 base::FilePath::FromUTF8Unsafe("/special/drive/foo.txt")));
   EXPECT_EQ(base::FilePath::FromUTF8Unsafe("drive/subdir/foo.txt"),
             ExtractDrivePath(base::FilePath::FromUTF8Unsafe(
                 "/special/drive/subdir/foo.txt")));
   EXPECT_EQ(base::FilePath::FromUTF8Unsafe("drive/foo.txt"),
             ExtractDrivePath(
                 base::FilePath::FromUTF8Unsafe("/special/drive-xxx/foo.txt")));
 }
 
-TEST(FileSystemUtilTest, ExtractDrivePathFromFileSystemUrl) {
+TEST_F(FileSystemUtilTest, ExtractDrivePathFromFileSystemUrl) {
   TestingProfile profile;
 
   // Set up file system context for testing.
   base::ScopedTempDir temp_dir_;
   ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 
-  base::MessageLoop message_loop;
   scoped_refptr<storage::ExternalMountPoints> mount_points =
       storage::ExternalMountPoints::CreateRefCounted();
   scoped_refptr<storage::FileSystemContext> context(
       new storage::FileSystemContext(
           base::MessageLoopProxy::current().get(),
           base::MessageLoopProxy::current().get(),
           mount_points.get(),
           NULL,  // special_storage_policy
           NULL,  // quota_manager_proxy,
           ScopedVector<storage::FileSystemBackend>(),
@@ skipping 43 matching lines @@
           std::string(),
           GetDriveMountPointPath(&profile).AppendASCII("bar/buz"),
           &isolated_name);
   EXPECT_EQ(
       base::FilePath::FromUTF8Unsafe("drive/bar/buz"),
       ExtractDrivePathFromFileSystemUrl(context->CrackURL(GURL(
           "filesystem:chrome-extension://dummy-id/isolated/" +
           isolated_id + "/" + isolated_name))));
 }
 
-TEST(FileSystemUtilTest, EscapeUnescapeCacheFileName) {
+TEST_F(FileSystemUtilTest, EscapeUnescapeCacheFileName) {
   const std::string kUnescapedFileName(
       "tmp:`~!@#$%^&*()-_=+[{|]}\\\\;\',<.>/?");
   const std::string kEscapedFileName(
       "tmp:`~!@#$%25^&*()-_=+[{|]}\\\\;\',<%2E>%2F?");
   EXPECT_EQ(kEscapedFileName, EscapeCacheFileName(kUnescapedFileName));
   EXPECT_EQ(kUnescapedFileName, UnescapeCacheFileName(kEscapedFileName));
 }
 
-TEST(FileSystemUtilTest, NormalizeFileName) {
+TEST_F(FileSystemUtilTest, NormalizeFileName) {
   EXPECT_EQ("", NormalizeFileName(""));
   EXPECT_EQ("foo", NormalizeFileName("foo"));
   // Slash
   EXPECT_EQ("foo_zzz", NormalizeFileName("foo/zzz"));
   EXPECT_EQ("___", NormalizeFileName("///"));
   // Japanese hiragana "hi" + semi-voiced-mark is normalized to "pi".
   EXPECT_EQ("\xE3\x81\xB4", NormalizeFileName("\xE3\x81\xB2\xE3\x82\x9A"));
   // Dot
   EXPECT_EQ("_", NormalizeFileName("."));
   EXPECT_EQ("_", NormalizeFileName(".."));
   EXPECT_EQ("_", NormalizeFileName("..."));
   EXPECT_EQ(".bashrc", NormalizeFileName(".bashrc"));
   EXPECT_EQ("._", NormalizeFileName("./"));
 }
 
-TEST(FileSystemUtilTest, GetCacheRootPath) {
+TEST_F(FileSystemUtilTest, GetCacheRootPath) {
   TestingProfile profile;
   base::FilePath profile_path = profile.GetPath();
   EXPECT_EQ(profile_path.AppendASCII("GCache/v1"),
             util::GetCacheRootPath(&profile));
 }
 
-TEST(FileSystemUtilTest, GDocFile) {
+TEST_F(FileSystemUtilTest, GDocFile) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   GURL url("https://docs.google.com/document/d/"
            "1YsCnrMxxgp7LDdtlFDt-WdtEIth89vA9inrILtvK-Ug/edit");
   std::string resource_id("1YsCnrMxxgp7LDdtlFDt-WdtEIth89vA9inrILtvK-Ug");
 
   // Read and write gdoc.
   base::FilePath file = temp_dir.path().AppendASCII("test.gdoc");
   EXPECT_TRUE(CreateGDocFile(file, url, resource_id));
@@ skipping 27 matching lines @@
   // Non GDoc file.
   file = temp_dir.path().AppendASCII("test.txt");
   std::string data = "Hello world!";
   EXPECT_TRUE(google_apis::test_util::WriteStringToFile(file, data));
   EXPECT_TRUE(ReadUrlFromGDocFile(file).is_empty());
   EXPECT_TRUE(ReadResourceIdFromGDocFile(file).empty());
 }
 
 }  // namespace util
 }  // namespace drive