Downloads: replace BrowserThread::FILE with task scheduler.

content/browser/download/download_item_impl_unittest.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 "content/browser/download/download_item_impl.h"
 
 #include <stdint.h>
 
 #include <deque>
 #include <iterator>
 #include <map>
 #include <memory>
 #include <queue>
 #include <utility>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/feature_list.h"
 #include "base/files/file_util.h"
 #include "base/memory/ptr_util.h"
-#include "base/message_loop/message_loop.h"
-#include "base/run_loop.h"
+#include "base/test/scoped_task_environment.h"
 #include "base/threading/thread.h"
 #include "content/browser/byte_stream.h"
 #include "content/browser/download/download_create_info.h"
 #include "content/browser/download/download_destination_observer.h"
 #include "content/browser/download/download_file_factory.h"
 #include "content/browser/download/download_item_impl_delegate.h"
 #include "content/browser/download/download_request_handle.h"
 #include "content/browser/download/mock_download_file.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/download_interrupt_reasons.h"
 #include "content/public/browser/download_url_parameters.h"
 #include "content/public/common/content_features.h"
 #include "content/public/test/mock_download_item.h"
 #include "content/public/test/test_browser_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
+#include "content/public/test/test_utils.h"
 #include "content/public/test/web_contents_tester.h"
 #include "crypto/secure_hash.h"
 #include "net/http/http_response_headers.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::DoAll;
 using ::testing::Invoke;
 using ::testing::InvokeWithoutArgs;
 using ::testing::NiceMock;
