Always use an async TaskScheduler in TestBrowserThreadBundle.

content/browser/loader/resource_dispatcher_host_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 <stddef.h>
 
 #include <memory>
 #include <utility>
 #include <vector>
 
@@ skipping 39 matching lines @@
 #include "content/public/browser/resource_throttle.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/common/browser_side_navigation_policy.h"
 #include "content/public/common/child_process_host.h"
 #include "content/public/common/process_type.h"
 #include "content/public/common/resource_response.h"
 #include "content/public/test/test_browser_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_renderer_host.h"
+#include "content/public/test/test_utils.h"
 #include "content/test/test_content_browser_client.h"
 #include "content/test/test_navigation_url_loader_delegate.h"
 #include "net/base/chunked_upload_data_stream.h"
 #include "net/base/elements_upload_data_stream.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/base/request_priority.h"
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/http/http_util.h"
 #include "net/test/cert_test_util.h"
@@ skipping 99 matching lines @@
   request.should_reset_appcache = false;
   request.is_main_frame = true;
   request.parent_is_main_frame = false;
   request.transition_type = ui::PAGE_TRANSITION_LINK;
   request.allow_download = true;
   return request;
 }
 
 // Spin up the message loop to kick off the request.
 static void KickOffRequest() {
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;

[mmenke, 2017/04/04 22:47:16]

I think you have a few extra semi-colons in this file.

[fdoray, 2017/04/05 12:34:21]

Done.

 }
 
 // We may want to move this to a shared space if it is useful for something else
 class ResourceIPCAccumulator {
  public:
   ~ResourceIPCAccumulator() {
     for (size_t i = 0; i < messages_.size(); i++) {
       ReleaseHandlesInMessage(messages_[i]);
     }
   }
@@ skipping 658 matching lines @@
 
   ResourceDispatcherHostTest()
       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
         host_(base::Bind(&DownloadResourceHandler::Create)),
         use_test_ssl_certificate_(false),
         send_data_received_acks_(false),
         auto_advance_(false) {
     host_.SetLoaderDelegate(&loader_delegate_);
     browser_context_.reset(new TestBrowserContext());
     BrowserContext::EnsureResourceContextInitialized(browser_context_.get());
-    base::RunLoop().RunUntilIdle();
+    content::RunAllBlockingPoolTasksUntilIdle();
+    ;
     filter_ = MakeForwardingFilter();
     // TODO(cbentzel): Better way to get URLRequestContext?
     net::URLRequestContext* request_context =
         browser_context_->GetResourceContext()->GetRequestContext();
     job_factory_.reset(new TestURLRequestJobFactory(this));
     request_context->set_job_factory(job_factory_.get());
     request_context->set_network_delegate(&network_delegate_);
   }
 
   ~ResourceDispatcherHostTest() override {
@@ skipping 54 matching lines @@
     host_.Shutdown();
 
     ChildProcessSecurityPolicyImpl::GetInstance()->Remove(0);
 
     // Flush the message loop to make application verifiers happy.
     if (ResourceDispatcherHostImpl::Get())
       ResourceDispatcherHostImpl::Get()->CancelRequestsForContext(
           browser_context_->GetResourceContext());
 
     browser_context_.reset();
-    base::RunLoop().RunUntilIdle();
+    content::RunAllBlockingPoolTasksUntilIdle();
+    ;
   }
 
   // Creates a new ForwardingFilter and registers it with |child_ids_| so as not
   // to leak per-child state on test shutdown.
   ForwardingFilter* MakeForwardingFilter() {
     ForwardingFilter* filter =
         new ForwardingFilter(this, browser_context_->GetResourceContext());
     child_ids_.insert(filter->child_id());
     return filter;
   }
@@ skipping 138 matching lines @@
       ASSERT_EQ(expected_error_code, delegate.net_error());
       return;
     }
 
     MakeTestRequestWithResourceType(filter_.get(), 0, 1, url,
                                     RESOURCE_TYPE_MAIN_FRAME);
 
     // Flush all pending requests.
     while (net::URLRequestTestJob::ProcessOnePendingMessage()) {
     }
-    base::RunLoop().RunUntilIdle();
+    content::RunAllBlockingPoolTasksUntilIdle();
+    ;
 
     // Sorts out all the messages we saw by request.
     ResourceIPCAccumulator::ClassifiedMessages msgs;
     accum_.GetClassifiedMessages(&msgs);
 
     // We should have gotten one RequestComplete message.
     ASSERT_EQ(1U, msgs.size());
     ASSERT_EQ(1U, msgs[0].size());
     EXPECT_EQ(ResourceMsg_RequestComplete::ID, msgs[0][0].type());
 
@@ skipping 239 matching lines @@
   MakeTestRequest(0, 2, net::URLRequestTestJob::test_url_2());
   MakeTestRequest(0, 3, net::URLRequestTestJob::test_url_3());
   MakeTestRequestWithResourceType(filter_.get(), 0, 4,
                                   net::URLRequestTestJob::test_url_4(),
                                   RESOURCE_TYPE_PREFETCH);  // detachable type
   MakeTestRequest(0, 5, net::URLRequestTestJob::test_url_redirect_to_url_2());
 
   // Finish the redirection
   ResourceHostMsg_FollowRedirect redirect_msg(5);
   OnMessageReceived(redirect_msg, filter_.get());
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   // flush all the pending requests
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
 
   // sorts out all the messages we saw by request
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   // there are five requests, so we should have gotten them classified as such
   ASSERT_EQ(5U, msgs.size());
@@ skipping 23 matching lines @@
   RendererCancelRequest(4);
 
   // The handler should have been detached now.
   GlobalRequestID global_request_id(filter_->child_id(), 4);
   ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest(
       host_.GetURLRequest(global_request_id));
   ASSERT_TRUE(info->detachable_handler()->is_detached());
 
   // flush all the pending requests
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   // Everything should be out now.
   EXPECT_EQ(0, host_.pending_requests());
 
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   // there are four requests, so we should have gotten them classified as such
   ASSERT_EQ(4U, msgs.size());
 
@@ skipping 31 matching lines @@
 
   // The handler for the cache-only request should have been detached now.
   GlobalRequestID global_request_id(filter_->child_id(), 2);
   ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest(
       host_.GetURLRequest(global_request_id));
   ASSERT_TRUE(info->detachable_handler()->is_detached());
 
   // Flush all the pending requests.
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {
   }
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   // Everything should be out now.
   EXPECT_EQ(0, host_.pending_requests());
 
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   // There are two requests, so we should have gotten them classified as such.
   ASSERT_EQ(2U, msgs.size());
 
