More aggressive IO asserts in content_browsertests.

content/browser/download/download_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.
 
 // This file contains download browser tests that are known to be runnable
 // in a pure content context.  Over time tests should be migrated here.
 
 #include <stddef.h>
 #include <stdint.h>
 #include <utility>
 #include <vector>
 
 #include "base/callback_helpers.h"
 #include "base/feature_list.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/format_macros.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/platform_thread.h"
+#include "base/threading/thread_restrictions.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "content/browser/byte_stream.h"
 #include "content/browser/download/download_file_factory.h"
 #include "content/browser/download/download_file_impl.h"
 #include "content/browser/download/download_item_impl.h"
 #include "content/browser/download/download_manager_impl.h"
 #include "content/browser/download/download_resource_handler.h"
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
@@ skipping 612 matching lines @@
     EXPECT_EQ(1u, observer->NumDownloadsSeenInState(expected_terminal_state));
   }
 
   // Checks that |path| is has |file_size| bytes, and matches the |value|
   // string.
   bool VerifyFile(const base::FilePath& path,
                   const std::string& value,
                   const int64_t file_size) {
     std::string file_contents;
 
-    bool read = base::ReadFileToString(path, &file_contents);
-    EXPECT_TRUE(read) << "Failed reading file: " << path.value() << std::endl;
-    if (!read)
-      return false;  // Couldn't read the file.
+    {
+      base::ThreadRestrictions::ScopedAllowIO allow_io_during_test_verification;
+      bool read = base::ReadFileToString(path, &file_contents);
+      EXPECT_TRUE(read) << "Failed reading file: " << path.value() << std::endl;
+      if (!read)
+        return false;  // Couldn't read the file.
+    }
 
     // Note: we don't handle really large files (more than size_t can hold)
     // so we will fail in that case.
     size_t expected_size = static_cast<size_t>(file_size);
 
     // Check the size.
     EXPECT_EQ(expected_size, file_contents.size());
     if (expected_size != file_contents.size())
       return false;
 
     // Check the contents.
     EXPECT_EQ(value, file_contents);
     if (memcmp(file_contents.c_str(), value.c_str(), expected_size) != 0)
       return false;
 
     return true;
   }
 
   // Start a download and return the item.
   DownloadItem* StartDownloadAndReturnItem(Shell* shell, GURL url) {
     std::unique_ptr<DownloadCreateObserver> observer(
         new DownloadCreateObserver(DownloadManagerForShell(shell)));
     shell->LoadURL(url);
     return observer->WaitForFinished();
   }
 
