Switching AudioInputDeviceManager from using AudioManager interface to AudioSystem one.

media/audio/audio_system_impl.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/single_thread_task_runner.h"
 #include "base/task_runner_util.h"
 #include "media/audio/audio_device_description.h"
 #include "media/audio/audio_manager.h"
+#include "media/base/bind_to_current_loop.h"
 
 // Using base::Unretained for |audio_manager_| is safe since it is deleted after
 // its task runner, and AudioSystemImpl is deleted on the UI thread after the IO
 // thread has been stopped and before |audio_manager_| deletion is scheduled.
 namespace media {
 
 namespace {
 
 AudioParameters GetInputParametersOnDeviceThread(AudioManager* audio_manager,
                                                  const std::string& device_id) {
@@ skipping 28 matching lines @@
     bool for_input) {
   DCHECK(audio_manager->GetTaskRunner()->BelongsToCurrentThread());
   AudioDeviceDescriptions descriptions;
   if (for_input)
     audio_manager->GetAudioInputDeviceDescriptions(&descriptions);
   else
     audio_manager->GetAudioOutputDeviceDescriptions(&descriptions);
   return descriptions;
 }
 
+void GetInputDeviceInfoOnDeviceThread(
+    AudioManager* audio_manager,
+    const std::string& input_device_id,
+    AudioSystem::OnInputDeviceInfoCallback on_input_device_info_cb) {
+  DCHECK(audio_manager->GetTaskRunner()->BelongsToCurrentThread());
+  const std::string associated_output_device_id =
+      audio_manager->GetAssociatedOutputDeviceID(input_device_id);
+
+  on_input_device_info_cb.Run(
+      GetInputParametersOnDeviceThread(audio_manager, input_device_id),
+      associated_output_device_id.empty()
+          ? AudioParameters()
+          : GetOutputParametersOnDeviceThread(audio_manager,
+                                              associated_output_device_id),
+      associated_output_device_id);
+}
+
 }  // namespace
 
 AudioSystemImpl::AudioSystemImpl(AudioManager* audio_manager)
     : audio_manager_(audio_manager) {
   DCHECK(audio_manager_);
   AudioSystem::SetInstance(this);
 }
 
 AudioSystemImpl::~AudioSystemImpl() {
   AudioSystem::ClearInstance(this);
@@ skipping 45 matching lines @@
     return;
   }
   base::PostTaskAndReplyWithResult(
       GetTaskRunner(), FROM_HERE,
       base::Bind(&AudioManager::HasAudioInputDevices,
                  base::Unretained(audio_manager_)),
       std::move(on_has_devices_cb));
 }
 
 void AudioSystemImpl::GetDeviceDescriptions(
-    OnDeviceDescriptionsCallback on_descriptions_cp,
+    OnDeviceDescriptionsCallback on_descriptions_cb,
     bool for_input) {
   if (GetTaskRunner()->BelongsToCurrentThread()) {
     GetTaskRunner()->PostTask(
-        FROM_HERE, base::Bind(on_descriptions_cp,
+        FROM_HERE, base::Bind(on_descriptions_cb,
                               base::Passed(GetDeviceDescriptionsOnDeviceThread(
                                   audio_manager_, for_input))));
     return;
   }
 
   base::PostTaskAndReplyWithResult(
       GetTaskRunner(), FROM_HERE,
       base::Bind(&GetDeviceDescriptionsOnDeviceThread,
                  base::Unretained(audio_manager_), for_input),
-      std::move(on_descriptions_cp));
+      std::move(on_descriptions_cb));
+}
+
+void AudioSystemImpl::GetAssociatedOutputDeviceID(
+    const std::string& input_device_id,
+    OnDeviceIdCallback on_device_id_cb) {
+  if (GetTaskRunner()->BelongsToCurrentThread()) {
+    GetTaskRunner()->PostTask(
+        FROM_HERE,
+        base::Bind(on_device_id_cb, audio_manager_->GetAssociatedOutputDeviceID(
+                                        input_device_id)));
+    return;
+  }
+  base::PostTaskAndReplyWithResult(
+      GetTaskRunner(), FROM_HERE,
+      base::Bind(&AudioManager::GetAssociatedOutputDeviceID,
+                 base::Unretained(audio_manager_), input_device_id),
+      std::move(on_device_id_cb));
+}
+
+void AudioSystemImpl::GetInputDeviceInfo(
+    const std::string& input_device_id,
+    OnInputDeviceInfoCallback on_input_device_info_cb) {
+  GetTaskRunner()->PostTask(

[DaleCurtis, 2017/03/28 18:22:11]

Hmm, seems like either the PostTask or BelongsToCurrentThread() check are
unnecessary? Who do you expect to call this and from what thread? Generally
you'd either not PostTask and use BindToCurrentLoop(), or always PostTask and
always BindToCurrentLoop.

[o1ka, 2017/03/30 15:11:53]

We may be either already on the audio thread (for example, on Mac), or on
another thread (for example, IO). If we are of the audio thread, we still cannot
reply synchronously, because the client expect to receive the reply in
asynchronous manner. But we don't need to bind to the current loop in this case.
I added a comment.

+      FROM_HERE, base::Bind(&GetInputDeviceInfoOnDeviceThread,
+                            base::Unretained(audio_manager_), input_device_id,
+                            GetTaskRunner()->BelongsToCurrentThread()
+                                ? std::move(on_input_device_info_cb)
+                                : media::BindToCurrentLoop(
+                                      std::move(on_input_device_info_cb))));
+}
+
+base::SingleThreadTaskRunner* AudioSystemImpl::GetTaskRunner() const {
+  return audio_manager_->GetTaskRunner();
 }
 
 AudioManager* AudioSystemImpl::GetAudioManager() const {
   return audio_manager_;
 }
 
-base::SingleThreadTaskRunner* AudioSystemImpl::GetTaskRunner() const {
-  return audio_manager_->GetTaskRunner();
-}
-
 }  // namespace media