@@ skipping 15 matching lines @@
 TEST_F(ResourceDispatcherHostTest, DetachedResourceTimesOut) {
   MakeTestRequestWithResourceType(filter_.get(), 0, 1,
                                   net::URLRequestTestJob::test_url_2(),
                                   RESOURCE_TYPE_PREFETCH);  // detachable type
   GlobalRequestID global_request_id(filter_->child_id(), 1);
   ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest(
       host_.GetURLRequest(global_request_id));
   ASSERT_TRUE(info->detachable_handler());
   info->detachable_handler()->set_cancel_delay(
       base::TimeDelta::FromMilliseconds(200));
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   RendererCancelRequest(1);
 
   // From the renderer's perspective, the request was cancelled.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
   ASSERT_EQ(1U, msgs.size());
   ASSERT_EQ(2U, msgs[0].size());
   ASSERT_EQ(ResourceMsg_ReceivedResponse::ID, msgs[0][0].type());
   CheckRequestCompleteErrorCode(msgs[0][1], net::ERR_ABORTED);
@@ skipping 18 matching lines @@
 
 TEST_F(ResourceDispatcherHostTest, SyncLoadSuccess) {
   ResourceRequest request = CreateResourceRequest(
       "GET", RESOURCE_TYPE_XHR, net::URLRequestTestJob::test_url_1());
   request.priority = net::MAXIMUM_PRIORITY;
 
   // Successful sync load.
   std::tuple<SyncLoadResult> result;
   ResourceHostMsg_SyncLoad sync_load_msg(0, 1, request, &std::get<0>(result));
   OnMessageReceived(sync_load_msg, filter_.get());
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   const IPC::Message* reply = accum_.GetReply(sync_load_msg);
   ASSERT_TRUE(reply);
 
   ASSERT_TRUE(ResourceHostMsg_SyncLoad::ReadReplyParam(reply, &result));
   EXPECT_EQ(net::OK, std::get<0>(result).error_code);
 }
 
 TEST_F(ResourceDispatcherHostTest, SyncLoadError) {
   ResourceRequest request = CreateResourceRequest(
       "GET", RESOURCE_TYPE_XHR, net::URLRequestTestJob::test_url_error());
   request.priority = net::MAXIMUM_PRIORITY;
 
   // Failued sync load.
   std::tuple<SyncLoadResult> result;
   ResourceHostMsg_SyncLoad sync_load_msg(0, 1, request, &std::get<0>(result));
   OnMessageReceived(sync_load_msg, filter_.get());
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   const IPC::Message* reply = accum_.GetReply(sync_load_msg);
   ASSERT_TRUE(reply);
 
   ASSERT_TRUE(ResourceHostMsg_SyncLoad::ReadReplyParam(reply, &result));
   EXPECT_EQ(net::ERR_INVALID_URL, std::get<0>(result).error_code);
 }
 
 TEST_F(ResourceDispatcherHostTest, SyncLoadCancel) {
   ResourceRequest request = CreateResourceRequest(
       "GET", RESOURCE_TYPE_XHR, net::URLRequestTestJob::test_url_1());
   request.priority = net::MAXIMUM_PRIORITY;
 
   // Cancelled sync load.
   SyncLoadResult result;
   ResourceHostMsg_SyncLoad sync_load_msg(0, 1, request, &result);
 
   OnMessageReceived(sync_load_msg, filter_.get());
   host_.CancelRequestsForProcess(filter_->child_id());
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   const IPC::Message* reply = accum_.GetReply(sync_load_msg);
   ASSERT_TRUE(reply);
   ASSERT_TRUE(reply->is_reply_error());
 }
 
 // If the filter has disappeared then detachable resources should continue to
 // load.
 TEST_F(ResourceDispatcherHostTest, DeletedFilterDetached) {
   // test_url_1's data is available synchronously, so use 2 and 3.
@@ skipping 28 matching lines @@
   EXPECT_EQ(2, host_.pending_requests());
   EXPECT_TRUE(info_prefetch->detachable_handler()->is_detached());
   EXPECT_TRUE(info_ping->detachable_handler()->is_detached());
 
   KickOffRequest();
 
   // Make sure the requests weren't canceled early.
   EXPECT_EQ(2, host_.pending_requests());
 
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   EXPECT_EQ(0, host_.pending_requests());
   EXPECT_EQ(2, network_delegate()->completed_requests());
   EXPECT_EQ(0, network_delegate()->canceled_requests());
   EXPECT_EQ(0, network_delegate()->error_count());
 }
 
 // If the filter has disappeared (original process dies) then detachable
 // resources should continue to load, even when redirected.
 TEST_F(ResourceDispatcherHostTest, DeletedFilterDetachedRedirect) {
@@ skipping 27 matching lines @@
   KickOffRequest();
 
   // Verify that a redirect was followed.
   EXPECT_EQ(2u, url_request->url_chain().size());
 
   // Make sure the request wasn't canceled early.
   EXPECT_EQ(1, host_.pending_requests());
 
   // Finish up the request.
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   EXPECT_EQ(0, host_.pending_requests());
   EXPECT_EQ(1, network_delegate()->completed_requests());
   EXPECT_EQ(0, network_delegate()->canceled_requests());
   EXPECT_EQ(0, network_delegate()->error_count());
 }
 
 TEST_F(ResourceDispatcherHostTest, CancelWhileStartIsDeferred) {
   bool was_deleted = false;
 
   // Arrange to have requests deferred before starting.
   TestResourceDispatcherHostDelegate delegate;
   delegate.set_flags(DEFER_STARTING_REQUEST);
   delegate.set_url_request_user_data(new TestUserData(&was_deleted));
   host_.SetDelegate(&delegate);
 
   MakeTestRequest(0, 1, net::URLRequestTestJob::test_url_1());
   // We cancel from the renderer because all non-renderer cancels delete
   // the request synchronously.
   RendererCancelRequest(1);
 
   // Our TestResourceThrottle should not have been deleted yet.  This is to
   // ensure that destruction of the URLRequest happens asynchronously to
   // calling CancelRequest.
   EXPECT_FALSE(was_deleted);
 
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   EXPECT_TRUE(was_deleted);
 }
 
 TEST_F(ResourceDispatcherHostTest, DetachWhileStartIsDeferred) {
   bool was_deleted = false;
 
   // Arrange to have requests deferred before starting.
   TestResourceDispatcherHostDelegate delegate;
   delegate.set_flags(DEFER_STARTING_REQUEST);
   delegate.set_url_request_user_data(new TestUserData(&was_deleted));
   host_.SetDelegate(&delegate);
 
   MakeTestRequestWithResourceType(filter_.get(), 0, 1,
                                   net::URLRequestTestJob::test_url_1(),
                                   RESOURCE_TYPE_PREFETCH);  // detachable type
   // Cancel request must come from the renderer for a detachable resource to
   // detach.
   RendererCancelRequest(1);
 
   // Even after driving the event loop, the request has not been deleted.
   EXPECT_FALSE(was_deleted);
 
   // However, it is still throttled because the defer happened above the
   // DetachableResourceHandler.
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
   EXPECT_FALSE(was_deleted);
 
   // Resume the request.
   GenericResourceThrottle* throttle =
       GenericResourceThrottle::active_throttle();
   ASSERT_TRUE(throttle);
   throttle->AssertAndResume();
 
   // Now, the request completes.
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
   EXPECT_TRUE(was_deleted);
   EXPECT_EQ(1, network_delegate()->completed_requests());
   EXPECT_EQ(0, network_delegate()->canceled_requests());
   EXPECT_EQ(0, network_delegate()->error_count());
 }
 
 // Tests if cancel is called in ResourceThrottle::WillStartRequest, then the
 // URLRequest will not be started.
 TEST_F(ResourceDispatcherHostTest, CancelInResourceThrottleWillStartRequest) {
   TestResourceDispatcherHostDelegate delegate;
   delegate.set_flags(CANCEL_BEFORE_START);
   host_.SetDelegate(&delegate);
 
   MakeTestRequest(0, 1, net::URLRequestTestJob::test_url_1());
 
   // flush all the pending requests
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   // Check that request got canceled.
   ASSERT_EQ(1U, msgs[0].size());
   CheckRequestCompleteErrorCode(msgs[0][0], net::ERR_ABORTED);
 
   // Make sure URLRequest is never started.
   EXPECT_EQ(0, job_factory_->url_request_jobs_created_count());
 }
 
 TEST_F(ResourceDispatcherHostTest, PausedStartError) {
   // Arrange to have requests deferred before processing response headers.
   TestResourceDispatcherHostDelegate delegate;
   delegate.set_flags(DEFER_PROCESSING_RESPONSE);
   host_.SetDelegate(&delegate);
 
   job_factory_->SetDelayedStartJobGeneration(true);
   MakeTestRequest(0, 1, net::URLRequestTestJob::test_url_error());
   CompleteStartRequest(1);
 
   // flush all the pending requests
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   EXPECT_EQ(0, host_.pending_requests());
 }
 
 TEST_F(ResourceDispatcherHostTest, ThrottleAndResumeTwice) {
   // Arrange to have requests deferred before starting.
   TestResourceDispatcherHostDelegate delegate;
   delegate.set_flags(DEFER_STARTING_REQUEST);
   delegate.set_create_two_throttles(true);
   host_.SetDelegate(&delegate);
 
   // Make sure the first throttle blocked the request, and then resume.
   MakeTestRequest(0, 1, net::URLRequestTestJob::test_url_1());
   GenericResourceThrottle* first_throttle =
       GenericResourceThrottle::active_throttle();
   ASSERT_TRUE(first_throttle);
   first_throttle->AssertAndResume();
 
   // Make sure the second throttle blocked the request, and then resume.
   ASSERT_TRUE(GenericResourceThrottle::active_throttle());
   ASSERT_NE(first_throttle, GenericResourceThrottle::active_throttle());
   GenericResourceThrottle::active_throttle()->AssertAndResume();
 
   ASSERT_FALSE(GenericResourceThrottle::active_throttle());
 
   // The request is started asynchronously.
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   // Flush all the pending requests.
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
 
   EXPECT_EQ(0, host_.pending_requests());
 
   // Make sure the request completed successfully.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
   ASSERT_EQ(1U, msgs.size());
   CheckSuccessfulRequest(msgs[0], net::URLRequestTestJob::test_data_1());
 }
 
 
 // Tests that the delegate can cancel a request and provide a error code.
 TEST_F(ResourceDispatcherHostTest, CancelInDelegate) {
   TestResourceDispatcherHostDelegate delegate;
   delegate.set_flags(CANCEL_BEFORE_START);
   delegate.set_error_code_for_cancellation(net::ERR_ACCESS_DENIED);
   host_.SetDelegate(&delegate);
 
   MakeTestRequest(0, 1, net::URLRequestTestJob::test_url_1());
   // The request will get cancelled by the throttle.
 
   // flush all the pending requests
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   // Check the cancellation
   ASSERT_EQ(1U, msgs.size());
   ASSERT_EQ(1U, msgs[0].size());
 
   CheckRequestCompleteErrorCode(msgs[0][0], net::ERR_ACCESS_DENIED);
 }
@@ skipping 18 matching lines @@
                                   RESOURCE_TYPE_SUB_RESOURCE);
 
   // request 4 goes to us
   MakeTestRequestWithResourceType(filter_.get(), 0, 4,
                                   net::URLRequestTestJob::test_url_4(),
                                   RESOURCE_TYPE_PREFETCH);  // detachable type
 
 
   // Make sure all requests have finished stage one. test_url_1 will have
   // finished.
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   // TODO(mbelshe):
   // Now that the async IO path is in place, the IO always completes on the
   // initial call; so the requests have already completed.  This basically
   // breaks the whole test.
   // EXPECT_EQ(3, host_.pending_requests());
 
   // Process test_url_2 and test_url_3 for one level so one callback is called.
   // We'll cancel test_url_4 (detachable) before processing it to verify that it
   // delays the cancel.