@@ skipping 202 matching lines @@
 const uint8_t kHashOfTestData1[] = {
     0xd2, 0xfc, 0x16, 0xa1, 0xf5, 0x1a, 0x65, 0x3a, 0xa0, 0x19, 0x64,
     0xef, 0x9c, 0x92, 0x33, 0x36, 0xe1, 0x06, 0x53, 0xfe, 0xc1, 0x95,
     0xf4, 0x93, 0x45, 0x8b, 0x3b, 0x21, 0x89, 0x0e, 0x1b, 0x97};
 
 }  // namespace
 
 class DownloadItemTest : public testing::Test {
  public:
   DownloadItemTest()
-      : delegate_(), next_download_id_(DownloadItem::kInvalidId + 1) {
+      : task_environment_(
+            base::test::ScopedTaskEnvironment::MainThreadType::UI,
+            base::test::ScopedTaskEnvironment::ExecutionMode::QUEUED),
+        next_download_id_(DownloadItem::kInvalidId + 1) {
     create_info_.reset(new DownloadCreateInfo());
     create_info_->save_info =
         std::unique_ptr<DownloadSaveInfo>(new DownloadSaveInfo());
     create_info_->save_info->prompt_for_save_location = false;
     create_info_->url_chain.push_back(GURL("http://example.com/download"));
     create_info_->etag = "SomethingToSatisfyResumption";
   }
 
-  ~DownloadItemTest() {
-    RunAllPendingInMessageLoops();
-  }
-
   DownloadItemImpl* CreateDownloadItemWithCreateInfo(
       std::unique_ptr<DownloadCreateInfo> info) {
     DownloadItemImpl* download =
-        new DownloadItemImpl(&delegate_, next_download_id_++, *(info.get()),
-                             net::NetLogWithSource());
+        new DownloadItemImpl(mock_delegate(), next_download_id_++,
+                             *(info.get()), net::NetLogWithSource());
     allocated_downloads_[download] = base::WrapUnique(download);
     return download;
   }
 
   // Creates a new net::HttpResponseHeaders object for the |response_code|.
   scoped_refptr<const net::HttpResponseHeaders> CreateResponseHeaders(
       int response_code) {
     return make_scoped_refptr(new net::HttpResponseHeaders(
         "HTTP/1.1 " + std::to_string(response_code)));
   }
 
   // This class keeps ownership of the created download item; it will
   // be torn down at the end of the test unless DestroyDownloadItem is
   // called.
   DownloadItemImpl* CreateDownloadItem() {
     create_info_->download_id = ++next_download_id_;
     DownloadItemImpl* download =
-        new DownloadItemImpl(&delegate_, create_info_->download_id,
+        new DownloadItemImpl(mock_delegate(), create_info_->download_id,
                              *create_info_, net::NetLogWithSource());
     allocated_downloads_[download] = base::WrapUnique(download);
     return download;
   }
 
   // Add DownloadFile to DownloadItem.
   MockDownloadFile* CallDownloadItemStart(DownloadItemImpl* item,
                                           DownloadTargetCallback* callback) {
     MockDownloadFile* mock_download_file = nullptr;
     std::unique_ptr<DownloadFile> download_file;
     EXPECT_CALL(*mock_delegate(), DetermineDownloadTarget(item, _))
         .WillOnce(SaveArg<1>(callback));
 
     // Only create a DownloadFile if the request was successful.
     if (create_info_->result == DOWNLOAD_INTERRUPT_REASON_NONE) {
       mock_download_file = new StrictMock<MockDownloadFile>;
       download_file.reset(mock_download_file);
       EXPECT_CALL(*mock_download_file, Initialize(_, _, _, _))
           .WillOnce(ScheduleCallbackWithParam(DOWNLOAD_INTERRUPT_REASON_NONE));
       EXPECT_CALL(*mock_download_file, FullPath())
           .WillRepeatedly(ReturnRefOfCopy(base::FilePath()));
     }
 
     std::unique_ptr<MockRequestHandle> request_handle =
         base::MakeUnique<NiceMock<MockRequestHandle>>();
     item->Start(std::move(download_file), std::move(request_handle),
                 *create_info_);
-    RunAllPendingInMessageLoops();
+    task_environment_.RunUntilIdle();
 
     // So that we don't have a function writing to a stack variable
     // lying around if the above failed.
     mock_delegate()->VerifyAndClearExpectations();
     EXPECT_CALL(*mock_delegate(), AssertStateConsistent(_))
         .WillRepeatedly(Return());
     EXPECT_CALL(*mock_delegate(), ShouldOpenFileBasedOnExtension(_))
         .WillRepeatedly(Return(false));
     EXPECT_CALL(*mock_delegate(), ShouldOpenDownload(_, _))
         .WillRepeatedly(Return(true));
@@ skipping 11 matching lines @@
     DownloadTargetCallback callback;
     MockDownloadFile* download_file = CallDownloadItemStart(item, &callback);
     base::FilePath target_path(kDummyTargetPath);
     base::FilePath intermediate_path(kDummyIntermediatePath);
     EXPECT_CALL(*download_file, RenameAndUniquify(intermediate_path, _))
         .WillOnce(ScheduleRenameAndUniquifyCallback(
             DOWNLOAD_INTERRUPT_REASON_NONE, intermediate_path));
     callback.Run(target_path, DownloadItem::TARGET_DISPOSITION_OVERWRITE,
                  danger_type, intermediate_path,
                  DOWNLOAD_INTERRUPT_REASON_NONE);
-    RunAllPendingInMessageLoops();
+    task_environment_.RunUntilIdle();
     return download_file;
   }
 
   void DoDestinationComplete(DownloadItemImpl* item,
                              MockDownloadFile* download_file) {
     EXPECT_CALL(*mock_delegate(), ShouldCompleteDownload(_, _))
         .WillOnce(Return(true));
     base::FilePath final_path(kDummyTargetPath);
     EXPECT_CALL(*download_file, RenameAndAnnotate(_, _, _, _, _))
         .WillOnce(ScheduleRenameAndAnnotateCallback(
             DOWNLOAD_INTERRUPT_REASON_NONE, final_path));
     EXPECT_CALL(*download_file, FullPath())
         .WillRepeatedly(ReturnRefOfCopy(base::FilePath(kDummyTargetPath)));
     EXPECT_CALL(*download_file, Detach());
 
     item->DestinationObserverAsWeakPtr()->DestinationCompleted(
         0, std::unique_ptr<crypto::SecureHash>());
-    RunAllPendingInMessageLoops();
+    task_environment_.RunUntilIdle();
   }
 
   // Cleanup a download item (specifically get rid of the DownloadFile on it).
   // The item must be in the expected state.
   void CleanupItem(DownloadItemImpl* item,
                    MockDownloadFile* download_file,
                    DownloadItem::DownloadState expected_state) {
     EXPECT_EQ(expected_state, item->GetState());
 
     if (expected_state == DownloadItem::IN_PROGRESS) {
       if (download_file)
         EXPECT_CALL(*download_file, Cancel());
       item->Cancel(true);
-      RunAllPendingInMessageLoops();
+      task_environment_.RunUntilIdle();
     }
   }
 
   // Destroy a previously created download item.
   void DestroyDownloadItem(DownloadItem* item) {
     allocated_downloads_.erase(item);
   }
 
-  void RunAllPendingInMessageLoops() { base::RunLoop().RunUntilIdle(); }
-
-  MockDelegate* mock_delegate() {
-    return &delegate_;
-  }
+  MockDelegate* mock_delegate() { return &mock_delegate_; }
 
   void OnDownloadFileAcquired(base::FilePath* return_path,
                               const base::FilePath& path) {
     *return_path = path;
   }
 
   DownloadCreateInfo* create_info() { return create_info_.get(); }
 
   BrowserContext* browser_context() { return &browser_context_; }
 
+  base::test::ScopedTaskEnvironment task_environment_;
+
  private:
   TestBrowserThreadBundle thread_bundle_;
-  StrictMock<MockDelegate> delegate_;
+  StrictMock<MockDelegate> mock_delegate_;
   std::map<DownloadItem*, std::unique_ptr<DownloadItem>> allocated_downloads_;
   std::unique_ptr<DownloadCreateInfo> create_info_;
   uint32_t next_download_id_ = DownloadItem::kInvalidId + 1;
   TestBrowserContext browser_context_;
 };
 
 // Tests to ensure calls that change a DownloadItem generate an update to
 // observers.
 // State changing functions not tested:
 //  void OpenDownload();
@@ skipping 159 matching lines @@
   EXPECT_CALL(*download_file, RenameAndUniquify(intermediate_path, _))
       .WillOnce(ScheduleRenameAndUniquifyCallback(
           DOWNLOAD_INTERRUPT_REASON_NONE, new_intermediate_path));
 
   // Currently, a notification would be generated if the danger type is anything
   // other than NOT_DANGEROUS.
   callback.Run(target_path, DownloadItem::TARGET_DISPOSITION_OVERWRITE,
                DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS, intermediate_path,
                DOWNLOAD_INTERRUPT_REASON_NONE);
   EXPECT_FALSE(observer.CheckAndResetDownloadUpdated());
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
   EXPECT_TRUE(observer.CheckAndResetDownloadUpdated());
   EXPECT_EQ(new_intermediate_path, item->GetFullPath());
 
   CleanupItem(item, download_file, DownloadItem::IN_PROGRESS);
 }
 
 TEST_F(DownloadItemTest, NotificationAfterTogglePause) {
   DownloadItemImpl* item = CreateDownloadItem();
   TestDownloadItemObserver observer(item);
   MockDownloadFile* mock_download_file(new MockDownloadFile);
   std::unique_ptr<DownloadFile> download_file(mock_download_file);
   std::unique_ptr<DownloadRequestHandleInterface> request_handle(
       new NiceMock<MockRequestHandle>);
 
   EXPECT_CALL(*mock_download_file, Initialize(_, _, _, _));
   EXPECT_CALL(*mock_delegate(), DetermineDownloadTarget(_, _));
   item->Start(std::move(download_file), std::move(request_handle),
               *create_info());
 
   item->Pause();
   ASSERT_TRUE(observer.CheckAndResetDownloadUpdated());
 
   ASSERT_TRUE(item->IsPaused());
 
   item->Resume();
   ASSERT_TRUE(observer.CheckAndResetDownloadUpdated());
 
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
 
   CleanupItem(item, mock_download_file, DownloadItem::IN_PROGRESS);
 }
 
 // Test that a download is resumed automatically after a continuable interrupt.
 TEST_F(DownloadItemTest, AutomaticResumption_Continue) {
   DownloadItemImpl* item = CreateDownloadItem();
   TestDownloadItemObserver observer(item);
   MockDownloadFile* download_file =
       DoIntermediateRename(item, DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS);
@@ skipping 22 matching lines @@
   ASSERT_TRUE(observer.CheckAndResetDownloadUpdated());
   // Since the download is resumed automatically, the interrupt count doesn't
   // increase.
   ASSERT_EQ(0, observer.interrupt_count());
 
   // Test expectations verify that ResumeInterruptedDownload() is called (by way
   // of MockResumeInterruptedDownload) after the download is interrupted. But
   // the mock doesn't follow through with the resumption.
   // ResumeInterruptedDownload() being called is sufficient for verifying that
   // the automatic resumption was triggered.
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
 
   // The download item is currently in RESUMING_INTERNAL state, which maps to
   // IN_PROGRESS.
   CleanupItem(item, nullptr, DownloadItem::IN_PROGRESS);
 }
 
 // Automatic resumption should restart and discard the intermediate file if the
 // interrupt reason requires it.
 TEST_F(DownloadItemTest, AutomaticResumption_Restart) {
   DownloadItemImpl* item = CreateDownloadItem();
@@ skipping 13 matching lines @@
                   _));
 
   item->DestinationObserverAsWeakPtr()->DestinationError(
       DOWNLOAD_INTERRUPT_REASON_SERVER_NO_RANGE, 1,
       std::unique_ptr<crypto::SecureHash>());
   ASSERT_TRUE(observer.CheckAndResetDownloadUpdated());
 
   // Since the download is resumed automatically, the interrupt count doesn't
   // increase.
   ASSERT_EQ(0, observer.interrupt_count());
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
 
   CleanupItem(item, nullptr, DownloadItem::IN_PROGRESS);
 }
 
 // Test that automatic resumption doesn't happen after an interrupt that
 // requires user action to resolve.
 TEST_F(DownloadItemTest, AutomaticResumption_NeedsUserAction) {
   DownloadItemImpl* item = CreateDownloadItem();
   TestDownloadItemObserver observer(item);
   MockDownloadFile* download_file =
       DoIntermediateRename(item, DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS);
 
   // Interrupt the download, using a restartable interrupt.
   EXPECT_CALL(*download_file, Cancel());
   item->DestinationObserverAsWeakPtr()->DestinationError(
       DOWNLOAD_INTERRUPT_REASON_FILE_FAILED, 1,
       std::unique_ptr<crypto::SecureHash>());
   ASSERT_TRUE(observer.CheckAndResetDownloadUpdated());
   // Should not try to auto-resume.
   ASSERT_EQ(1, observer.interrupt_count());
   ASSERT_EQ(0, observer.resume_count());
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
 
   CleanupItem(item, nullptr, DownloadItem::INTERRUPTED);
 }
 
 // Test that a download is resumed automatically after a content length mismatch
 // error.
 TEST_F(DownloadItemTest, AutomaticResumption_ContentLengthMismatch) {
   DownloadItemImpl* item = CreateDownloadItem();
   TestDownloadItemObserver observer(item);
   MockDownloadFile* download_file =
@@ skipping 18 matching lines @@
 
   item->DestinationObserverAsWeakPtr()->DestinationError(
       DOWNLOAD_INTERRUPT_REASON_SERVER_CONTENT_LENGTH_MISMATCH, 1,
       std::unique_ptr<crypto::SecureHash>());
   ASSERT_TRUE(observer.CheckAndResetDownloadUpdated());
   // Since the download is resumed automatically, the observer shouldn't notice
   // the interruption.
   ASSERT_EQ(0, observer.interrupt_count());
   ASSERT_EQ(0, observer.resume_count());
 
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
   CleanupItem(item, nullptr, DownloadItem::IN_PROGRESS);
 }
 
 // Check we do correct cleanup for RESUME_MODE_INVALID interrupts.
 TEST_F(DownloadItemTest, UnresumableInterrupt) {
   DownloadItemImpl* item = CreateDownloadItem();
   TestDownloadItemObserver observer(item);
   MockDownloadFile* download_file =
       DoIntermediateRename(item, DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS);
 
   // Fail final rename with unresumable reason.
   EXPECT_CALL(*mock_delegate(), ShouldCompleteDownload(item, _))
       .WillOnce(Return(true));
   EXPECT_CALL(*download_file,
               RenameAndAnnotate(base::FilePath(kDummyTargetPath), _, _, _, _))
       .WillOnce(ScheduleRenameAndAnnotateCallback(
           DOWNLOAD_INTERRUPT_REASON_FILE_BLOCKED, base::FilePath()));
   EXPECT_CALL(*download_file, Cancel());
 
   // Complete download to trigger final rename.
   item->DestinationObserverAsWeakPtr()->DestinationCompleted(
       0, std::unique_ptr<crypto::SecureHash>());
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
 
   ASSERT_TRUE(observer.CheckAndResetDownloadUpdated());
   // Should not try to auto-resume.
   ASSERT_EQ(1, observer.interrupt_count());
   ASSERT_EQ(0, observer.resume_count());
 
   CleanupItem(item, nullptr, DownloadItem::INTERRUPTED);
 }
 
 TEST_F(DownloadItemTest, AutomaticResumption_AttemptLimit) {
@@ skipping 25 matching lines @@
     mock_download_file_ref = mock_download_file.get();
     mock_request_handle = base::MakeUnique<NiceMock<MockRequestHandle>>();
 
     ON_CALL(*mock_download_file_ref, FullPath())
         .WillByDefault(ReturnRefOfCopy(base::FilePath()));
 
     // Copied key parts of DoIntermediateRename & CallDownloadItemStart
     // to allow for holding onto the request handle.
     item->Start(std::move(mock_download_file), std::move(mock_request_handle),
                 *create_info());
-    RunAllPendingInMessageLoops();
+    task_environment_.RunUntilIdle();
 
     base::FilePath target_path(kDummyTargetPath);
     base::FilePath intermediate_path(kDummyIntermediatePath);
 
     // Target of RenameAndUniquify is always the intermediate path.
     ON_CALL(*mock_download_file_ref, RenameAndUniquify(_, _))
         .WillByDefault(ScheduleRenameAndUniquifyCallback(
             DOWNLOAD_INTERRUPT_REASON_NONE, intermediate_path));
 
     // RenameAndUniquify is only called the first time. In all the subsequent
     // iterations, the intermediate file already has the correct name, hence no
     // rename is necessary.
     EXPECT_CALL(*mock_download_file_ref, RenameAndUniquify(_, _)).Times(i == 0);
 
     ASSERT_FALSE(callback.is_null());
     base::ResetAndReturn(&callback).Run(
         target_path, DownloadItem::TARGET_DISPOSITION_OVERWRITE,
         DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS, intermediate_path,
         DOWNLOAD_INTERRUPT_REASON_NONE);
-    RunAllPendingInMessageLoops();
+    task_environment_.RunUntilIdle();
 
     // Use a continuable interrupt.
     EXPECT_CALL(*mock_download_file_ref, Cancel()).Times(0);
     item->DestinationObserverAsWeakPtr()->DestinationError(
         DOWNLOAD_INTERRUPT_REASON_FILE_TRANSIENT_ERROR, 1,
         std::unique_ptr<crypto::SecureHash>());
 
-    RunAllPendingInMessageLoops();
+    task_environment_.RunUntilIdle();
     ::testing::Mock::VerifyAndClearExpectations(mock_download_file_ref);
   }
 
   EXPECT_EQ(DownloadItem::INTERRUPTED, item->GetState());
   EXPECT_EQ(1, observer.interrupt_count());
   CleanupItem(item, nullptr, DownloadItem::INTERRUPTED);
 }
 
 // If the download attempts to resume and the resumption request fails, the
 // subsequent Start() call shouldn't update the origin state (URL redirect
