Fix integration tests in src/chrome and src/extensions so that we can turn on IO thread checks wi...

chrome/browser/extensions/api/file_system/file_system_apitest.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 "apps/saved_files_service.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
 #include "base/path_service.h"
 #include "base/scoped_observer.h"
+#include "base/threading/thread_restrictions.h"
 #include "build/build_config.h"
 #include "chrome/browser/apps/app_browsertest_util.h"
 #include "chrome/browser/extensions/api/file_system/file_system_api.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_paths.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_registry_observer.h"
 
 namespace content {
@@ skipping 58 matching lines @@
   }
 
   void TearDown() override {
     FileSystemChooseEntryFunction::StopSkippingPickerForTest();
     PlatformAppBrowserTest::TearDown();
   };
 
  protected:
   base::FilePath TempFilePath(const std::string& destination_name,
                               bool copy_gold) {
+    base::ThreadRestrictions::ScopedAllowIO allow_io;
     if (!temp_dir_.CreateUniqueTempDir()) {
       ADD_FAILURE() << "CreateUniqueTempDir failed";
       return base::FilePath();
     }
     FileSystemChooseEntryFunction::RegisterTempExternalFileSystemForTest(
         "test_temp", temp_dir_.GetPath());
 
     base::FilePath destination =
         temp_dir_.GetPath().AppendASCII(destination_name);
     if (copy_gold) {
       base::FilePath source = test_root_folder_.AppendASCII("gold.txt");
       EXPECT_TRUE(base::CopyFile(source, destination));
     }
     return destination;
   }
 
   std::vector<base::FilePath> TempFilePaths(
       const std::vector<std::string>& destination_names,
       bool copy_gold) {
+    base::ThreadRestrictions::ScopedAllowIO allow_io;
     if (!temp_dir_.CreateUniqueTempDir()) {
       ADD_FAILURE() << "CreateUniqueTempDir failed";
       return std::vector<base::FilePath>();
     }
     FileSystemChooseEntryFunction::RegisterTempExternalFileSystemForTest(
         "test_temp", temp_dir_.GetPath());
 
     std::vector<base::FilePath> result;
     for (std::vector<std::string>::const_iterator it =
              destination_names.begin();
          it != destination_names.end(); ++it) {
       base::FilePath destination = temp_dir_.GetPath().AppendASCII(*it);
       if (copy_gold) {
         base::FilePath source = test_root_folder_.AppendASCII("gold.txt");
         EXPECT_TRUE(base::CopyFile(source, destination));
       }
       result.push_back(destination);
     }
     return result;
   }
 
   void CheckStoredDirectoryMatches(const base::FilePath& filename) {
+    base::ThreadRestrictions::ScopedAllowIO allow_io;
     const Extension* extension = GetSingleLoadedExtension();
     ASSERT_TRUE(extension);
     std::string extension_id = extension->id();
     ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
     base::FilePath stored_value =
         file_system_api::GetLastChooseEntryDirectory(prefs, extension_id);
     if (filename.empty()) {
       EXPECT_TRUE(stored_value.empty());
     } else {
       EXPECT_EQ(base::MakeAbsoluteFilePath(filename.DirName()),
                 base::MakeAbsoluteFilePath(stored_value));
     }
   }
 
   base::FilePath test_root_folder_;
   base::ScopedTempDir temp_dir_;
 };
 
 IN_PROC_BROWSER_TEST_F(FileSystemApiTest, FileSystemApiGetDisplayPath) {
   base::FilePath test_file = test_root_folder_.AppendASCII("gold.txt");
   FileSystemChooseEntryFunction::SkipPickerAndAlwaysSelectPathForTest(
       &test_file);
   ASSERT_TRUE(RunPlatformAppTest("api_test/file_system/get_display_path"))
       << message_;
 }
 
 #if defined(OS_WIN) || defined(OS_POSIX)
 IN_PROC_BROWSER_TEST_F(FileSystemApiTest, FileSystemApiGetDisplayPathPrettify) {
-  ASSERT_TRUE(PathService::OverrideAndCreateIfNeeded(base::DIR_HOME,
-      test_root_folder_, false, false));
+  {
+    base::ThreadRestrictions::ScopedAllowIO allow_io;
+    ASSERT_TRUE(PathService::OverrideAndCreateIfNeeded(
+        base::DIR_HOME, test_root_folder_, false, false));
+  }
 
   base::FilePath test_file = test_root_folder_.AppendASCII("gold.txt");
   FileSystemChooseEntryFunction::SkipPickerAndAlwaysSelectPathForTest(
       &test_file);
   ASSERT_TRUE(RunPlatformAppTest(
       "api_test/file_system/get_display_path_prettify")) << message_;
 }
 #endif
 
 #if defined(OS_MACOSX)
 IN_PROC_BROWSER_TEST_F(FileSystemApiTest,
     FileSystemApiGetDisplayPathPrettifyMac) {
-  // On Mac, "test.localized" will be localized into just "test".
-  base::FilePath test_path = TempFilePath("test.localized", false);
-  ASSERT_TRUE(base::CreateDirectory(test_path));
+  base::FilePath test_file;
+  {
+    base::ThreadRestrictions::ScopedAllowIO allow_io;
+    // On Mac, "test.localized" will be localized into just "test".
+    base::FilePath test_path = TempFilePath("test.localized", false);
+    ASSERT_TRUE(base::CreateDirectory(test_path));
 
-  base::FilePath test_file = test_path.AppendASCII("gold.txt");
-  base::FilePath source = test_root_folder_.AppendASCII("gold.txt");
-  EXPECT_TRUE(base::CopyFile(source, test_file));
+    test_file = test_path.AppendASCII("gold.txt");
+    base::FilePath source = test_root_folder_.AppendASCII("gold.txt");
+    EXPECT_TRUE(base::CopyFile(source, test_file));
+  }
 
   FileSystemChooseEntryFunction::SkipPickerAndAlwaysSelectPathForTest(
       &test_file);
   ASSERT_TRUE(RunPlatformAppTest(
       "api_test/file_system/get_display_path_prettify_mac")) << message_;
 }
 #endif
 
 IN_PROC_BROWSER_TEST_F(FileSystemApiTest, FileSystemApiOpenExistingFileTest) {
   base::FilePath test_file = TempFilePath("open_existing.txt", true);
@@ skipping 19 matching lines @@
     ASSERT_TRUE(RunPlatformAppTest("api_test/file_system/open_existing"))
         << message_;
   }
   CheckStoredDirectoryMatches(test_file);
 }
 
 IN_PROC_BROWSER_TEST_F(FileSystemApiTest,
     FileSystemApiOpenExistingFilePreviousPathDoesNotExistTest) {
   base::FilePath test_file = TempFilePath("open_existing.txt", true);
   ASSERT_FALSE(test_file.empty());
-  ASSERT_TRUE(PathService::OverrideAndCreateIfNeeded(
-      chrome::DIR_USER_DOCUMENTS, test_file.DirName(), false, false));
+  {
+    base::ThreadRestrictions::ScopedAllowIO allow_io;
+    ASSERT_TRUE(PathService::OverrideAndCreateIfNeeded(
+        chrome::DIR_USER_DOCUMENTS, test_file.DirName(), false, false));
+  }
   FileSystemChooseEntryFunction::
       SkipPickerAndSelectSuggestedPathForTest();
   {
     AppLoadObserver observer(
         profile(),
         base::Bind(SetLastChooseEntryDirectory,
                    test_file.DirName().Append(base::FilePath::FromUTF8Unsafe(
                        "fake_directory_does_not_exist")),
                    ExtensionPrefs::Get(profile())));
     ASSERT_TRUE(RunPlatformAppTest("api_test/file_system/open_existing"))
         << message_;
   }
   CheckStoredDirectoryMatches(test_file);
 }
 
 IN_PROC_BROWSER_TEST_F(FileSystemApiTest,
                        FileSystemApiOpenExistingFileDefaultPathTest) {
   base::FilePath test_file = TempFilePath("open_existing.txt", true);
   ASSERT_FALSE(test_file.empty());
-  ASSERT_TRUE(PathService::OverrideAndCreateIfNeeded(
-      chrome::DIR_USER_DOCUMENTS, test_file.DirName(), false, false));
+  {
+    base::ThreadRestrictions::ScopedAllowIO allow_io;
+    ASSERT_TRUE(PathService::OverrideAndCreateIfNeeded(
+        chrome::DIR_USER_DOCUMENTS, test_file.DirName(), false, false));
+  }
   FileSystemChooseEntryFunction::
       SkipPickerAndSelectSuggestedPathForTest();
   ASSERT_TRUE(RunPlatformAppTest("api_test/file_system/open_existing"))
       << message_;
   CheckStoredDirectoryMatches(test_file);
 }
 
 IN_PROC_BROWSER_TEST_F(FileSystemApiTest, FileSystemApiOpenMultipleSuggested) {
   base::FilePath test_file = TempFilePath("open_existing.txt", true);
   ASSERT_FALSE(test_file.empty());
-  ASSERT_TRUE(PathService::OverrideAndCreateIfNeeded(
-      chrome::DIR_USER_DOCUMENTS, test_file.DirName(), false, false));
+  {
+    base::ThreadRestrictions::ScopedAllowIO allow_io;
+    ASSERT_TRUE(PathService::OverrideAndCreateIfNeeded(
+        chrome::DIR_USER_DOCUMENTS, test_file.DirName(), false, false));
+  }
   FileSystemChooseEntryFunction::SkipPickerAndSelectSuggestedPathForTest();
   ASSERT_TRUE(RunPlatformAppTest(
       "api_test/file_system/open_multiple_with_suggested_name"))
       << message_;
   CheckStoredDirectoryMatches(test_file);
 }
 
 IN_PROC_BROWSER_TEST_F(FileSystemApiTest,
                        FileSystemApiOpenMultipleExistingFilesTest) {
   std::vector<std::string> names;
@@ skipping 57 matching lines @@
   CheckStoredDirectoryMatches(base::FilePath());
 }
 
 #if defined(OS_WIN) || defined(OS_POSIX)
 IN_PROC_BROWSER_TEST_F(FileSystemApiTest,
                        FileSystemApiOpenDirectoryOnGraylistAndAllowTest) {
   FileSystemChooseEntryFunction::SkipDirectoryConfirmationForTest();
   base::FilePath test_file = TempFilePath("open_existing.txt", true);
   ASSERT_FALSE(test_file.empty());
   base::FilePath test_directory = test_file.DirName();
-  ASSERT_TRUE(PathService::OverrideAndCreateIfNeeded(
-      kGraylistedPath, test_directory, false, false));
+  {
+    base::ThreadRestrictions::ScopedAllowIO allow_io;
+    ASSERT_TRUE(PathService::OverrideAndCreateIfNeeded(
+        kGraylistedPath, test_directory, false, false));
+  }
   FileSystemChooseEntryFunction::SkipPickerAndAlwaysSelectPathForTest(
       &test_directory);
   ASSERT_TRUE(RunPlatformAppTest("api_test/file_system/open_directory"))
       << message_;
   CheckStoredDirectoryMatches(test_file);
 }
 
 IN_PROC_BROWSER_TEST_F(FileSystemApiTest,
                        FileSystemApiOpenDirectoryOnGraylistTest) {
   FileSystemChooseEntryFunction::AutoCancelDirectoryConfirmationForTest();
   base::FilePath test_file = TempFilePath("open_existing.txt", true);
   ASSERT_FALSE(test_file.empty());
   base::FilePath test_directory = test_file.DirName();
-  ASSERT_TRUE(PathService::OverrideAndCreateIfNeeded(
-      kGraylistedPath, test_directory, false, false));
+  {
+    base::ThreadRestrictions::ScopedAllowIO allow_io;
+    ASSERT_TRUE(PathService::OverrideAndCreateIfNeeded(
+        kGraylistedPath, test_directory, false, false));
+  }
   FileSystemChooseEntryFunction::SkipPickerAndAlwaysSelectPathForTest(
       &test_directory);
   ASSERT_TRUE(RunPlatformAppTest("api_test/file_system/open_directory_cancel"))
       << message_;
   CheckStoredDirectoryMatches(test_file);
 }
 
 IN_PROC_BROWSER_TEST_F(FileSystemApiTest,
                        FileSystemApiOpenDirectoryContainingGraylistTest) {
   FileSystemChooseEntryFunction::AutoCancelDirectoryConfirmationForTest();
   base::FilePath test_file = TempFilePath("open_existing.txt", true);
   ASSERT_FALSE(test_file.empty());
   base::FilePath test_directory = test_file.DirName();
   base::FilePath parent_directory = test_directory.DirName();
-  ASSERT_TRUE(PathService::OverrideAndCreateIfNeeded(
-      kGraylistedPath, test_directory, false, false));
+  {
+    base::ThreadRestrictions::ScopedAllowIO allow_io;
+    ASSERT_TRUE(PathService::OverrideAndCreateIfNeeded(
+        kGraylistedPath, test_directory, false, false));
+  }
   FileSystemChooseEntryFunction::SkipPickerAndAlwaysSelectPathForTest(
       &parent_directory);
   ASSERT_TRUE(RunPlatformAppTest("api_test/file_system/open_directory_cancel"))
       << message_;
   CheckStoredDirectoryMatches(test_directory);
 }
 
 // Test that choosing a subdirectory of a path does not require confirmation.
 IN_PROC_BROWSER_TEST_F(FileSystemApiTest,
                        FileSystemApiOpenDirectorySubdirectoryOfGraylistTest) {
   // If a dialog is erroneously displayed, auto cancel it, so that the test
   // fails.
   FileSystemChooseEntryFunction::AutoCancelDirectoryConfirmationForTest();
   base::FilePath test_file = TempFilePath("open_existing.txt", true);
   ASSERT_FALSE(test_file.empty());
   base::FilePath test_directory = test_file.DirName();
   base::FilePath parent_directory = test_directory.DirName();
-  ASSERT_TRUE(PathService::OverrideAndCreateIfNeeded(
-      kGraylistedPath, parent_directory, false, false));
+  {
+    base::ThreadRestrictions::ScopedAllowIO allow_io;
+    ASSERT_TRUE(PathService::OverrideAndCreateIfNeeded(
+        kGraylistedPath, parent_directory, false, false));
+  }
   FileSystemChooseEntryFunction::SkipPickerAndAlwaysSelectPathForTest(
       &test_directory);
   ASSERT_TRUE(RunPlatformAppTest("api_test/file_system/open_directory"))
       << message_;
   CheckStoredDirectoryMatches(test_file);
 }
 #endif  // defined(OS_WIN) || defined(OS_POSIX)
 
 IN_PROC_BROWSER_TEST_F(FileSystemApiTest,
     FileSystemApiInvalidChooseEntryTypeTest) {
@@ skipping 248 matching lines @@
 #if !defined(OS_CHROMEOS)
 IN_PROC_BROWSER_TEST_F(FileSystemApiTest, RequestFileSystem_NotChromeOS) {
   ASSERT_TRUE(RunPlatformAppTestWithFlags(
       "api_test/file_system/request_file_system_not_chromeos",
       kFlagIgnoreManifestWarnings))
       << message_;
 }
 #endif
 
 }  // namespace extensions