Always use an async TaskScheduler in TestBrowserThreadBundle.

chrome/browser/chromeos/policy/device_status_collector_browsertest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/chromeos/policy/device_status_collector.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 136 matching lines @@
   }
 
   std::string GetDMTokenForProfile(Profile* profile) override {
     // Return the profile user name (passed to CreateTestingProfile) to make it
     // easy to confirm that the correct profile's DMToken was requested.
     return profile->GetProfileUserName();
   }
 
   void RefreshSampleResourceUsage() {
     SampleResourceUsage();
-    content::BrowserThread::GetBlockingPool()->FlushForTesting();
+    content::RunAllBlockingPoolTasksUntilIdle();
   }
 
  protected:
   void CheckIdleState() override {
     // This should never be called in testing, as it results in a dbus call.
     ADD_FAILURE();
   }
 
   // Each time this is called, returns a time that is a fixed increment
   // later than the previous time.
@@ skipping 185 matching lines @@
             mount_point, mount_point, chromeos::MOUNT_TYPE_DEVICE,
             chromeos::disks::MOUNT_CONDITION_NONE)));
   }
 
   ~DeviceStatusCollectorTest() override {
     chromeos::CrasAudioHandler::Shutdown();
     chromeos::KioskAppManager::Shutdown();
     TestingBrowserProcess::GetGlobal()->SetLocalState(nullptr);
 
     // Finish pending tasks.
-    content::BrowserThread::GetBlockingPool()->FlushForTesting();
-    base::RunLoop().RunUntilIdle();

[fdoray, 2017/04/04 17:52:55]

When a synchronous TaskScheduler was used, base::RunLoop().RunUntilIdle()
indirectly flushed TaskScheduler. Now,
content::RunAllBlockingPoolTasksUntilIdle() is required to flush blocking pool +
task scheduler + main MessageLoop.

+    content::RunAllBlockingPoolTasksUntilIdle();
     storage::ExternalMountPoints::GetSystemInstance()->RevokeAllFileSystems();
     DiskMountManager::Shutdown();
   }
 
   void SetUp() override {
     // Disable network interface reporting since it requires additional setup.
     settings_helper_.SetBoolean(chromeos::kReportDeviceNetworkInterfaces,
                                 false);
   }
 
@@ skipping 521 matching lines @@
     info.set_storage_free(size++);
     expected_volume_info.push_back(info);
   }
   EXPECT_FALSE(expected_volume_info.empty());
 
   RestartStatusCollector(base::Bind(&GetFakeVolumeInfo, expected_volume_info),
                          base::Bind(&GetEmptyCPUStatistics),
                          base::Bind(&GetEmptyCPUTempInfo),
                          base::Bind(&GetEmptyAndroidStatus));
   // Force finishing tasks posted by ctor of DeviceStatusCollector.
-  content::BrowserThread::GetBlockingPool()->FlushForTesting();
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
 
   GetStatus();
   EXPECT_EQ(expected_mount_points.size(),
             static_cast<size_t>(device_status_.volume_info_size()));
 
   // Walk the returned VolumeInfo to make sure it matches.
   for (const em::VolumeInfo& expected_info : expected_volume_info) {
     bool found = false;
     for (const em::VolumeInfo& info : device_status_.volume_info()) {
       if (info.volume_id() == expected_info.volume_id()) {
@@ skipping 32 matching lines @@
 }
 
 TEST_F(DeviceStatusCollectorTest, TestCPUSamples) {
   // Mock 100% CPU usage.
   std::string full_cpu_usage("cpu  500 0 500 0 0 0 0");
   RestartStatusCollector(base::Bind(&GetEmptyVolumeInfo),
                          base::Bind(&GetFakeCPUStatistics, full_cpu_usage),
                          base::Bind(&GetEmptyCPUTempInfo),
                          base::Bind(&GetEmptyAndroidStatus));
   // Force finishing tasks posted by ctor of DeviceStatusCollector.
-  content::BrowserThread::GetBlockingPool()->FlushForTesting();
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
   GetStatus();
   ASSERT_EQ(1, device_status_.cpu_utilization_pct().size());
   EXPECT_EQ(100, device_status_.cpu_utilization_pct(0));
 
   // Now sample CPU usage again (active usage counters will not increase
   // so should show 0% cpu usage).
   status_collector_->RefreshSampleResourceUsage();
   base::RunLoop().RunUntilIdle();
   GetStatus();
   ASSERT_EQ(2, device_status_.cpu_utilization_pct().size());
@@ skipping 30 matching lines @@
     info.set_cpu_temp(i * 10 + 100);
     info.set_cpu_label(base::StringPrintf("Core %d", i));
     expected_temp_info.push_back(info);
   }
 
   RestartStatusCollector(base::Bind(&GetEmptyVolumeInfo),
                          base::Bind(&GetEmptyCPUStatistics),
                          base::Bind(&GetFakeCPUTempInfo, expected_temp_info),
                          base::Bind(&GetEmptyAndroidStatus));
   // Force finishing tasks posted by ctor of DeviceStatusCollector.
-  content::BrowserThread::GetBlockingPool()->FlushForTesting();
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
 
   GetStatus();
   EXPECT_EQ(expected_temp_info.size(),
             static_cast<size_t>(device_status_.cpu_temp_info_size()));
 
   // Walk the returned CPUTempInfo to make sure it matches.
   for (const em::CPUTempInfo& expected_info : expected_temp_info) {
     bool found = false;
     for (const em::CPUTempInfo& info : device_status_.cpu_temp_info()) {
       if (info.cpu_label() == expected_info.cpu_label()) {
@@ skipping 583 matching lines @@
       AccountId::FromUserEmail(kPublicAccountId));
   EXPECT_CALL(*user_manager_, IsLoggedInAsPublicAccount())
       .WillRepeatedly(Return(true));
 
   settings_helper_.SetBoolean(chromeos::kReportDeviceNetworkInterfaces, true);
   GetStatus();
   VerifyNetworkReporting();
 }
 
 }  // namespace policy