@@ skipping 27 matching lines @@
               MockResumeInterruptedDownload(
                   AllOf(Property(&DownloadUrlParameters::file_path,
                                  Property(&base::FilePath::value,
                                           kDummyIntermediatePath)),
                         Property(&DownloadUrlParameters::offset, 1)),
                   _));
   EXPECT_CALL(*download_file, Detach());
   item->DestinationObserverAsWeakPtr()->DestinationError(
       DOWNLOAD_INTERRUPT_REASON_FILE_TRANSIENT_ERROR, 1,
       std::unique_ptr<crypto::SecureHash>());
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
   EXPECT_EQ(DownloadItem::IN_PROGRESS, item->GetState());
 
   // Now change the create info. The changes should not cause the DownloadItem
   // to be updated.
   constexpr int kSecondResponseCode = 418;
   const char kSecondContentDisposition[] = "attachment; filename=bar";
   const char kSecondETag[] = "123";
   const char kSecondLastModified[] = "Today";
   const char kSecondURL[] = "http://example.com/another-download";
   const char kSecondMimeType[] = "text/html";
@@ skipping 11 matching lines @@
   // Calling Start() with a response indicating failure shouldn't cause a target
   // update, nor should it result in discarding the intermediate file.
   DownloadTargetCallback target_callback;
   download_file = CallDownloadItemStart(item, &target_callback);
   ASSERT_FALSE(target_callback.is_null());
   target_callback.Run(base::FilePath(kDummyTargetPath),
                       DownloadItem::TARGET_DISPOSITION_OVERWRITE,
                       DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
                       base::FilePath(kDummyIntermediatePath),
                       DOWNLOAD_INTERRUPT_REASON_NONE);
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
 
   ASSERT_TRUE(item->GetResponseHeaders());
   EXPECT_EQ(kFirstResponseCode, item->GetResponseHeaders()->response_code());
   EXPECT_EQ(kContentDisposition, item->GetContentDisposition());
   EXPECT_EQ(kFirstETag, item->GetETag());
   EXPECT_EQ(kFirstLastModified, item->GetLastModifiedTime());
   EXPECT_EQ(kFirstURL, item->GetURL().spec());
   EXPECT_EQ(kMimeType, item->GetMimeType());
   EXPECT_EQ(DownloadItem::INTERRUPTED, item->GetState());
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED, item->GetLastReason());
@@ skipping 18 matching lines @@
   create_info()->mime_type = kMimeType;
 
   DownloadItemImpl* item = CreateDownloadItem();
   MockDownloadFile* download_file =
       DoIntermediateRename(item, DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS);
   EXPECT_CALL(*mock_delegate(), MockResumeInterruptedDownload(_, _));
   EXPECT_CALL(*download_file, Detach());
   item->DestinationObserverAsWeakPtr()->DestinationError(
       DOWNLOAD_INTERRUPT_REASON_FILE_TRANSIENT_ERROR, 0,
       std::unique_ptr<crypto::SecureHash>());
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
   EXPECT_EQ(DownloadItem::IN_PROGRESS, item->GetState());
 
   // Now change the create info. The changes should not cause the DownloadItem
   // to be updated.
   constexpr int kSecondResponseCode = 201;
   const char kSecondContentDisposition[] = "attachment; filename=bar";
   const char kSecondETag[] = "123";
   const char kSecondLastModified[] = "Today";
   const char kSecondURL[] = "http://example.com/another-download";
   const char kSecondMimeType[] = "text/html";