@@ skipping 71 matching lines @@
   KickOffRequest();
   EXPECT_EQ(3, network_delegate_.created_requests());
   EXPECT_EQ(0, network_delegate_.canceled_requests());
 
   // The first two RenderFrameHosts are destroyed.  All 4 of their requests
   // should be cancelled, and none of the two deferred requests should be
   // started.
   DeleteRenderFrame(GlobalFrameRoutingId(filter_->child_id(), 10));
   DeleteRenderFrame(GlobalFrameRoutingId(filter_->child_id(), 11));
   host_.OnRenderViewHostDeleted(filter_->child_id(), 0);
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
   EXPECT_EQ(3, network_delegate_.created_requests());
   EXPECT_EQ(4, network_delegate_.canceled_requests());
 
   // No messages should have been sent, since none of the jobs made any
   // progress.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
   EXPECT_EQ(0U, msgs.size());
 }
 
 TEST_F(ResourceDispatcherHostTest, TestProcessCancelDetachedTimesOut) {
   MakeTestRequestWithResourceType(filter_.get(), 0, 1,
                                   net::URLRequestTestJob::test_url_4(),
                                   RESOURCE_TYPE_PREFETCH);  // detachable type
   GlobalRequestID global_request_id(filter_->child_id(), 1);
   ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest(
       host_.GetURLRequest(global_request_id));
   ASSERT_TRUE(info->detachable_handler());
   info->detachable_handler()->set_cancel_delay(
       base::TimeDelta::FromMilliseconds(200));
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   // Cancel the requests to the test process.
   host_.CancelRequestsForProcess(filter_->child_id());
   EXPECT_EQ(1, host_.pending_requests());
 
   // Wait until after the delay timer times out before we start processing any
   // messages.
   base::OneShotTimer timer;
   timer.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(210),
               base::MessageLoop::current(), &base::MessageLoop::QuitWhenIdle);
   base::RunLoop().Run();
 
   // The prefetch should be cancelled by now.
   EXPECT_EQ(0, host_.pending_requests());
 
   // In case any messages are still to be processed.
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   ASSERT_EQ(1U, msgs.size());
 
   // The request should have cancelled.
   ASSERT_EQ(2U, msgs[0].size());
   ASSERT_EQ(ResourceMsg_ReceivedResponse::ID, msgs[0][0].type());
   CheckRequestCompleteErrorCode(msgs[0][1], net::ERR_ABORTED);
