Remove calls to deprecated MessageLoop methods in extensions.

extensions/browser/api/alarms/alarms_api_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.
 
 // This file tests the chrome.alarms extension API.
 
 #include <stddef.h>
 
 #include "base/json/json_reader.h"
+#include "base/run_loop.h"
 #include "base/test/simple_test_clock.h"
 #include "base/values.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "extensions/browser/api/alarms/alarm_manager.h"
 #include "extensions/browser/api/alarms/alarms_api.h"
 #include "extensions/browser/api/alarms/alarms_api_constants.h"
 #include "extensions/browser/api_test_utils.h"
 #include "extensions/browser/api_unittest.h"
 #include "extensions/common/extension_messages.h"
@@ skipping 99 matching lines @@
 
 void ExtensionAlarmsTestGetAlarmCallback(ExtensionAlarmsTest* test,
                                          Alarm* alarm) {
   ASSERT_TRUE(alarm);
   EXPECT_EQ("", alarm->js_alarm->name);
   EXPECT_DOUBLE_EQ(10000, alarm->js_alarm->scheduled_time);
   EXPECT_FALSE(alarm->js_alarm->period_in_minutes.get());
 
   // Now wait for the alarm to fire. Our test delegate will quit the
   // MessageLoop when that happens.
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   ASSERT_EQ(1u, test->alarm_delegate_->alarms_seen.size());
   EXPECT_EQ("", test->alarm_delegate_->alarms_seen[0]);
 
   // Ensure the alarm is gone.
   test->alarm_manager_->GetAllAlarms(
       test->extension()->id(),
       base::Bind(ExtensionAlarmsTestGetAllAlarmsCallback));
 }
 