@@ skipping 38 matching lines @@
   item->DestinationObserverAsWeakPtr()->DestinationUpdate(10, 100,
                                                           kReceivedSlice);
   EXPECT_EQ(kReceivedSlice, item->GetReceivedSlices());
   EXPECT_EQ(10, item->GetReceivedBytes());
 
   item->DestinationObserverAsWeakPtr()->DestinationError(
       DOWNLOAD_INTERRUPT_REASON_FILE_TRANSIENT_ERROR, 0,
       std::unique_ptr<crypto::SecureHash>());
   EXPECT_EQ(kReceivedSlice, item->GetReceivedSlices());
 
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
 
   // Change the strong validator and resume the download, the received slices
   // should be cleared.
   create_info()->etag = kSecondETag;
   DownloadTargetCallback target_callback;
   download_file = CallDownloadItemStart(item, &target_callback);
   EXPECT_TRUE(item->GetReceivedSlices().empty());
   EXPECT_EQ(0, item->GetReceivedBytes());
 
   CleanupItem(item, download_file, DownloadItem::IN_PROGRESS);
@@ skipping 23 matching lines @@
       .Times(1);
   item->DestinationObserverAsWeakPtr()->DestinationError(
       DOWNLOAD_INTERRUPT_REASON_FILE_TRANSIENT_ERROR, 1,
       std::unique_ptr<crypto::SecureHash>());
 
   // Test expectations verify that ResumeInterruptedDownload() is called (by way
   // of MockResumeInterruptedDownload) after the download is interrupted. But
   // the mock doesn't follow through with the resumption.
   // ResumeInterruptedDownload() being called is sufficient for verifying that
   // the resumption was triggered.
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
 
   // The download is currently in RESUMING_INTERNAL, which maps to IN_PROGRESS.
   CleanupItem(item, nullptr, DownloadItem::IN_PROGRESS);
 }
 
 TEST_F(DownloadItemTest, DisplayName) {
   DownloadItemImpl* item = CreateDownloadItem();
   DownloadTargetCallback callback;
   MockDownloadFile* download_file = CallDownloadItemStart(item, &callback);
   base::FilePath target_path(
       base::FilePath(kDummyTargetPath).AppendASCII("foo.bar"));
   base::FilePath intermediate_path(target_path.InsertBeforeExtensionASCII("x"));
   EXPECT_EQ(FILE_PATH_LITERAL(""),
             item->GetFileNameToReportUser().value());
   EXPECT_CALL(*download_file, RenameAndUniquify(_, _))
       .WillOnce(ScheduleRenameAndUniquifyCallback(
           DOWNLOAD_INTERRUPT_REASON_NONE, intermediate_path));
   callback.Run(target_path, DownloadItem::TARGET_DISPOSITION_OVERWRITE,
                DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS, intermediate_path,
                DOWNLOAD_INTERRUPT_REASON_NONE);
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
   EXPECT_EQ(FILE_PATH_LITERAL("foo.bar"),
             item->GetFileNameToReportUser().value());
   item->SetDisplayName(base::FilePath(FILE_PATH_LITERAL("new.name")));
   EXPECT_EQ(FILE_PATH_LITERAL("new.name"),
             item->GetFileNameToReportUser().value());
   CleanupItem(item, download_file, DownloadItem::IN_PROGRESS);
 }
 
 // Test to make sure that Start method calls DF initialize properly.
 TEST_F(DownloadItemTest, Start) {
   MockDownloadFile* mock_download_file(new MockDownloadFile);
   std::unique_ptr<DownloadFile> download_file(mock_download_file);
   DownloadItemImpl* item = CreateDownloadItem();
   EXPECT_CALL(*mock_download_file, Initialize(_, _, _, _));
   std::unique_ptr<DownloadRequestHandleInterface> request_handle(
       new NiceMock<MockRequestHandle>);
   EXPECT_CALL(*mock_delegate(), DetermineDownloadTarget(item, _));
   item->Start(std::move(download_file), std::move(request_handle),
               *create_info());
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
 
   CleanupItem(item, mock_download_file, DownloadItem::IN_PROGRESS);
 }
 
 // Download file and the request should be cancelled as a result of download
 // file initialization failing.
 TEST_F(DownloadItemTest, InitDownloadFileFails) {
   DownloadItemImpl* item = CreateDownloadItem();
   std::unique_ptr<MockDownloadFile> file = base::MakeUnique<MockDownloadFile>();
   std::unique_ptr<MockRequestHandle> request_handle =
       base::MakeUnique<MockRequestHandle>();
 
   EXPECT_CALL(*file, Cancel());
   EXPECT_CALL(*request_handle, CancelRequest(_));
   EXPECT_CALL(*file, Initialize(_, _, _, _))
       .WillOnce(ScheduleCallbackWithParam(
           DOWNLOAD_INTERRUPT_REASON_FILE_ACCESS_DENIED));
 
-  base::RunLoop start_download_loop;
   DownloadTargetCallback download_target_callback;
   EXPECT_CALL(*mock_delegate(), DetermineDownloadTarget(item, _))
-      .WillOnce(DoAll(SaveArg<1>(&download_target_callback),
-                      ScheduleClosure(start_download_loop.QuitClosure())));
+      .WillOnce(SaveArg<1>(&download_target_callback));
 
   item->Start(std::move(file), std::move(request_handle), *create_info());
-  start_download_loop.Run();
+  task_environment_.RunUntilIdle();
 
   download_target_callback.Run(base::FilePath(kDummyTargetPath),
                                DownloadItem::TARGET_DISPOSITION_OVERWRITE,
                                DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
                                base::FilePath(kDummyIntermediatePath),
                                DOWNLOAD_INTERRUPT_REASON_NONE);
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
 
   EXPECT_EQ(DownloadItem::INTERRUPTED, item->GetState());
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_FILE_ACCESS_DENIED,
             item->GetLastReason());
   EXPECT_FALSE(item->GetTargetFilePath().empty());
   EXPECT_TRUE(item->GetFullPath().empty());
 }
 
 // Handling of downloads initiated via a failed request. In this case, Start()
 // will get called with a DownloadCreateInfo with a non-zero interrupt_reason.
 TEST_F(DownloadItemTest, StartFailedDownload) {
   create_info()->result = DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED;
   DownloadItemImpl* item = CreateDownloadItem();
 
   // DownloadFile and DownloadRequestHandleInterface objects aren't created for
   // failed downloads.
   std::unique_ptr<DownloadFile> null_download_file;
   std::unique_ptr<DownloadRequestHandleInterface> null_request_handle;
   DownloadTargetCallback download_target_callback;
   EXPECT_CALL(*mock_delegate(), DetermineDownloadTarget(item, _))
       .WillOnce(SaveArg<1>(&download_target_callback));
   item->Start(std::move(null_download_file), std::move(null_request_handle),
               *create_info());
   EXPECT_EQ(DownloadItem::IN_PROGRESS, item->GetState());
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
 
   // The DownloadItemImpl should attempt to determine a target path even if the
   // download was interrupted.
   ASSERT_FALSE(download_target_callback.is_null());
   ASSERT_EQ(DownloadItem::IN_PROGRESS, item->GetState());
   base::FilePath target_path(FILE_PATH_LITERAL("foo"));
   download_target_callback.Run(target_path,
                                DownloadItem::TARGET_DISPOSITION_OVERWRITE,
                                DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS, target_path,
                                DOWNLOAD_INTERRUPT_REASON_NONE);
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
 
   EXPECT_EQ(target_path, item->GetTargetFilePath());
   CleanupItem(item, NULL, DownloadItem::INTERRUPTED);
 }
 
 // Test that the delegate is invoked after the download file is renamed.
 TEST_F(DownloadItemTest, CallbackAfterRename) {
   DownloadItemImpl* item = CreateDownloadItem();
   DownloadTargetCallback callback;
   MockDownloadFile* download_file = CallDownloadItemStart(item, &callback);
   base::FilePath final_path(
       base::FilePath(kDummyTargetPath).AppendASCII("foo.bar"));
   base::FilePath intermediate_path(final_path.InsertBeforeExtensionASCII("x"));
   base::FilePath new_intermediate_path(
       final_path.InsertBeforeExtensionASCII("y"));
   EXPECT_CALL(*download_file, RenameAndUniquify(intermediate_path, _))
       .WillOnce(ScheduleRenameAndUniquifyCallback(
           DOWNLOAD_INTERRUPT_REASON_NONE, new_intermediate_path));
 
   callback.Run(final_path, DownloadItem::TARGET_DISPOSITION_OVERWRITE,
                DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS, intermediate_path,
                DOWNLOAD_INTERRUPT_REASON_NONE);
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
   // All the callbacks should have happened by now.
   ::testing::Mock::VerifyAndClearExpectations(download_file);
   mock_delegate()->VerifyAndClearExpectations();
 
   EXPECT_CALL(*mock_delegate(), ShouldCompleteDownload(item, _))
       .WillOnce(Return(true));
   EXPECT_CALL(*download_file, RenameAndAnnotate(final_path, _, _, _, _))
       .WillOnce(ScheduleRenameAndAnnotateCallback(
           DOWNLOAD_INTERRUPT_REASON_NONE, final_path));
   EXPECT_CALL(*download_file, FullPath())
       .WillOnce(ReturnRefOfCopy(base::FilePath()));
   EXPECT_CALL(*download_file, Detach());
   item->DestinationObserverAsWeakPtr()->DestinationCompleted(
       0, std::unique_ptr<crypto::SecureHash>());
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
   ::testing::Mock::VerifyAndClearExpectations(download_file);
   mock_delegate()->VerifyAndClearExpectations();
 }
 
 // Test that the delegate is invoked after the download file is renamed and the
 // download item is in an interrupted state.
 TEST_F(DownloadItemTest, CallbackAfterInterruptedRename) {
   DownloadItemImpl* item = CreateDownloadItem();
   DownloadTargetCallback callback;
   MockDownloadFile* download_file = CallDownloadItemStart(item, &callback);
   base::FilePath final_path(
       base::FilePath(kDummyTargetPath).AppendASCII("foo.bar"));
   base::FilePath intermediate_path(final_path.InsertBeforeExtensionASCII("x"));
   base::FilePath new_intermediate_path(
       final_path.InsertBeforeExtensionASCII("y"));
   EXPECT_CALL(*download_file, RenameAndUniquify(intermediate_path, _))
       .WillOnce(ScheduleRenameAndUniquifyCallback(
           DOWNLOAD_INTERRUPT_REASON_FILE_FAILED, new_intermediate_path));
   EXPECT_CALL(*download_file, Cancel())
       .Times(1);
 
   callback.Run(final_path, DownloadItem::TARGET_DISPOSITION_OVERWRITE,
                DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS, intermediate_path,
                DOWNLOAD_INTERRUPT_REASON_NONE);
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
   // All the callbacks should have happened by now.
   ::testing::Mock::VerifyAndClearExpectations(download_file);
   mock_delegate()->VerifyAndClearExpectations();
 }
 
 TEST_F(DownloadItemTest, Interrupted) {
   DownloadItemImpl* item = CreateDownloadItem();
   MockDownloadFile* download_file =
       DoIntermediateRename(item, DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS);
 
   const DownloadInterruptReason reason(
       DOWNLOAD_INTERRUPT_REASON_FILE_ACCESS_DENIED);
 
   // Confirm interrupt sets state properly.
   EXPECT_CALL(*download_file, Cancel());
   item->DestinationObserverAsWeakPtr()->DestinationError(
       reason, 0, std::unique_ptr<crypto::SecureHash>());
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
   EXPECT_EQ(DownloadItem::INTERRUPTED, item->GetState());
   EXPECT_EQ(reason, item->GetLastReason());
 
   // Cancel should kill it.
   item->Cancel(true);
   EXPECT_EQ(DownloadItem::CANCELLED, item->GetState());
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_USER_CANCELED, item->GetLastReason());
 }
 
 // Destination errors that occur before the intermediate rename shouldn't cause
