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

chrome/browser/download/save_page_browsertest.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 <stddef.h>
 #include <stdint.h>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/test_file_util.h"
+#include "base/threading/thread_restrictions.h"
 #include "build/build_config.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/download/chrome_download_manager_delegate.h"
 #include "chrome/browser/download/download_history.h"
 #include "chrome/browser/download/download_prefs.h"
 #include "chrome/browser/download/download_service.h"
 #include "chrome/browser/download/download_service_factory.h"
 #include "chrome/browser/download/save_package_file_picker.h"
 #include "chrome/browser/net/url_request_mock_util.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 398 matching lines @@
 };
 
 IN_PROC_BROWSER_TEST_F(SavePageBrowserTest, SaveHTMLOnly) {
   GURL url = NavigateToMockURL("a");
 
   base::FilePath full_file_name, dir;
   SaveCurrentTab(url, content::SAVE_PAGE_TYPE_AS_ONLY_HTML, "a", 1, &dir,
                  &full_file_name);
   ASSERT_FALSE(HasFailure());
 
+  base::ThreadRestrictions::ScopedAllowIO allow_io;
   EXPECT_TRUE(base::PathExists(full_file_name));
   EXPECT_FALSE(base::PathExists(dir));
   EXPECT_TRUE(base::ContentsEqual(GetTestDirFile("a.htm"), full_file_name));
 }
 
 IN_PROC_BROWSER_TEST_F(SavePageBrowserTest, SaveHTMLOnlyCancel) {
   GURL url = NavigateToMockURL("a");
   DownloadManager* manager(GetDownloadManager());
   std::vector<DownloadItem*> downloads;
   manager->GetAllDownloads(&downloads);
@@ skipping 67 matching lines @@
   ASSERT_TRUE(GetCurrentTab(browser())->SavePage(full_file_name, dir,
                                         content::SAVE_PAGE_TYPE_AS_ONLY_HTML));
   std::vector<DownloadItem*> items;
   creation_observer.WaitForDownloadItem(&items);
   ASSERT_TRUE(items.size() == 1);
 
   // Close the tab; does this cancel the download?
   GetCurrentTab(browser())->Close();
   EXPECT_EQ(DownloadItem::CANCELLED, items[0]->GetState());
 
+  base::ThreadRestrictions::ScopedAllowIO allow_io;
   EXPECT_FALSE(base::PathExists(full_file_name));
   EXPECT_FALSE(base::PathExists(dir));
 }
 
 IN_PROC_BROWSER_TEST_F(SavePageBrowserTest, SaveViewSourceHTMLOnly) {
   GURL mock_url = URLRequestMockHTTPJob::GetMockUrl("save_page/a.htm");
   GURL view_source_url =
       GURL(content::kViewSourceScheme + std::string(":") + mock_url.spec());
   GURL actual_page_url = URLRequestMockHTTPJob::GetMockUrl(
       "save_page/a.htm");
   ui_test_utils::NavigateToURL(browser(), view_source_url);
 
   base::FilePath full_file_name, dir;
   SaveCurrentTab(actual_page_url, content::SAVE_PAGE_TYPE_AS_ONLY_HTML, "a", 1,
                  &dir, &full_file_name);
   ASSERT_FALSE(HasFailure());
 
+  base::ThreadRestrictions::ScopedAllowIO allow_io;
   EXPECT_TRUE(base::PathExists(full_file_name));
   EXPECT_FALSE(base::PathExists(dir));
   EXPECT_TRUE(base::ContentsEqual(GetTestDirFile("a.htm"), full_file_name));
 }
 
 IN_PROC_BROWSER_TEST_F(SavePageBrowserTest, SaveCompleteHTML) {
   GURL url = NavigateToMockURL("b");
 
   base::FilePath full_file_name, dir;
   SaveCurrentTab(url, content::SAVE_PAGE_TYPE_AS_COMPLETE_HTML, "b", 3, &dir,
                  &full_file_name);
   ASSERT_FALSE(HasFailure());
 
+  base::ThreadRestrictions::ScopedAllowIO allow_io;
   EXPECT_TRUE(base::PathExists(full_file_name));
   EXPECT_TRUE(base::PathExists(dir));
 
   EXPECT_EQ(ReadFileAndCollapseWhitespace(full_file_name),
             ReadFileAndCollapseWhitespace(GetTestDirFile("b.saved1.htm")));
   EXPECT_TRUE(
       base::ContentsEqual(GetTestDirFile("1.png"), dir.AppendASCII("1.png")));
   EXPECT_EQ(ReadFileAndCollapseWhitespace(dir.AppendASCII("1.css")),
             ReadFileAndCollapseWhitespace(GetTestDirFile("1.css")));
 }