@@ skipping 12 matching lines @@
     Alarm* alarm) {
   ASSERT_TRUE(alarm);
   EXPECT_EQ("", alarm->js_alarm->name);
   EXPECT_DOUBLE_EQ(10060, alarm->js_alarm->scheduled_time);
   EXPECT_THAT(alarm->js_alarm->period_in_minutes,
               testing::Pointee(testing::DoubleEq(0.001)));
 
   test->test_clock_->Advance(base::TimeDelta::FromSeconds(1));
   // Now wait for the alarm to fire. Our test delegate will quit the
   // MessageLoop when that happens.
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   test->test_clock_->Advance(base::TimeDelta::FromSeconds(1));
   // Wait again, and ensure the alarm fires again.
   RunScheduleNextPoll(test->alarm_manager_);
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   ASSERT_EQ(2u, test->alarm_delegate_->alarms_seen.size());
   EXPECT_EQ("", test->alarm_delegate_->alarms_seen[0]);
 }
 
 TEST_F(ExtensionAlarmsTest, CreateRepeating) {
   test_clock_->SetNow(base::Time::FromDoubleT(10));
 
   // Create 1 repeating alarm.
   CreateAlarm("[null, {\"periodInMinutes\": 0.001}]");
@@ skipping 16 matching lines @@
     ExtensionAlarmsTest* test,
     Alarm* alarm) {
   ASSERT_TRUE(alarm);
   EXPECT_EQ("", alarm->js_alarm->name);
   EXPECT_DOUBLE_EQ(10001, alarm->js_alarm->scheduled_time);
   EXPECT_THAT(alarm->js_alarm->period_in_minutes, testing::IsNull());
 
   test->test_clock_->SetNow(base::Time::FromDoubleT(10.1));
   // Now wait for the alarm to fire. Our test delegate will quit the
   // MessageLoop when that happens.
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   test->alarm_manager_->GetAlarm(
       test->extension()->id(), std::string(),
       base::Bind(ExtensionAlarmsTestCreateAbsoluteGetAlarm2Callback, test));
 }
 
 TEST_F(ExtensionAlarmsTest, CreateAbsolute) {
   test_clock_->SetNow(base::Time::FromDoubleT(9.99));
   CreateAlarm("[null, {\"when\": 10001}]");
 
   alarm_manager_->GetAlarm(
       extension()->id(), std::string(),
       base::Bind(ExtensionAlarmsTestCreateAbsoluteGetAlarm1Callback, this));
 }
 
 void ExtensionAlarmsTestCreateRepeatingWithQuickFirstCallGetAlarm3Callback(
     ExtensionAlarmsTest* test,
     Alarm* alarm) {
   ASSERT_TRUE(alarm);
   EXPECT_THAT(test->alarm_delegate_->alarms_seen, testing::ElementsAre("", ""));
 }
 
 void ExtensionAlarmsTestCreateRepeatingWithQuickFirstCallGetAlarm2Callback(
     ExtensionAlarmsTest* test,
     Alarm* alarm) {
   ASSERT_TRUE(alarm);
   EXPECT_THAT(test->alarm_delegate_->alarms_seen, testing::ElementsAre(""));
 
   test->test_clock_->SetNow(base::Time::FromDoubleT(10.7));
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   test->alarm_manager_->GetAlarm(
       test->extension()->id(), std::string(),
       base::Bind(
           ExtensionAlarmsTestCreateRepeatingWithQuickFirstCallGetAlarm3Callback,
           test));
 }
 
 void ExtensionAlarmsTestCreateRepeatingWithQuickFirstCallGetAlarm1Callback(
     ExtensionAlarmsTest* test,
     Alarm* alarm) {
   ASSERT_TRUE(alarm);
   EXPECT_EQ("", alarm->js_alarm->name);
   EXPECT_DOUBLE_EQ(10001, alarm->js_alarm->scheduled_time);
   EXPECT_THAT(alarm->js_alarm->period_in_minutes,
               testing::Pointee(testing::DoubleEq(0.001)));
 
   test->test_clock_->SetNow(base::Time::FromDoubleT(10.1));
   // Now wait for the alarm to fire. Our test delegate will quit the
   // MessageLoop when that happens.
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   test->alarm_manager_->GetAlarm(
       test->extension()->id(), std::string(),
       base::Bind(
           ExtensionAlarmsTestCreateRepeatingWithQuickFirstCallGetAlarm2Callback,
           test));
 }
 
 TEST_F(ExtensionAlarmsTest, CreateRepeatingWithQuickFirstCall) {
   test_clock_->SetNow(base::Time::FromDoubleT(9.99));
@@ skipping 135 matching lines @@
     const AlarmManager::AlarmList* alarms) {
   ASSERT_TRUE(alarms);
   EXPECT_EQ(1u, alarms->size());
   EXPECT_THAT((*alarms)[0]->js_alarm->period_in_minutes,
               testing::Pointee(0.001));
 
   // Now wait for the alarms to fire, and ensure the cancelled alarms don't
   // fire.
   test->test_clock_->Advance(base::TimeDelta::FromMilliseconds(60));
   RunScheduleNextPoll(test->alarm_manager_);
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   ASSERT_EQ(1u, test->alarm_delegate_->alarms_seen.size());
   EXPECT_EQ("", test->alarm_delegate_->alarms_seen[0]);
 
   // Ensure the 0.001-minute alarm is still there, since it's repeating.
   test->alarm_manager_->GetAllAlarms(
       test->extension()->id(),
       base::Bind(ExtensionAlarmsTestClearGetAllAlarms2Callback));
 }
 