@@ skipping 14 matching lines @@
       final_path.InsertBeforeExtensionASCII("y"));
   EXPECT_CALL(*download_file, RenameAndUniquify(intermediate_path, _))
       .WillOnce(ScheduleRenameAndUniquifyCallback(
           DOWNLOAD_INTERRUPT_REASON_NONE, new_intermediate_path));
   EXPECT_CALL(*download_file, Cancel())
       .Times(1);
 
   callback.Run(final_path, DownloadItem::TARGET_DISPOSITION_OVERWRITE,
                DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS, intermediate_path,
                DOWNLOAD_INTERRUPT_REASON_NONE);
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
   // All the callbacks should have happened by now.
   ::testing::Mock::VerifyAndClearExpectations(download_file);
   mock_delegate()->VerifyAndClearExpectations();
   EXPECT_EQ(DownloadItem::INTERRUPTED, item->GetState());
   EXPECT_TRUE(item->GetFullPath().empty());
   EXPECT_EQ(final_path, item->GetTargetFilePath());
 }
 
 // As above. But if the download can be resumed by continuing, then the
 // intermediate path should be retained when the download is interrupted after
@@ skipping 18 matching lines @@
   EXPECT_CALL(*download_file, RenameAndUniquify(intermediate_path, _))
       .WillOnce(ScheduleRenameAndUniquifyCallback(
           DOWNLOAD_INTERRUPT_REASON_NONE, new_intermediate_path));
   EXPECT_CALL(*download_file, FullPath())
       .WillOnce(ReturnRefOfCopy(base::FilePath(new_intermediate_path)));
   EXPECT_CALL(*download_file, Detach());
 
   callback.Run(final_path, DownloadItem::TARGET_DISPOSITION_OVERWRITE,
                DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS, intermediate_path,
                DOWNLOAD_INTERRUPT_REASON_NONE);
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
   // All the callbacks should have happened by now.
   ::testing::Mock::VerifyAndClearExpectations(download_file);
   mock_delegate()->VerifyAndClearExpectations();
   EXPECT_EQ(DownloadItem::INTERRUPTED, item->GetState());
   EXPECT_EQ(new_intermediate_path, item->GetFullPath());
   EXPECT_EQ(final_path, item->GetTargetFilePath());
 }
 
 // As above. If the intermediate rename fails, then the interrupt reason should
 // be set to the file error and the intermediate path should be empty.
