Remove calls to deprecated MessageLoop methods in chrome.

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 316 matching lines @@
             mount_point, mount_point, chromeos::MOUNT_TYPE_DEVICE,
             chromeos::disks::MOUNT_CONDITION_NONE)));
   }
 
   ~DeviceStatusCollectorTest() override {
     chromeos::KioskAppManager::Shutdown();
     TestingBrowserProcess::GetGlobal()->SetLocalState(nullptr);
 
     // Finish pending tasks.
     content::BrowserThread::GetBlockingPool()->FlushForTesting();
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
     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 119 matching lines @@
     manager->SetEnableAutoLaunch(true);
 
     std::vector<DeviceLocalAccount> accounts;
     accounts.push_back(auto_launch_app_account);
     SetDeviceLocalAccounts(owner_settings_service_.get(), accounts);
 
     owner_settings_service_->SetString(
         chromeos::kAccountsPrefDeviceLocalAccountAutoLoginId,
         auto_launch_app_account.account_id);
 
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
 
     ASSERT_EQ(required_platform_version,
               manager->GetAutoLaunchAppRequiredPlatformVersion());
   }
 
  protected:
   // Convenience method.
   int64_t ActivePeriodMilliseconds() {
     return policy::DeviceStatusCollector::kIdlePollIntervalSeconds * 1000;
   }
@@ skipping 247 matching lines @@
             kMillisecondsPerDay);
   EXPECT_EQ(time_period1.end_timestamp() - time_period1.start_timestamp(),
             kMillisecondsPerDay);
 }
 
 TEST_F(DeviceStatusCollectorTest, ActivityTimesKeptUntilSubmittedSuccessfully) {
   ui::IdleState test_states[] = {
     ui::IDLE_STATE_ACTIVE,
     ui::IDLE_STATE_ACTIVE,
   };
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   settings_helper_.SetBoolean(chromeos::kReportDeviceActivityTimes, true);
 
   status_collector_->Simulate(test_states, 2);
   GetDeviceStatus();
   EXPECT_EQ(2 * ActivePeriodMilliseconds(),
             GetActiveMilliseconds(device_status_));
   em::DeviceStatusReportRequest first_status(device_status_);
 
   // The collector returns the same status again.
   GetDeviceStatus();
@@ skipping 106 matching lines @@
                          base::Bind(&GetEmptyCPUStatistics),
                          base::Bind(&GetEmptyCPUTempInfo));
   CheckThatAValidLocationIsReported();
   EXPECT_TRUE(mock_position_to_return_next.get());
 
   // Check that after disabling location reporting again, the last known
   // location has been cleared from local state and is no longer reported.
   SetMockPositionToReturnNext(valid_fix);
   settings_helper_.SetBoolean(chromeos::kReportDeviceLocation, false);
   // Allow the new pref to propagate to the status collector.
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(prefs_.GetDictionary(prefs::kDeviceLocation)->empty());
   CheckThatNoLocationIsReported();
 
   // Check that after enabling location reporting again, an error is reported
   // if no valid fix is available.
   SetMockPositionToReturnNext(invalid_fix);
   settings_helper_.SetBoolean(chromeos::kReportDeviceLocation, true);
   // Allow the new pref to propagate to the status collector.
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   CheckThatALocationErrorIsReported();
 }
 
 TEST_F(DeviceStatusCollectorTest, ReportUsers) {
   const AccountId public_account_id(
       AccountId::FromUserEmail("public@localhost"));
   const AccountId account_id0(AccountId::FromUserEmail("user0@managed.com"));
   const AccountId account_id1(AccountId::FromUserEmail("user1@managed.com"));
   const AccountId account_id2(AccountId::FromUserEmail("user2@managed.com"));
   const AccountId account_id3(AccountId::FromUserEmail("user3@unmanaged.com"));
@@ skipping 53 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));
   // Force finishing tasks posted by ctor of DeviceStatusCollector.
   content::BrowserThread::GetBlockingPool()->FlushForTesting();
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   GetDeviceStatus();
   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 13 matching lines @@
   EXPECT_EQ(0, device_status_.volume_info_size());
 }
 
 TEST_F(DeviceStatusCollectorTest, TestAvailableMemory) {
   // Refresh our samples. Sample more than kMaxHardwareSamples times to
   // make sure that the code correctly caps the number of cached samples.
   for (int i = 0; i < static_cast<int>(
                           DeviceStatusCollector::kMaxResourceUsageSamples + 1);
        ++i) {
     status_collector_->RefreshSampleResourceUsage();
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
   GetDeviceStatus();
   EXPECT_EQ(static_cast<int>(DeviceStatusCollector::kMaxResourceUsageSamples),
             device_status_.system_ram_free().size());
   EXPECT_TRUE(device_status_.has_system_ram_total());
   // No good way to inject specific test values for available system RAM, so
   // just make sure it's > 0.
   EXPECT_GT(device_status_.system_ram_total(), 0);
 }
 
 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));
   // Force finishing tasks posted by ctor of DeviceStatusCollector.
   content::BrowserThread::GetBlockingPool()->FlushForTesting();
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   GetDeviceStatus();
   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();
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   GetDeviceStatus();
   ASSERT_EQ(2, device_status_.cpu_utilization_pct().size());
   EXPECT_EQ(0, device_status_.cpu_utilization_pct(1));
 
   // Now store a bunch of 0% cpu usage and make sure we cap the max number of
   // samples.
   for (int i = 0;
        i < static_cast<int>(DeviceStatusCollector::kMaxResourceUsageSamples);
        ++i) {
     status_collector_->RefreshSampleResourceUsage();
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
   GetDeviceStatus();
 
   // Should not be more than kMaxResourceUsageSamples, and they should all show
   // the CPU is idle.
   EXPECT_EQ(static_cast<int>(DeviceStatusCollector::kMaxResourceUsageSamples),
             device_status_.cpu_utilization_pct().size());
   for (const auto utilization : device_status_.cpu_utilization_pct())
     EXPECT_EQ(0, utilization);
 
@@ skipping 11 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));
   // Force finishing tasks posted by ctor of DeviceStatusCollector.
   content::BrowserThread::GetBlockingPool()->FlushForTesting();
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   GetDeviceStatus();
   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 465 matching lines @@
       AccountId::FromUserEmail(kPublicAccountId));
   EXPECT_CALL(*user_manager_, IsLoggedInAsPublicAccount())
       .WillRepeatedly(Return(true));
 
   settings_helper_.SetBoolean(chromeos::kReportDeviceNetworkInterfaces, true);
   GetDeviceStatus();
   VerifyNetworkReporting();
 }
 
 }  // namespace policy