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"
@@ skipping 42 matching lines @@
   if (for_input)
     audio_manager->GetAudioInputDeviceDescriptions(&descriptions);
   else
     audio_manager->GetAudioOutputDeviceDescriptions(&descriptions);
   return descriptions;
 }
 
 }  // namespace
 
 AudioSystemImpl::AudioSystemImpl(AudioManager* audio_manager)
-    : audio_manager_(audio_manager) {
+    : audio_manager_(audio_manager), weak_factory_(this) {
   DCHECK(audio_manager_);
   AudioSystem::SetInstance(this);
 }
 
 AudioSystemImpl::~AudioSystemImpl() {
-  AudioSystem::ClearInstance(this);
+  DCHECK(GetTaskRunner()->BelongsToCurrentThread());
 }
 
 // static
-std::unique_ptr<AudioSystem> AudioSystemImpl::Create(
-    AudioManager* audio_manager) {
-  return base::WrapUnique(new AudioSystemImpl(audio_manager));
+AudioSystem::UniquePtr AudioSystemImpl::Create(AudioManager* audio_manager) {
+  return UniquePtr(new AudioSystemImpl(audio_manager));
 }
 
 void AudioSystemImpl::GetInputStreamParameters(
     const std::string& device_id,
     OnAudioParamsCallback on_params_cb) const {
   if (GetTaskRunner()->BelongsToCurrentThread()) {
     GetTaskRunner()->PostTask(
         FROM_HERE, base::Bind(on_params_cb, GetInputParametersOnDeviceThread(
                                                 audio_manager_, device_id)));
     return;
@@ skipping 29 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));
+}
+
+base::WeakPtr<AudioSystem> AudioSystemImpl::GetWeakPtr() {
+  return weak_factory_.GetWeakPtr();
+}
+
+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