Downloads: replace BrowserThread::FILE with task scheduler.

content/browser/download/parallel_download_job_unittest.cc

 // Copyright 2017 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 "content/browser/download/parallel_download_job.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
+#include "base/test/scoped_task_environment.h"
 #include "content/browser/download/download_destination_observer.h"
 #include "content/browser/download/download_file_impl.h"
 #include "content/browser/download/download_item_impl_delegate.h"
+#include "content/browser/download/download_task_runner.h"
 #include "content/browser/download/mock_download_item_impl.h"
 #include "content/browser/download/parallel_download_utils.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::NiceMock;
 using ::testing::StrictMock;
 
@@ skipping 80 matching lines @@
 
  private:
   int request_count_;
   int min_slice_size_;
   int min_remaining_time_;
   DISALLOW_COPY_AND_ASSIGN(ParallelDownloadJobForTest);
 };
 
 class ParallelDownloadJobTest : public testing::Test {
  public:
+  ParallelDownloadJobTest()
+      : task_environment_(
+            base::test::ScopedTaskEnvironment::MainThreadType::UI,
+            base::test::ScopedTaskEnvironment::ExecutionMode::QUEUED) {}
+
   void CreateParallelJob(int64_t initial_request_offset,
                          int64_t content_length,
                          const DownloadItem::ReceivedSlices& slices,
                          int request_count,
                          int64_t min_slice_size,
                          int min_remaining_time) {
     item_delegate_ = base::MakeUnique<DownloadItemImplDelegate>();
     download_item_ = base::MakeUnique<NiceMock<MockDownloadItemImpl>>(
         item_delegate_.get(), slices);
     EXPECT_CALL(*download_item_, GetTotalBytes())
@@ skipping 41 matching lines @@
   void VerifyWorker(int64_t offset, int64_t length) const {
     EXPECT_TRUE(job_->workers_.find(offset) != job_->workers_.end());
     EXPECT_EQ(offset, job_->workers_[offset]->offset());
     EXPECT_EQ(length, job_->workers_[offset]->length());
   }
 
   void OnFileInitialized(DownloadInterruptReason result) {
     file_initialized_ = true;
   }
 
+  base::test::ScopedTaskEnvironment task_environment_;
   content::TestBrowserThreadBundle browser_threads_;
   std::unique_ptr<DownloadItemImplDelegate> item_delegate_;
   std::unique_ptr<MockDownloadItemImpl> download_item_;
   std::unique_ptr<ParallelDownloadJobForTest> job_;
   bool file_initialized_;
   // Request handle for the original request.
   MockDownloadRequestHandle* mock_request_handle_;
 };
 
 // Test if parallel requests can be built correctly for a new download without
@@ skipping 186 matching lines @@
   CreateParallelJob(0, 100, DownloadItem::ReceivedSlices(), 2, 0, 0);
   job_->Start(download_file.get(),
               base::Bind(&ParallelDownloadJobTest::OnFileInitialized,
                          base::Unretained(this)),
               DownloadItem::ReceivedSlices());
   EXPECT_FALSE(file_initialized_);
   EXPECT_EQ(0u, job_->workers().size());
   EXPECT_CALL(*input_stream, RegisterCallback(_));
   EXPECT_CALL(*input_stream, Read(_, _));
   EXPECT_CALL(*(observer.get()), DestinationUpdate(_, _, _));
-  base::RunLoop().RunUntilIdle();
+  task_environment_.RunUntilIdle();
   EXPECT_TRUE(file_initialized_);
   EXPECT_EQ(1u, job_->workers().size());
   DestroyParallelJob();
+
+  // The download file lives on the download sequence, and must
+  // be deleted there.
+  GetDownloadTaskRunner()->DeleteSoon(FROM_HERE, std::move(download_file));
+  task_environment_.RunUntilIdle();
 }
 
 }  // namespace content