@@ skipping 123 matching lines @@
     VerifyScheduledTime("a");
     RemoveAllAlarms();
   }
   {
     test_clock_->SetNow(base::Time::FromDoubleT(3 * 60 + 1));
     std::unique_ptr<Alarm> alarm(new Alarm);
     alarm->js_alarm->name = "bb";
     alarm->js_alarm->scheduled_time = 3 * 60000;
     alarm->js_alarm->period_in_minutes.reset(new double(3));
     alarm_manager_->AddAlarmImpl(extension()->id(), std::move(alarm));
-    base::MessageLoop::current()->Run();
+    base::RunLoop().Run();
     EXPECT_EQ(
         base::Time::FromJsTime(3 * 60000) + base::TimeDelta::FromMinutes(3),
         alarm_manager_->next_poll_time_);
     RemoveAllAlarms();
   }
   {
     test_clock_->SetNow(base::Time::FromDoubleT(4 * 60 + 1));
     CreateAlarm("[\"a\", {\"periodInMinutes\": 2}]");
     RemoveAlarm("a");
     std::unique_ptr<Alarm> alarm2(new Alarm);
     alarm2->js_alarm->name = "bb";
     alarm2->js_alarm->scheduled_time = 4 * 60000;
     alarm2->js_alarm->period_in_minutes.reset(new double(4));
     alarm_manager_->AddAlarmImpl(extension()->id(), std::move(alarm2));
     std::unique_ptr<Alarm> alarm3(new Alarm);
     alarm3->js_alarm->name = "ccc";
     alarm3->js_alarm->scheduled_time = 25 * 60000;
     alarm3->js_alarm->period_in_minutes.reset(new double(25));
     alarm_manager_->AddAlarmImpl(extension()->id(), std::move(alarm3));
-    base::MessageLoop::current()->Run();
+    base::RunLoop().Run();
     EXPECT_EQ(
         base::Time::FromJsTime(4 * 60000) + base::TimeDelta::FromMinutes(4),
         alarm_manager_->next_poll_time_);
     RemoveAllAlarms();
   }
 }
 
 TEST_F(ExtensionAlarmsSchedulingTest, ReleasedExtensionPollsInfrequently) {
   set_extension(
       utils::CreateEmptyExtensionWithLocation(extensions::Manifest::INTERNAL));
@@ skipping 13 matching lines @@
   EXPECT_DOUBLE_EQ((alarm_manager_->last_poll_time_ +
                     base::TimeDelta::FromMinutes(1)).ToJsTime(),
                    alarm_manager_->next_poll_time_.ToJsTime());
 }
 
 TEST_F(ExtensionAlarmsSchedulingTest, TimerRunning) {
   EXPECT_FALSE(alarm_manager_->timer_.IsRunning());
   CreateAlarm("[\"a\", {\"delayInMinutes\": 0.001}]");
   EXPECT_TRUE(alarm_manager_->timer_.IsRunning());
   test_clock_->Advance(base::TimeDelta::FromMilliseconds(60));
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
   EXPECT_FALSE(alarm_manager_->timer_.IsRunning());
   CreateAlarm("[\"bb\", {\"delayInMinutes\": 10}]");
   EXPECT_TRUE(alarm_manager_->timer_.IsRunning());
   RemoveAllAlarms();
   EXPECT_FALSE(alarm_manager_->timer_.IsRunning());
 }
 
 TEST_F(ExtensionAlarmsSchedulingTest, MinimumGranularity) {
   set_extension(
       utils::CreateEmptyExtensionWithLocation(extensions::Manifest::INTERNAL));
@@ skipping 41 matching lines @@
 void FrequencyTestGetAlarmsCallback(ExtensionAlarmsTest* test, Alarm* alarm) {
   ASSERT_TRUE(alarm);
   EXPECT_EQ("hello", alarm->js_alarm->name);
   EXPECT_DOUBLE_EQ(10000, alarm->js_alarm->scheduled_time);
   EXPECT_THAT(alarm->js_alarm->period_in_minutes,
               testing::Pointee(testing::DoubleEq(0.0001)));
 
   test->test_clock_->Advance(base::TimeDelta::FromMilliseconds(10));
   // Now wait for the alarm to fire. Our test delegate will quit the
   // MessageLoop when that happens.
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 }
 
 // Tests that alarms with very small period written to storage are also
 // subjected to minimum polling interval.
 // Regression test for https://crbug.com/618540.
 TEST_F(ExtensionAlarmsSchedulingTest, PollFrequencyFromStoredAlarm) {
   struct {
     bool is_unpacked;
     double delay_minimum;
   } test_data[] = {
@@ skipping 71 matching lines @@
 
   // The next poll should be the first poll that hasn't happened and is in-line
   // with the original scheduling.
   // Last poll was at 380 seconds; next poll should be at 480 seconds.
   EXPECT_DOUBLE_EQ((alarm_manager_->last_poll_time_ +
                     base::TimeDelta::FromSeconds(100)).ToJsTime(),
                    alarm_manager_->next_poll_time_.ToJsTime());
 }
 
 }  // namespace extensions