Removing public access to AudioManager device info interface.

media/audio/audio_manager_unittest.cc

 // Copyright 2013 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 "media/audio/audio_manager.h"
 
 #include <memory>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/environment.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_message_loop.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "media/audio/audio_device_description.h"
+#include "media/audio/audio_device_info_accessor_for_tests.h"
 #include "media/audio/audio_device_name.h"
 #include "media/audio/audio_output_proxy.h"
 #include "media/audio/audio_unittest_util.h"
 #include "media/audio/fake_audio_log_factory.h"
 #include "media/audio/fake_audio_manager.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(USE_ALSA)
 #include "media/audio/alsa/audio_manager_alsa.h"
@@ skipping 165 matching lines @@
     stream->Close();
 
     // Create a non-default device and ensure it gets a different dispatcher.
     stream = audio_manager_->MakeAudioOutputStreamProxy(params, "123456");
     ASSERT_NE(dispatcher1, reinterpret_cast<AudioOutputProxy*>(stream)
                                ->get_dispatcher_for_testing());
     stream->Close();
   }
 
   void GetDefaultOutputStreamParameters(media::AudioParameters* params) {
-    *params = audio_manager_->GetDefaultOutputStreamParameters();
+    *params = device_info_accessor_->GetDefaultOutputStreamParameters();
   }
 
   void GetAssociatedOutputDeviceID(const std::string& input_device_id,
                                    std::string* output_device_id) {
     *output_device_id =
-        audio_manager_->GetAssociatedOutputDeviceID(input_device_id);
+        device_info_accessor_->GetAssociatedOutputDeviceID(input_device_id);
   }
 
 #if defined(USE_CRAS)
   void TearDown() override {
     chromeos::CrasAudioHandler::Shutdown();
     audio_pref_handler_ = nullptr;
     chromeos::DBusThreadManager::Shutdown();
   }
 
   void SetUpCrasAudioHandlerWithTestingNodes(const AudioNodeList& audio_nodes) {
@@ skipping 89 matching lines @@
     } else {
       // Log a warning so we can see the status on the build bots. No need to
       // break the test though since this does successfully test the code and
       // some failure cases.
       LOG(WARNING) << "No input devices detected";
     }
   }
 #endif  // defined(USE_CRAS)
 
   bool InputDevicesAvailable() {
-    return audio_manager_->HasAudioInputDevices();
+    return device_info_accessor_->HasAudioInputDevices();
   }
   bool OutputDevicesAvailable() {
-    return audio_manager_->HasAudioOutputDevices();
+    return device_info_accessor_->HasAudioOutputDevices();
   }
 
   template <typename T = std::nullptr_t>
   void CreateAudioManagerForTesting() {
     // Only one AudioManager may exist at a time, so destroy the one we're
     // currently holding before creating a new one.
     // Flush the message loop to run any shutdown tasks posted by AudioManager.
     audio_manager_.reset();
     base::RunLoop().RunUntilIdle();
 
     audio_manager_ =
         TestAudioManagerFactory<T>::Create(&fake_audio_log_factory_);
     // A few AudioManager implementations post initialization tasks to
     // audio thread. Flush the thread to ensure that |audio_manager_| is
     // initialized and ready to use before returning from this function.
     // TODO(alokp): We should perhaps do this in AudioManager::Create().
     base::RunLoop().RunUntilIdle();
+    device_info_accessor_ =
+        base::MakeUnique<AudioDeviceInfoAccessorForTests>(audio_manager_.get());
   }
 
   base::TestMessageLoop message_loop_;
   FakeAudioLogFactory fake_audio_log_factory_;
   ScopedAudioManagerPtr audio_manager_;