+  static bool PathExists(const base::FilePath& path) {
+    base::ThreadRestrictions::ScopedAllowIO allow_io_during_test_verification;
+    return base::PathExists(path);
+  }
+
   static void ReadAndVerifyFileContents(int seed,
                                         int64_t expected_size,
                                         const base::FilePath& path) {
+    base::ThreadRestrictions::ScopedAllowIO allow_io_during_test_verification;
     base::File file(path, base::File::FLAG_OPEN | base::File::FLAG_READ);
     ASSERT_TRUE(file.IsValid());
     int64_t file_length = file.GetLength();
     ASSERT_EQ(expected_size, file_length);
 
     const int64_t kBufferSize = 64 * 1024;
     std::vector<char> pattern;
     std::vector<char> data;
     pattern.resize(kBufferSize);
     data.resize(kBufferSize);
@@ skipping 678 matching lines @@
   TestDownloadRequestHandler::Parameters parameters =
       TestDownloadRequestHandler::Parameters::WithSingleInterruption();
 
   TestDownloadRequestHandler request_handler;
   request_handler.StartServing(parameters);
   DownloadItem* download =
       StartDownloadAndReturnItem(shell(), request_handler.url());
   WaitForInterrupt(download);
 
   // Delete the intermediate file.
-  ASSERT_TRUE(base::PathExists(download->GetFullPath()));
-  ASSERT_TRUE(base::DeleteFile(download->GetFullPath(), false));
+  {
+    base::ThreadRestrictions::ScopedAllowIO allow_io_for_testing;
+    ASSERT_TRUE(PathExists(download->GetFullPath()));
+    ASSERT_TRUE(base::DeleteFile(download->GetFullPath(), false));
+  }
 
   parameters.ClearInjectedErrors();
   request_handler.StartServing(parameters);
 
   download->Resume();
   WaitForCompletion(download);
 
   ASSERT_EQ(parameters.size, download->GetReceivedBytes());
   ASSERT_EQ(parameters.size, download->GetTotalBytes());
   ASSERT_NO_FATAL_FAILURE(ReadAndVerifyFileContents(
@@ skipping 180 matching lines @@
   TestDownloadRequestHandler request_handler;
   request_handler.StartServing(
       TestDownloadRequestHandler::Parameters::WithSingleInterruption());
 
   DownloadItem* download =
       StartDownloadAndReturnItem(shell(), request_handler.url());
   WaitForInterrupt(download);
 
   base::FilePath intermediate_path = download->GetFullPath();
   ASSERT_FALSE(intermediate_path.empty());
-  ASSERT_TRUE(base::PathExists(intermediate_path));
+  ASSERT_TRUE(PathExists(intermediate_path));
 
   download->Cancel(true /* user_cancel */);
   RunAllPendingInMessageLoop(BrowserThread::FILE);
   RunAllPendingInMessageLoop();
 
   // The intermediate file should now be gone.
-  EXPECT_FALSE(base::PathExists(intermediate_path));
+  EXPECT_FALSE(PathExists(intermediate_path));
   EXPECT_TRUE(download->GetFullPath().empty());
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadContentTest, RemoveInterruptedDownload) {
   TestDownloadRequestHandler request_handler;
   request_handler.StartServing(
       TestDownloadRequestHandler::Parameters::WithSingleInterruption());
 
   DownloadItem* download =
       StartDownloadAndReturnItem(shell(), request_handler.url());
   WaitForInterrupt(download);
 
   base::FilePath intermediate_path = download->GetFullPath();
   ASSERT_FALSE(intermediate_path.empty());
-  ASSERT_TRUE(base::PathExists(intermediate_path));
+  ASSERT_TRUE(PathExists(intermediate_path));
 
   download->Remove();
   RunAllPendingInMessageLoop(BrowserThread::FILE);
   RunAllPendingInMessageLoop();
 
   // The intermediate file should now be gone.
-  EXPECT_FALSE(base::PathExists(intermediate_path));
+  EXPECT_FALSE(PathExists(intermediate_path));
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadContentTest, RemoveCompletedDownload) {
   // A completed download shouldn't delete the downloaded file when it is
   // removed.
   TestDownloadRequestHandler request_handler;
   request_handler.StartServing(TestDownloadRequestHandler::Parameters());
   std::unique_ptr<DownloadTestObserver> completion_observer(
       CreateWaiter(shell(), 1));
   DownloadItem* download(
       StartDownloadAndReturnItem(shell(), request_handler.url()));
   completion_observer->WaitForFinished();
 
   // The target path should exist.
   base::FilePath target_path(download->GetTargetFilePath());
-  EXPECT_TRUE(base::PathExists(target_path));
+  EXPECT_TRUE(PathExists(target_path));
   download->Remove();
   RunAllPendingInMessageLoop(BrowserThread::FILE);
   RunAllPendingInMessageLoop();
 
   // The file should still exist.
-  EXPECT_TRUE(base::PathExists(target_path));
+  EXPECT_TRUE(PathExists(target_path));
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadContentTest, RemoveResumingDownload) {
   TestDownloadRequestHandler::Parameters parameters =
       TestDownloadRequestHandler::Parameters::WithSingleInterruption();
   TestDownloadRequestHandler request_handler;
   request_handler.StartServing(parameters);
 
   DownloadItem* download =
       StartDownloadAndReturnItem(shell(), request_handler.url());
   WaitForInterrupt(download);
 
   base::FilePath intermediate_path(download->GetFullPath());
   ASSERT_FALSE(intermediate_path.empty());
-  EXPECT_TRUE(base::PathExists(intermediate_path));
+  EXPECT_TRUE(PathExists(intermediate_path));
 
   // Resume and remove download. We expect only a single OnDownloadCreated()
   // call, and that's for the second download created below.
   MockDownloadManagerObserver dm_observer(DownloadManagerForShell(shell()));
   EXPECT_CALL(dm_observer, OnDownloadCreated(_,_)).Times(1);
 
   TestRequestStartHandler request_start_handler;
   parameters.on_start_handler = request_start_handler.GetOnStartHandler();
   request_handler.StartServing(parameters);
 
   download->Resume();
   request_start_handler.WaitForCallback();
 
   // At this point, the download resumption request has been sent out, but the
   // reponse hasn't been received yet.
   download->Remove();
 
   request_start_handler.RespondWith(std::string(), net::OK);
 
   // The intermediate file should now be gone.
   RunAllPendingInMessageLoop(BrowserThread::FILE);
   RunAllPendingInMessageLoop();
-  EXPECT_FALSE(base::PathExists(intermediate_path));
+  EXPECT_FALSE(PathExists(intermediate_path));
 
   parameters.ClearInjectedErrors();
   parameters.on_start_handler.Reset();
   request_handler.StartServing(parameters);
 
   // Start the second download and wait until it's done. This exercises the
   // entire downloads stack and effectively flushes all of our worker threads.
   // We are testing whether the URL request created in the previous
   // DownloadItem::Resume() call reulted in a new download or not.
   NavigateToURLAndWaitForDownload(shell(), request_handler.url(),
                                   DownloadItem::COMPLETE);
   EXPECT_TRUE(EnsureNoPendingDownloads());
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadContentTest, CancelResumingDownload) {
   TestDownloadRequestHandler::Parameters parameters =
       TestDownloadRequestHandler::Parameters::WithSingleInterruption();
   TestDownloadRequestHandler request_handler;
   request_handler.StartServing(parameters);
 
   DownloadItem* download =
       StartDownloadAndReturnItem(shell(), request_handler.url());
   WaitForInterrupt(download);
 
   base::FilePath intermediate_path(download->GetFullPath());
   ASSERT_FALSE(intermediate_path.empty());
-  EXPECT_TRUE(base::PathExists(intermediate_path));
+  EXPECT_TRUE(PathExists(intermediate_path));
 
   // Resume and cancel download. We expect only a single OnDownloadCreated()
   // call, and that's for the second download created below.
   MockDownloadManagerObserver dm_observer(DownloadManagerForShell(shell()));
   EXPECT_CALL(dm_observer, OnDownloadCreated(_,_)).Times(1);
 
   TestRequestStartHandler request_start_handler;
   parameters.on_start_handler = request_start_handler.GetOnStartHandler();
   request_handler.StartServing(parameters);
 
   download->Resume();
   request_start_handler.WaitForCallback();
 
   // At this point, the download item has initiated a network request for the
   // resumption attempt, but hasn't received a response yet.
   download->Cancel(true /* user_cancel */);
 
   request_start_handler.RespondWith(std::string(), net::OK);
 
   // The intermediate file should now be gone.
   RunAllPendingInMessageLoop(BrowserThread::IO);
   RunAllPendingInMessageLoop(BrowserThread::FILE);
   RunAllPendingInMessageLoop();
-  EXPECT_FALSE(base::PathExists(intermediate_path));
+  EXPECT_FALSE(PathExists(intermediate_path));
 
   parameters.ClearInjectedErrors();
   parameters.on_start_handler.Reset();
   request_handler.StartServing(parameters);
 
   // Start the second download and wait until it's done. This exercises the
   // entire downloads stack and effectively flushes all of our worker threads.
   // We are testing whether the URL request created in the previous
   // DownloadItem::Resume() call reulted in a new download or not.
   NavigateToURLAndWaitForDownload(shell(), request_handler.url(),
                                   DownloadItem::COMPLETE);
   EXPECT_TRUE(EnsureNoPendingDownloads());
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadContentTest, RemoveResumedDownload) {
   TestDownloadRequestHandler::Parameters parameters =
       TestDownloadRequestHandler::Parameters::WithSingleInterruption();
   TestDownloadRequestHandler request_handler;
   request_handler.StartServing(parameters);
 
   DownloadItem* download =
       StartDownloadAndReturnItem(shell(), request_handler.url());
   WaitForInterrupt(download);
 
   base::FilePath intermediate_path(download->GetFullPath());
   base::FilePath target_path(download->GetTargetFilePath());
   ASSERT_FALSE(intermediate_path.empty());
-  EXPECT_TRUE(base::PathExists(intermediate_path));
-  EXPECT_FALSE(base::PathExists(target_path));
+  EXPECT_TRUE(PathExists(intermediate_path));
+  EXPECT_FALSE(PathExists(target_path));
 
   // Resume and remove download. We don't expect OnDownloadCreated() calls.
   MockDownloadManagerObserver dm_observer(DownloadManagerForShell(shell()));
   EXPECT_CALL(dm_observer, OnDownloadCreated(_, _)).Times(0);
 
   download->Resume();
   WaitForInProgress(download);
 
   download->Remove();
 
   // The intermediate file should now be gone.
   RunAllPendingInMessageLoop(BrowserThread::FILE);
   RunAllPendingInMessageLoop();
-  EXPECT_FALSE(base::PathExists(intermediate_path));
-  EXPECT_FALSE(base::PathExists(target_path));
+  EXPECT_FALSE(PathExists(intermediate_path));
+  EXPECT_FALSE(PathExists(target_path));
   EXPECT_TRUE(EnsureNoPendingDownloads());
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadContentTest, CancelResumedDownload) {
   TestDownloadRequestHandler::Parameters parameters =
       TestDownloadRequestHandler::Parameters::WithSingleInterruption();
   TestDownloadRequestHandler request_handler;
   request_handler.StartServing(parameters);
 
   DownloadItem* download =
       StartDownloadAndReturnItem(shell(), request_handler.url());
   WaitForInterrupt(download);
 
   base::FilePath intermediate_path(download->GetFullPath());
   base::FilePath target_path(download->GetTargetFilePath());
   ASSERT_FALSE(intermediate_path.empty());
-  EXPECT_TRUE(base::PathExists(intermediate_path));
-  EXPECT_FALSE(base::PathExists(target_path));
+  EXPECT_TRUE(PathExists(intermediate_path));
+  EXPECT_FALSE(PathExists(target_path));
 
   // Resume and remove download. We don't expect OnDownloadCreated() calls.
   MockDownloadManagerObserver dm_observer(DownloadManagerForShell(shell()));
   EXPECT_CALL(dm_observer, OnDownloadCreated(_, _)).Times(0);
 
   download->Resume();
   WaitForInProgress(download);
 
   download->Cancel(true);
 
   // The intermediate file should now be gone.
   RunAllPendingInMessageLoop(BrowserThread::FILE);
   RunAllPendingInMessageLoop();
-  EXPECT_FALSE(base::PathExists(intermediate_path));
-  EXPECT_FALSE(base::PathExists(target_path));
+  EXPECT_FALSE(PathExists(intermediate_path));
+  EXPECT_FALSE(PathExists(target_path));
   EXPECT_TRUE(EnsureNoPendingDownloads());
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadContentTest, ResumeRestoredDownload_NoFile) {
   TestDownloadRequestHandler request_handler;
   TestDownloadRequestHandler::Parameters parameters;
   request_handler.StartServing(parameters);
 
   base::FilePath intermediate_file_path =
       GetDownloadDirectory().AppendASCII("intermediate");
   std::vector<GURL> url_chain;
 
   const int kIntermediateSize = 1331;
   url_chain.push_back(request_handler.url());
 
   DownloadItem* download = DownloadManagerForShell(shell())->CreateDownloadItem(
       "F7FB1F59-7DE1-4845-AFDB-8A688F70F583", 1, intermediate_file_path,
       base::FilePath(), url_chain, GURL(), GURL(), GURL(), GURL(),
       "application/octet-stream", "application/octet-stream", base::Time::Now(),
       base::Time(), parameters.etag, std::string(), kIntermediateSize,
       parameters.size, std::string(), DownloadItem::INTERRUPTED,
       DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
       DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED, false);
 
   download->Resume();
   WaitForCompletion(download);
 
-  EXPECT_FALSE(base::PathExists(intermediate_file_path));
+  EXPECT_FALSE(PathExists(intermediate_file_path));
   ReadAndVerifyFileContents(parameters.pattern_generator_seed,
                             parameters.size,
                             download->GetTargetFilePath());
 
   TestDownloadRequestHandler::CompletedRequests completed_requests;
   request_handler.GetCompletedRequestInfo(&completed_requests);
 
   // There will be two requests. The first one is issued optimistically assuming
   // that the intermediate file exists and matches the size expectations set
   // forth in the download metadata (i.e. assuming that a 1331 byte file exists
@@ skipping 21 matching lines @@
   request_handler.StartServing(parameters);
 
   base::FilePath intermediate_file_path =
       GetDownloadDirectory().AppendASCII("intermediate");
   std::vector<GURL> url_chain;
 
   const int kIntermediateSize = 1331;
   std::vector<char> buffer(kIntermediateSize);
   request_handler.GetPatternBytes(
       parameters.pattern_generator_seed, 0, buffer.size(), buffer.data());
-  ASSERT_EQ(
-      kIntermediateSize,
-      base::WriteFile(intermediate_file_path, buffer.data(), buffer.size()));
+  {
+    base::ThreadRestrictions::ScopedAllowIO allow_io_for_test_setup;
+    ASSERT_EQ(kIntermediateSize, base::WriteFile(intermediate_file_path,
+                                                 buffer.data(), buffer.size()));
+  }
 
   url_chain.push_back(request_handler.url());
 
   DownloadItem* download = DownloadManagerForShell(shell())->CreateDownloadItem(
       "F7FB1F59-7DE1-4845-AFDB-8A688F70F583", 1, intermediate_file_path,
       base::FilePath(), url_chain, GURL(), GURL(), GURL(), GURL(),
       "application/octet-stream", "application/octet-stream", base::Time::Now(),
       base::Time(), parameters.etag, std::string(), kIntermediateSize,
       parameters.size, std::string(), DownloadItem::INTERRUPTED,
       DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
       DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED, false);
 
   download->Resume();
   WaitForCompletion(download);
 
-  EXPECT_FALSE(base::PathExists(intermediate_file_path));
+  EXPECT_FALSE(PathExists(intermediate_file_path));
   ReadAndVerifyFileContents(parameters.pattern_generator_seed,
                             parameters.size,
                             download->GetTargetFilePath());
 
   TestDownloadRequestHandler::CompletedRequests completed_requests;
   request_handler.GetCompletedRequestInfo(&completed_requests);
 
   // There's only one network request issued, and that is for the remainder of
   // the file.
   ASSERT_EQ(1u, completed_requests.size());
   EXPECT_EQ(parameters.size - kIntermediateSize,
             completed_requests[0]->transferred_byte_count);
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadContentTest,
                        ResumeRestoredDownload_EtagMismatch) {
   TestDownloadRequestHandler request_handler;
   TestDownloadRequestHandler::Parameters parameters;
   request_handler.StartServing(parameters);
 
   base::FilePath intermediate_file_path =
       GetDownloadDirectory().AppendASCII("intermediate");
   std::vector<GURL> url_chain;
 
   const int kIntermediateSize = 1331;
   std::vector<char> buffer(kIntermediateSize);
   request_handler.GetPatternBytes(
       parameters.pattern_generator_seed + 1, 0, buffer.size(), buffer.data());
-  ASSERT_EQ(
-      kIntermediateSize,
-      base::WriteFile(intermediate_file_path, buffer.data(), buffer.size()));
+  {
+    base::ThreadRestrictions::ScopedAllowIO allow_io_for_test_setup;
+    ASSERT_EQ(kIntermediateSize, base::WriteFile(intermediate_file_path,
+                                                 buffer.data(), buffer.size()));
+  }
 
   url_chain.push_back(request_handler.url());
 
   DownloadItem* download = DownloadManagerForShell(shell())->CreateDownloadItem(
       "F7FB1F59-7DE1-4845-AFDB-8A688F70F583", 1, intermediate_file_path,
       base::FilePath(), url_chain, GURL(), GURL(), GURL(), GURL(),
       "application/octet-stream", "application/octet-stream", base::Time::Now(),
       base::Time(), "fake-etag", std::string(), kIntermediateSize,
       parameters.size, std::string(), DownloadItem::INTERRUPTED,
       DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
       DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED, false);
 
   download->Resume();
   WaitForCompletion(download);
 
-  EXPECT_FALSE(base::PathExists(intermediate_file_path));
+  EXPECT_FALSE(PathExists(intermediate_file_path));
   ReadAndVerifyFileContents(parameters.pattern_generator_seed,
                             parameters.size,
                             download->GetTargetFilePath());
 
   TestDownloadRequestHandler::CompletedRequests completed_requests;
   request_handler.GetCompletedRequestInfo(&completed_requests);
 
   // There's only one network request issued. The If-Range header allows the
   // server to respond with the entire entity in one go. The existing contents
   // of the file should be discarded, and overwritten by the new contents.
   ASSERT_EQ(1u, completed_requests.size());
   EXPECT_EQ(parameters.size, completed_requests[0]->transferred_byte_count);
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadContentTest,
                        ResumeRestoredDownload_CorrectHash) {
   TestDownloadRequestHandler request_handler;
   TestDownloadRequestHandler::Parameters parameters;
   request_handler.StartServing(parameters);
 
   base::FilePath intermediate_file_path =
       GetDownloadDirectory().AppendASCII("intermediate");
   std::vector<GURL> url_chain;
 
   const int kIntermediateSize = 1331;
   std::vector<char> buffer(kIntermediateSize);
   request_handler.GetPatternBytes(
       parameters.pattern_generator_seed, 0, buffer.size(), buffer.data());
-  ASSERT_EQ(
-      kIntermediateSize,
-      base::WriteFile(intermediate_file_path, buffer.data(), buffer.size()));
+  {
+    base::ThreadRestrictions::ScopedAllowIO allow_io_for_test_setup;
+    ASSERT_EQ(kIntermediateSize, base::WriteFile(intermediate_file_path,
+                                                 buffer.data(), buffer.size()));
+  }
   // SHA-256 hash of the pattern bytes in buffer.
   static const uint8_t kPartialHash[] = {
       0x77, 0x14, 0xfd, 0x83, 0x06, 0x15, 0x10, 0x7a, 0x47, 0x15, 0xd3,
       0xcf, 0xdd, 0x46, 0xa2, 0x61, 0x96, 0xff, 0xc3, 0xbb, 0x49, 0x30,
       0xaf, 0x31, 0x3a, 0x64, 0x0b, 0xd5, 0xfa, 0xb1, 0xe3, 0x81};
 
   url_chain.push_back(request_handler.url());
 
   DownloadItem* download = DownloadManagerForShell(shell())->CreateDownloadItem(
       "F7FB1F59-7DE1-4845-AFDB-8A688F70F583", 1, intermediate_file_path,
       base::FilePath(), url_chain, GURL(), GURL(), GURL(), GURL(),
       "application/octet-stream", "application/octet-stream", base::Time::Now(),
       base::Time(), parameters.etag, std::string(), kIntermediateSize,
       parameters.size,
       std::string(std::begin(kPartialHash), std::end(kPartialHash)),
       DownloadItem::INTERRUPTED, DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
       DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED, false);
 
   download->Resume();
   WaitForCompletion(download);
 
-  EXPECT_FALSE(base::PathExists(intermediate_file_path));
+  EXPECT_FALSE(PathExists(intermediate_file_path));
   ReadAndVerifyFileContents(parameters.pattern_generator_seed,
                             parameters.size,
                             download->GetTargetFilePath());
 
   TestDownloadRequestHandler::CompletedRequests completed_requests;
   request_handler.GetCompletedRequestInfo(&completed_requests);
 
   // There's only one network request issued, and that is for the remainder of
   // the file.
   ASSERT_EQ(1u, completed_requests.size());
@@ skipping 13 matching lines @@
   TestDownloadRequestHandler request_handler;
   TestDownloadRequestHandler::Parameters parameters;
   request_handler.StartServing(parameters);
 
   base::FilePath intermediate_file_path =
       GetDownloadDirectory().AppendASCII("intermediate");
   std::vector<GURL> url_chain;
 
   const int kIntermediateSize = 1331;
   std::vector<char> buffer(kIntermediateSize);
-  ASSERT_EQ(
-      kIntermediateSize,
-      base::WriteFile(intermediate_file_path, buffer.data(), buffer.size()));
+  {
+    base::ThreadRestrictions::ScopedAllowIO allow_io_for_test_setup;
+    ASSERT_EQ(kIntermediateSize, base::WriteFile(intermediate_file_path,
+                                                 buffer.data(), buffer.size()));
+  }
   // SHA-256 hash of the expected pattern bytes in buffer. This doesn't match
   // the current contents of the intermediate file which should all be 0.
   static const uint8_t kPartialHash[] = {
       0x77, 0x14, 0xfd, 0x83, 0x06, 0x15, 0x10, 0x7a, 0x47, 0x15, 0xd3,
       0xcf, 0xdd, 0x46, 0xa2, 0x61, 0x96, 0xff, 0xc3, 0xbb, 0x49, 0x30,
       0xaf, 0x31, 0x3a, 0x64, 0x0b, 0xd5, 0xfa, 0xb1, 0xe3, 0x81};
 
   url_chain.push_back(request_handler.url());
 
   DownloadItem* download = DownloadManagerForShell(shell())->CreateDownloadItem(
       "F7FB1F59-7DE1-4845-AFDB-8A688F70F583", 1, intermediate_file_path,
       base::FilePath(), url_chain, GURL(), GURL(), GURL(), GURL(),
       "application/octet-stream", "application/octet-stream", base::Time::Now(),
       base::Time(), parameters.etag, std::string(), kIntermediateSize,
       parameters.size,
       std::string(std::begin(kPartialHash), std::end(kPartialHash)),
       DownloadItem::INTERRUPTED, DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
       DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED, false);
 
   download->Resume();
   WaitForCompletion(download);
 
-  EXPECT_FALSE(base::PathExists(intermediate_file_path));
+  EXPECT_FALSE(PathExists(intermediate_file_path));
   ReadAndVerifyFileContents(parameters.pattern_generator_seed,
                             parameters.size,
                             download->GetTargetFilePath());
 
   TestDownloadRequestHandler::CompletedRequests completed_requests;
   request_handler.GetCompletedRequestInfo(&completed_requests);
 
   // There will be two requests. The first one is issued optimistically assuming
   // that the intermediate file exists and matches the size expectations set
   // forth in the download metadata (i.e. assuming that a 1331 byte file exists
@@ skipping 29 matching lines @@
 
   base::FilePath intermediate_file_path =
       GetDownloadDirectory().AppendASCII("intermediate");
   std::vector<GURL> url_chain;
 
   const int kIntermediateSize = 1331;
   // Size of file is slightly shorter than the size known to DownloadItem.
   std::vector<char> buffer(kIntermediateSize - 100);
   request_handler.GetPatternBytes(
       parameters.pattern_generator_seed, 0, buffer.size(), buffer.data());
-  ASSERT_EQ(
-      kIntermediateSize - 100,
-      base::WriteFile(intermediate_file_path, buffer.data(), buffer.size()));
+  {
+    base::ThreadRestrictions::ScopedAllowIO allow_io_for_test_setup;
+    ASSERT_EQ(
+        kIntermediateSize - 100,
+        base::WriteFile(intermediate_file_path, buffer.data(), buffer.size()));
+  }
   url_chain.push_back(request_handler.url());
 
   DownloadItem* download = DownloadManagerForShell(shell())->CreateDownloadItem(
       "F7FB1F59-7DE1-4845-AFDB-8A688F70F583", 1, intermediate_file_path,
       base::FilePath(), url_chain, GURL(), GURL(), GURL(), GURL(),
       "application/octet-stream", "application/octet-stream", base::Time::Now(),
       base::Time(), parameters.etag, std::string(), kIntermediateSize,
       parameters.size, std::string(), DownloadItem::INTERRUPTED,
       DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
       DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED, false);
 
   download->Resume();
   WaitForCompletion(download);
 
-  EXPECT_FALSE(base::PathExists(intermediate_file_path));
+  EXPECT_FALSE(PathExists(intermediate_file_path));
   ReadAndVerifyFileContents(parameters.pattern_generator_seed,
                             parameters.size,
                             download->GetTargetFilePath());
 
   TestDownloadRequestHandler::CompletedRequests completed_requests;
   request_handler.GetCompletedRequestInfo(&completed_requests);
 
   // There will be two requests. The first one is issued optimistically assuming
   // that the intermediate file exists and matches the size expectations set
   // forth in the download metadata (i.e. assuming that a 1331 byte file exists
@@ skipping 27 matching lines @@
   request_handler.StartServing(parameters);
 
   base::FilePath intermediate_file_path =
       GetDownloadDirectory().AppendASCII("intermediate");
   std::vector<GURL> url_chain;
 
   // Size of file is slightly longer than the size known to DownloadItem.
   std::vector<char> buffer(kIntermediateSize + 100);
   request_handler.GetPatternBytes(
       parameters.pattern_generator_seed, 0, buffer.size(), buffer.data());
-  ASSERT_EQ(
-      kIntermediateSize + 100,
-      base::WriteFile(intermediate_file_path, buffer.data(), buffer.size()));
+  {
+    base::ThreadRestrictions::ScopedAllowIO allow_io_for_test_setup;
+    ASSERT_EQ(
+        kIntermediateSize + 100,
+        base::WriteFile(intermediate_file_path, buffer.data(), buffer.size()));
+  }
   url_chain.push_back(request_handler.url());
 
   DownloadItem* download = DownloadManagerForShell(shell())->CreateDownloadItem(
       "F7FB1F59-7DE1-4845-AFDB-8A688F70F583", 1, intermediate_file_path,
       base::FilePath(), url_chain, GURL(), GURL(), GURL(), GURL(),
       "application/octet-stream", "application/octet-stream", base::Time::Now(),
       base::Time(), parameters.etag, std::string(), kIntermediateSize,
       parameters.size, std::string(), DownloadItem::INTERRUPTED,
       DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
       DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED, false);
 
   download->Resume();
   WaitForCompletion(download);
 
-  EXPECT_FALSE(base::PathExists(intermediate_file_path));
+  EXPECT_FALSE(PathExists(intermediate_file_path));
   ReadAndVerifyFileContents(parameters.pattern_generator_seed,
                             parameters.size,
                             download->GetTargetFilePath());
 
   TestDownloadRequestHandler::CompletedRequests completed_requests;
   request_handler.GetCompletedRequestInfo(&completed_requests);
 
   // There should be only one request. The intermediate file should be truncated
   // to the expected size, and the request should be issued for the remainder.
   //
@@ skipping 319 matching lines @@
   GURL document_url =
       origin_two.GetURL("/iframe-host.html?target=" + frame_url.spec());
   DownloadItem* download = StartDownloadAndReturnItem(shell(), document_url);
   WaitForCompletion(download);
 
   EXPECT_STREQ(FILE_PATH_LITERAL("download-test.lib"),
                download->GetTargetFilePath().BaseName().value().c_str());
 }
 
 }  // namespace content