Remove calls to deprecated MessageLoop methods in chromeos.

chromeos/dbus/cras_audio_client_unittest.cc

 // Copyright 2016 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 "chromeos/dbus/cras_audio_client.h"
 
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
 #include "dbus/message.h"
 #include "dbus/mock_bus.h"
 #include "dbus/mock_object_proxy.h"
 #include "dbus/object_path.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 using ::testing::_;
 using ::testing::Invoke;
@@ skipping 276 matching lines @@
                                dbus::ObjectPath(cras::kCrasServicePath)))
         .WillOnce(Return(mock_cras_proxy_.get()));
 
     // ShutdownAndBlock() will be called in TearDown().
     EXPECT_CALL(*mock_bus_.get(), ShutdownAndBlock()).WillOnce(Return());
 
     // Create a client with the mock bus.
     client_.reset(CrasAudioClient::Create());
     client_->Init(mock_bus_.get());
     // Run the message loop to run the signal connection result callback.
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   void TearDown() override { mock_bus_->ShutdownAndBlock(); }
 
  protected:
   // A callback to intercept and check the method call arguments.
   typedef base::Callback<void(
       dbus::MessageReader* reader)> ArgumentCheckCallback;
 
   // Sets expectations for called method name and arguments, and sets response.
@@ skipping 212 matching lines @@
   SendOutputMuteChangedSignal(&signal);
 
   // Remove the observer.
   client_->RemoveObserver(&observer);
 
   EXPECT_CALL(observer, OutputMuteChanged(_)).Times(0);
 
   // Run the signal callback again and make sure the observer isn't called.
   SendOutputMuteChangedSignal(&signal);
 
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(CrasAudioClientTest, InputMuteChanged) {
   const bool kInputMuteOn = true;
   // Create a signal.
   dbus::Signal signal(cras::kCrasControlInterface,
                       cras::kInputMuteChanged);
   dbus::MessageWriter writer(&signal);
   writer.AppendBool(kInputMuteOn);
 
   // Set expectations.
   MockObserver observer;
   EXPECT_CALL(observer, InputMuteChanged(kInputMuteOn)).Times(1);
 
   // Add the observer.
   client_->AddObserver(&observer);
 
   // Run the signal callback.
   SendInputMuteChangedSignal(&signal);
 
   // Remove the observer.
   client_->RemoveObserver(&observer);
 
   EXPECT_CALL(observer, InputMuteChanged(_)).Times(0);
 
   // Run the signal callback again and make sure the observer isn't called.
   SendInputMuteChangedSignal(&signal);
 
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(CrasAudioClientTest, NodesChanged) {
   // Create a signal.
   dbus::Signal signal(cras::kCrasControlInterface,
                       cras::kNodesChanged);
   // Set expectations.
   MockObserver observer;
   EXPECT_CALL(observer, NodesChanged()).Times(1);
 
   // Add the observer.
   client_->AddObserver(&observer);
 
   // Run the signal callback.
   SendNodesChangedSignal(&signal);
 
   // Remove the observer.
   client_->RemoveObserver(&observer);
 
   EXPECT_CALL(observer, NodesChanged()).Times(0);
 
   // Run the signal callback again and make sure the observer isn't called.
   SendNodesChangedSignal(&signal);
 
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(CrasAudioClientTest, ActiveOutputNodeChanged) {
   const uint64_t kNodeId = 10002;
   // Create a signal.
   dbus::Signal signal(cras::kCrasControlInterface,
                       cras::kActiveOutputNodeChanged);
   dbus::MessageWriter writer(&signal);
   writer.AppendUint64(kNodeId);
 
   // Set expectations.
   MockObserver observer;
   EXPECT_CALL(observer, ActiveOutputNodeChanged(kNodeId)).Times(1);
 
   // Add the observer.
   client_->AddObserver(&observer);
 
   // Run the signal callback.
   SendActiveOutputNodeChangedSignal(&signal);
 
   // Remove the observer.
   client_->RemoveObserver(&observer);
   EXPECT_CALL(observer, ActiveOutputNodeChanged(_)).Times(0);
 
   // Run the signal callback again and make sure the observer isn't called.
   SendActiveOutputNodeChangedSignal(&signal);
 
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(CrasAudioClientTest, ActiveInputNodeChanged) {
   const uint64_t kNodeId = 20002;
   // Create a signal.
   dbus::Signal signal(cras::kCrasControlInterface,
                       cras::kActiveInputNodeChanged);
   dbus::MessageWriter writer(&signal);
   writer.AppendUint64(kNodeId);
 
   // Set expectations.
   MockObserver observer;
   EXPECT_CALL(observer, ActiveInputNodeChanged(kNodeId)).Times(1);
 
   // Add the observer.
   client_->AddObserver(&observer);
 
   // Run the signal callback.
   SendActiveInputNodeChangedSignal(&signal);
 
   // Remove the observer.
   client_->RemoveObserver(&observer);
   EXPECT_CALL(observer, ActiveInputNodeChanged(_)).Times(0);
 
   // Run the signal callback again and make sure the observer isn't called.
   SendActiveInputNodeChangedSignal(&signal);
 
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(CrasAudioClientTest, OutputNodeVolumeChanged) {
   const uint64_t kNodeId = 20003;
   const int32_t volume = 82;
   // Create a signal
   dbus::Signal signal(cras::kCrasControlInterface,
                       cras::kOutputNodeVolumeChanged);
   dbus::MessageWriter writer(&signal);
   writer.AppendUint64(kNodeId);
   writer.AppendInt32(volume);
 
   // Set expectations
   MockObserver observer;
   EXPECT_CALL(observer, OutputNodeVolumeChanged(kNodeId, volume)).Times(1);
 
   // Add the observer.
   client_->AddObserver(&observer);
 
   // Run the signal callback.
   SendOutputNodeVolumeChangedSignal(&signal);
 
   // Remove the observer.
   client_->RemoveObserver(&observer);
   EXPECT_CALL(observer, OutputNodeVolumeChanged(_, _)).Times(0);
 
   // Run the signal callback again and make sure the observer isn't called.
   SendOutputNodeVolumeChangedSignal(&signal);
 
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(CrasAudioClientTest, GetNodes) {
   // Create the expected value.
   AudioNodeList expected_node_list;
   expected_node_list.push_back(kInternalSpeaker);
   expected_node_list.push_back(kInternalMic);
 
   // Create response.
   std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
   dbus::MessageWriter writer(response.get());
   WriteNodesToResponse(writer, expected_node_list);
 
   // Set expectations.
   PrepareForMethodCall(cras::kGetNodes,
                        base::Bind(&ExpectNoArgument),
                        response.get());
   // Call method.
   MockErrorCallback error_callback;
   client_->GetNodes(base::Bind(&ExpectAudioNodeListResult,
                                &expected_node_list),
                     error_callback.GetCallback());
   EXPECT_CALL(error_callback, Run(_, _)).Times(0);
   // Run the message loop.
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(CrasAudioClientTest, SetOutputNodeVolume) {
   const uint64_t kNodeId = 10003;
   const int32_t kVolume = 80;
   // Create response.
   std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
 
   // Set expectations.
   PrepareForMethodCall(cras::kSetOutputNodeVolume,
                        base::Bind(&ExpectUint64AndInt32Arguments,
                                   kNodeId,
                                   kVolume),
                        response.get());
   // Call method.
   client_->SetOutputNodeVolume(kNodeId, kVolume);
   // Run the message loop.
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(CrasAudioClientTest, SetOutputUserMute) {
   const bool kUserMuteOn = true;
   // Create response.
   std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
 
   // Set expectations.
   PrepareForMethodCall(cras::kSetOutputUserMute,
                        base::Bind(&ExpectBoolArgument, kUserMuteOn),
                        response.get());
   // Call method.
   client_->SetOutputUserMute(kUserMuteOn);
   // Run the message loop.
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(CrasAudioClientTest, SetInputNodeGain) {
   const uint64_t kNodeId = 20003;
   const int32_t kInputGain = 2;
   // Create response.
   std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
 
   // Set expectations.
   PrepareForMethodCall(cras::kSetInputNodeGain,
                        base::Bind(&ExpectUint64AndInt32Arguments,
                                   kNodeId,
                                   kInputGain),
                        response.get());
   // Call method.
   client_->SetInputNodeGain(kNodeId, kInputGain);
   // Run the message loop.
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(CrasAudioClientTest, SetInputMute) {
   const bool kInputMuteOn = true;
   // Create response.
   std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
 
   // Set expectations.
   PrepareForMethodCall(cras::kSetInputMute,
                        base::Bind(&ExpectBoolArgument, kInputMuteOn),
                        response.get());
   // Call method.
   client_->SetInputMute(kInputMuteOn);
   // Run the message loop.
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(CrasAudioClientTest, SetActiveOutputNode) {
   const uint64_t kNodeId = 10004;
   // Create response.
   std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
 
   // Set expectations.
   PrepareForMethodCall(cras::kSetActiveOutputNode,
                        base::Bind(&ExpectUint64Argument, kNodeId),
                        response.get());
   // Call method.
   client_->SetActiveOutputNode(kNodeId);
   // Run the message loop.
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(CrasAudioClientTest, SetActiveInputNode) {
   const uint64_t kNodeId = 20004;
   // Create response.
   std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
 
   // Set expectations.
   PrepareForMethodCall(cras::kSetActiveInputNode,
                        base::Bind(&ExpectUint64Argument, kNodeId),
                        response.get());
   // Call method.
   client_->SetActiveInputNode(kNodeId);
   // Run the message loop.
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(CrasAudioClientTest, AddActiveInputNode) {
   const uint64_t kNodeId = 20005;
   // Create response.
   std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
 
   // Set expectations.
   PrepareForMethodCall(cras::kAddActiveInputNode,
                        base::Bind(&ExpectUint64Argument, kNodeId),
                        response.get());
   // Call method.
   client_->AddActiveInputNode(kNodeId);
   // Run the message loop.
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(CrasAudioClientTest, RemoveActiveInputNode) {
   const uint64_t kNodeId = 20006;
   // Create response.
   std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
 
   // Set expectations.
   PrepareForMethodCall(cras::kRemoveActiveInputNode,
                        base::Bind(&ExpectUint64Argument, kNodeId),
                        response.get());
   // Call method.
   client_->RemoveActiveInputNode(kNodeId);
   // Run the message loop.
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(CrasAudioClientTest, AddActiveOutputNode) {
   const uint64_t kNodeId = 10005;
   // Create response.
   std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
 
   // Set expectations.
   PrepareForMethodCall(cras::kAddActiveOutputNode,
                        base::Bind(&ExpectUint64Argument, kNodeId),
                        response.get());
   // Call method.
   client_->AddActiveOutputNode(kNodeId);
   // Run the message loop.
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(CrasAudioClientTest, RemoveActiveOutputNode) {
   const uint64_t kNodeId = 10006;
   // Create response.
   std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
 
   // Set expectations.
   PrepareForMethodCall(cras::kRemoveActiveOutputNode,
                        base::Bind(&ExpectUint64Argument, kNodeId),
                        response.get());
   // Call method.
   client_->RemoveActiveOutputNode(kNodeId);
   // Run the message loop.
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(CrasAudioClientTest, SwapLeftRight) {
   const uint64_t kNodeId = 10007;
   const bool kSwap = true;
   // Create response.
   std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
 
   // Set expectations.
   PrepareForMethodCall(cras::kSwapLeftRight,
                        base::Bind(&ExpectUint64AndBoolArguments,
                                   kNodeId,
                                   kSwap),
                        response.get());
   // Call method.
   client_->SwapLeftRight(kNodeId, kSwap);
   // Run the message loop.
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(CrasAudioClientTest, SetGlobalOutputChannelRemix) {
   const int32_t kChannels = 2;
   const std::vector<double> kMixer = {0, 0.1, 0.5, 1};
   // Create response.
   std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
 
   // Set expectations.
   PrepareForMethodCall(cras::kSetGlobalOutputChannelRemix,
                        base::Bind(&ExpectInt32AndArrayOfDoublesArguments,
                                   kChannels,
                                   kMixer),
                        response.get());
 
   // Call method.
   client_->SetGlobalOutputChannelRemix(kChannels, kMixer);
   // Run the message loop.
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace chromeos