@@ skipping 271 matching lines @@
   // it is just process 0 that is saturated.
   MakeTestRequestWithResourceType(second_filter.get(), 0, kMaxRequests + 3,
                                   net::URLRequestTestJob::test_url_2(),
                                   RESOURCE_TYPE_SUB_RESOURCE);
   MakeTestRequestWithResourceType(second_filter.get(), 0, kMaxRequests + 4,
                                   net::URLRequestTestJob::test_url_2(),
                                   RESOURCE_TYPE_SUB_RESOURCE);
 
   // Flush all the pending requests.
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   // Sorts out all the messages we saw by request.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   // We issued (kMaxRequests + 4) total requests.
   ASSERT_EQ(kMaxRequests + 4, msgs.size());
 
   // Check that the first kMaxRequests succeeded.
   for (size_t i = 0; i < kMaxRequests; ++i)
@@ skipping 50 matching lines @@
       net::URLRequestTestJob::test_url_2(), RESOURCE_TYPE_SUB_RESOURCE);
 
   // Issue a request for the third process -- this should fail, because the
   // global limit has been reached.
   MakeTestRequestWithResourceType(
       third_filter.get(), 0, kMaxRequestsPerProcess + 3,
       net::URLRequestTestJob::test_url_2(), RESOURCE_TYPE_SUB_RESOURCE);
 
   // Flush all the pending requests.
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   // Sorts out all the messages we saw by request.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   // The processes issued the following requests:
   // #1 issued kMaxRequestsPerProcess that passed + 1 that failed
   // #2 issued 1 request that passed
   // #3 issued 1 request that failed
   ASSERT_EQ((kMaxRequestsPerProcess + 1) + 1 + 1, msgs.size());
@@ skipping 168 matching lines @@
   SetResponse(raw_headers, response_data);
   job_factory_->SetDelayedCompleteJobGeneration(true);
   HandleScheme("http");
 
   MakeTestRequestWithResourceType(filter_.get(), render_view_id, request_id,
                                   GURL("http://example.com/blah"),
                                   RESOURCE_TYPE_MAIN_FRAME);
   // Return some data so that the request is identified as a download
   // and the proper resource handlers are created.
   EXPECT_TRUE(net::URLRequestTestJob::ProcessOnePendingMessage());
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   // And now simulate a cancellation coming from the renderer.
   ResourceHostMsg_CancelRequest msg(request_id);
   OnMessageReceived(msg, filter_.get());
 
   // Since the request had already started processing as a download,
   // the cancellation above should have been ignored and the request
   // should still be alive.
   EXPECT_EQ(1, host_.pending_requests());
 
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 }
 
 TEST_F(ResourceDispatcherHostTest, CancelRequestsForContext) {
   EXPECT_EQ(0, host_.pending_requests());
   NavigationResourceThrottle::set_ui_checks_always_succeed_for_testing(true);
 
   int render_view_id = 0;
   int request_id = 1;
 
   std::string raw_headers("HTTP\n"
@@ skipping 27 matching lines @@
         browser_context_->GetResourceContext(),
         BrowserContext::GetDefaultStoragePartition(browser_context_.get()),
         std::move(request_info), nullptr, nullptr, nullptr, &delegate);
 
     // Wait until a response has been received and proceed with the response.
     KickOffRequest();
 
     // Return some data so that the request is identified as a download
     // and the proper resource handlers are created.
     EXPECT_TRUE(net::URLRequestTestJob::ProcessOnePendingMessage());
-    base::RunLoop().RunUntilIdle();
+    content::RunAllBlockingPoolTasksUntilIdle();
+    ;
 
     // The UI thread will be informed that the navigation failed with an error
     // code of ERR_ABORTED because the navigation turns out to be a download.
     // The navigation is aborted, but the request goes on as a download.
     EXPECT_EQ(delegate.net_error(), net::ERR_ABORTED);
     EXPECT_EQ(1, host_.pending_requests());
 
     // In PlzNavigate, the renderer cannot cancel the request directly.
     // However, cancelling by context should work.
     host_.CancelRequestsForContext(browser_context_->GetResourceContext());
     EXPECT_EQ(0, host_.pending_requests());
 
-    base::RunLoop().RunUntilIdle();
+    content::RunAllBlockingPoolTasksUntilIdle();
+    ;
   } else {
     MakeTestRequestWithResourceType(filter_.get(), render_view_id, request_id,
                                     download_url, RESOURCE_TYPE_MAIN_FRAME);
 
     // Return some data so that the request is identified as a download
     // and the proper resource handlers are created.
     EXPECT_TRUE(net::URLRequestTestJob::ProcessOnePendingMessage());
-    base::RunLoop().RunUntilIdle();
+    content::RunAllBlockingPoolTasksUntilIdle();
+    ;
 
     // And now simulate a cancellation coming from the renderer.
     ResourceHostMsg_CancelRequest msg(request_id);
     OnMessageReceived(msg, filter_.get());
 
     // Since the request had already started processing as a download,
     // the cancellation above should have been ignored and the request
     // should still be alive.
     EXPECT_EQ(1, host_.pending_requests());
 
     // Cancelling by other methods shouldn't work either.
     host_.CancelRequestsForProcess(render_view_id);
     EXPECT_EQ(1, host_.pending_requests());
 
     // Cancelling by context should work.
     host_.CancelRequestsForContext(filter_->resource_context());
     EXPECT_EQ(0, host_.pending_requests());
 
     while (net::URLRequestTestJob::ProcessOnePendingMessage()) {
     }
-    base::RunLoop().RunUntilIdle();
+    content::RunAllBlockingPoolTasksUntilIdle();
+    ;
   }
 }
 
 TEST_F(ResourceDispatcherHostTest, CancelRequestsForContextDetached) {
   EXPECT_EQ(0, host_.pending_requests());
 
   int render_view_id = 0;
   int request_id = 1;
 
   MakeTestRequestWithResourceType(filter_.get(), render_view_id, request_id,
@@ skipping 90 matching lines @@
                                   RESOURCE_TYPE_MAIN_FRAME);
 
   // Now that we're blocked on the redirect, update the response and unblock by
   // telling the AsyncResourceHandler to follow the redirect.
   const std::string kResponseBody = "hello world";
   SetResponse("HTTP/1.1 200 OK\n"
               "Content-Type: text/html\n\n",
               kResponseBody);
   ResourceHostMsg_FollowRedirect redirect_msg(request_id);
   OnMessageReceived(redirect_msg, filter_.get());
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   // Flush all the pending requests to get the response through the
   // MimeTypeResourceHandler.
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
 
   // This second filter is used to emulate a second process.
   scoped_refptr<ForwardingFilter> second_filter = MakeForwardingFilter();
 
   int new_render_view_id = 1;
   int new_request_id = 2;
 
   ResourceRequest request = CreateResourceRequest(
       "GET", RESOURCE_TYPE_MAIN_FRAME, GURL("http://other.com/blech"));
   request.transferred_request_child_id = filter_->child_id();
   request.transferred_request_request_id = request_id;
 
   ResourceHostMsg_RequestResource transfer_request_msg(
       new_render_view_id, new_request_id, request);
   OnMessageReceived(transfer_request_msg, second_filter.get());
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   // Check generated messages.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   ASSERT_EQ(2U, msgs.size());
   EXPECT_EQ(ResourceMsg_ReceivedRedirect::ID, msgs[0][0].type());
   CheckSuccessfulRequest(msgs[1], kResponseBody);
 
   second_filter->OnChannelClosing();
@@ skipping 48 matching lines @@
   int new_render_view_id = 1;
   int new_request_id = 5;
   ResourceRequest request = CreateResourceRequest(
       "GET", RESOURCE_TYPE_MAIN_FRAME, GURL("http://example.com/blah"));
   request.transferred_request_child_id = filter_->child_id();
   request.transferred_request_request_id = request_id;
 
   ResourceHostMsg_RequestResource transfer_request_msg(
       new_render_view_id, new_request_id, request);
   OnMessageReceived(transfer_request_msg, second_filter.get());
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   // Transfer the second request.
   int new_second_request_id = 6;
   ResourceRequest second_request = CreateResourceRequest(
       "GET", RESOURCE_TYPE_MAIN_FRAME, GURL("http://example.com/foo"));
   request.transferred_request_child_id = filter_->child_id();
   request.transferred_request_request_id = second_request_id;
 
   ResourceHostMsg_RequestResource second_transfer_request_msg(
       new_render_view_id, new_second_request_id, second_request);
   OnMessageReceived(second_transfer_request_msg, second_filter.get());
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   // Check generated messages.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   ASSERT_EQ(2U, msgs.size());
   CheckSuccessfulRequest(msgs[0], kResponseBody);
 
   second_filter->OnChannelClosing();
 }