@@ skipping 13 matching lines @@
       final_path.InsertBeforeExtensionASCII("y"));
   EXPECT_CALL(*download_file, RenameAndUniquify(intermediate_path, _))
       .WillOnce(ScheduleRenameAndUniquifyCallback(
           DOWNLOAD_INTERRUPT_REASON_FILE_FAILED, new_intermediate_path));
   EXPECT_CALL(*download_file, Cancel())
       .Times(1);
 
   callback.Run(final_path, DownloadItem::TARGET_DISPOSITION_OVERWRITE,
                DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS, intermediate_path,
                DOWNLOAD_INTERRUPT_REASON_NONE);
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
   // All the callbacks should have happened by now.
   ::testing::Mock::VerifyAndClearExpectations(download_file);
   mock_delegate()->VerifyAndClearExpectations();
   EXPECT_EQ(DownloadItem::INTERRUPTED, item->GetState());
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_FILE_FAILED, item->GetLastReason());
   EXPECT_TRUE(item->GetFullPath().empty());
   EXPECT_EQ(final_path, item->GetTargetFilePath());
 }
 
 TEST_F(DownloadItemTest, Canceled) {
@@ skipping 202 matching lines @@
   EXPECT_CALL(*download_file, RenameAndAnnotate(_, _, _, _, _))
       .WillOnce(ScheduleRenameAndAnnotateCallback(
           DOWNLOAD_INTERRUPT_REASON_NONE, base::FilePath(kDummyTargetPath)));
   EXPECT_CALL(*mock_delegate(), ShouldCompleteDownload(item, _))
       .WillOnce(Return(true));
   EXPECT_CALL(*download_file, FullPath())
       .WillOnce(ReturnRefOfCopy(base::FilePath()));
   EXPECT_CALL(*download_file, Detach());
   item->DestinationObserverAsWeakPtr()->DestinationCompleted(
       0, std::unique_ptr<crypto::SecureHash>());
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
 
   ASSERT_EQ(DownloadItem::COMPLETE, item->GetState());
   EXPECT_TRUE(item->CanShowInFolder());
   EXPECT_TRUE(item->CanOpenDownload());
 }
 
 TEST_F(DownloadItemTest, EnabledActionsForTemporaryDownload) {
   // A download created with a non-empty FilePath is considered a temporary
   // download.
   create_info()->save_info->file_path = base::FilePath(kDummyTargetPath);
@@ skipping 12 matching lines @@
   EXPECT_CALL(*mock_delegate(), ShouldCompleteDownload(item, _))
       .WillOnce(Return(true));
   EXPECT_CALL(*download_file, RenameAndAnnotate(_, _, _, _, _))
       .WillOnce(ScheduleRenameAndAnnotateCallback(
           DOWNLOAD_INTERRUPT_REASON_NONE, base::FilePath(kDummyTargetPath)));
   EXPECT_CALL(*download_file, FullPath())
       .WillOnce(ReturnRefOfCopy(base::FilePath()));
   EXPECT_CALL(*download_file, Detach());
   item->DestinationObserverAsWeakPtr()->DestinationCompleted(
       0, std::unique_ptr<crypto::SecureHash>());
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
 
   ASSERT_EQ(DownloadItem::COMPLETE, item->GetState());
   EXPECT_FALSE(item->CanShowInFolder());
   EXPECT_FALSE(item->CanOpenDownload());
 }
 
 TEST_F(DownloadItemTest, EnabledActionsForInterruptedDownload) {
   DownloadItemImpl* item = CreateDownloadItem();
   MockDownloadFile* download_file =
       DoIntermediateRename(item, DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS);
 
   EXPECT_CALL(*download_file, Cancel());
   item->DestinationObserverAsWeakPtr()->DestinationError(
       DOWNLOAD_INTERRUPT_REASON_FILE_FAILED, 0,
       std::unique_ptr<crypto::SecureHash>());
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
 
   ASSERT_EQ(DownloadItem::INTERRUPTED, item->GetState());
   ASSERT_FALSE(item->GetTargetFilePath().empty());
   EXPECT_FALSE(item->CanShowInFolder());
   EXPECT_TRUE(item->CanOpenDownload());
 }
 
 TEST_F(DownloadItemTest, EnabledActionsForCancelledDownload) {
   DownloadItemImpl* item = CreateDownloadItem();
   MockDownloadFile* download_file =
       DoIntermediateRename(item, DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS);
 
   EXPECT_CALL(*download_file, Cancel());
   item->Cancel(true);
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
 
   ASSERT_EQ(DownloadItem::CANCELLED, item->GetState());
   EXPECT_FALSE(item->CanShowInFolder());
   EXPECT_FALSE(item->CanOpenDownload());
 }
 
 // Test various aspects of the delegate completion blocker.
 
 // Just allowing completion.
 TEST_F(DownloadItemTest, CompleteDelegate_ReturnTrue) {
@@ skipping 14 matching lines @@
   // Make sure the download can complete.
   EXPECT_CALL(*download_file,
               RenameAndAnnotate(base::FilePath(kDummyTargetPath), _, _, _, _))
       .WillOnce(ScheduleRenameAndAnnotateCallback(
           DOWNLOAD_INTERRUPT_REASON_NONE, base::FilePath(kDummyTargetPath)));
   EXPECT_CALL(*mock_delegate(), ShouldOpenDownload(item, _))
       .WillOnce(Return(true));
   EXPECT_CALL(*download_file, FullPath())
       .WillOnce(ReturnRefOfCopy(base::FilePath()));
   EXPECT_CALL(*download_file, Detach());
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
   EXPECT_EQ(DownloadItem::COMPLETE, item->GetState());
 }
 
 // Just delaying completion.
 TEST_F(DownloadItemTest, CompleteDelegate_BlockOnce) {
   // Test to confirm that if we have a callback that returns true,
   // we complete immediately.
+
   DownloadItemImpl* item = CreateDownloadItem();
   MockDownloadFile* download_file =
       DoIntermediateRename(item, DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS);
 
-  // Drive the delegate interaction.
   base::Closure delegate_callback;
   base::Closure copy_delegate_callback;
   EXPECT_CALL(*mock_delegate(), ShouldCompleteDownload(item, _))
       .WillOnce(DoAll(SaveArg<1>(&delegate_callback),
                       Return(false)))
       .WillOnce(Return(true));
   item->DestinationObserverAsWeakPtr()->DestinationCompleted(
       0, std::unique_ptr<crypto::SecureHash>());
   ASSERT_FALSE(delegate_callback.is_null());
   copy_delegate_callback = delegate_callback;
   delegate_callback.Reset();
   EXPECT_EQ(DownloadItem::IN_PROGRESS, item->GetState());
   copy_delegate_callback.Run();
   ASSERT_TRUE(delegate_callback.is_null());
   EXPECT_EQ(DownloadItem::IN_PROGRESS, item->GetState());
   EXPECT_FALSE(item->IsDangerous());
 
   // Make sure the download can complete.
   EXPECT_CALL(*download_file,
               RenameAndAnnotate(base::FilePath(kDummyTargetPath), _, _, _, _))
       .WillOnce(ScheduleRenameAndAnnotateCallback(
           DOWNLOAD_INTERRUPT_REASON_NONE, base::FilePath(kDummyTargetPath)));
   EXPECT_CALL(*mock_delegate(), ShouldOpenDownload(item, _))
       .WillOnce(Return(true));
   EXPECT_CALL(*download_file, FullPath())
       .WillOnce(ReturnRefOfCopy(base::FilePath()));
   EXPECT_CALL(*download_file, Detach());
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
   EXPECT_EQ(DownloadItem::COMPLETE, item->GetState());
 }
 
 // Delay and set danger.
 TEST_F(DownloadItemTest, CompleteDelegate_SetDanger) {
   // Test to confirm that if we have a callback that returns true,
   // we complete immediately.
   DownloadItemImpl* item = CreateDownloadItem();
   MockDownloadFile* download_file =
       DoIntermediateRename(item, DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS);
@@ skipping 22 matching lines @@
   // Make sure the download doesn't complete until we've validated it.
   EXPECT_CALL(*download_file,
               RenameAndAnnotate(base::FilePath(kDummyTargetPath), _, _, _, _))
       .WillOnce(ScheduleRenameAndAnnotateCallback(
           DOWNLOAD_INTERRUPT_REASON_NONE, base::FilePath(kDummyTargetPath)));
   EXPECT_CALL(*mock_delegate(), ShouldOpenDownload(item, _))
       .WillOnce(Return(true));
   EXPECT_CALL(*download_file, FullPath())
       .WillOnce(ReturnRefOfCopy(base::FilePath()));
   EXPECT_CALL(*download_file, Detach());
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
   EXPECT_EQ(DownloadItem::IN_PROGRESS, item->GetState());
   EXPECT_TRUE(item->IsDangerous());
 
   item->ValidateDangerousDownload();
   EXPECT_EQ(DOWNLOAD_DANGER_TYPE_USER_VALIDATED, item->GetDangerType());
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
   EXPECT_EQ(DownloadItem::COMPLETE, item->GetState());
 }
 
 // Just delaying completion twice.
 TEST_F(DownloadItemTest, CompleteDelegate_BlockTwice) {
   // Test to confirm that if we have a callback that returns true,
   // we complete immediately.
   DownloadItemImpl* item = CreateDownloadItem();
   MockDownloadFile* download_file =
       DoIntermediateRename(item, DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS);
@@ skipping 26 matching lines @@
   // Make sure the download can complete.
   EXPECT_CALL(*download_file,
               RenameAndAnnotate(base::FilePath(kDummyTargetPath), _, _, _, _))
       .WillOnce(ScheduleRenameAndAnnotateCallback(
           DOWNLOAD_INTERRUPT_REASON_NONE, base::FilePath(kDummyTargetPath)));
   EXPECT_CALL(*mock_delegate(), ShouldOpenDownload(item, _))
       .WillOnce(Return(true));
   EXPECT_CALL(*download_file, FullPath())
       .WillOnce(ReturnRefOfCopy(base::FilePath()));
   EXPECT_CALL(*download_file, Detach());
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
   EXPECT_EQ(DownloadItem::COMPLETE, item->GetState());
 }
 
 TEST_F(DownloadItemTest, StealDangerousDownloadAndDiscard) {
   DownloadItemImpl* item = CreateDownloadItem();
   MockDownloadFile* download_file =
       DoIntermediateRename(item, DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE);
   ASSERT_TRUE(item->IsDangerous());
   base::FilePath full_path(FILE_PATH_LITERAL("foo.txt"));
   base::FilePath returned_path;
 
   EXPECT_CALL(*download_file, FullPath()).WillOnce(ReturnRefOfCopy(full_path));
   EXPECT_CALL(*download_file, Detach());
   EXPECT_CALL(*mock_delegate(), DownloadRemoved(_));
   base::WeakPtrFactory<DownloadItemTest> weak_ptr_factory(this);
   item->OnAllDataSaved(0, std::unique_ptr<crypto::SecureHash>());
   item->StealDangerousDownload(
       true,  // delete_file_after_feedback
       base::Bind(&DownloadItemTest::OnDownloadFileAcquired,
                  weak_ptr_factory.GetWeakPtr(),
                  base::Unretained(&returned_path)));
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
   EXPECT_EQ(full_path, returned_path);
 }
 
 TEST_F(DownloadItemTest, StealDangerousDownloadAndKeep) {
   DownloadItemImpl* item = CreateDownloadItem();
   MockDownloadFile* download_file =
       DoIntermediateRename(item, DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE);
   ASSERT_TRUE(item->IsDangerous());
   base::FilePath full_path(FILE_PATH_LITERAL("foo.txt"));
   base::FilePath returned_path;
   EXPECT_CALL(*download_file, FullPath()).WillOnce(ReturnRefOfCopy(full_path));
   base::WeakPtrFactory<DownloadItemTest> weak_ptr_factory(this);
   item->OnAllDataSaved(0, std::unique_ptr<crypto::SecureHash>());
   item->StealDangerousDownload(
       false,  // delete_file_after_feedback
       base::Bind(&DownloadItemTest::OnDownloadFileAcquired,
                  weak_ptr_factory.GetWeakPtr(),
                  base::Unretained(&returned_path)));
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
   EXPECT_NE(full_path, returned_path);
   CleanupItem(item, download_file, DownloadItem::IN_PROGRESS);
 }
 
 TEST_F(DownloadItemTest, StealInterruptedContinuableDangerousDownload) {
   base::FilePath returned_path;
   DownloadItemImpl* item = CreateDownloadItem();
   MockDownloadFile* download_file =
       DoIntermediateRename(item, DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE);
   base::FilePath full_path = item->GetFullPath();
   EXPECT_FALSE(full_path.empty());
   EXPECT_CALL(*download_file, FullPath()).WillOnce(ReturnRefOfCopy(full_path));
   EXPECT_CALL(*download_file, Detach());
   item->DestinationObserverAsWeakPtr()->DestinationError(
       DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED, 1,
       std::unique_ptr<crypto::SecureHash>());
   ASSERT_TRUE(item->IsDangerous());
 
   EXPECT_CALL(*mock_delegate(), DownloadRemoved(_));
   base::WeakPtrFactory<DownloadItemTest> weak_ptr_factory(this);
   item->OnAllDataSaved(0, std::unique_ptr<crypto::SecureHash>());
   item->StealDangerousDownload(
       true, base::Bind(&DownloadItemTest::OnDownloadFileAcquired,
                        weak_ptr_factory.GetWeakPtr(),
                        base::Unretained(&returned_path)));
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
   EXPECT_EQ(full_path, returned_path);
 }
 
 TEST_F(DownloadItemTest, StealInterruptedNonContinuableDangerousDownload) {
   base::FilePath returned_path;
   DownloadItemImpl* item = CreateDownloadItem();
   MockDownloadFile* download_file =
       DoIntermediateRename(item, DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE);
   EXPECT_CALL(*download_file, Cancel());
   item->DestinationObserverAsWeakPtr()->DestinationError(
       DOWNLOAD_INTERRUPT_REASON_FILE_FAILED, 1,
       std::unique_ptr<crypto::SecureHash>());
   ASSERT_TRUE(item->IsDangerous());
 
   EXPECT_CALL(*mock_delegate(), DownloadRemoved(_));
   base::WeakPtrFactory<DownloadItemTest> weak_ptr_factory(this);
   item->OnAllDataSaved(0, std::unique_ptr<crypto::SecureHash>());
   item->StealDangerousDownload(
       true, base::Bind(&DownloadItemTest::OnDownloadFileAcquired,
                        weak_ptr_factory.GetWeakPtr(),
                        base::Unretained(&returned_path)));
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
   EXPECT_TRUE(returned_path.empty());
 }
 
 namespace {
 
 // The DownloadItemDestinationUpdateRaceTest fixture (defined below) is used to
 // test for race conditions between download destination events received via the
 // DownloadDestinationObserver interface, and the target determination logic.
 //
 // The general control flow for DownloadItemImpl looks like this:
@@ skipping 224 matching lines @@
 }  // namespace
 
 // Run through the DII workflow but the embedder cancels the download at target
 // determination.
 TEST_P(DownloadItemDestinationUpdateRaceTest, DownloadCancelledByUser) {
   // Expect that the download file and the request will be cancelled as a
   // result.
   EXPECT_CALL(*file_, Cancel());
   EXPECT_CALL(*request_handle_, CancelRequest(_));
 
-  base::RunLoop download_start_loop;
   DownloadFile::InitializeCallback initialize_callback;
   EXPECT_CALL(*file_, Initialize(_, _, _, _))
-      .WillOnce(DoAll(SaveArg<0>(&initialize_callback),
-                      ScheduleClosure(download_start_loop.QuitClosure())));
+      .WillOnce(SaveArg<0>(&initialize_callback));
   item_->Start(std::move(file_), std::move(request_handle_), *create_info());
-  download_start_loop.Run();
+  task_environment_.RunUntilIdle();
 
   base::WeakPtr<DownloadDestinationObserver> destination_observer =
       item_->DestinationObserverAsWeakPtr();
 
   ScheduleObservations(PreInitializeFileObservations(), destination_observer);
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
 
-  base::RunLoop initialize_completion_loop;
   DownloadTargetCallback target_callback;
   EXPECT_CALL(*mock_delegate(), DetermineDownloadTarget(_, _))
-      .WillOnce(
-          DoAll(SaveArg<1>(&target_callback),
-                ScheduleClosure(initialize_completion_loop.QuitClosure())));
+      .WillOnce(SaveArg<1>(&target_callback));
   ScheduleObservations(PostInitializeFileObservations(), destination_observer);
   initialize_callback.Run(DOWNLOAD_INTERRUPT_REASON_NONE);
-  initialize_completion_loop.Run();
 
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
 
   ASSERT_FALSE(target_callback.is_null());
   ScheduleObservations(PostTargetDeterminationObservations(),
                        destination_observer);
   target_callback.Run(base::FilePath(),
                       DownloadItem::TARGET_DISPOSITION_OVERWRITE,
                       DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS, base::FilePath(),
                       DOWNLOAD_INTERRUPT_REASON_NONE);
   EXPECT_EQ(DownloadItem::CANCELLED, item_->GetState());
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
 }
 
 // Run through the DII workflow, but the intermediate rename fails.
 TEST_P(DownloadItemDestinationUpdateRaceTest, IntermediateRenameFails) {
   // Expect that the download file and the request will be cancelled as a
   // result.
   EXPECT_CALL(*file_, Cancel());
   EXPECT_CALL(*request_handle_, CancelRequest(_));
 
   // Intermediate rename loop is not used immediately, but let's set up the
   // DownloadFile expectations since we are about to transfer its ownership to
   // the DownloadItem.
-  base::RunLoop intermediate_rename_loop;
   DownloadFile::RenameCompletionCallback intermediate_rename_callback;
   EXPECT_CALL(*file_, RenameAndUniquify(_, _))
-      .WillOnce(DoAll(SaveArg<1>(&intermediate_rename_callback),
-                      ScheduleClosure(intermediate_rename_loop.QuitClosure())));
+      .WillOnce(SaveArg<1>(&intermediate_rename_callback));
 
-  base::RunLoop download_start_loop;
   DownloadFile::InitializeCallback initialize_callback;
   EXPECT_CALL(*file_, Initialize(_, _, _, _))
-      .WillOnce(DoAll(SaveArg<0>(&initialize_callback),
-                      ScheduleClosure(download_start_loop.QuitClosure())));
+      .WillOnce(SaveArg<0>(&initialize_callback));
 
   item_->Start(std::move(file_), std::move(request_handle_), *create_info());
-  download_start_loop.Run();
+  task_environment_.RunUntilIdle();
+
   base::WeakPtr<DownloadDestinationObserver> destination_observer =
       item_->DestinationObserverAsWeakPtr();
 
   ScheduleObservations(PreInitializeFileObservations(), destination_observer);
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
 
-  base::RunLoop initialize_completion_loop;
   DownloadTargetCallback target_callback;
   EXPECT_CALL(*mock_delegate(), DetermineDownloadTarget(_, _))
-      .WillOnce(
-          DoAll(SaveArg<1>(&target_callback),
-                ScheduleClosure(initialize_completion_loop.QuitClosure())));
+      .WillOnce(SaveArg<1>(&target_callback));
   ScheduleObservations(PostInitializeFileObservations(), destination_observer);
   initialize_callback.Run(DOWNLOAD_INTERRUPT_REASON_NONE);
-  initialize_completion_loop.Run();
 
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
   ASSERT_FALSE(target_callback.is_null());
 
   ScheduleObservations(PostTargetDeterminationObservations(),
                        destination_observer);
   target_callback.Run(base::FilePath(kDummyTargetPath),
                       DownloadItem::TARGET_DISPOSITION_OVERWRITE,
                       DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
                       base::FilePath(kDummyIntermediatePath),
                       DOWNLOAD_INTERRUPT_REASON_NONE);
 
-  intermediate_rename_loop.Run();
+  task_environment_.RunUntilIdle();
   ASSERT_FALSE(intermediate_rename_callback.is_null());
 
   ScheduleObservations(PostIntermediateRenameObservations(),
                        destination_observer);
   intermediate_rename_callback.Run(DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
                                    base::FilePath());
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
 
   EXPECT_EQ(DownloadItem::INTERRUPTED, item_->GetState());
 }
 
 // Run through the DII workflow. Download file initialization, target
 // determination and intermediate rename all succeed.
 TEST_P(DownloadItemDestinationUpdateRaceTest, IntermediateRenameSucceeds) {
   // We expect either that the download will fail (in which case the request and
   // the download file will be cancelled), or it will succeed (in which case the
   // DownloadFile will Detach()). It depends on the list of observations that
   // are given to us.
   EXPECT_CALL(*file_, Cancel()).Times(::testing::AnyNumber());
   EXPECT_CALL(*request_handle_, CancelRequest(_)).Times(::testing::AnyNumber());
   EXPECT_CALL(*file_, Detach()).Times(::testing::AnyNumber());
 
   EXPECT_CALL(*file_, FullPath())
       .WillRepeatedly(ReturnRefOfCopy(base::FilePath(kDummyIntermediatePath)));
 
   // Intermediate rename loop is not used immediately, but let's set up the
   // DownloadFile expectations since we are about to transfer its ownership to
   // the DownloadItem.
-  base::RunLoop intermediate_rename_loop;
   DownloadFile::RenameCompletionCallback intermediate_rename_callback;
   EXPECT_CALL(*file_, RenameAndUniquify(_, _))
-      .WillOnce(DoAll(SaveArg<1>(&intermediate_rename_callback),
-                      ScheduleClosure(intermediate_rename_loop.QuitClosure())));
+      .WillOnce(SaveArg<1>(&intermediate_rename_callback));
 
-  base::RunLoop download_start_loop;
   DownloadFile::InitializeCallback initialize_callback;
   EXPECT_CALL(*file_, Initialize(_, _, _, _))
-      .WillOnce(DoAll(SaveArg<0>(&initialize_callback),
-                      ScheduleClosure(download_start_loop.QuitClosure())));
+      .WillOnce(SaveArg<0>(&initialize_callback));
 
   item_->Start(std::move(file_), std::move(request_handle_), *create_info());
-  download_start_loop.Run();
+  task_environment_.RunUntilIdle();
+
   base::WeakPtr<DownloadDestinationObserver> destination_observer =
       item_->DestinationObserverAsWeakPtr();
 
   ScheduleObservations(PreInitializeFileObservations(), destination_observer);
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
 
-  base::RunLoop initialize_completion_loop;
   DownloadTargetCallback target_callback;
   EXPECT_CALL(*mock_delegate(), DetermineDownloadTarget(_, _))
-      .WillOnce(
-          DoAll(SaveArg<1>(&target_callback),
-                ScheduleClosure(initialize_completion_loop.QuitClosure())));
+      .WillOnce(SaveArg<1>(&target_callback));
   ScheduleObservations(PostInitializeFileObservations(), destination_observer);
   initialize_callback.Run(DOWNLOAD_INTERRUPT_REASON_NONE);
-  initialize_completion_loop.Run();
 
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
   ASSERT_FALSE(target_callback.is_null());
 
   ScheduleObservations(PostTargetDeterminationObservations(),
                        destination_observer);
   target_callback.Run(base::FilePath(kDummyTargetPath),
                       DownloadItem::TARGET_DISPOSITION_OVERWRITE,
                       DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
                       base::FilePath(kDummyIntermediatePath),
                       DOWNLOAD_INTERRUPT_REASON_NONE);
 
-  intermediate_rename_loop.Run();
+  task_environment_.RunUntilIdle();
   ASSERT_FALSE(intermediate_rename_callback.is_null());
 
   // This may or may not be called, depending on whether there are any errors in
   // our action list.
   EXPECT_CALL(*mock_delegate(), ShouldCompleteDownload(_, _))
       .Times(::testing::AnyNumber());
 
   ScheduleObservations(PostIntermediateRenameObservations(),
                        destination_observer);
   intermediate_rename_callback.Run(DOWNLOAD_INTERRUPT_REASON_NONE,
                                    base::FilePath(kDummyIntermediatePath));
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
 
   // The state of the download depends on the observer events that were played
   // back to the DownloadItemImpl. Hence we can't establish a single expectation
   // here. On Debug builds, the DCHECKs will verify that the state transitions
   // were correct. On Release builds, tests are expected to run to completion
   // without crashing on success.
   EXPECT_TRUE(item_->GetState() == DownloadItem::IN_PROGRESS ||
               item_->GetState() == DownloadItem::INTERRUPTED);
   if (item_->GetState() == DownloadItem::INTERRUPTED)
     EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED, item_->GetLastReason());
 
   item_->Cancel(true);
-  RunAllPendingInMessageLoops();
+  task_environment_.RunUntilIdle();
 }
 
 TEST(MockDownloadItem, Compiles) {
   MockDownloadItem mock_item;
 }
 
 }  // namespace content