Switching AudioInputDeviceManager from using AudioManager interface to AudioSystem one.

media/audio/audio_system_impl_unittest.cc

 // Copyright 2017 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_system_impl.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread.h"
@@ skipping 88 matching lines @@
   }
 
   void OnGetDeviceDescriptions(
       const AudioDeviceDescriptions& expected_descriptions,
       AudioDeviceDescriptions descriptions) {
     EXPECT_TRUE(thread_checker_.CalledOnValidThread());
     EXPECT_EQ(expected_descriptions, descriptions);
     DeviceDescriptionsReceived();
   }
 
+  void OnInputDeviceInfo(const AudioParameters& expected_input,
+                         const AudioParameters& expected_associated_output,
+                         const std::string& expected_associated_device_id,
+                         const AudioParameters& input,
+                         const AudioParameters& associated_output,
+                         const std::string& associated_device_id) {
+    EXPECT_TRUE(thread_checker_.CalledOnValidThread());
+    EXPECT_EQ(expected_input.AsHumanReadableString(),
+              input.AsHumanReadableString());
+    EXPECT_EQ(expected_associated_output.AsHumanReadableString(),
+              associated_output.AsHumanReadableString());
+    EXPECT_EQ(expected_associated_device_id, associated_device_id);
+    InputDeviceInfoReceived();
+  }
+
   void WaitForCallback() {
     if (!use_audio_thread_) {
       base::RunLoop().RunUntilIdle();
       return;
     }
     WaitableMessageLoopEvent event;
     audio_thread_.task_runner()->PostTaskAndReply(
         FROM_HERE, base::Bind(&base::DoNothing), event.GetClosure());
     // Runs the loop and waits for the |audio_thread_| to call event's closure,
     // which means AudioSystem reply containing device parameters is already
     // queued on the main thread.
     event.RunAndWait();
     base::RunLoop().RunUntilIdle();
   }
 
   // Mocks to verify that AudioSystem replied with an expected callback.
   MOCK_METHOD0(AudioParametersReceived, void(void));
   MOCK_METHOD1(HasInputDevicesCallback, void(bool));
   MOCK_METHOD0(DeviceDescriptionsReceived, void(void));
+  MOCK_METHOD1(AssociatedOutputDeviceIDReceived, void(const std::string&));
+  MOCK_METHOD0(InputDeviceInfoReceived, void(void));
 
  protected:
   base::MessageLoop message_loop_;
   base::ThreadChecker thread_checker_;
   bool use_audio_thread_;
   base::Thread audio_thread_;
   MockAudioManager::UniquePtr audio_manager_;
   std::unique_ptr<media::AudioSystem> audio_system_;
   AudioParameters input_params_;
   AudioParameters output_params_;
@@ skipping 14 matching lines @@
 TEST_P(AudioSystemImplTest, GetInputStreamParametersNoDevice) {
   audio_manager_->SetHasInputDevices(false);
   EXPECT_CALL(*this, AudioParametersReceived());
   audio_system_->GetInputStreamParameters(
       media::AudioDeviceDescription::kDefaultDeviceId,
       base::Bind(&AudioSystemImplTest::OnAudioParams, base::Unretained(this),
                  media::AudioParameters()));
   WaitForCallback();
 }
 
-TEST_P(AudioSystemImplTest, GetStreamParameters) {
+TEST_P(AudioSystemImplTest, GetOutputStreamParameters) {
   EXPECT_CALL(*this, AudioParametersReceived());
   audio_system_->GetOutputStreamParameters(
       kNonDefaultDeviceId, base::Bind(&AudioSystemImplTest::OnAudioParams,
                                       base::Unretained(this), output_params_));
   WaitForCallback();
 }
 
 TEST_P(AudioSystemImplTest, GetDefaultOutputStreamParameters) {
   EXPECT_CALL(*this, AudioParametersReceived());
   audio_system_->GetOutputStreamParameters(
@@ skipping 88 matching lines @@
   EXPECT_EQ(2, static_cast<int>(output_device_descriptions_.size()));
   EXPECT_EQ(1, static_cast<int>(input_device_descriptions_.size()));
   EXPECT_CALL(*this, DeviceDescriptionsReceived());
   audio_system_->GetDeviceDescriptions(
       base::Bind(&AudioSystemImplTest::OnGetDeviceDescriptions,
                  base::Unretained(this), output_device_descriptions_),
       false);
   WaitForCallback();
 }
 
+TEST_P(AudioSystemImplTest, GetAssociatedOutputDeviceID) {
+  const std::string associated_id("associated_id");
+  audio_manager_->SetAssociatedOutputDeviceIDCallback(
+      base::Bind([](const std::string& result,
+                    const std::string&) -> std::string { return result; },
+                 associated_id));
+
+  EXPECT_CALL(*this, AssociatedOutputDeviceIDReceived(associated_id));
+
+  audio_system_->GetAssociatedOutputDeviceID(
+      std::string(),
+      base::Bind(&AudioSystemImplTest::AssociatedOutputDeviceIDReceived,
+                 base::Unretained(this)));
+  WaitForCallback();
+}
+
+TEST_P(AudioSystemImplTest, GetInputDeviceInfoNoAssociation) {
+  EXPECT_CALL(*this, InputDeviceInfoReceived());
+
+  audio_system_->GetInputDeviceInfo(
+      kNonDefaultDeviceId, base::Bind(&AudioSystemImplTest::OnInputDeviceInfo,
+                                      base::Unretained(this), input_params_,
+                                      AudioParameters(), std::string()));
+  WaitForCallback();
+}
+
+TEST_P(AudioSystemImplTest, GetInputDeviceInfoWithAssociation) {
+  EXPECT_CALL(*this, InputDeviceInfoReceived());
+
+  const std::string associated_id("associated_id");
+  audio_manager_->SetAssociatedOutputDeviceIDCallback(
+      base::Bind([](const std::string& result,
+                    const std::string&) -> std::string { return result; },
+                 associated_id));
+
+  audio_system_->GetInputDeviceInfo(
+      kNonDefaultDeviceId, base::Bind(&AudioSystemImplTest::OnInputDeviceInfo,
+                                      base::Unretained(this), input_params_,
+                                      output_params_, associated_id));
+  WaitForCallback();
+}
+
 INSTANTIATE_TEST_CASE_P(, AudioSystemImplTest, testing::Values(false, true));
 
 }  // namespace media