@@ skipping 28 matching lines @@
   // Now that we're blocked on the redirect, update the response and unblock by
   // telling the AsyncResourceHandler to follow the redirect.  Use a text/plain
   // MIME type, which causes MimeTypeResourceHandler to buffer it before the
   // transfer occurs.
   const std::string kResponseBody = "hello world";
   SetResponse("HTTP/1.1 200 OK\n"
               "Content-Type: text/plain\n\n",
               kResponseBody);
   ResourceHostMsg_FollowRedirect redirect_msg(request_id);
   OnMessageReceived(redirect_msg, filter_.get());
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   // Flush all the pending requests to get the response through the
   // MimeTypeResourceHandler.
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   // This second filter is used to emulate a second process.
   scoped_refptr<ForwardingFilter> second_filter = MakeForwardingFilter();
 
   int new_render_view_id = 1;
   int new_request_id = 2;
 
   ResourceRequest request = CreateResourceRequest(
       "GET", RESOURCE_TYPE_MAIN_FRAME, GURL("http://other.com/blech"));
   request.transferred_request_child_id = filter_->child_id();
   request.transferred_request_request_id = request_id;
 
   ResourceHostMsg_RequestResource transfer_request_msg(
       new_render_view_id, new_request_id, request);
   OnMessageReceived(transfer_request_msg, second_filter.get());
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   // Check generated messages.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   ASSERT_EQ(2U, msgs.size());
   EXPECT_EQ(ResourceMsg_ReceivedRedirect::ID, msgs[0][0].type());
   CheckSuccessfulRequest(msgs[1], kResponseBody);
 
   second_filter->OnChannelClosing();
@@ skipping 25 matching lines @@
   {
     scoped_refptr<ForwardingFilter> first_filter = MakeForwardingFilter();
     first_child_id = first_filter->child_id();
 
     ResourceRequest first_request = CreateResourceRequest(
         "GET", RESOURCE_TYPE_MAIN_FRAME, GURL("http://example.com/blah"));
 
     ResourceHostMsg_RequestResource first_request_msg(
         render_view_id, request_id, first_request);
     OnMessageReceived(first_request_msg, first_filter.get());
-    base::RunLoop().RunUntilIdle();
+    content::RunAllBlockingPoolTasksUntilIdle();
+    ;
 
     // Now that we're blocked on the redirect, update the response and unblock
     // by telling the AsyncResourceHandler to follow the redirect.
     SetResponse("HTTP/1.1 200 OK\n"
                 "Content-Type: text/html\n\n",
                 kResponseBody);
     ResourceHostMsg_FollowRedirect redirect_msg(request_id);
     OnMessageReceived(redirect_msg, first_filter.get());
-    base::RunLoop().RunUntilIdle();
+    content::RunAllBlockingPoolTasksUntilIdle();
+    ;
 
     // Flush all the pending requests to get the response through the
     // MimeTypeResourceHandler.
     while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
 
     first_filter->OnChannelClosing();
   }
   // The first filter is now deleted, as if the child process died.
 
   // Make sure we don't hold onto the ResourceMessageFilter after it is deleted.
   GlobalRequestID first_global_request_id(first_child_id, request_id);
 
   // This second filter is used to emulate a second process.
   scoped_refptr<ForwardingFilter> second_filter = MakeForwardingFilter();
 
   int new_render_view_id = 1;
   int new_request_id = 2;
 
   ResourceRequest request = CreateResourceRequest(
       "GET", RESOURCE_TYPE_MAIN_FRAME, GURL("http://other.com/blech"));
   request.transferred_request_child_id = first_child_id;
   request.transferred_request_request_id = request_id;
 
   // For cleanup.
   child_ids_.insert(second_filter->child_id());
   ResourceHostMsg_RequestResource transfer_request_msg(
       new_render_view_id, new_request_id, request);
   OnMessageReceived(transfer_request_msg, second_filter.get());
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   // Check generated messages.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   ASSERT_EQ(2U, msgs.size());
   EXPECT_EQ(ResourceMsg_ReceivedRedirect::ID, msgs[0][0].type());
   CheckSuccessfulRequest(msgs[1], kResponseBody);
 
   second_filter->OnChannelClosing();