@@ skipping 55 matching lines @@
   SavePackageFinishedObserver observer(
       content::BrowserContext::GetDownloadManager(browser()->profile()),
       loop_runner->QuitClosure());
   ASSERT_TRUE(GetCurrentTab(browser())->SavePage(
       full_file_name, dir, content::SAVE_PAGE_TYPE_AS_COMPLETE_HTML));
 
   loop_runner->Run();
   ASSERT_TRUE(VerifySavePackageExpectations(browser(), url));
   persisted.WaitForPersisted();
 
+  base::ThreadRestrictions::ScopedAllowIO allow_io;
   EXPECT_TRUE(base::PathExists(full_file_name));
   EXPECT_TRUE(base::PathExists(dir));
 
   EXPECT_EQ(ReadFileAndCollapseWhitespace(full_file_name),
             ReadFileAndCollapseWhitespace(GetTestDirFile("b.saved2.htm")));
   EXPECT_TRUE(
       base::ContentsEqual(GetTestDirFile("1.png"), dir.AppendASCII("1.png")));
   EXPECT_EQ(ReadFileAndCollapseWhitespace(dir.AppendASCII("1.css")),
             ReadFileAndCollapseWhitespace(GetTestDirFile("1.css")));
 }
 
 IN_PROC_BROWSER_TEST_F(SavePageBrowserTest, RemoveFromList) {
   GURL url = NavigateToMockURL("a");
 
   base::FilePath full_file_name, dir;
   SaveCurrentTab(url, content::SAVE_PAGE_TYPE_AS_ONLY_HTML, "a", 1, &dir,
                  &full_file_name);
   ASSERT_FALSE(HasFailure());
 
   DownloadManager* manager(GetDownloadManager());
   std::vector<DownloadItem*> downloads;
   manager->GetAllDownloads(&downloads);
   ASSERT_EQ(1UL, downloads.size());
 
   DownloadRemovedObserver removed(browser()->profile(), downloads[0]->GetId());
   downloads[0]->Remove();
   removed.WaitForRemoved();
 
+  base::ThreadRestrictions::ScopedAllowIO allow_io;
   EXPECT_TRUE(base::PathExists(full_file_name));
   EXPECT_FALSE(base::PathExists(dir));
   EXPECT_TRUE(base::ContentsEqual(GetTestDirFile("a.htm"), full_file_name));
 }
 
 // This tests that a webpage with the title "test.exe" is saved as
 // "test.exe.htm".
 // We probably don't care to handle this on Linux or Mac.
 #if defined(OS_WIN)
 IN_PROC_BROWSER_TEST_F(SavePageBrowserTest, CleanFilenameFromPageTitle) {
   base::FilePath download_dir =
       DownloadPrefs::FromDownloadManager(GetDownloadManager())->
           DownloadPath();
   base::FilePath full_file_name =
       download_dir.AppendASCII(std::string("test.exe") + kAppendedExtension);
   base::FilePath dir = download_dir.AppendASCII("test.exe_files");
 
+  base::ThreadRestrictions::ScopedAllowIO allow_io;
   EXPECT_FALSE(base::PathExists(full_file_name));
   GURL url = URLRequestMockHTTPJob::GetMockUrl("save_page/c.htm");
   ui_test_utils::NavigateToURL(browser(), url);
 
   SavePackageFilePicker::SetShouldPromptUser(false);
   scoped_refptr<content::MessageLoopRunner> loop_runner(
       new content::MessageLoopRunner);
   SavePackageFinishedObserver observer(
       content::BrowserContext::GetDownloadManager(browser()->profile()),
       loop_runner->QuitClosure());
@@ skipping 36 matching lines @@
   scoped_refptr<content::MessageLoopRunner> loop_runner(
       new content::MessageLoopRunner);
   SavePackageFinishedObserver observer(
       content::BrowserContext::GetDownloadManager(browser()->profile()),
       loop_runner->QuitClosure());
   chrome::SavePage(browser());
   loop_runner->Run();
   ASSERT_TRUE(VerifySavePackageExpectations(browser(), url));
   persisted.WaitForPersisted();
 
+  base::ThreadRestrictions::ScopedAllowIO allow_io;
   ASSERT_TRUE(base::PathExists(full_file_name));
   int64_t actual_file_size = -1;
   EXPECT_TRUE(base::GetFileSize(full_file_name, &actual_file_size));
   EXPECT_LE(kFileSizeMin, actual_file_size);
 
   std::string contents;
   EXPECT_TRUE(base::ReadFileToString(full_file_name, &contents));
   // Test for a CSS encoded character.  This used to use HTML encoding.
   EXPECT_THAT(contents, HasSubstr("content: \"\\e003 \\e004 b\""));
 }
 
 IN_PROC_BROWSER_TEST_F(SavePageBrowserTest, SavePageBrowserTest_NonMHTML) {
   SavePackageFilePicker::SetShouldPromptUser(false);
   GURL url("data:text/plain,foo");
   ui_test_utils::NavigateToURL(browser(), url);
   scoped_refptr<content::MessageLoopRunner> loop_runner(
       new content::MessageLoopRunner);
   SavePackageFinishedObserver observer(
       content::BrowserContext::GetDownloadManager(browser()->profile()),
       loop_runner->QuitClosure());
   chrome::SavePage(browser());
   loop_runner->Run();
   base::FilePath download_dir = DownloadPrefs::FromDownloadManager(
       GetDownloadManager())->DownloadPath();
   base::FilePath filename = download_dir.AppendASCII("dataurl.txt");
+  base::ThreadRestrictions::ScopedAllowIO allow_io;
   ASSERT_TRUE(base::PathExists(filename));
   std::string contents;
   EXPECT_TRUE(base::ReadFileToString(filename, &contents));
   EXPECT_EQ("foo", contents);
 }
 
 // If a save-page-complete operation results in creating subresources that would
 // otherwise be considered dangerous, such files should get a .download
 // extension appended so that they won't be accidentally executed by the user.
 IN_PROC_BROWSER_TEST_F(SavePageBrowserTest, DangerousSubresources) {
   GURL url =
       URLRequestMockHTTPJob::GetMockUrl("/save_page/dubious-subresources.html");
 
   ui_test_utils::NavigateToURL(browser(), url);
   base::FilePath full_file_name, dir;
   SaveCurrentTab(url, content::SAVE_PAGE_TYPE_AS_COMPLETE_HTML,
                  "dubious-subresources", 2, &dir, &full_file_name);
   ASSERT_FALSE(HasFailure());
 
+  base::ThreadRestrictions::ScopedAllowIO allow_io;
   EXPECT_TRUE(base::PathExists(full_file_name));
   EXPECT_TRUE(base::PathExists(dir.AppendASCII("not-a-crx.crx.download")));
 }
 
 // Test that we don't crash when the page contains an iframe that
 // was handled as a download (http://crbug.com/42212).
 IN_PROC_BROWSER_TEST_F(SavePageBrowserTest, SaveDownloadableIFrame) {
   GURL url = URLRequestMockHTTPJob::GetMockUrl(
       "downloads/iframe-src-is-a-download.htm");
 
@@ skipping 14 matching lines @@
     GetDownloadManager()->GetAllDownloads(&downloads);
     for (auto* download : downloads)
       download->Remove();
   }
 
   base::FilePath full_file_name, dir;
   SaveCurrentTab(url, content::SAVE_PAGE_TYPE_AS_COMPLETE_HTML,
                  "iframe-src-is-a-download", 3, &dir, &full_file_name);
   ASSERT_FALSE(HasFailure());
 