+  std::unique_ptr<AudioDeviceInfoAccessorForTests> device_info_accessor_;
 
 #if defined(USE_CRAS)
   chromeos::CrasAudioHandler* cras_audio_handler_ = nullptr;  // Not owned.
   chromeos::FakeCrasAudioClient* audio_client_ = nullptr;     // Not owned.
   scoped_refptr<chromeos::AudioDevicesPrefHandlerStub> audio_pref_handler_;
 #endif  // defined(USE_CRAS)
 };
 
 #if defined(USE_CRAS)
 TEST_F(AudioManagerTest, EnumerateInputDevicesCras) {
@@ skipping 14 matching lines @@
   expectation[kJabraMic1.id] =
       cras_audio_handler_->GetDeviceFromId(kJabraMic1.id)->display_name;
   expectation[kJabraMic2.id] =
       cras_audio_handler_->GetDeviceFromId(kJabraMic2.id)->display_name;
   expectation[kUSBCameraMic.id] =
       cras_audio_handler_->GetDeviceFromId(kUSBCameraMic.id)->display_name;
 
   DVLOG(2) << "Testing AudioManagerCras.";
   CreateAudioManagerForTesting<AudioManagerCras>();
   AudioDeviceDescriptions device_descriptions;
-  audio_manager_->GetAudioInputDeviceDescriptions(&device_descriptions);
+  device_info_accessor_->GetAudioInputDeviceDescriptions(&device_descriptions);
   CheckDeviceDescriptionsCras(device_descriptions, expectation);
 }
 
 TEST_F(AudioManagerTest, EnumerateOutputDevicesCras) {
   // Setup the devices without internal mic, so that it doesn't exist
   // beamforming capable mic.
   AudioNodeList audio_nodes;
   audio_nodes.push_back(kJabraMic1);
   audio_nodes.push_back(kJabraMic2);
   audio_nodes.push_back(kUSBCameraMic);
   audio_nodes.push_back(kHDMIOutput);
   audio_nodes.push_back(kJabraSpeaker1);
   SetUpCrasAudioHandlerWithTestingNodes(audio_nodes);
 
   ABORT_AUDIO_TEST_IF_NOT(OutputDevicesAvailable());
 
   // Setup expectation with physical devices.
   std::map<uint64_t, std::string> expectation;
   expectation[kHDMIOutput.id] =
       cras_audio_handler_->GetDeviceFromId(kHDMIOutput.id)->display_name;
   expectation[kJabraSpeaker1.id] =
       cras_audio_handler_->GetDeviceFromId(kJabraSpeaker1.id)->display_name;
 
   DVLOG(2) << "Testing AudioManagerCras.";
   CreateAudioManagerForTesting<AudioManagerCras>();
   AudioDeviceDescriptions device_descriptions;
-  audio_manager_->GetAudioOutputDeviceDescriptions(&device_descriptions);
+  device_info_accessor_->GetAudioOutputDeviceDescriptions(&device_descriptions);
   CheckDeviceDescriptionsCras(device_descriptions, expectation);
 }
 #else  // !defined(USE_CRAS)
 
 TEST_F(AudioManagerTest, HandleDefaultDeviceIDs) {
   // Use a fake manager so we can makeup device ids, this will still use the
   // AudioManagerBase code.
   CreateAudioManagerForTesting<FakeAudioManager>();
   HandleDefaultDeviceIDsTest();
   base::RunLoop().RunUntilIdle();
 }
 
 // Test that devices can be enumerated.
 TEST_F(AudioManagerTest, EnumerateInputDevices) {
   ABORT_AUDIO_TEST_IF_NOT(InputDevicesAvailable());
 
   AudioDeviceDescriptions device_descriptions;
-  audio_manager_->GetAudioInputDeviceDescriptions(&device_descriptions);
+  device_info_accessor_->GetAudioInputDeviceDescriptions(&device_descriptions);
   CheckDeviceDescriptions(device_descriptions);
 }
 
 // Test that devices can be enumerated.
 TEST_F(AudioManagerTest, EnumerateOutputDevices) {
   ABORT_AUDIO_TEST_IF_NOT(OutputDevicesAvailable());
 
   AudioDeviceDescriptions device_descriptions;
-  audio_manager_->GetAudioOutputDeviceDescriptions(&device_descriptions);
+  device_info_accessor_->GetAudioOutputDeviceDescriptions(&device_descriptions);
   CheckDeviceDescriptions(device_descriptions);
 }
 
 // Run additional tests for Windows since enumeration can be done using
 // two different APIs. MMDevice is default for Vista and higher and Wave
 // is default for XP and lower.
 #if defined(OS_WIN)
 
 // Override default enumeration API and force usage of Windows MMDevice.
 // This test will only run on Windows Vista and higher.
 TEST_F(AudioManagerTest, EnumerateInputDevicesWinMMDevice) {
   ABORT_AUDIO_TEST_IF_NOT(InputDevicesAvailable());
 
   AudioDeviceDescriptions device_descriptions;
-  audio_manager_->GetAudioInputDeviceDescriptions(&device_descriptions);
+  device_info_accessor_->GetAudioInputDeviceDescriptions(&device_descriptions);
   CheckDeviceDescriptions(device_descriptions);
 }
 
 TEST_F(AudioManagerTest, EnumerateOutputDevicesWinMMDevice) {
   ABORT_AUDIO_TEST_IF_NOT(OutputDevicesAvailable());
 
   AudioDeviceDescriptions device_descriptions;
-  audio_manager_->GetAudioOutputDeviceDescriptions(&device_descriptions);
+  device_info_accessor_->GetAudioOutputDeviceDescriptions(&device_descriptions);
   CheckDeviceDescriptions(device_descriptions);
 }
 #endif  // defined(OS_WIN)
 
 #if defined(USE_PULSEAUDIO)
 // On Linux, there are two implementations available and both can
 // sometimes be tested on a single system. These tests specifically
 // test Pulseaudio.
 
 TEST_F(AudioManagerTest, EnumerateInputDevicesPulseaudio) {
   ABORT_AUDIO_TEST_IF_NOT(InputDevicesAvailable());
 
   CreateAudioManagerForTesting<AudioManagerPulse>();
   if (audio_manager_.get()) {
     AudioDeviceDescriptions device_descriptions;
-    audio_manager_->GetAudioInputDeviceDescriptions(&device_descriptions);
+    device_info_accessor_->GetAudioInputDeviceDescriptions(
+        &device_descriptions);
     CheckDeviceDescriptions(device_descriptions);
   } else {
     LOG(WARNING) << "No pulseaudio on this system.";
   }
 }
 
 TEST_F(AudioManagerTest, EnumerateOutputDevicesPulseaudio) {
   ABORT_AUDIO_TEST_IF_NOT(OutputDevicesAvailable());
 
   CreateAudioManagerForTesting<AudioManagerPulse>();
   if (audio_manager_.get()) {
     AudioDeviceDescriptions device_descriptions;
-    audio_manager_->GetAudioOutputDeviceDescriptions(&device_descriptions);
+    device_info_accessor_->GetAudioOutputDeviceDescriptions(
+        &device_descriptions);
     CheckDeviceDescriptions(device_descriptions);
   } else {
     LOG(WARNING) << "No pulseaudio on this system.";
   }
 }
 #endif  // defined(USE_PULSEAUDIO)
 
 #if defined(USE_ALSA)
 // On Linux, there are two implementations available and both can
 // sometimes be tested on a single system. These tests specifically
 // test Alsa.
 
 TEST_F(AudioManagerTest, EnumerateInputDevicesAlsa) {
   ABORT_AUDIO_TEST_IF_NOT(InputDevicesAvailable());
 
   DVLOG(2) << "Testing AudioManagerAlsa.";
   CreateAudioManagerForTesting<AudioManagerAlsa>();
   AudioDeviceDescriptions device_descriptions;
-  audio_manager_->GetAudioInputDeviceDescriptions(&device_descriptions);
+  device_info_accessor_->GetAudioInputDeviceDescriptions(&device_descriptions);
   CheckDeviceDescriptions(device_descriptions);
 }
 
 TEST_F(AudioManagerTest, EnumerateOutputDevicesAlsa) {
   ABORT_AUDIO_TEST_IF_NOT(OutputDevicesAvailable());
 
   DVLOG(2) << "Testing AudioManagerAlsa.";
   CreateAudioManagerForTesting<AudioManagerAlsa>();
   AudioDeviceDescriptions device_descriptions;
-  audio_manager_->GetAudioOutputDeviceDescriptions(&device_descriptions);
+  device_info_accessor_->GetAudioOutputDeviceDescriptions(&device_descriptions);
   CheckDeviceDescriptions(device_descriptions);
 }
 #endif  // defined(USE_ALSA)
 
 TEST_F(AudioManagerTest, GetDefaultOutputStreamParameters) {
 #if defined(OS_WIN) || defined(OS_MACOSX)
   ABORT_AUDIO_TEST_IF_NOT(InputDevicesAvailable());
 
   AudioParameters params;
   GetDefaultOutputStreamParameters(&params);
   EXPECT_TRUE(params.IsValid());
 #endif  // defined(OS_WIN) || defined(OS_MACOSX)
 }
 
 TEST_F(AudioManagerTest, GetAssociatedOutputDeviceID) {
 #if defined(OS_WIN) || defined(OS_MACOSX)
   ABORT_AUDIO_TEST_IF_NOT(InputDevicesAvailable() && OutputDevicesAvailable());
 
   AudioDeviceDescriptions device_descriptions;
-  audio_manager_->GetAudioInputDeviceDescriptions(&device_descriptions);
+  device_info_accessor_->GetAudioInputDeviceDescriptions(&device_descriptions);
   bool found_an_associated_device = false;
   for (const auto& description : device_descriptions) {
     EXPECT_FALSE(description.unique_id.empty());
     EXPECT_FALSE(description.device_name.empty());
     EXPECT_FALSE(description.group_id.empty());
     std::string output_device_id;
     GetAssociatedOutputDeviceID(description.unique_id, &output_device_id);
     if (!output_device_id.empty()) {
       DVLOG(2) << description.unique_id << " matches with " << output_device_id;
       found_an_associated_device = true;
@@ skipping 74 matching lines @@
 
 TEST_F(AudioManagerTest, GroupId) {
   CreateAudioManagerForTesting<TestAudioManager>();
   // Groups:
   // input1, output1, default input
   // input2, output2
   // input3,
   // output3
   // output4, default output
   AudioDeviceDescriptions inputs;
-  audio_manager_->GetAudioInputDeviceDescriptions(&inputs);
+  device_info_accessor_->GetAudioInputDeviceDescriptions(&inputs);
   AudioDeviceDescriptions outputs;
-  audio_manager_->GetAudioOutputDeviceDescriptions(&outputs);
+  device_info_accessor_->GetAudioOutputDeviceDescriptions(&outputs);
   EXPECT_EQ(inputs[0].group_id, outputs[1].group_id);
   EXPECT_EQ(inputs[1].group_id, outputs[1].group_id);
   EXPECT_EQ(inputs[2].group_id, outputs[2].group_id);
   EXPECT_NE(inputs[3].group_id, outputs[3].group_id);
   EXPECT_EQ(outputs[4].group_id, outputs[0].group_id);
   EXPECT_NE(inputs[0].group_id, outputs[0].group_id);
   EXPECT_NE(inputs[1].group_id, outputs[2].group_id);
   EXPECT_NE(inputs[2].group_id, outputs[3].group_id);
   EXPECT_NE(inputs[1].group_id, outputs[3].group_id);
 }
@@ skipping 19 matching lines @@
 
   base::FilePath file_path(FILE_PATH_LITERAL("path"));
   EXPECT_CALL(*mock_debug_recording_manager, EnableDebugRecording(file_path));
   audio_manager_->EnableOutputDebugRecording(file_path);
 
   EXPECT_CALL(*mock_debug_recording_manager, DisableDebugRecording());
   audio_manager_->DisableOutputDebugRecording();
 }
 
 }  // namespace media