@@ skipping 21 matching lines @@
 
   MakeTestRequestWithResourceType(filter_.get(), render_view_id, request_id,
                                   GURL("http://example.com/blah"),
                                   RESOURCE_TYPE_MAIN_FRAME);
 
   // Now that we're blocked on the redirect, simulate hitting another redirect.
   SetResponse("HTTP/1.1 302 Found\n"
               "Location: http://other.com/blerg\n\n");
   ResourceHostMsg_FollowRedirect redirect_msg(request_id);
   OnMessageReceived(redirect_msg, filter_.get());
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   // Now that we're blocked on the second redirect, update the response and
   // unblock by telling the AsyncResourceHandler to follow the redirect.
   // Again, use text/plain to force MimeTypeResourceHandler to buffer before
   // the transfer.
   const std::string kResponseBody = "hello world";
   SetResponse("HTTP/1.1 200 OK\n"
               "Content-Type: text/plain\n\n",
               kResponseBody);
   ResourceHostMsg_FollowRedirect redirect_msg2(request_id);
   OnMessageReceived(redirect_msg2, filter_.get());
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   // Flush all the pending requests to get the response through the
   // MimeTypeResourceHandler.
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   // This second filter is used to emulate a second process.
   scoped_refptr<ForwardingFilter> second_filter = MakeForwardingFilter();
 
   int new_render_view_id = 1;
   int new_request_id = 2;
 
   ResourceRequest request = CreateResourceRequest(
       "GET", RESOURCE_TYPE_MAIN_FRAME, GURL("http://other.com/blech"));
   request.transferred_request_child_id = filter_->child_id();
   request.transferred_request_request_id = request_id;
 
   // For cleanup.
   child_ids_.insert(second_filter->child_id());
   ResourceHostMsg_RequestResource transfer_request_msg(
       new_render_view_id, new_request_id, request);
   OnMessageReceived(transfer_request_msg, second_filter.get());
 
   // Verify that we update the ResourceRequestInfo.
   GlobalRequestID global_request_id(second_filter->child_id(), new_request_id);
   ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest(
       host_.GetURLRequest(global_request_id));
   EXPECT_EQ(second_filter->child_id(), info->GetChildID());
   EXPECT_EQ(new_render_view_id, info->GetRouteID());
   EXPECT_EQ(new_request_id, info->GetRequestID());
   EXPECT_EQ(second_filter.get(), info->requester_info()->filter());
 
   // Let request complete.
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   // Check generated messages.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   ASSERT_EQ(2U, msgs.size());
   EXPECT_EQ(ResourceMsg_ReceivedRedirect::ID, msgs[0][0].type());
   CheckSuccessfulRequest(msgs[1], kResponseBody);
 
   second_filter->OnChannelClosing();
@@ skipping 12 matching lines @@
 }
 
 TEST_F(ResourceDispatcherHostTest, DataReceivedACKs) {
   EXPECT_EQ(0, host_.pending_requests());
 
   SendDataReceivedACKs(true);
 
   HandleScheme("big-job");
   MakeTestRequest(0, 1, GURL("big-job:0123456789,1000000"));
 
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
 
   // Sort all the messages we saw by request.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   size_t size = msgs[0].size();
 
   EXPECT_EQ(ResourceMsg_ReceivedResponse::ID, msgs[0][0].type());
   EXPECT_EQ(ResourceMsg_SetDataBuffer::ID, msgs[0][1].type());
   for (size_t i = 2; i < size - 1; ++i)
@@ skipping 58 matching lines @@
       std::string(response_data.begin(), response_data.begin() + data_length),
       net::ERR_ABORTED);
 }
 
 TEST_F(ResourceDispatcherHostTest, DelayedDataReceivedACKs) {
   EXPECT_EQ(0, host_.pending_requests());
 
   HandleScheme("big-job");
   MakeTestRequest(0, 1, GURL("big-job:0123456789,1000000"));
 
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
 
   // Sort all the messages we saw by request.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   // We expect 1x ReceivedResponse, 1x SetDataBuffer, Nx ReceivedData messages.
   EXPECT_EQ(ResourceMsg_ReceivedResponse::ID, msgs[0][0].type());
   EXPECT_EQ(ResourceMsg_SetDataBuffer::ID, msgs[0][1].type());
   for (size_t i = 2; i < msgs[0].size(); ++i)
     EXPECT_EQ(ResourceMsg_DataReceived::ID, msgs[0][i].type());
@@ skipping 13 matching lines @@
         complete = true;
         break;
       }
 
       EXPECT_EQ(ResourceMsg_DataReceived::ID, msgs[0][i].type());
 
       ResourceHostMsg_DataReceived_ACK msg(1);
       OnMessageReceived(msg, filter_.get());
     }
 
-    base::RunLoop().RunUntilIdle();
+    content::RunAllBlockingPoolTasksUntilIdle();
 
     msgs.clear();
     accum_.GetClassifiedMessages(&msgs);
   }
 }
 
 // Flakyness of this test might indicate memory corruption issues with
 // for example the ResourceBuffer of AsyncResourceHandler.
 TEST_F(ResourceDispatcherHostTest, DataReceivedUnexpectedACKs) {
   EXPECT_EQ(0, host_.pending_requests());
 
   HandleScheme("big-job");
   MakeTestRequest(0, 1, GURL("big-job:0123456789,1000000"));
 
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
 
   // Sort all the messages we saw by request.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   // We expect 1x ReceivedResponse, 1x SetDataBuffer, Nx ReceivedData messages.
   EXPECT_EQ(ResourceMsg_ReceivedResponse::ID, msgs[0][0].type());
   EXPECT_EQ(ResourceMsg_SetDataBuffer::ID, msgs[0][1].type());
   for (size_t i = 2; i < msgs[0].size(); ++i)
     EXPECT_EQ(ResourceMsg_DataReceived::ID, msgs[0][i].type());
@@ skipping 18 matching lines @@
         complete = true;
         break;
       }
 
       EXPECT_EQ(ResourceMsg_DataReceived::ID, msgs[0][i].type());
 
       ResourceHostMsg_DataReceived_ACK msg(1);
       OnMessageReceived(msg, filter_.get());
     }
 