+  base::ThreadRestrictions::ScopedAllowIO allow_io;
   EXPECT_TRUE(base::PathExists(full_file_name));
   EXPECT_TRUE(base::PathExists(dir.AppendASCII("thisdayinhistory.html")));
   EXPECT_TRUE(base::PathExists(dir.AppendASCII("no-such-file.html")));
 }
 
 // Test that file: URI won't be saved when referred to from an HTTP page.
 // See also https://crbug.com/616429.
 IN_PROC_BROWSER_TEST_F(SavePageBrowserTest, SaveUnauthorizedResource) {
   GURL url = NavigateToMockURL("unauthorized-access");
 
   // Create a test file (that the web page should not have access to).
+  base::ThreadRestrictions::ScopedAllowIO allow_io;
   base::ScopedTempDir temp_dir2;
   ASSERT_TRUE(temp_dir2.CreateUniqueTempDir());
   base::FilePath file_path =
       temp_dir2.GetPath().Append(FILE_PATH_LITERAL("should-not-save.jpg"));
   std::string file_content("fake-jpg");
   ASSERT_LT(
       0, base::WriteFile(file_path, file_content.data(), file_content.size()));
 
   // Refer to the test file from the test page.
   GURL file_url = net::FilePathToFileURL(file_path);
@@ skipping 47 matching lines @@
 IN_PROC_BROWSER_TEST_F(SavePageSitePerProcessBrowserTest, SaveAsCompleteHtml) {
   GURL url(
       embedded_test_server()->GetURL("a.com", "/save_page/frames-xsite.htm"));
   ui_test_utils::NavigateToURL(browser(), url);
 
   base::FilePath full_file_name, dir;
   SaveCurrentTab(url, content::SAVE_PAGE_TYPE_AS_COMPLETE_HTML,
                  "frames-xsite-complete-html", 5, &dir, &full_file_name);
   ASSERT_FALSE(HasFailure());
 
+  base::ThreadRestrictions::ScopedAllowIO allow_io;
   EXPECT_TRUE(base::DirectoryExists(dir));
   base::FilePath expected_files[] = {
       full_file_name,
       dir.AppendASCII("a.html"),  // From iframes.htm
       dir.AppendASCII("b.html"),  // From iframes.htm
       dir.AppendASCII("1.css"),   // From b.htm
       dir.AppendASCII("1.png"),   // Deduplicated from iframes.htm and b.htm.
   };
   for (auto file_path : expected_files) {
     EXPECT_TRUE(base::PathExists(file_path)) << "Does " << file_path.value()
@@ skipping 40 matching lines @@
   GURL url(
       embedded_test_server()->GetURL("a.com", "/save_page/frames-xsite.htm"));
   ui_test_utils::NavigateToURL(browser(), url);
 
   base::FilePath full_file_name, dir;
   SaveCurrentTab(url, content::SAVE_PAGE_TYPE_AS_MHTML, "frames-xsite-mhtml",
                  -1, &dir, &full_file_name);
   ASSERT_FALSE(HasFailure());
 
   std::string mhtml;
-  ASSERT_TRUE(base::ReadFileToString(full_file_name, &mhtml));
+  {
+    base::ThreadRestrictions::ScopedAllowIO allow_io;
+    ASSERT_TRUE(base::ReadFileToString(full_file_name, &mhtml));
+  }
 
   // Verify content of main frame, subframes and some savable resources.
   EXPECT_THAT(
       mhtml,
       HasSubstr("frames-xsite.htm: 896fd88d-a77a-4f46-afd8-24db7d5af9c2"));
   EXPECT_THAT(mhtml, HasSubstr("a.htm: 1b8aae2b-e164-462f-bd5b-98aa366205f2"));
   EXPECT_THAT(mhtml, HasSubstr("b.htm: 3a35f7fa-96a9-4487-9f18-4470263907fa"));
   EXPECT_THAT(mhtml, HasSubstr("font-size: 20px;"))
       << "Verifying if content from 1.css is present";
 
@@ skipping 45 matching lines @@
       break;
     }
   }
   EXPECT_TRUE(did_kill_a_process);
 
   // Main verification is that we don't hang and time out when saving.
   base::FilePath full_file_name, dir;
   SaveCurrentTab(url, content::SAVE_PAGE_TYPE_AS_COMPLETE_HTML,
                  "frames-xsite-complete-html", 5, &dir, &full_file_name);
   ASSERT_FALSE(HasFailure());
+  base::ThreadRestrictions::ScopedAllowIO allow_io;
   EXPECT_TRUE(base::DirectoryExists(dir));
   EXPECT_TRUE(base::PathExists(full_file_name));
 }
 
 // Test suite that verifies that the frame tree "looks" the same before
 // and after a save-page-as.
 class SavePageOriginalVsSavedComparisonTest
     : public SavePageSitePerProcessBrowserTest,
       public ::testing::WithParamInterface<content::SavePageType> {
  protected:
@@ skipping 303 matching lines @@
   TestOriginalVsSavedPage(save_page_type, url, 1, 1, expected_substrings);
 }
 
 INSTANTIATE_TEST_CASE_P(
     SaveType,
     SavePageOriginalVsSavedComparisonTest,
     ::testing::Values(content::SAVE_PAGE_TYPE_AS_COMPLETE_HTML,
                       content::SAVE_PAGE_TYPE_AS_MHTML));
 
 }  // namespace