-    base::RunLoop().RunUntilIdle();
+    content::RunAllBlockingPoolTasksUntilIdle();
 
     msgs.clear();
     accum_.GetClassifiedMessages(&msgs);
   }
 }
 
 // Tests the dispatcher host's temporary file management.
 TEST_F(ResourceDispatcherHostTest, RegisterDownloadedTempFile) {
   const int kRequestID = 1;
 
@@ skipping 23 matching lines @@
 
   // Still readable because there is another reference to the file. (The child
   // may take additional blob references.)
   EXPECT_TRUE(ChildProcessSecurityPolicyImpl::GetInstance()->CanReadFile(
       filter_->child_id(), file_path));
 
   // Release extra references and wait for the file to be deleted. (This relies
   // on the delete happening on the FILE thread which is mapped to main thread
   // in this test.)
   deletable_file = nullptr;
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   // The file is no longer readable to the child and has been deleted.
   EXPECT_FALSE(ChildProcessSecurityPolicyImpl::GetInstance()->CanReadFile(
       filter_->child_id(), file_path));
   EXPECT_FALSE(base::PathExists(file_path));
 }
 
 // Tests the dispatcher host's temporary file management in the mojo-enabled
 // loading.
 TEST_F(ResourceDispatcherHostTest, RegisterDownloadedTempFileWithMojo) {
@@ skipping 18 matching lines @@
   mojom::DownloadedTempFilePtr downloaded_file_ptr =
       DownloadedTempFileImpl::Create(filter_->child_id(), kRequestID);
   host_.RegisterDownloadedTempFile(filter_->child_id(), kRequestID, file_path);
 
   // Should be readable now.
   EXPECT_TRUE(ChildProcessSecurityPolicyImpl::GetInstance()->CanReadFile(
       filter_->child_id(), file_path));
 
   // The child releases from the request.
   downloaded_file_ptr = nullptr;
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   // Still readable because there is another reference to the file. (The child
   // may take additional blob references.)
   EXPECT_TRUE(ChildProcessSecurityPolicyImpl::GetInstance()->CanReadFile(
       filter_->child_id(), file_path));
 
   // Release extra references and wait for the file to be deleted. (This relies
   // on the delete happening on the FILE thread which is mapped to main thread
   // in this test.)
   deletable_file = nullptr;
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   // The file is no longer readable to the child and has been deleted.
   EXPECT_FALSE(ChildProcessSecurityPolicyImpl::GetInstance()->CanReadFile(
       filter_->child_id(), file_path));
   EXPECT_FALSE(base::PathExists(file_path));
 }
 
 // Tests that temporary files held on behalf of child processes are released
 // when the child process dies.
 TEST_F(ResourceDispatcherHostTest, ReleaseTemporiesOnProcessExit) {
@@ skipping 10 matching lines @@
   // Register it for a resource request.
   host_.RegisterDownloadedTempFile(filter_->child_id(), kRequestID, file_path);
   deletable_file = NULL;
 
   // Should be readable now.
   EXPECT_TRUE(ChildProcessSecurityPolicyImpl::GetInstance()->CanReadFile(
       filter_->child_id(), file_path));
 
   // Let the process die.
   filter_->OnChannelClosing();
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   // The file is no longer readable to the child and has been deleted.
   EXPECT_FALSE(ChildProcessSecurityPolicyImpl::GetInstance()->CanReadFile(
       filter_->child_id(), file_path));
   EXPECT_FALSE(base::PathExists(file_path));
 }
 
 TEST_F(ResourceDispatcherHostTest, DownloadToFile) {
   // Make a request which downloads to file.
   ResourceRequest request = CreateResourceRequest(
       "GET", RESOURCE_TYPE_SUB_RESOURCE, net::URLRequestTestJob::test_url_1());
   request.download_to_file = true;
   ResourceHostMsg_RequestResource request_msg(0, 1, request);
   OnMessageReceived(request_msg, filter_.get());
 
   // Running the message loop until idle does not work because
   // RedirectToFileResourceHandler posts things to base::WorkerPool. Instead,
   // wait for the ResourceMsg_RequestComplete to go out. Then run the event loop
   // until idle so the loader is gone.
   WaitForRequestComplete();
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
   EXPECT_EQ(0, host_.pending_requests());
 
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   ASSERT_EQ(1U, msgs.size());
   const std::vector<IPC::Message>& messages = msgs[0];
 
   // The request should contain the following messages:
   //     ReceivedResponse    (indicates headers received and filename)
@@ skipping 32 matching lines @@
 
   // When the renderer releases the file, it should be deleted. Again,
   // RunUntilIdle doesn't work because base::WorkerPool is involved.
   ShareableFileReleaseWaiter waiter(response_head.download_file_path);
   ResourceHostMsg_ReleaseDownloadedFile release_msg(1);
   OnMessageReceived(release_msg, filter_.get());
   waiter.Wait();
   // The release callback runs before the delete is scheduled, so pump the
   // message loop for the delete itself. (This relies on the delete happening on
   // the FILE thread which is mapped to main thread in this test.)
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   EXPECT_FALSE(base::PathExists(response_head.download_file_path));
   EXPECT_FALSE(ChildProcessSecurityPolicyImpl::GetInstance()->CanReadFile(
       filter_->child_id(), response_head.download_file_path));
 }
 
 WebContents* WebContentsBinder(WebContents* rv) { return rv; }
 
 // Tests GetLoadInfoForAllRoutes when there are 3 requests from the same
 // RenderView.  The second one is farthest along.
@@ skipping 155 matching lines @@
   EXPECT_EQ(0u, (*load_info_map)[wc2].upload_position);
   EXPECT_EQ(0u, (*load_info_map)[wc2].upload_size);
 }
 
 // Confirm that resource response started notifications are correctly
 // transmitted to the WebContents.
 TEST_F(ResourceDispatcherHostTest, TransferResponseStarted) {
   int initial_count = web_contents_observer_->resource_response_start_count();
 
   MakeWebContentsAssociatedTestRequest(1, net::URLRequestTestJob::test_url_1());
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   EXPECT_EQ(initial_count + 1,
             web_contents_observer_->resource_response_start_count());
 }
 
 // Confirm that request redirected notifications are correctly
 // transmitted to the WebContents.
 TEST_F(ResourceDispatcherHostTest, TransferRequestRedirected) {
   int initial_count = web_contents_observer_->resource_request_redirect_count();
 
   MakeWebContentsAssociatedTestRequest(
       1, net::URLRequestTestJob::test_url_redirect_to_url_2());
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   EXPECT_EQ(initial_count + 1,
             web_contents_observer_->resource_request_redirect_count());
 }
 
 // Confirm that DidChangePriority messages are respected.
 TEST_F(ResourceDispatcherHostTest, DidChangePriority) {
   // ResourceScheduler only throttles http and https requests.
   HandleScheme("http");
 
@@ skipping 12 matching lines @@
   MakeTestRequestWithPriority(0, 3, net::IDLE);
 
   KickOffRequest();
 
   EXPECT_EQ(2, job_factory_->url_request_jobs_created_count());
 
   // Increase the priority of the second idle priority request. It was
   // scheduled later, so it is not currently running.
   ResourceHostMsg_DidChangePriority priority_msg(3, net::MAXIMUM_PRIORITY, 0);
   OnMessageReceived(priority_msg, filter_.get());
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 
   EXPECT_EQ(3, job_factory_->url_request_jobs_created_count());
 
   // Cleanup.
   host_.OnRenderViewHostDeleted(filter_->child_id(),  // child_id
                                 0);                   // route_id
 }
 
 // Confirm that resource response started notifications for downloads are not
 // transmitted to the WebContents.
 TEST_F(ResourceDispatcherHostTest, TransferResponseStartedDownload) {
   int initial_count(web_contents_observer_->resource_response_start_count());
 
   MakeWebContentsAssociatedDownloadRequest(
       1, net::URLRequestTestJob::test_url_1());
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
   EXPECT_EQ(initial_count,
             web_contents_observer_->resource_response_start_count());
 }
 
 // Confirm that request redirected notifications for downloads are not
 // transmitted to the WebContents.
 TEST_F(ResourceDispatcherHostTest, TransferRequestRedirectedDownload) {
   int initial_count(web_contents_observer_->resource_request_redirect_count());
 
   MakeWebContentsAssociatedDownloadRequest(
       1, net::URLRequestTestJob::test_url_redirect_to_url_2());
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
   EXPECT_EQ(initial_count,
             web_contents_observer_->resource_request_redirect_count());
 }
 
 // Tests that a ResourceThrottle that needs to process the response before any
 // part of the body is read can do so.
 TEST_F(ResourceDispatcherHostTest, ThrottleMustProcessResponseBeforeRead) {
   // Ensure all jobs will check that no read operation is called.
   job_factory_->SetMustNotReadJobGeneration(true);
   HandleScheme("http");
@@ skipping 13 matching lines @@
       "Content-Type: text/plain; charset=utf-8\n\n");
   std::string response_data("p { text-align: center; }");
   SetResponse(raw_headers, response_data);
 
   MakeTestRequestWithResourceType(filter_.get(), filter_->child_id(), 1,
                                   GURL("http://example.com/blah"),
                                   RESOURCE_TYPE_STYLESHEET);
 
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {
   }
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
 }
 
 namespace {
 
 void StoreSyncLoadResult(bool* called,
                          bool* was_null,
                          SyncLoadResult* result_out,
                          const SyncLoadResult* result) {
   *called = true;
   *was_null = !result;
 
   if (result)
     *result_out = *result;
 }
 
 } // namespace
 
 TEST_F(ResourceDispatcherHostTest, SyncLoadWithMojoSuccess) {
   ResourceRequest request = CreateResourceRequest(
       "GET", RESOURCE_TYPE_XHR, net::URLRequestTestJob::test_url_1());
   request.priority = net::MAXIMUM_PRIORITY;
 
   bool called = false;
   bool was_null = false;
   SyncLoadResult result;
   host_.OnSyncLoadWithMojo(
       GetResourceRequesterInfo(filter_.get()), 0, 1, request,
       base::Bind(&StoreSyncLoadResult, &called, &was_null, &result));
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
   EXPECT_TRUE(called);
   EXPECT_FALSE(was_null);
   EXPECT_EQ(net::OK, result.error_code);
 }
 
 TEST_F(ResourceDispatcherHostTest, SyncLoadWithMojoError) {
   ResourceRequest request = CreateResourceRequest(
       "GET", RESOURCE_TYPE_XHR, net::URLRequestTestJob::test_url_error());
   request.priority = net::MAXIMUM_PRIORITY;
 
   bool called = false;
   bool was_null = false;
   SyncLoadResult result;
   host_.OnSyncLoadWithMojo(
       GetResourceRequesterInfo(filter_.get()), 0, 1, request,
       base::Bind(&StoreSyncLoadResult, &called, &was_null, &result));
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
   EXPECT_TRUE(called);
   EXPECT_FALSE(was_null);
   EXPECT_EQ(net::ERR_INVALID_URL, result.error_code);
 }
 
 TEST_F(ResourceDispatcherHostTest, SyncLoadWithMojoCancel) {
   ResourceRequest request = CreateResourceRequest(
       "GET", RESOURCE_TYPE_XHR, net::URLRequestTestJob::test_url_error());
   request.priority = net::MAXIMUM_PRIORITY;
 
   bool called = false;
   bool was_null = false;
   SyncLoadResult result;
   host_.OnSyncLoadWithMojo(
       GetResourceRequesterInfo(filter_.get()), 0, 1, request,
       base::Bind(&StoreSyncLoadResult, &called, &was_null, &result));
   host_.CancelRequestsForProcess(filter_->child_id());
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
+  ;
   EXPECT_TRUE(called);
   EXPECT_TRUE(was_null);
 }
 
 // A URLRequestTestJob that sets a test certificate on the |ssl_info|
 // field of the response.
 class TestHTTPSURLRequestJob : public net::URLRequestTestJob {
  public:
   TestHTTPSURLRequestJob(net::URLRequest* request,
                          net::NetworkDelegate* network_delegate,
@@ skipping 68 matching lines @@
   return nullptr;
 }
 
 net::URLRequestJob* TestURLRequestJobFactory::MaybeInterceptResponse(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate) const {
   return nullptr;
 }
 
 }  // namespace content